const std = @import("std");const io_mod = @import("../shared/io.zig");const text_utils = @import("../shared/text_utils.zig"); pub fn detectServerUrl(alloc: std.mem.Allocator, external_path: []const u8) !?[]u8 {    const content = readLogSnapshot(alloc, external_path) catch |err| switch (err) {        error.FileNotFound => return null,        else => return err,    };    defer alloc.free(content);     return detectServerUrlFromContent(alloc, content);} pub fn detectServerUrlFromContent(    alloc: std.mem.Allocator,    content: []const u8,) !?[]u8 {    const url = extractUrl(content) orelse return null;    return try alloc.dupe(u8, url);} pub fn isLikelyServerCommand(command: []const u8) bool {    return hasCommandTokensInOrder(command, &.{ "npm", "run", "dev" }) or        hasCommandTokensInOrder(command, &.{ "npm", "run", "start" }) or        hasCommandTokensInOrder(command, &.{ "pnpm", "dev" }) or        hasCommandTokensInOrder(command, &.{ "pnpm", "run", "dev" }) or        hasCommandTokensInOrder(command, &.{ "pnpm", "start" }) or        hasCommandTokensInOrder(command, &.{ "yarn", "dev" }) or        hasCommandTokensInOrder(command, &.{ "yarn", "start" }) or        hasCommandTokensInOrder(command, &.{ "bun", "dev" }) or        hasCommandTokensInOrder(command, &.{ "bun", "run", "dev" }) or        hasCommandTokensInOrder(command, &.{ "next", "dev" }) or        hasCommandTokensInOrder(command, &.{"vite"}) or        hasCommandTokensInOrder(command, &.{ "astro", "dev" }) or        hasCommandTokensInOrder(command, &.{"serve"});} fn hasCommandTokensInOrder(command: []const u8, expected: []const []const u8) bool {    if (expected.len == 0) return false;     var token_index: usize = 0;    var i: usize = 0;    while (i < command.len) {        while (i < command.len and !isCommandTokenByte(command[i])) : (i += 1) {}        if (i >= command.len) break;         const start = i;        while (i < command.len and isCommandTokenByte(command[i])) : (i += 1) {}        const token = command[start..i];        if (std.ascii.eqlIgnoreCase(token, expected[token_index])) {            token_index += 1;            if (token_index == expected.len) return true;        }    }     return false;} fn isCommandTokenByte(byte: u8) bool {    return std.ascii.isAlphanumeric(byte) or byte == '_' or byte == '-' or byte == '.' or byte == '/';} fn readLogSnapshot(alloc: std.mem.Allocator, external_path: []const u8) ![]u8 {    var file = try std.Io.Dir.openFileAbsolute(        io_mod.getIo(),        external_path,        .{},    );    defer file.close(io_mod.getIo());    return io_mod.readFileToEnd(alloc, &file, 64 * 1024);} fn extractUrl(text: []const u8) ?[]const u8 {    var search_start: usize = 0;    var best_url: ?[]const u8 = null;    var best_score: i32 = std.math.minInt(i32);    var best_start: usize = 0;     while (nextUrlCandidate(text, search_start)) |candidate| {        const score = scoreUrlCandidate(candidate.url, candidate.line);        if (best_url == null or score > best_score or (score == best_score and candidate.start > best_start)) {            best_url = candidate.url;            best_score = score;            best_start = candidate.start;        }        search_start = candidate.start + candidate.url.len;    }     return best_url;} const UrlCandidate = struct {    url: []const u8,    line: []const u8,    start: usize,}; fn nextUrlCandidate(text: []const u8, search_start: usize) ?UrlCandidate {    const schemes = [_][]const u8{ "http://", "https://" };     var best_start: ?usize = null;    for (schemes) |scheme| {        if (std.mem.indexOfPos(u8, text, search_start, scheme)) |start| {            if (best_start == null or start < best_start.?) {                best_start = start;            }        }    }     const start = best_start orelse return null;    var end = start;    while (end < text.len) : (end += 1) {        const ch = text[end];        if (ch == ' ' or ch == '\n' or ch == '\r' or ch == '\t' or ch == ')' or ch == '"' or ch == '\'') {            break;        }    }     const line_start = if (std.mem.findScalarLast(u8, text[0..start], '\n')) |index| index + 1 else 0;    const line_end = std.mem.findScalarPos(u8, text, end, '\n') orelse text.len;     return .{        .url = text[start..end],        .line = text[line_start..line_end],        .start = start,    };} fn scoreUrlCandidate(url: []const u8, line: []const u8) i32 {    var score: i32 = 0;     if (text_utils.containsIgnoreCase(url, "localhost") or std.mem.find(u8, url, "127.0.0.1") != null or std.mem.find(u8, url, "[::1]") != null) {        score += 100;    } else if (std.mem.find(u8, url, "0.0.0.0") != null) {        score += 80;    } else if (std.mem.find(u8, url, "192.168.") != null or std.mem.find(u8, url, "10.") != null or std.mem.find(u8, url, "172.") != null) {        score += 40;    }     if (text_utils.containsIgnoreCase(line, "local")) score += 20;    if (text_utils.containsIgnoreCase(line, "url")) score += 6;    if (text_utils.containsIgnoreCase(line, "ready") or text_utils.containsIgnoreCase(line, "started") or text_utils.containsIgnoreCase(line, "listening") or text_utils.containsIgnoreCase(line, "server")) score += 10;    if (text_utils.containsIgnoreCase(line, "network")) score -= 15;    if (text_utils.containsIgnoreCase(line, "error") or text_utils.containsIgnoreCase(line, "warn")) score -= 25;     return score;} test "server command detection handles shell wrappers" {    try std.testing.expect(isLikelyServerCommand("cd app && npm run dev"));    try std.testing.expect(isLikelyServerCommand("pnpm --filter web dev"));    try std.testing.expect(isLikelyServerCommand("bun run dev"));    try std.testing.expect(isLikelyServerCommand("vite --host 0.0.0.0"));    try std.testing.expect(!isLikelyServerCommand("watchexec zig build test"));} test "server url detection finds local dev server url" {    try std.testing.expectEqualStrings(        "http://localhost:3000",        extractUrl("ready - started server on 0.0.0.0:3000, url: http://localhost:3000\n").?,    );} test "server url detection prefers latest local url" {    try std.testing.expectEqualStrings(        "http://localhost:3000",        extractUrl(            "Network: http://192.168.1.20:3000\n" ++                "Local: http://localhost:3001\n" ++                "warn  - restarting dev server\n" ++                "Local: http://localhost:3000\n",        ).?,    );}