smolcoder-plus 1.0.0

package/dist/tools/index.js

@@ -0,0 +1,260 @@
+"use strict";
+// Tool registry. Eight tools with flat parameters — no
+// nested objects or arrays: small models mangle them), an example call inside
+// every description (small models imitate better than they infer), and the
+// mode decides which schemas are sent. The agent rechecks mode at execution.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODE_LABELS = void 0;
+exports.buildToolSpecs = buildToolSpecs;
+exports.executeTool = executeTool;
+exports.commandOf = commandOf;
+const fs_tools_1 = require("./fs-tools");
+const check_1 = require("./check");
+const shell_1 = require("./shell");
+const sandbox_1 = require("../sandbox");
+const util_1 = require("../util");
+const search_worker_1 = require("./search-worker");
+const web_search_1 = require("./web-search");
+exports.MODE_LABELS = {
+    ro: "read-only",
+    edit: "edit",
+    bypass: "bypass permissions",
+};
+const TOOL_RESULT_CAP = 10000; // chars — final safety net over per-tool caps
+function buildToolSpecs(mode) {
+    const read = [
+        {
+            name: "read_file",
+            description: 'Read a text file in the workspace. Example: {"path": "src/app.js"}. Long files are returned in chunks; pass "offset" (a line number) to continue reading.',
+            parameters: {
+                type: "object",
+                properties: {
+                    path: { type: "string", description: "File path relative to the workspace" },
+                    offset: { type: "number", description: "Line number to start from (optional)" },
+                    limit: { type: "number", description: "Max lines to return (optional)" },
+                },
+                required: ["path"],
+            },
+        },
+        {
+            name: "list_files",
+            description: 'List files and folders in the workspace. Example: {} for everything, or {"path": "src"} for one folder. Folders end with "/".',
+            parameters: {
+                type: "object",
+                properties: {
+                    path: { type: "string", description: "Folder to list (optional, default: whole workspace)" },
+                },
+            },
+        },
+        {
+            name: "search",
+            description: 'Search inside files for a pattern (regular expression; plain text also works). Example: {"pattern": "TODO"}. Returns file:line: matching text.',
+            parameters: {
+                type: "object",
+                properties: {
+                    pattern: { type: "string", description: "Text or regex to find" },
+                    path: { type: "string", description: "Folder to search in (optional)" },
+                },
+                required: ["pattern"],
+            },
+        },
+        {
+            name: "web_search",
+            description: 'Search the internet using Brave Search API (no local files). Example: {"query": "2026 Asian Games medal table"}. Max results 1-8 via {"query": "...", "maxResults": 3}. Requires BRAVE_API_KEY in .env. Returns numbered titles, snippets and URLs.',
+            parameters: {
+                type: "object",
+                properties: {
+                    query: { type: "string", description: "Search query" },
+                    maxResults: { type: "number", description: "Max results (1-8, default 5)", default: 5 },
+                },
+                required: ["query"],
+            },
+        },
+        {
+            name: "plan",
+            description: 'Plan runnable increments, kept across compaction. Create: {"action":"set","steps":"wire entry point; run build; add movement and test"}. Finish current step: {"action":"done"} (or supply step). Save exact APIs, error and next edit before a long investigation: {"action":"checkpoint","text":"..."} (max 1000 chars, replaces current step notes). Append: {"action":"add","text":"..."}. Show: {"action":"show"}.',
+            parameters: {
+                type: "object",
+                properties: {
+                    action: { type: "string", enum: ["set", "done", "add", "show", "checkpoint"] },
+                    steps: { type: "string", description: 'The steps, one per line; semicolon lists also accepted (only for "set")' },
+                    step: { type: "number", description: 'Step number to mark done (optional, for "done")' },
+                    text: { type: "string", description: 'Step to append or working checkpoint' },
+                },
+                required: ["action"],
+            },
+        },
+    ];
+    const write = [
+        {
+            name: "write_file",
+            description: 'Create a new file or completely overwrite an existing one. Example: {"path": "src/new.js", "content": "..."}. Parent folders are created automatically. To change part of an existing file, prefer edit_file.',
+            parameters: {
+                type: "object",
+                properties: {
+                    path: { type: "string", description: "File path relative to the workspace" },
+                    content: { type: "string", description: "The full file content" },
+                },
+                required: ["path", "content"],
+            },
+        },
+        {
+            name: "edit_file",
+            description: 'Replace text inside an existing file. Copy old_text EXACTLY from the file (a few lines, enough to be unique), and give the replacement as new_text. Example: {"path": "src/app.js", "old_text": "const x = 1;", "new_text": "const x = 2;"}',
+            parameters: {
+                type: "object",
+                properties: {
+                    path: { type: "string", description: "File path relative to the workspace" },
+                    old_text: { type: "string", description: "Exact text currently in the file" },
+                    new_text: { type: "string", description: "Text to replace it with" },
+                },
+                required: ["path", "old_text", "new_text"],
+            },
+        },
+    ];
+    const exec = [
+        {
+            name: "run_command",
+            description: 'Run a shell command in the workspace and wait for it to finish. Example: {"command": "npm test"}. Times out after 120s — for servers or watchers use the task tool instead.',
+            parameters: {
+                type: "object",
+                properties: {
+                    command: { type: "string", description: "The command to run" },
+                },
+                required: ["command"],
+            },
+        },
+        {
+            name: "task",
+            description: 'Manage background tasks (things that keep running, like dev servers). action "start" runs a command in the background: {"action": "start", "command": "npm run dev"}. action "logs" shows recent output: {"action": "logs", "task_id": "t1"}. action "list" shows all tasks. action "stop" kills one: {"action": "stop", "task_id": "t1"}.',
+            parameters: {
+                type: "object",
+                properties: {
+                    action: { type: "string", enum: ["start", "list", "logs", "stop"] },
+                    command: { type: "string", description: 'Command to run (only for "start")' },
+                    task_id: { type: "string", description: 'Task id like "t1" (for "logs" and "stop")' },
+                },
+                required: ["action"],
+            },
+        },
+    ];
+    if (mode === "ro")
+        return read;
+    return [...read, ...write, ...exec];
+}
+async function executeTool(name, args, ctx, signal) {
+    try {
+        let result;
+        switch (name) {
+            case "read_file":
+                result = (0, fs_tools_1.readFile)(ctx.workspace, args, ctx.resultCharLimit ? ctx.resultCharLimit - 256 : undefined);
+                break;
+            case "list_files":
+                result = (0, fs_tools_1.listFiles)(ctx.workspace, args);
+                break;
+            case "search":
+                result = await (0, search_worker_1.searchFilesBounded)(ctx.workspace, args, signal);
+                break;
+            case "web_search": {
+                if (!args.query || typeof args.query !== "string")
+                    return 'Error: query is required. Example: {"query": "..."}';
+                const maxResults = Number(args.maxResults) || web_search_1.DEFAULT_MAX_RESULTS;
+                result = await (0, web_search_1.webSearch)(args.query, maxResults);
+                break;
+            }
+            case "plan": {
+                const action = args.action ?? (typeof args.steps === "string" ? "set" : undefined);
+                if (action === "set")
+                    result = ctx.plan.set(typeof args.steps === "string" ? args.steps : "");
+                else if (action === "done")
+                    result = ctx.plan.markDone(args.step === undefined ? undefined : Number(args.step));
+                else if (action === "add")
+                    result = ctx.plan.add(String(args.text ?? ""));
+                else if (action === "checkpoint")
+                    result = ctx.plan.checkpoint(String(args.text ?? ""));
+                else if (action === "show")
+                    result = ctx.plan.modelView();
+                else
+                    return 'Error: action must be one of "set", "done", "add", "show", "checkpoint". Example: {"action": "done"}';
+                break;
+            }
+            case "write_file":
+                result = (0, fs_tools_1.writeFile)(ctx.workspace, args);
+                if (!result.startsWith("Error")) {
+                    ctx.filesTouched.add(String(args.path));
+                    result += afterWrite(ctx.workspace, String(args.path));
+                }
+                break;
+            case "edit_file":
+                result = (0, fs_tools_1.editFile)(ctx.workspace, args);
+                if (!result.startsWith("Error")) {
+                    ctx.filesTouched.add(String(args.path));
+                    result += afterWrite(ctx.workspace, String(args.path));
+                }
+                break;
+            case "run_command":
+                if (typeof args.command !== "string" || !args.command.trim()) {
+                    return 'Error: command is required. Example: {"command": "npm test"}';
+                }
+                result = await (0, shell_1.runCommand)(args.command, ctx.workspace, signal);
+                ctx.commandsRun.push(`${args.command} → ${result.split("\n").at(-1)}`);
+                if (ctx.commandsRun.length > 50)
+                    ctx.commandsRun.splice(0, ctx.commandsRun.length - 50);
+                break;
+            case "task": {
+                const action = args.action;
+                if (action === "start") {
+                    if (typeof args.command !== "string" || !args.command.trim()) {
+                        return 'Error: "start" needs a command. Example: {"action": "start", "command": "npm run dev"}';
+                    }
+                    ctx.commandsRun.push(`[bg] ${args.command}`);
+                    result = await ctx.taskManager.startWithEarlyOutput(args.command);
+                }
+                else if (action === "logs") {
+                    result = ctx.taskManager.logs(String(args.task_id ?? ""), Number(args.lines) || 50);
+                }
+                else if (action === "stop") {
+                    result = ctx.taskManager.stop(String(args.task_id ?? ""));
+                }
+                else if (action === "list") {
+                    result = ctx.taskManager.list();
+                }
+                else {
+                    return 'Error: action must be one of "start", "list", "logs", "stop". Example: {"action": "list"}';
+                }
+                break;
+            }
+            default:
+                return `Error: unknown tool "${name}". Available tools are listed in your tool definitions — use one of those.`;
+        }
+        return (0, util_1.truncateMiddle)(result, TOOL_RESULT_CAP);
+    }
+    catch (err) {
+        if (err instanceof sandbox_1.SandboxError)
+            return `Error: ${err.message}`;
+        return `Error: ${err?.message ?? String(err)}`;
+    }
+}
+/** Post-write hook: parse what was just written and coach on the first
+ * syntax error. A one-line warning riding on the success message is the
+ * cheapest possible feedback loop for a local model. */
+function afterWrite(workspace, relPath) {
+    try {
+        const abs = (0, sandbox_1.resolveInWorkspace)(workspace, relPath);
+        const warning = (0, check_1.syntaxCheck)(abs, relPath);
+        return warning ? `
+Warning: ${warning} Fix this before moving on (use edit_file).` : "";
+    }
+    catch {
+        return "";
+    }
+}
+/** The command a call would run, if it is an exec call (edit mode may gate it;
+ * bypass never asks; in ro mode the tool does not exist). */
+function commandOf(name, args) {
+    if (name === "run_command")
+        return String(args.command ?? "");
+    if (name === "task" && args.action === "start")
+        return String(args.command ?? "");
+    return null;
+}

