teapot-coding-agent 0.37.101 → 0.37.103

package/dist/agent/kill.js

@@ -1,10 +1,32 @@
+import { spawnSync } from "node:child_process";
 export function canKillProcessGroup(platform = process.platform) {
     return platform !== "win32";
 }
-export function killTree(child, platform = process.platform) {
+const runTaskkill = (file, args) => {
+    try {
+        const r = spawnSync(file, args, { stdio: "ignore", windowsHide: true });
+        return { status: r.status };
+    }
+    catch {
+        return { status: null };
+    }
+};
+export function killTree(child, platform = process.platform, run = runTaskkill) {
     if (!child?.pid)
         return { killed: false, wholeTree: false, reason: "no-pid" };
     if (!canKillProcessGroup(platform)) {
+        /**
+         * Windows has no process groups, and `process.kill(pid)` terminates ONLY the process you name — the
+         * shell — so everything it started keeps running. That is not just a leak: the caller waits for the
+         * child's stdio to close, and a surviving grandchild holds those pipes open, so the tool call never
+         * returns even though the timeout fired (#190).
+         *
+         * `taskkill /T` walks the parent-child tree and is the only way to get all of it. If it is missing or
+         * refuses, fall back to the direct kill and SAY the tree is uncovered.
+         */
+        const r = run("taskkill", ["/pid", String(child.pid), "/T", "/F"]);
+        if (r.status === 0)
+            return { killed: true, wholeTree: true };
         try {
             process.kill(child.pid, "SIGKILL");
             return { killed: true, wholeTree: false };
@@ -39,11 +61,13 @@ export function killTree(child, platform = process.platform) {
     }
 }
 export function describeKill(outcome) {
+    // "tree", not "process group": on Windows the mechanism is `taskkill /T`, and the report is read by an
+    // operator who cannot see which platform it came from
     if (outcome.killed && outcome.wholeTree)
-        return "killed (whole process group)";
+        return "killed (whole process tree)";
     if (outcome.killed) {
-        return ("killed the process, but this platform has no process groups — any " +
-            "background children it started may still be running");
+        return ("killed the process, but its children may still be running — " +
+            "a background command it started could survive this");
     }
     switch (outcome.reason) {
         case "no-pid":

package/dist/agent/tools.js

@@ -466,7 +466,7 @@ function runShell(cmd, ctx, timeoutMs, explicitTimeout = false) {
                 resolve({ ok: false, result: `spawn error: ${err.message}${elapsed(t0)}` });
             }
         });
-        child.on("close", (code, signal) => {
+        const finish = (code, signal) => {
             clearTimeout(timer);
             ctx.signal?.removeEventListener("abort", onAbort);
             if (done)
@@ -485,7 +485,23 @@ function runShell(cmd, ctx, timeoutMs, explicitTimeout = false) {
                     clip(out.trim() || "(no output)", ctx.maxOutputBytes) +
                     elapsed(t0),
             });
+        };
+        /**
+         * `close` is the normal end: it fires only once the child AND everything holding its stdio has gone, so
+         * the output is complete.
+         *
+         * `exit` is the escape hatch for the kill paths, and without it a timeout can hang forever. `close`
+         * waits for the pipes to close, and a surviving grandchild holds those pipes open — measured on Linux
+         * with a child that leaves the process group: `exit` at 501ms, `close` still not fired 2.5s later. On
+         * Windows that is the NORMAL case, because `process.kill` cannot end anything but the shell (#190,
+         * "timeout時間超過って / stopおしても継続しちゃった"). Once a kill has been requested there is no more
+         * waiting to do, so settle on `exit`.
+         */
+        child.on("exit", (code, signal) => {
+            if (killReason)
+                finish(code, signal);
         });
+        child.on("close", (code, signal) => finish(code, signal));
     });
 }
 function matchLines(text, needle) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teapot-coding-agent",
-  "version": "0.37.101",
+  "version": "0.37.103",
   "description": "A lightweight, always-on multi-agent harness for AI coding agents",
   "type": "module",
   "license": "AGPL-3.0-or-later",