@livx.cc/agentx 0.99.41 → 0.99.42

package/dist/tools.shell.d.ts

@@ -141,6 +141,14 @@ declare class ShellJobRegistry {
         command: string;
         status: JobStatus;
     }>;
+    /**
+     * Take over an ALREADY-RUNNING child as a background job. A foreground command that outruns its
+     * timeout is not necessarily a hung command — killing it throws away work that was nearly done and,
+     * worse, a launcher that spawned its own detached worker leaves that worker running with nothing
+     * tracking it. Adopting hands the model a handle instead: the command keeps going, its completion
+     * is reported like any other job, and `seed` carries the output produced before the handoff.
+     */
+    adopt(command: string, proc: SpawnedProcess, seed?: string): string;
     kill(id: string): boolean;
     killAll(): void;
 }

package/dist/tools.shell.js

@@ -650,6 +650,41 @@ var ShellJobRegistry = class {
   list() {
     return [...this.jobs].map(([id, j]) => ({ id, command: j.command, status: j.status }));
   }
+  /**
+   * Take over an ALREADY-RUNNING child as a background job. A foreground command that outruns its
+   * timeout is not necessarily a hung command — killing it throws away work that was nearly done and,
+   * worse, a launcher that spawned its own detached worker leaves that worker running with nothing
+   * tracking it. Adopting hands the model a handle instead: the command keeps going, its completion
+   * is reported like any other job, and `seed` carries the output produced before the handoff.
+   */
+  adopt(command, proc, seed = "") {
+    const id = `job-${++this.seq}`;
+    const max = this.cfg.maxBuffer ?? 256 * 1024;
+    const job = { command, buf: seed.slice(-max), status: "running", proc };
+    const append = (chunk) => {
+      const s = typeof chunk === "string" ? chunk : chunk?.toString?.("utf8") ?? "";
+      job.buf = (job.buf + s).slice(-max);
+    };
+    proc.stdout?.on("data", append);
+    proc.stderr?.on("data", append);
+    proc.on("error", (err) => {
+      if (job.status === "running") {
+        job.status = "error";
+        append(`
+[error] ${err?.message ?? err}`);
+        this.notifyExit(id, job);
+      }
+    });
+    proc.on("close", (code) => {
+      if (job.status === "running") {
+        job.status = "exited";
+        job.exitCode = code ?? void 0;
+        this.notifyExit(id, job);
+      }
+    });
+    this.jobs.set(id, job);
+    return id;
+  }
   kill(id) {
     const j = this.jobs.get(id);
     if (!j) return false;
@@ -698,7 +733,7 @@ function makeRealShellTool(options) {
       return { ...this, description: rebound.description, run: rebound.run, withCwd: rebound.withCwd };
     },
     get description() {
-      return `Run a shell command via /bin/sh in the working directory. Executes any installed binary \u2014 ls, cat, grep, git, bun, node, curl, scripts, etc. Returns combined stdout+stderr; non-zero exits are prefixed \`[exit N]\`. Runs non-interactively with no terminal (stdin is /dev/null): commands that prompt for input fail fast rather than hang \u2014 for privileged actions use a non-interactive flag (e.g. \`sudo -n\`), or ask the user to run the command themselves. Each command is killed after ${defaultTimeoutMs}ms (result \`[exit 124]\` with whatever output it produced) \u2014 pass \`timeoutMs\` (max ${maxTimeoutMs}) for a legitimately slower command, and always bound network commands yourself (e.g. \`curl -m 10\`). ` + backgroundDoc();
+      return "Run a shell command via /bin/sh in the working directory. Executes any installed binary \u2014 ls, cat, grep, git, bun, node, curl, scripts, etc. Returns combined stdout+stderr; non-zero exits are prefixed `[exit N]`. Runs non-interactively with no terminal (stdin is /dev/null): commands that prompt for input fail fast rather than hang \u2014 for privileged actions use a non-interactive flag (e.g. `sudo -n`), or ask the user to run the command themselves. " + (options.registry?.adopt ? `A command still running after ${defaultTimeoutMs}ms is NOT killed \u2014 it is handed to a background job and you get its id, so you can keep checking on it (\`[still running]\`). Pass \`timeoutMs\` (max ${maxTimeoutMs}) to wait longer in the foreground, and always bound network commands yourself (e.g. \`curl -m 10\`). ` : `Each command is killed after ${defaultTimeoutMs}ms (result \`[exit 124]\` with whatever output it produced) \u2014 pass \`timeoutMs\` (max ${maxTimeoutMs}) for a legitimately slower command, and always bound network commands yourself (e.g. \`curl -m 10\`). `) + backgroundDoc();
     },
     // Declared so transports above the agent loop can size their own deadline with headroom (see AgentTool.maxDurationMs).
     maxDurationMs: maxTimeoutMs,
@@ -737,9 +772,12 @@ function makeRealShellTool(options) {
         else ctx.signal.addEventListener("abort", onAbort, { once: true });
       }
       let timedOut = false;
-      const timer = setTimeout(() => {
+      let onDeadline = () => {
         timedOut = true;
         ctl.abort();
+      };
+      const timer = setTimeout(() => {
+        onDeadline();
       }, timeoutMs);
       let pend = "";
       let flushTimer = null;
@@ -770,6 +808,18 @@ function makeRealShellTool(options) {
           }
           if (ctl.signal.aborted) killGroup(proc, "SIGKILL");
           else ctl.signal.addEventListener("abort", () => killGroup(proc, "SIGKILL"), { once: true });
+          const registry = options.registry;
+          if (registry?.adopt) {
+            onDeadline = () => {
+              timedOut = true;
+              if (settled) return;
+              flushEmit(ctx);
+              proc.stdout?.off?.("data", collect);
+              proc.stderr?.off?.("data", collect);
+              const id = registry.adopt(cmd, proc, out);
+              finish(handoffFor(timeoutMs, id, clean(out), !!registry.notifiesOnExit));
+            };
+          }
           const collect = (chunk) => {
             const s = typeof chunk === "string" ? chunk : chunk?.toString?.("utf8") ?? "";
             out += s;
@@ -802,6 +852,12 @@ function makeRealShellTool(options) {
     }
   };
 }
+function handoffFor(timeoutMs, id, body, notifies) {
+  const head = `[still running] exceeded ${timeoutMs}ms, so it was handed to background job ${id} \u2014 NOT killed, it is still going. Check on it with ShellOutput({id:"${id}"}) / ShellStatus({id:"${id}"}), stop it with ShellKill({id:"${id}"}). ` + (notifies ? "Its completion will be reported to you, so you may continue with other work meanwhile." : "Nothing will tell you when it finishes \u2014 poll it yourself before you rely on its result.");
+  return body ? `${head}
+Output so far:
+${body}` : head;
+}
 function reasonFor(timedOut, timeoutMs, body) {
   const head = timedOut ? `[exit 124] timed out after ${timeoutMs}ms (killed). Re-running this command unchanged will time out again. Either re-run it with background:true (returns a job id immediately; poll with ShellOutput/ShellStatus, stop with ShellKill) or narrow it so it can finish \u2014 bound it, scope it, or ask for less.` : "[exit 130] cancelled (killed)";
   return body ? `${head}