package/dist/tools/search-worker.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchFilesBounded = searchFilesBounded;
+const worker_threads_1 = require("worker_threads");
+const fs_tools_1 = require("./fs-tools");
+if (!worker_threads_1.isMainThread)
+    worker_threads_1.parentPort.postMessage((0, fs_tools_1.searchFiles)(worker_threads_1.workerData.root, worker_threads_1.workerData.args));
+/** A pathological regex can be terminated without freezing the agent/UI. */
+function searchFilesBounded(root, args, signal, timeoutMs = 5000) {
+    if (signal?.aborted)
+        return Promise.resolve("Error: search cancelled");
+    return new Promise((resolve) => {
+        const worker = new worker_threads_1.Worker(__filename, { workerData: { root, args } });
+        let settled = false;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", cancel);
+            void worker.terminate();
+            resolve(result);
+        };
+        const cancel = () => finish("Error: search cancelled");
+        const timer = setTimeout(() => finish("Error: search timed out. Use a simpler pattern or search a smaller folder."), timeoutMs);
+        signal?.addEventListener("abort", cancel, { once: true });
+        if (signal?.aborted)
+            cancel();
+        worker.once("message", finish);
+        worker.once("error", (err) => finish(`Error: search failed: ${err.message}`));
+        worker.once("exit", (code) => { if (!settled)
+            finish(`Error: search worker exited (${code})`); });
+    });
+}

