teapot-coding-agent 0.26.12 → 0.26.14

package/dist/agent/kill.js

@@ -0,0 +1,70 @@
+/** can this platform kill a whole process group? */
+export function canKillProcessGroup(platform = process.platform) {
+    return platform !== "win32";
+}
+/**
+ * Kill a spawned child, and its whole group where the platform allows it.
+ *
+ * Deliberately does NOT throw: callers are timeouts and abort handlers, where a
+ * throw would replace the real message with a secondary failure.
+ */
+export function killTree(child, platform = process.platform) {
+    if (!child?.pid)
+        return { killed: false, wholeTree: false, reason: "no-pid" };
+    if (!canKillProcessGroup(platform)) {
+        // Windows: no group kill. Try the direct child so at least THAT stops, and
+        // report that the tree is not covered rather than implying it is.
+        try {
+            process.kill(child.pid, "SIGKILL");
+            return { killed: true, wholeTree: false };
+        }
+        catch (err) {
+            const code = err.code;
+            return {
+                killed: false,
+                wholeTree: false,
+                reason: code === "ESRCH" ? "already-gone" : "error",
+            };
+        }
+    }
+    try {
+        process.kill(-child.pid, "SIGKILL"); // whole group
+        return { killed: true, wholeTree: true };
+    }
+    catch (err) {
+        const code = err.code;
+        // EPERM on the group can still mean the child is killable directly, and
+        // EPERM is what a partially-privileged tree produces.
+        if (code === "EPERM") {
+            try {
+                process.kill(child.pid, "SIGKILL");
+                return { killed: true, wholeTree: false };
+            }
+            catch {
+                return { killed: false, wholeTree: false, reason: "error" };
+            }
+        }
+        if (code === "ESRCH")
+            return { killed: false, wholeTree: false, reason: "already-gone" };
+        return { killed: false, wholeTree: false, reason: "error" };
+    }
+}
+/** a sentence for the tool result, so a partial kill is never silent */
+export function describeKill(outcome) {
+    if (outcome.killed && outcome.wholeTree)
+        return "killed (whole process group)";
+    if (outcome.killed) {
+        return ("killed the process, but this platform has no process groups — any " +
+            "background children it started may still be running");
+    }
+    switch (outcome.reason) {
+        case "no-pid":
+            return "no process handle to kill";
+        case "already-gone":
+            return "already exited";
+        case "group-unsupported":
+            return "process groups are not supported on this platform";
+        default:
+            return "could not be killed";
+    }
+}

package/dist/agent/skills.js

@@ -18,6 +18,7 @@
  */
 import { promises as fs } from "node:fs";
 import path from "node:path";
