@livx.cc/agentx 0.99.41 → 0.99.42

package/dist/cli.js

@@ -2179,7 +2179,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,
@@ -2218,9 +2218,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;
@@ -2251,6 +2254,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;
@@ -2283,6 +2298,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}
@@ -2422,6 +2443,41 @@ var init_tools_shell = __esm({
       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", (err2) => {
+          if (job.status === "running") {
+            job.status = "error";
+            append(`
+[error] ${err2?.message ?? err2}`);
+            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;