package/dist/tools/shell.js

@@ -0,0 +1,186 @@
+"use strict";
+// run_command: one-shot foreground commands, cwd-locked to the workspace.
+// Shell picking matters on Windows: local models emit POSIX commands, so we
+// prefer Git Bash when it exists, skip WSL's System32 bash (different
+// filesystem world), and fall back to PowerShell. The chosen shell is named in
+// the system prompt so the model knows what dialect to write.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pickShell = pickShell;
+exports.killTree = killTree;
+exports.managedCommand = managedCommand;
+exports.runCommand = runCommand;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const util_1 = require("../util");
+let cached = null;
+function pickShell() {
+    if (cached)
+        return cached;
+    if (process.platform === "win32") {
+        const candidates = [
+            path.join(process.env["ProgramFiles"] ?? "C:\\Program Files", "Git", "bin", "bash.exe"),
+            path.join(process.env["ProgramFiles(x86)"] ?? "C:\\Program Files (x86)", "Git", "bin", "bash.exe"),
+            path.join(process.env["LOCALAPPDATA"] ?? "", "Programs", "Git", "bin", "bash.exe"),
+        ];
+        for (const p of candidates) {
+            if (p && fs.existsSync(p)) {
+                cached = { exe: p, argsFor: (cmd) => ["-o", "pipefail", "-lc", cmd], label: "bash (Git Bash)" };
+                return cached;
+            }
+        }
+        // any bash on PATH that is not WSL's System32 shim
+        const where = (0, child_process_1.spawnSync)("where.exe", ["bash"], { encoding: "utf8" });
+        if (where.status === 0) {
+            const found = where.stdout
+                .split(/\r?\n/)
+                .map((s) => s.trim())
+                .find((p) => p && !p.toLowerCase().includes("system32"));
+            if (found) {
+                cached = { exe: found, argsFor: (cmd) => ["-o", "pipefail", "-lc", cmd], label: "bash (Git Bash)" };
+                return cached;
+            }
+        }
+        cached = {
+            exe: "powershell.exe",
+            argsFor: (cmd) => ["-NoProfile", "-NonInteractive", "-Command", cmd],
+            label: "PowerShell",
+        };
+        return cached;
+    }
+    const sh = fs.existsSync("/bin/bash") ? "/bin/bash" : "/bin/sh";
+    cached = { exe: sh, argsFor: (cmd) => sh.endsWith("/bash") ? ["-o", "pipefail", "-lc", cmd] : ["-lc", cmd], label: path.basename(sh) };
+    return cached;
+}
+function killTree(pid) {
+    try {
+        if (process.platform === "win32") {
+            (0, child_process_1.spawnSync)("taskkill", ["/pid", String(pid), "/t", "/f"], { stdio: "ignore" });
+        }
+        else {
+            process.kill(-pid, "SIGKILL");
+        }
+    }
+    catch {
+        try {
+            process.kill(pid, "SIGKILL");
+        }
+        catch {
+            /* already gone */
+        }
+    }
+}
+const OUTPUT_CAP = 8000;
+const DEFAULT_TIMEOUT_MS = 120_000;
+/** Keep bash alive while ordinary background jobs own its output pipes. On
+ * Windows taskkill cannot find descendants after their shell has exited. */
+function managedCommand(shell, command) {
+    return /(?:^|[\\/])bash(?:\.exe)?$/.test(shell.exe)
+        ? `${command}\n__smol_command_status=$?\nwait\nexit "$__smol_command_status"`
+        : command;
+}
+function runCommand(command, cwd, signal) {
+    if (signal?.aborted)
+        return Promise.resolve("Error: command cancelled before starting");
+    return new Promise((resolve) => {
+        const shell = pickShell();
+        let output = "";
+        let finished = false;
+        const started = Date.now();
+        const proc = (0, child_process_1.spawn)(shell.exe, shell.argsFor(managedCommand(shell, command)), {
+            cwd,
+            env: process.env,
+            detached: process.platform !== "win32", // process group for killTree
+            windowsHide: true,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const append = (chunk) => {
+            // Keep the end of a long build/test log: failures usually appear there.
+            // Dropping all output after 32k hid the actual failure from the model.
+            output += chunk.toString("utf8");
+            if (output.length > OUTPUT_CAP * 4)
+                output = (0, util_1.truncateMiddle)(output, OUTPUT_CAP * 4);
+        };
+        proc.stdout.on("data", append);
+        proc.stderr.on("data", append);
+        // User interrupt (esc / ctrl+c / web stop button): kill the whole tree now.
+        const onAbort = () => {
+            if (finished)
+                return;
+            finished = true;
+            clearTimeout(timer);
+            cleanup();
+            killTree(proc.pid);
+            proc.stdout.destroy();
+            proc.stderr.destroy();
+            resolve((output.trim() ? (0, util_1.truncateMiddle)(output, OUTPUT_CAP) + "\n" : "") +
+                "[command cancelled by the user before it finished]");
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+        const cleanup = () => signal?.removeEventListener("abort", onAbort);
+        const timer = setTimeout(() => {
+            if (finished)
+                return;
+            finished = true;
+            cleanup();
+            killTree(proc.pid);
+            proc.stdout.destroy();
+            proc.stderr.destroy();
+            resolve("Error: " + (0, util_1.truncateMiddle)(output, OUTPUT_CAP) +
+                `\n[command timed out after ${DEFAULT_TIMEOUT_MS / 1000}s and was killed. For tests/builds, isolate the stuck test or phase and inspect its loop or initialization before rerunning. For a persistent dev server, use task {"action": "start"}.]`);
+        }, DEFAULT_TIMEOUT_MS);
+        proc.on("error", (err) => {
+            if (finished)
+                return;
+            finished = true;
+            clearTimeout(timer);
+            cleanup();
+            resolve(`Error: could not start command: ${err.message}`);
+        });
+        proc.on("close", (code) => {
+            if (finished)
+                return;
+            finished = true;
+            clearTimeout(timer);
+            cleanup();
+            const secs = ((Date.now() - started) / 1000).toFixed(1);
+            const body = output.trim() ? (0, util_1.truncateMiddle)(output, OUTPUT_CAP) : "(no output)";
+            resolve(`${code !== 0 ? `Error: command exited with code ${code ?? "?"}\n` : ""}${body}\n[exit code ${code ?? "?"} in ${secs}s]`);
+        });
+        if (signal?.aborted)
+            onAbort();
+    });
+}

package/dist/tools/tasks.js

@@ -0,0 +1,147 @@
+"use strict";
+// Background tasks: one `task` tool with an action enum instead of four
+// separate tools — one schema costs fewer context tokens, and small models
+// handle enum dispatch on a single tool fine. Each task keeps a ring buffer of
+// recent output so the agent (and the user, via /tasks and /logs) has
+// visibility. All tasks are killed when smolcoder exits.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskManager = void 0;
+const child_process_1 = require("child_process");
+const shell_1 = require("./shell");
+const RING_SIZE = 300;
+class TaskManager {
+    cwd;
+    tasks = new Map();
+    counter = 0;
+    constructor(cwd) {
+        this.cwd = cwd;
+    }
+    start(command) {
+        const shell = (0, shell_1.pickShell)();
+        const id = `t${++this.counter}`;
+        const proc = (0, child_process_1.spawn)(shell.exe, shell.argsFor((0, shell_1.managedCommand)(shell, command)), {
+            cwd: this.cwd,
+            env: process.env,
+            detached: process.platform !== "win32",
+            windowsHide: true,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const task = {
+            id,
+            command,
+            proc,
+            lines: [],
+            status: "running",
+            exitCode: null,
+            startedAt: Date.now(),
+        };
+        const push = (chunk) => {
+            for (const line of chunk.toString("utf8").split(/\r?\n/)) {
+                if (line === "")
+                    continue;
+                task.lines.push(line);
+                if (task.lines.length > RING_SIZE)
+                    task.lines.shift();
+            }
+        };
+        proc.stdout?.on("data", push);
+        proc.stderr?.on("data", push);
+        proc.on("error", (err) => {
+            task.lines.push(`[failed to start: ${err.message}]`);
+            task.status = "exited";
+            task.exitCode = -1;
+        });
+        proc.on("close", (code) => {
+            if (task.status === "running") {
+                task.status = "exited";
+                task.exitCode = code;
+            }
+        });
+        this.tasks.set(id, task);
+        return id;
+    }
+    /** Wait briefly after start so early output (or an instant crash) is visible. */
+    async startWithEarlyOutput(command) {
+        const id = this.start(command);
+        await new Promise((r) => setTimeout(r, 1500));
+        const task = this.tasks.get(id);
+        const early = task.lines.slice(-15).join("\n");
+        const status = task.status === "running"
+            ? `Task ${id} is running in the background.`
+            : `Task ${id} exited almost immediately (exit code ${task.exitCode}).`;
+        return `${status} Command: ${command}\n${early ? `Early output:\n${early}\n` : ""}Use task {"action": "logs", "task_id": "${id}"} to check on it, {"action": "stop"} to kill it.`;
+    }
+    logs(taskId, lineCount = 50) {
+        const task = this.tasks.get(taskId);
+        if (!task)
+            return this.unknownTask(taskId);
+        const tail = task.lines.slice(-Math.min(Math.max(lineCount, 1), RING_SIZE));
+        const header = `Task ${task.id} [${task.status}${task.exitCode !== null ? ` code ${task.exitCode}` : ""}] ${task.command}`;
+        return `${header}\n${tail.length ? tail.join("\n") : "(no output yet)"}`;
+    }
+    stop(taskId) {
+        const task = this.tasks.get(taskId);
+        if (!task)
+            return this.unknownTask(taskId);
+        if (task.status !== "running")
+            return `Task ${taskId} already ${task.status}.`;
+        task.status = "stopped";
+        (0, shell_1.killTree)(task.proc.pid);
+        task.proc.stdout?.destroy();
+        task.proc.stderr?.destroy();
+        return `Task ${taskId} stopped. (${task.command})`;
+    }
+    list() {
+        if (this.tasks.size === 0)
+            return "No background tasks. Start one with task {\"action\": \"start\", \"command\": \"...\"}.";
+        const rows = [...this.tasks.values()].map((t) => {
+            const age = Math.round((Date.now() - t.startedAt) / 1000);
+            const status = t.status === "running" ? "running" : `${t.status}${t.exitCode !== null ? `(${t.exitCode})` : ""}`;
+            return `${t.id}  ${status}  ${age}s  ${t.command}`;
+        });
+        return "id  status  age  command\n" + rows.join("\n");
+    }
+    hasRunning() {
+        return [...this.tasks.values()].some((t) => t.status === "running");
+    }
+    runningSummary() {
+        return [...this.tasks.values()]
+            .filter((t) => t.status === "running")
+            .map((t) => `${t.id}: ${t.command}`);
+    }
+    /** http://localhost-style URLs printed by running tasks — what a dev server
+     * announces on start — so the web UI can offer them in its browser panel. */
+    recentUrls() {
+        const out = new Set();
+        const re = /https?:\/\/(?:localhost|127\.0\.0\.1|0\.0\.0\.0|\[::1?\])(?::\d+)?(?:\/[^\s"'<>)\]]*)?/g;
+        for (const t of this.tasks.values()) {
+            if (t.status !== "running")
+                continue;
+            for (const line of t.lines) {
+                for (const m of line.matchAll(re))
+                    out.add(m[0].replace("0.0.0.0", "localhost").replace(/\/$/, ""));
+            }
+        }
+        return [...out].slice(0, 8);
+    }
+    killAll() {
+        for (const t of this.tasks.values()) {
+            if (t.status === "running") {
+                t.status = "stopped";
+                try {
+                    (0, shell_1.killTree)(t.proc.pid);
+                    t.proc.stdout?.destroy();
+                    t.proc.stderr?.destroy();
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+        }
+    }
+    unknownTask(taskId) {
+        const known = [...this.tasks.keys()].join(", ") || "none";
+        return `Error: no task with id "${taskId}". Known tasks: ${known}. Use task {"action": "list"} to see them.`;
+    }
+}
+exports.TaskManager = TaskManager;