+import { homeDir } from "../home.js";
 export const SKILL_FILE = "SKILL.md";
 /**
  * Cheap change-detector for a set of skill roots. Returns a stable string
@@ -148,7 +149,9 @@ function unquote(v) {
  * directories are skipped silently, and nothing is read unless it exists.
  */
 export function foreignSkillRoots(workspace) {
-    const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+    // #110: the shared helper also covers HOMEDRIVE/HOMEPATH, which is how
+    // Windows reports a home when USERPROFILE is absent.
+    const home = homeDir();
     const out = [];
     const add = (dir) => {
         if (dir && !out.some((r) => r.dir === dir))

package/dist/agent/tools.js

@@ -7,6 +7,7 @@ import { existsSync, promises as fs, readlinkSync, realpathSync } from "node:fs"
 import path from "node:path";
 import { discoverSkills, isValidSkillName, readSkillFile, saveSkill, SKILL_FILE, } from "./skills.js";
 import { isReasoningEffort } from "../model-meta.js";
+import { killTree, describeKill } from "./kill.js";
 const str = (v, fallback = "") => (typeof v === "string" ? v : fallback);
 const num = (v, fallback) => (typeof v === "number" ? v : fallback);
 function clip(s, max) {
@@ -322,23 +323,18 @@ function runShell(cmd, ctx, timeoutMs) {
         };
         child.stdout.on("data", collect);
         child.stderr.on("data", collect);
-        const killGroup = () => {
-            try {
-                if (child.pid)
-                    process.kill(-child.pid, "SIGKILL"); // whole group
-            }
-            catch {
-                /* already gone */
-            }
-        };
+        // #110: the kill REPORTS whether it worked. It used to swallow every failure
+        // as "already gone", and on Windows a group kill throws ALWAYS — so a timeout
+        // would report `TIMEOUT after …ms` for a process that was still running, and
+        // shutdown would leave it alive. A timeout that claims success is worse than
+        // a crash, because nothing afterwards looks wrong.
+        const killGroup = () => killTree(child);
         const timer = setTimeout(() => {
-            killReason = `TIMEOUT after ${timeoutMs}ms`;
-            killGroup();
+            killReason = `TIMEOUT after ${timeoutMs}ms — ${describeKill(killGroup())}`;
         }, timeoutMs);
         // harness shutdown must not wait out a long-running command
         const onAbort = () => {
-            killReason = "ABORTED (harness shutdown)";
-            killGroup();
+            killReason = `ABORTED (harness shutdown) — ${describeKill(killGroup())}`;
         };
         if (ctx.signal) {
             if (ctx.signal.aborted)
@@ -1422,14 +1418,9 @@ export const TOOLS = [
                         `jobs are per-workspace and forgotten on harness restart`,
                 };
             if (str(args.action) === "kill") {
-                if (!sh.exited) {
-                    try {
-                        if (sh.child.pid)
-                            process.kill(-sh.child.pid, "SIGKILL");
-                    }
-                    catch { /* already gone */ }
-                }
-                const note = sh.exited ? "(already exited)" : "killed";
+                // #110: same swallowed-kill bug — this reported "killed" and dropped the
+                // job from the map while the process kept running, now untrackable.
+                const note = sh.exited ? "(already exited)" : describeKill(killTree(sh.child));
                 map.delete(sh.id);
                 return { ok: true, result: `job ${sh.id} ${note}. Output so far:\n${clip(sh.out, 4000)}` };
             }

package/dist/home.js

@@ -0,0 +1,51 @@
+/**
+ * The user's home directory, on every platform.
+ *
+ * #110: `process.env.HOME` is a POSIX convention and is normally UNSET on
+ * Windows. Code that expanded `~` with `process.env.HOME ?? "~"` therefore got
+ * the LITERAL string "~" back on Windows — and since the result was then passed
+ * to `path.resolve(base, …)` and `mkdirSync`, teapot created a directory named
+ * `~`. That is the reported symptom.
+ *
+ * `os.homedir()` is the answer: on Windows Node resolves it from `USERPROFILE`,
+ * on POSIX from `HOME`, so it is never the literal `~`. The env lookups are kept
+ * only so a test can drive the Windows shape deterministically — `os.homedir()`
+ * on a Linux CI box would report `/root` and hide the very condition under test.
+ *
+ * Returns "" only when nothing at all is known, which callers treat as "leave the
+ * `~` alone" rather than inventing a path.
+ */
+export function homeDir(env = process.env) {
+    if (env.HOME)
+        return env.HOME;
+    if (env.USERPROFILE)
+        return env.USERPROFILE;
+    // Windows also reports a home as HOMEDRIVE + HOMEPATH. Concatenate
+    // defensively: `drive.replace(...) + path` yields the STRING "undefined"
+    // rather than undefined when either part is missing, which is exactly the
+    // class of bug this helper exists to remove.
+    const drive = env.HOMEDRIVE;
+    const rest = env.HOMEPATH;
+    if (drive && rest)
+        return drive.replace(/\\+$/, "") + rest;
+    if (drive)
+        return drive;
+    return "";
+}
+/**
+ * Expand a leading `~` to the home directory.
+ *
+ * Kept in one place so the Windows case cannot be got wrong a second time — the
+ * bug existed in three separate places before this helper (#110).
+ */
+export function expandTilde(input, env = process.env) {
+    // #110: on Windows a path can be `~\foo`, hence the backslash in the lookahead.
+    if (!/^~(?=$|[/\\])/.test(input))
+        return input;
+    const home = homeDir(env);
+    // With no home known, returning the input untouched is more honest than
+    // substituting a literal that would become a real directory.
+    if (!home)
+        return input;
+    return input.replace(/^~(?=$|[/\\])/, home);
+}

package/dist/master.js

@@ -7,6 +7,7 @@ import { readFileSync, existsSync, mkdirSync, writeFileSync, readdirSync, statSy
 import { randomUUID } from "node:crypto";
 import path from "node:path";
 import os from "node:os";
+import { expandTilde } from "./home.js";
 import { fileURLToPath } from "node:url";
 import { spawn } from "node:child_process";
 import { Agent } from "./agent/agent.js";
@@ -64,7 +65,9 @@ function readAppVersion() {
  * `~` is expanded for both forms; absolute paths pass through untouched.
  */
 export function resolveWorkspace(input, base) {
-    const expanded = input.trim().replace(/^~(?=$|\/|\\)/, process.env.HOME ?? "~");
+    // #110: `~` must not expand to the LITERAL "~" — that is how a directory named
+    // `~` got created on Windows, where process.env.HOME is unset. See src/home.ts.
+    const expanded = expandTilde(input.trim());
     if (path.isAbsolute(expanded))
         return path.normalize(expanded);
     return path.resolve(base, expanded);

package/dist/server/api.js

@@ -11,6 +11,7 @@ import { promises as fs } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { parseSchedule } from "../scheduler/cron.js";
 import { TermSizeTracker } from "./term-size.js";
+import { expandTilde, homeDir } from "../home.js";
 import { SUB_PERSONAS, resolveWorkspace } from "../master.js";
 import { ConfigPatchSchema, formatZodError } from "../config-schema.js";
 import { providerHeaders } from "../agent/llm.js";
@@ -440,8 +441,11 @@ export function buildApp(master) {
     });
     // ---- filesystem browsing (read-only, for the workspace picker) ----
     app.get("/api/fs", async (c) => {
-        let p = c.req.query("path") || process.env.HOME || "/";
-        p = path.resolve(p.replace(/^~/, process.env.HOME ?? "~"));
+        // #110: read the home directory through the shared helper. `process.env.HOME`
+        // is unset on Windows, which made the old fallback yield the literal "~" —
+        // and /api/fs would then browse a directory named ~.
+        let p = c.req.query("path") || homeDir() || path.parse(process.cwd()).root;
+        p = path.resolve(expandTilde(p));
         try {
             const entries = await fs.readdir(p, { withFileTypes: true });
             return c.json({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teapot-coding-agent",
-  "version": "0.26.12",
+  "version": "0.26.14",
   "description": "A lightweight, always-on multi-agent harness for AI coding agents",
   "type": "module",
   "license": "AGPL-3.0-or-later",
@@ -39,7 +39,8 @@
     "start": "node dist/index.js",
     "dev": "node src/index.ts",
     "dev-web": "vite",
-    "test": "node --test test/*.test.ts"
+    "test": "node --test test/*.test.ts",
+    "test:portable": "node scripts/run-portable-tests.mjs"
   },
   "dependencies": {
     "@hono/node-server": "^2.1.1",