teapot-coding-agent 0.22.10 → 0.22.12

package/dist/agent/agent.js

@@ -10,7 +10,7 @@ import { promises as fs, existsSync, readFileSync, readdirSync, statSync } from
 import path from "node:path";
 import { EventLog, readEvents } from "../log/events.js";
 import { chat, chatStream } from "./llm.js";
-import { executeTool, toolSpecs, currentSkills, safeJoin, isContextOverflow } from "./tools.js";
+import { executeTool, toolSpecs, currentSkills, safeJoin, isContextOverflow, hasRunningBgShells } from "./tools.js";
 import { bus } from "../bus.js";
 /**
  * SYSTEM_TEMPLATE must stay byte-identical across every request of a session:
@@ -884,6 +884,13 @@ export class Agent {
         if (this.bgExits.length > 32)
             this.bgExits.shift(); // cap runaway spam
         bus.emit("update", { kind: "agent-update", agentId: this.opts.id });
+        // the round ended BECAUSE this job was running (auto-continue is
+        // suppressed while bg jobs are alive) — its exit IS the wake-up call.
+        // Without this the report would sit unread until the operator poked
+        // the agent. Stopped agents stay stopped (a deliberate human stop).
+        if (this.status === "idle" && !this.stopRequested) {
+            this.start(`background job ${info.id} finished`);
+        }
     }
     /** fold queued background-exit reports into the next LLM call (once each) */
     drainBackgroundExits() {
@@ -994,6 +1001,19 @@ export class Agent {
                 // fresh user input arrived while we were finishing up — another round now
                 if (this.pendingPrompts.length)
                     continue;
+                // A round that parked its work on a background bash (dev server,
+                // watcher, long build) ENDED ON PURPOSE — the job's exit notification
+                // is the wake-up. Nagging with "continue working" here just made the
+                // agent spin up duplicate work while it meant to wait. Checked BEFORE
+                // the finished/goal gates: a finish(goalComplete=false) round that
+                // leaves a bg job running is exactly the "wait for it" pattern.
+                if (hasRunningBgShells(this.toolCtx.cwd)) {
+                    await this.log.append("system_note", this.currentSession, this.currentBranch, {
+                        event: "auto-continue-suppressed",
+                        reason: "background job still running — the agent resumes when it exits",
+                    });
+                    break;
+                }
                 // auto-continue only makes sense with an active goal to continue toward
                 if (finished ||
                     !this.opts.autoContinue ||

package/dist/agent/tools.js

@@ -109,6 +109,26 @@ export function isContextOverflow(err) {
     const msg = String(err?.message ?? "").toLowerCase();
     return (/context (length|window|limit)|too many tokens|prompt is too long|max.{0,12}tokens.{0,20}(exceed|surpass)|request too large|payload too large|exceeds.{0,20}limit/.test(msg) || /\b(400|413)\b.*token/.test(msg));
 }
+/** Any background shell still running for this workspace? The auto-continue
+ *  loop consults this before nudging a finished round: an agent that parked
+ *  its work on `bash(background=true)` — dev server, watcher, long build —
+ *  must NOT be nagged with "Continue working toward the current goal". The
+ *  job's exit notification will wake the agent on its own. */
+export function hasRunningBgShells(cwd) {
+    const m = bgShellsByWs.get(cwd);
+    if (!m)
+        return false;
+    for (const sh of m.values()) {
+        // opportunistic cleanup mirrors startBackgroundShell's
+        if (sh.exited && Date.now() - sh.startedAt > 30 * 60_000) {
+            m.delete(sh.id);
+            continue;
+        }
+        if (!sh.exited)
+            return true;
+    }
+    return false;
+}
 /** Run a command in its own process group; kill the whole group on timeout. */
 function runShell(cmd, ctx, timeoutMs) {
     return new Promise((resolve) => {

package/dist/index.js

@@ -31,6 +31,33 @@ async function main() {
         console.log("  env: TEAPOT_PORT, TEAPOT_HOST, TEAPOT_CONFIG_DIR, TEAPOT_DATA_DIR, TEAPOT_API_TOKEN");
         return;
     }
+    // Handle restart-from-old-process: if we're the new process spawned by a
+    // live update, wait for the old process to release the port and exit.
+    const restartFromPid = process.env.TEAPOT_RESTART_FROM
+        ? parseInt(process.env.TEAPOT_RESTART_FROM, 10)
+        : null;
+    if (restartFromPid && !Number.isNaN(restartFromPid)) {
+        // Give the old process time to gracefully shut down and release the port
+        console.log(`[teapot] restart: waiting for old process ${restartFromPid} to exit...`);
+        try {
+            // Send SIGTERM to old process (it handles graceful shutdown)
+            process.kill(restartFromPid, "SIGTERM");
+            // Wait for it to exit (max 5 seconds)
+            for (let i = 0; i < 50; i++) {
+                try {
+                    process.kill(restartFromPid, 0); // check if alive
+                    await new Promise((r) => setTimeout(r, 100));
+                }
+                catch {
+                    // Process no longer exists
+                    break;
+                }
+            }
+        }
+        catch {
+            // Old process might already be gone
+        }
+    }
     const configPath = resolveConfigPath(cfgArg);
     const configExisted = existsSync(configPath);
     const config = loadConfig(configPath);
@@ -57,12 +84,16 @@ async function main() {
     process.on("unhandledRejection", (err) => {
         console.error("[teapot] unhandled rejection (master survived):", err);
     });
-    const shutdown = async () => {
-        console.log("\n[teapot] shutting down...");
+    let shuttingDown = false;
+    const shutdown = async (signal) => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        console.log(`\n[teapot] shutting down${signal ? ` (${signal})` : ""}...`);
         await Promise.allSettled([...master.agents.values()].map((a) => a.dispose()));
         process.exit(0);
     };
-    process.on("SIGINT", () => void shutdown());
-    process.on("SIGTERM", () => void shutdown());
+    process.on("SIGINT", () => void shutdown("SIGINT"));
+    process.on("SIGTERM", () => void shutdown("SIGTERM"));
 }
 void main();

package/dist/master.js

@@ -8,6 +8,7 @@ import { randomUUID } from "node:crypto";
 import path from "node:path";
 import os from "node:os";
 import { fileURLToPath } from "node:url";
+import { spawn } from "node:child_process";
 import { Agent } from "./agent/agent.js";
 import { parseSchedule, matches, nextFireAt } from "./scheduler/cron.js";
 import { bus } from "./bus.js";
@@ -966,6 +967,11 @@ When this task is done (or truly blocked), call finish() with a summary for @${p
         if (!llm.baseUrl)
             throw new Error("no baseUrl resolved");
         agent.setLlmConfig(llm);
+        // keep the snapshot's provider in sync — the UI's model switcher reads
+        // sel().provider, and the old code only updated the config entry (ac)
+        // so the live snapshot kept the stale provider (the "right panel model
+        // switching doesn't work" backend half).
+        agent.opts.provider = effectiveProvider;
         const ac = this.config.agents.find((a) => a.id === id);
         if (ac && providerName)
             ac.provider = providerName;
@@ -1069,4 +1075,53 @@ When this task is done (or truly blocked), call finish() with a summary for @${p
             })),
         };
     }
+    /** Current application version (injected at build time via package.json). */
+    static VERSION = "__APP_VERSION__";
+    /** Return the current server version. */
+    getVersion() {
+        return Master.VERSION;
+    }
+    /** Gracefully stop all agents with a timeout. Returns when all are stopped or timeout. */
+    async stopAllAgents(timeoutMs = 30_000) {
+        console.log(`[teapot] stopping all ${this.agents.size} agents...`);
+        const ids = [...this.agents.keys()];
+        const stopPromises = ids.map(async (id) => {
+            const a = this.agents.get(id);
+            if (!a)
+                return;
+            try {
+                await a.dispose();
+            }
+            catch (err) {
+                console.error("[teapot] dispose error:", err);
+            }
+            // remove from map so a re-spawn after restart doesn't carry state
+            this.agents.delete(id);
+        });
+        const timeout = new Promise((_, reject) => setTimeout(() => reject(new Error("agent stop timeout")), timeoutMs));
+        await Promise.race([Promise.all(stopPromises), timeout]);
+        console.log("[teapot] all agents stopped");
+    }
+    /** Restart the server process (spawns a new master, keeps this one alive until ready). */
+    async restartServer() {
+        console.log("[teapot] restarting server...");
+        // Stop all agents first
+        await this.stopAllAgents(30_000);
+        // Spawn a new process that will become the new master
+        // We keep THIS process alive until the new one is ready to accept connections
+        const execPath = process.execPath;
+        const args = process.argv.slice(1);
+        const env = { ...process.env };
+        // Tell the new process it's a restart (it will read the version from the old one)
+        env.TEAPOT_RESTART_FROM = String(process.pid);
+        const child = spawn(execPath, args, {
+            detached: true,
+            stdio: "ignore",
+            env,
+        });
+        child.unref(); // Let the parent exit when ready
+        // Give the new process time to start and bind the port
+        // This process will exit when the new one takes over (SIGTERM handled in index.ts)
+        await new Promise((r) => setTimeout(r, 1_000));
+    }
 }

package/dist/server/api.js

@@ -556,6 +556,7 @@ export function buildApp(master) {
             maxSpawnDepth: master.config.maxSpawnDepth,
             tasks: master.config.tasks,
             agents: master.config.agents.map((a) => ({ id: a.id, workspace: a.workspace, provider: a.provider, model: a.model })),
+            version: master.getVersion(),
         });
     });
     app.put("/api/config", async (c) => {
@@ -871,6 +872,23 @@ export function buildApp(master) {
         return c.json({ ok: true });
     });
     // edit a previously-sent prompt: forks there, optionally summarizes the tail
+    app.post("/api/agents/:id/edit-prompt", async (c) => {
+        const a = master.agents.get(c.req.param("id"));
+        if (!a)
+            return c.json({ error: "not found" }, 404);
+        const body = await c.req
+            .json()
+            .catch(() => null);
+        if (!body?.eventId || !body.text?.trim())
+            return c.json({ error: "eventId and text required" }, 400);
+        try {
+            const r = await a.editPromptAt(body.eventId, body.text, body.tail === "summarize" ? "summarize" : "discard");
+            return c.json({ ok: true, ...r });
+        }
+        catch (err) {
+            return c.json({ error: err.message }, 409);
+        }
+    });
     app.post("/api/agents/:id/fork", async (c) => {
         const a = master.agents.get(c.req.param("id"));
         if (!a)
@@ -964,6 +982,18 @@ export function buildApp(master) {
     });
     // ---- metrics / SSE ----
     app.get("/api/metrics", (c) => c.json(master.metrics()));
+    // current server version (for live-update polling)
+    app.get("/api/version", (c) => c.json({ version: master.getVersion() }));
+    // trigger a full server restart (agents stopped gracefully, new process spawned)
+    app.post("/api/update/restart", async (c) => {
+        try {
+            await master.restartServer();
+            return c.json({ ok: true });
+        }
+        catch (err) {
+            return c.json({ error: err.message }, 500);
+        }
+    });
     // scheduled tasks with computed next-fire times (cron visibility for the UI)
     app.get("/api/tasks", (c) => c.json({ tasks: master.tasksView() }));
     app.get("/api/events", (c) => {

package/package.json

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