@livx.cc/agentx 0.94.38

package/dist/tools.shell.js

@@ -0,0 +1,539 @@
+// src/tools.ts
+import { CommandExecutor, registerHeadlessCommands } from "@livx.cc/wcli/core";
+
+// src/redact.ts
+var REDACTED = "\u2039redacted\u203A";
+var SECRET_PAIR = /((?:^|[\s,{[])(?:export\s+)?["']?[\w.\-]*(?:KEY|TOKEN|SECRET|PASSWORD|PASSWD|CREDENTIAL|PRIVATE_KEY|ACCESS_?KEY|AUTH(?:_?TOKEN)?|BEARER)[\w.\-]*["']?\s*[:=]\s*)(["']?)([^\s"',{}\]]+)/gi;
+var SECRET_TOKEN = /\b(sk-ant-[\w-]{12,}|sk-[A-Za-z0-9]{20,}|ghp_[A-Za-z0-9]{20,}|gho_[A-Za-z0-9]{20,}|github_pat_[\w]{20,}|xox[baprs]-[\w-]{10,}|AKIA[0-9A-Z]{12,}|AIza[\w-]{20,}|eyJ[\w-]{8,}\.[\w-]{8,}\.[\w-]{8,})\b/g;
+function redactSecrets(text) {
+  if (!text) return text;
+  return text.replace(SECRET_PAIR, (_m, head, quote, _val) => `${head}${quote}${REDACTED}`).replace(SECRET_TOKEN, REDACTED);
+}
+
+// src/logging.ts
+import { log } from "libx.js/src/modules/log";
+var forComponent = (name) => log.forComponent(name);
+
+// src/tools.web.ts
+var log2 = forComponent("web");
+function htmlToText(html) {
+  let s = html.replace(/<script[\s\S]*?<\/script>/gi, " ").replace(/<style[\s\S]*?<\/style>/gi, " ").replace(/<title[\s\S]*?<\/title>/gi, " ").replace(/<noscript[\s\S]*?<\/noscript>/gi, " ").replace(/<textarea[\s\S]*?<\/textarea>/gi, " ").replace(/<!--[\s\S]*?-->/g, " ").replace(/<\/(p|div|li|h[1-6]|tr|section|article|header|footer|nav)>/gi, "\n").replace(/<br\s*\/?>/gi, "\n").replace(/<[^>]+>/g, " ");
+  s = s.replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#0?39;/g, "'").replace(/&#x27;/gi, "'");
+  return s.replace(/[ \t\f\v]+/g, " ").split("\n").map((l) => l.trim()).join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+function isPrivateHost(host) {
+  const h = host.toLowerCase().replace(/^\[|\]$/g, "");
+  if (h === "" || h === "localhost" || h.endsWith(".localhost") || h.endsWith(".internal")) return true;
+  if (h === "::1" || h === "::" || h.startsWith("fe80:") || h.startsWith("fc") || h.startsWith("fd")) return true;
+  const m = h.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
+  if (m) {
+    const a = +m[1], b = +m[2];
+    return a === 0 || a === 127 || a === 10 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168 || a === 100 && b >= 64 && b <= 127;
+  }
+  return false;
+}
+var _dnsLookup;
+async function resolveIps(host) {
+  if (_dnsLookup === void 0) {
+    try {
+      _dnsLookup = (await import("dns/promises")).lookup;
+    } catch {
+      _dnsLookup = null;
+    }
+  }
+  if (!_dnsLookup) return null;
+  try {
+    return (await _dnsLookup(host, { all: true })).map((a) => a.address);
+  } catch {
+    return null;
+  }
+}
+async function readCapped(res, maxBytes) {
+  const reader = res.body?.getReader?.();
+  if (!reader) {
+    const t = await res.text();
+    return t.length > maxBytes ? t.slice(0, maxBytes) : t;
+  }
+  const chunks = [];
+  let total = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    if (value) {
+      chunks.push(value);
+      total += value.length;
+    }
+    if (total >= maxBytes) {
+      try {
+        await reader.cancel();
+      } catch {
+      }
+      break;
+    }
+  }
+  const out = new Uint8Array(Math.min(total, maxBytes));
+  let off = 0;
+  for (const c of chunks) {
+    if (off >= out.length) break;
+    const take = Math.min(c.length, out.length - off);
+    out.set(c.subarray(0, take), off);
+    off += take;
+  }
+  return new TextDecoder().decode(out);
+}
+function makeWebFetchTool(options = {}) {
+  const maxBytes = options.maxBytes ?? 2e6;
+  const maxChars = options.maxChars ?? 1e5;
+  const timeoutMs = options.timeoutMs ?? 15e3;
+  return {
+    name: "WebFetch",
+    description: "Fetch an http/https URL and return its readable text (HTML is stripped to text). Use to read docs or web pages. Returns the status line then up to ~100k chars of content.",
+    parameters: { type: "object", required: ["url"], properties: { url: { type: "string", description: "absolute http(s) URL" } } },
+    async run({ url }) {
+      const doFetch = options.fetch ?? globalThis.fetch;
+      const customFetch = !!options.fetch;
+      const u = String(url ?? "");
+      try {
+        new URL(u);
+      } catch {
+        return `Error: invalid URL: ${u}`;
+      }
+      if (!doFetch) return "Error: no network (fetch) available in this runtime";
+      const hostBlock = async (hostname) => {
+        if (options.allowPrivateHosts) return null;
+        if (isPrivateHost(hostname)) return hostname;
+        if (!customFetch) {
+          const ips = await resolveIps(hostname);
+          if (ips) {
+            for (const ip of ips) if (isPrivateHost(ip)) return `${hostname} \u2192 ${ip}`;
+          }
+        }
+        return null;
+      };
+      const ctl = new AbortController();
+      const timer = setTimeout(() => ctl.abort(), timeoutMs);
+      try {
+        let current = u;
+        let res;
+        for (let hop = 0; ; hop++) {
+          const pu = new URL(current);
+          if (pu.protocol !== "http:" && pu.protocol !== "https:") return `Error: only http/https URLs are allowed (got "${pu.protocol}")`;
+          const blocked = await hostBlock(pu.hostname);
+          if (blocked) return `Error: refusing to fetch a private/internal address (${blocked}) \u2014 set allowPrivateHosts to override`;
+          res = await doFetch(current, { signal: ctl.signal, redirect: "manual", headers: { "user-agent": "agentx (+https://github.com/Livshitz/agentx)" } });
+          if (res.status >= 300 && res.status < 400 && res.headers.get("location")) {
+            if (hop >= 5) return `Error fetching ${u}: too many redirects`;
+            current = new URL(res.headers.get("location"), current).toString();
+            continue;
+          }
+          break;
+        }
+        const type = res.headers.get("content-type") ?? "";
+        const body = await readCapped(res, maxBytes);
+        const text = /html/i.test(type) || /^\s*<(?:!doctype|html)/i.test(body) ? htmlToText(body) : body.trim();
+        const capped = text.length > maxChars ? text.slice(0, maxChars) + `
+\u2026 [truncated at ${maxChars} chars]` : text;
+        return `${res.status} ${res.statusText} \xB7 ${new URL(current).host}
+
+${capped}`;
+      } catch (e) {
+        log2.debug(`WebFetch ${u} failed`, e);
+        return `Error fetching ${u}: ${e?.name === "AbortError" ? `timed out after ${timeoutMs}ms` : e?.message ?? e}`;
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+  };
+}
+function decodeDdgUrl(href) {
+  const m = href.match(/[?&]uddg=([^&]+)/);
+  if (m) {
+    try {
+      return decodeURIComponent(m[1]);
+    } catch {
+    }
+  }
+  return href.startsWith("//") ? "https:" + href : href;
+}
+function parseDdgHtml(html, max) {
+  const anchors = [...html.matchAll(/<a[^>]*class="[^"]*result__a[^"]*"[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/g)];
+  const snippets = [...html.matchAll(/<a[^>]*class="[^"]*result__snippet[^"]*"[^>]*>([\s\S]*?)<\/a>/g)].map((m) => htmlToText(m[1]));
+  const hits = [];
+  for (let i = 0; i < anchors.length && hits.length < max; i++) {
+    const url = decodeDdgUrl(anchors[i][1]);
+    try {
+      if (isPrivateHost(new URL(url).hostname)) continue;
+    } catch {
+      continue;
+    }
+    hits.push({ title: htmlToText(anchors[i][2]) || "(untitled)", url, snippet: snippets[i] ?? "" });
+  }
+  return hits;
+}
+function formatHits(hits) {
+  if (!hits.length) return "(no results)";
+  return hits.map((r, i) => `${i + 1}. ${r.title}
+   ${r.url}
+   ${r.snippet.replace(/\s+/g, " ").slice(0, 240)}`).join("\n\n");
+}
+function makeWebSearchTool(options = {}) {
+  const tavilyEndpoint = options.endpoint ?? "https://api.tavily.com/search";
+  const maxResults = options.maxResults ?? 5;
+  const timeoutMs = options.timeoutMs ?? 15e3;
+  return {
+    name: "WebSearch",
+    description: "Search the web by query; returns ranked results (title, URL, snippet). Use to look things up, find pages, or research a topic \u2014 then WebFetch a result URL to read it in full.",
+    parameters: { type: "object", required: ["query"], properties: { query: { type: "string" } } },
+    async run({ query }) {
+      const doFetch = options.fetch ?? globalThis.fetch;
+      if (!doFetch) return "Error: no network (fetch) available in this runtime";
+      const q = String(query ?? "").trim();
+      if (!q) return "Error: empty query";
+      const key = options.apiKey ?? process.env.TAVILY_API_KEY;
+      const provider = options.provider ?? "auto";
+      const useTavily = provider === "tavily" || provider === "auto" && !!key;
+      const ctl = new AbortController();
+      const timer = setTimeout(() => ctl.abort(), timeoutMs);
+      try {
+        if (useTavily) {
+          if (!key) return "Error: Tavily provider selected but TAVILY_API_KEY is not set";
+          const res2 = await doFetch(tavilyEndpoint, {
+            method: "POST",
+            signal: ctl.signal,
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ api_key: key, query: q, max_results: maxResults })
+          });
+          if (!res2.ok) return `Error: search provider returned ${res2.status} ${res2.statusText}`;
+          const data = await res2.json();
+          const results = Array.isArray(data?.results) ? data.results.slice(0, maxResults) : [];
+          return formatHits(results.map((r) => ({ title: r.title ?? "(untitled)", url: r.url ?? "", snippet: String(r.content ?? "") })));
+        }
+        const res = await doFetch("https://html.duckduckgo.com/html/?q=" + encodeURIComponent(q), {
+          signal: ctl.signal,
+          headers: { "user-agent": "Mozilla/5.0 (compatible; agentx/1.0; +https://github.com/Livshitz/agentx)" }
+        });
+        if (!res.ok) return `Error: search returned ${res.status} ${res.statusText}`;
+        return formatHits(parseDdgHtml(await res.text(), maxResults));
+      } catch (e) {
+        log2.debug("WebSearch failed", e);
+        return `Error searching: ${e?.name === "AbortError" ? `timed out after ${timeoutMs}ms` : e?.message ?? e}`;
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+  };
+}
+var webFetchTool = makeWebFetchTool();
+var webSearchTool = makeWebSearchTool();
+
+// src/tools.ts
+function truncateOutput(s, headLines = 80, tailLines = 20) {
+  const lines = s.split("\n");
+  if (lines.length <= headLines + tailLines + 1) return s;
+  const omitted = lines.length - headLines - tailLines;
+  return [...lines.slice(0, headLines), `\u2026 (${omitted} lines omitted \u2014 narrow the command to see more) \u2026`, ...lines.slice(-tailLines)].join("\n");
+}
+
+// src/shell.sandbox.ts
+var OsSandboxOptions = class {
+  /** Allow outbound network. Default OFF (Tier-1: no network unless granted). */
+  network = false;
+  /** Extra absolute paths writable beyond cwd + tmp (e.g. a build cache). */
+  writePaths = [];
+};
+function writable(cwd, o, tmpDir) {
+  const set = /* @__PURE__ */ new Set([cwd, "/tmp", "/private/tmp", "/private/var/folders", "/dev", ...tmpDir ? [tmpDir] : [], ...o.writePaths]);
+  return [...set];
+}
+var sbQuote = (p) => `"${p.replace(/(["\\])/g, "\\$1")}"`;
+function seatbeltProfile(cwd, o, tmpDir) {
+  const allows = writable(cwd, o, tmpDir).map((p) => `(subpath ${sbQuote(p)})`).join(" ");
+  return [
+    "(version 1)",
+    "(allow default)",
+    ...o.network ? [] : ["(deny network*)"],
+    "(deny file-write*)",
+    `(allow file-write* ${allows})`
+  ].join("\n");
+}
+function sandboxArgv(command, cwd, opts = {}, platform = process.platform, tmpDir) {
+  const o = { ...new OsSandboxOptions(), ...opts };
+  if (platform === "darwin") {
+    return { bin: "/usr/bin/sandbox-exec", args: ["-p", seatbeltProfile(cwd, o, tmpDir), "/bin/sh", "-c", command] };
+  }
+  if (platform === "linux") {
+    const binds = writable(cwd, o, tmpDir).filter((p) => p !== "/dev" && !p.startsWith("/private")).flatMap((p) => ["--bind-try", p, p]);
+    return {
+      bin: "bwrap",
+      args: ["--ro-bind", "/", "/", ...binds, "--dev", "/dev", "--proc", "/proc", "--die-with-parent", ...o.network ? [] : ["--unshare-net"], "/bin/sh", "-c", command]
+    };
+  }
+  return null;
+}
+async function findSandboxWrapper(platform = process.platform) {
+  const { existsSync } = await import("fs");
+  if (platform === "darwin") return existsSync("/usr/bin/sandbox-exec") ? "/usr/bin/sandbox-exec" : null;
+  if (platform === "linux") {
+    for (const dir of (process.env.PATH ?? "/usr/bin:/bin").split(":")) if (dir && existsSync(`${dir}/bwrap`)) return `${dir}/bwrap`;
+    return null;
+  }
+  return null;
+}
+
+// src/tools.shell.ts
+var log3 = forComponent("shell");
+var clean = (s) => truncateOutput(redactSecrets(s.replace(/\n+$/, "")));
+var DETACHED = { stdio: ["ignore", "pipe", "pipe"], detached: true };
+function killGroup(proc, signal) {
+  if (!proc?.pid) return false;
+  try {
+    process.kill(-proc.pid, signal);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function spawnArgvFor(command, cwd, osSandbox) {
+  if (!osSandbox) return { bin: "/bin/sh", args: ["-c", command] };
+  const opts = osSandbox === true ? {} : osSandbox;
+  const wrapper = await findSandboxWrapper();
+  const wrapped = wrapper ? sandboxArgv(command, cwd, opts, process.platform, process.env.TMPDIR) : null;
+  if (!wrapped) throw new Error(`OS sandbox requested but no wrapper available on ${process.platform} (need sandbox-exec or bwrap)`);
+  return wrapped;
+}
+var SECRET_ENV_RE = /(_API_KEY|_TOKEN|_SECRET|_PASSWORD|_PRIVATE_KEY|^AWS_|^GITHUB_TOKEN$|^OPENAI_|^ANTHROPIC_|^GOOGLE_|^GEMINI_|^GROQ_|^NPM_TOKEN$)/i;
+function childEnv(opts) {
+  const base = {};
+  const redact = opts.redactEnv !== false;
+  for (const [k, v] of Object.entries(process.env)) if (!(redact && SECRET_ENV_RE.test(k))) base[k] = v;
+  return { ...base, ...opts.env };
+}
+var _spawn;
+async function nodeSpawn() {
+  if (!_spawn) _spawn = (await import("child_process")).spawn;
+  return _spawn;
+}
+var ShellJobRegistry = class {
+  constructor(cfg) {
+    this.cfg = cfg;
+    if (cfg.killOnExit && typeof process !== "undefined") process.once("exit", () => this.killAll());
+  }
+  cfg;
+  jobs = /* @__PURE__ */ new Map();
+  seq = 0;
+  async start(command) {
+    const id = `job-${++this.seq}`;
+    const max = this.cfg.maxBuffer ?? 256 * 1024;
+    const job = { command, buf: "", status: "running" };
+    const append = (chunk) => {
+      const s = typeof chunk === "string" ? chunk : chunk?.toString?.("utf8") ?? "";
+      job.buf = (job.buf + s).slice(-max);
+    };
+    try {
+      const spawn = this.cfg.spawn ?? await nodeSpawn();
+      const argv = this.cfg.osSandbox ? await spawnArgvFor(command, this.cfg.cwd, this.cfg.osSandbox) : { bin: "/bin/sh", args: ["-c", command] };
+      const proc = spawn(argv.bin, argv.args, { cwd: this.cfg.cwd, env: childEnv(this.cfg), ...DETACHED });
+      job.proc = proc;
+      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}`);
+        }
+      });
+      proc.on("close", (code) => {
+        if (job.status === "running") {
+          job.status = "exited";
+          job.exitCode = code ?? void 0;
+        }
+      });
+    } catch (e) {
+      job.status = "error";
+      job.buf = `failed to spawn: ${e?.message ?? e}`;
+    }
+    this.jobs.set(id, job);
+    return id;
+  }
+  /** Current tail output for a job (null = no such job). */
+  output(id) {
+    return this.jobs.get(id)?.buf ?? (this.jobs.has(id) ? "" : null);
+  }
+  status(id) {
+    const j = this.jobs.get(id);
+    return j ? { status: j.status, exitCode: j.exitCode, bytes: j.buf.length } : null;
+  }
+  list() {
+    return [...this.jobs].map(([id, j]) => ({ id, command: j.command, status: j.status }));
+  }
+  kill(id) {
+    const j = this.jobs.get(id);
+    if (!j) return false;
+    if (j.status === "running") {
+      if (!killGroup(j.proc, "SIGTERM")) {
+        try {
+          j.proc?.kill("SIGTERM");
+        } catch {
+        }
+      }
+      j.status = "killed";
+    }
+    return true;
+  }
+  killAll() {
+    for (const id of this.jobs.keys()) this.kill(id);
+  }
+};
+function makeRealShellTool(options) {
+  const timeoutMs = options.timeoutMs ?? 12e4;
+  return {
+    name: "Shell",
+    description: "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. Set `background:true` for long-running processes (servers, watchers) \u2014 returns a job id immediately; poll with ShellOutput, stop with ShellKill.",
+    parameters: {
+      type: "object",
+      required: ["command"],
+      properties: {
+        command: { type: "string", description: "the shell command line to execute" },
+        background: { type: "boolean", description: "run detached and return a job id immediately (for servers/watchers/long builds)" }
+      }
+    },
+    async run({ command, background }, ctx) {
+      const cmd = String(command ?? "");
+      if (!cmd.trim()) return "[exit 1] empty command";
+      if (background) {
+        if (!options.registry) return "Error: background execution is not enabled in this host (no job registry).";
+        const id = await options.registry.start(cmd);
+        return `Started background job ${id}. Poll output with ShellOutput({id:"${id}"}), check ShellStatus({id:"${id}"}), stop with ShellKill({id:"${id}"}).`;
+      }
+      const spawn = options.spawn ?? await nodeSpawn();
+      let argv = { bin: options.shell || "/bin/sh", args: ["-c", cmd] };
+      if (options.osSandbox) {
+        try {
+          argv = await spawnArgvFor(cmd, options.cwd, options.osSandbox);
+        } catch (e) {
+          return `[exit 1] ${e?.message ?? e}`;
+        }
+      }
+      const ctl = new AbortController();
+      const onAbort = () => ctl.abort();
+      if (ctx.signal) {
+        if (ctx.signal.aborted) ctl.abort();
+        else ctx.signal.addEventListener("abort", onAbort, { once: true });
+      }
+      let timedOut = false;
+      const timer = setTimeout(() => {
+        timedOut = true;
+        ctl.abort();
+      }, timeoutMs);
+      let pend = "";
+      let flushTimer = null;
+      const flushEmit = (ctx2) => {
+        if (flushTimer) {
+          clearTimeout(flushTimer);
+          flushTimer = null;
+        }
+        if (pend) {
+          ctx2.emit?.(redactSecrets(pend));
+          pend = "";
+        }
+      };
+      try {
+        return await new Promise((resolve) => {
+          let out = "";
+          let settled = false;
+          const finish = (s) => {
+            if (settled) return;
+            settled = true;
+            resolve(s);
+          };
+          let proc;
+          try {
+            proc = spawn(argv.bin, argv.args, { cwd: options.cwd, env: childEnv(options), signal: ctl.signal, ...DETACHED });
+          } catch (e) {
+            return finish(`[exit 1] failed to spawn shell: ${e?.message ?? e}`);
+          }
+          if (ctl.signal.aborted) killGroup(proc, "SIGKILL");
+          else ctl.signal.addEventListener("abort", () => killGroup(proc, "SIGKILL"), { once: true });
+          const collect = (chunk) => {
+            const s = typeof chunk === "string" ? chunk : chunk?.toString?.("utf8") ?? "";
+            out += s;
+            if (ctx.emit && !settled) {
+              pend += s;
+              if (pend.length >= 1024) flushEmit(ctx);
+              else flushTimer ??= setTimeout(() => flushEmit(ctx), 250);
+            }
+          };
+          proc.stdout?.on("data", collect);
+          proc.stderr?.on("data", collect);
+          proc.on("error", (err) => {
+            if (err?.name === "AbortError" || ctl.signal.aborted) return finish(reasonFor(timedOut, timeoutMs, clean(out)));
+            log3.debug("shell spawn error", err);
+            finish(`[exit 1] ${err?.message ?? err}${out ? "\n" + clean(out) : ""}`);
+          });
+          proc.on("close", (code) => {
+            flushEmit(ctx);
+            if (ctl.signal.aborted) return finish(reasonFor(timedOut, timeoutMs, clean(out)));
+            const body = clean(out);
+            if (code && code !== 0) return finish(`[exit ${code}]${body ? "\n" + body : ""}`);
+            finish(body || "(command succeeded, no output)");
+          });
+        });
+      } finally {
+        clearTimeout(timer);
+        if (flushTimer) clearTimeout(flushTimer);
+        ctx.signal?.removeEventListener("abort", onAbort);
+      }
+    }
+  };
+}
+function reasonFor(timedOut, timeoutMs, body) {
+  const head = timedOut ? `[exit 124] timed out after ${timeoutMs}ms (killed)` : "[exit 130] cancelled (killed)";
+  return body ? `${head}
+${body}` : head;
+}
+var NO_JOB = (id) => `Error: no background job '${id}'. Use ShellStatus with no id to list jobs, or start one with Shell({background:true}).`;
+function makeShellJobTools(registry) {
+  const idParam = { type: "object", properties: { id: { type: "string", description: "the job id from Shell({background:true})" } } };
+  return [
+    {
+      name: "ShellOutput",
+      description: "Read the accumulated output (tail) of a background Shell job by id.",
+      parameters: { type: "object", required: ["id"], properties: { id: { type: "string" } } },
+      async run({ id }) {
+        const out = registry.output(String(id));
+        if (out == null) return NO_JOB(String(id));
+        const st = registry.status(String(id));
+        return `[${st.status}${st.exitCode != null ? ` exit ${st.exitCode}` : ""}]
+${clean(out) || "(no output yet)"}`;
+      }
+    },
+    {
+      name: "ShellStatus",
+      description: "Status of a background Shell job (running/exited/killed + exit code). Omit `id` to list all jobs.",
+      parameters: idParam,
+      async run({ id }) {
+        if (!id) {
+          const jobs = registry.list();
+          return jobs.length ? jobs.map((j) => `${j.id}  ${j.status}  ${j.command}`).join("\n") : "(no background jobs)";
+        }
+        const st = registry.status(String(id));
+        return st ? `${st.status}${st.exitCode != null ? ` (exit ${st.exitCode})` : ""} \xB7 ${st.bytes} byte(s) buffered` : NO_JOB(String(id));
+      }
+    },
+    {
+      name: "ShellKill",
+      description: "Stop a running background Shell job by id (SIGTERM).",
+      parameters: { type: "object", required: ["id"], properties: { id: { type: "string" } } },
+      async run({ id }) {
+        return registry.kill(String(id)) ? `Killed job ${id}.` : NO_JOB(String(id));
+      }
+    }
+  ];
+}
+export {
+  ShellJobRegistry,
+  makeRealShellTool,
+  makeShellJobTools
+};
+//# sourceMappingURL=tools.shell.js.map