@agent-commons/cli 0.1.14 → 0.1.17

package/dist/bin.js

@@ -106,7 +106,7 @@ var sym = {
   bullet: import_chalk.default.dim("\u2022"),
   dot: import_chalk.default.dim("\xB7")
 };
-function banner(version = "0.1.14") {
+function banner(version = "0.1.17") {
   const line = import_chalk.default.cyan("  \u2500".padEnd(2) + "\u2500".repeat(44));
   console.log("");
   console.log(line);
@@ -515,7 +515,7 @@ ${sym.ok} Agent created`);
       process.exit(1);
     }
   });
-  const autonomy = cmd.command("autonomy").description("Manage agent heartbeat / autonomy");
+  const autonomy = cmd.command("autonomy").description("Manage agent heartbeat");
   autonomy.command("status").description("Show autonomy status for an agent").requiredOption("--agent <agentId>", "Agent ID").option("--json", "Output as JSON").action(async (opts) => {
     const client = makeClient();
     const spinner = spin("Fetching autonomy status\u2026");
@@ -525,7 +525,7 @@ ${sym.ok} Agent created`);
       const s = res.data;
       if (opts.json) return jsonOut(s);
       console.log(`
-${c.bold("Autonomy Status")}`);
+${c.bold("Heartbeat Status")}`);
       detail([
         ["Enabled", s.enabled ? c.bold("yes") : "no"],
         ["Interval", s.intervalSec ? `${s.intervalSec}s` : "n/a"],
@@ -539,7 +539,7 @@ ${c.bold("Autonomy Status")}`);
       process.exit(1);
     }
   });
-  autonomy.command("enable").description("Enable autonomous heartbeat for an agent").requiredOption("--agent <agentId>", "Agent ID").option("--interval <seconds>", "Heartbeat interval in seconds (min 30)", "300").action(async (opts) => {
+  autonomy.command("enable").description("Enable heartbeat for an agent").requiredOption("--agent <agentId>", "Agent ID").option("--interval <seconds>", "Heartbeat interval in seconds (min 30)", "300").action(async (opts) => {
     const client = makeClient();
     const spinner = spin("Enabling autonomy\u2026");
     try {
@@ -557,7 +557,7 @@ ${sym.ok} Autonomy enabled for agent ${c.id(opts.agent)}`);
       process.exit(1);
     }
   });
-  autonomy.command("disable").description("Disable autonomous heartbeat for an agent").requiredOption("--agent <agentId>", "Agent ID").action(async (opts) => {
+  autonomy.command("disable").description("Disable heartbeat for an agent").requiredOption("--agent <agentId>", "Agent ID").action(async (opts) => {
     const client = makeClient();
     const spinner = spin("Disabling autonomy\u2026");
     try {
@@ -571,7 +571,7 @@ ${sym.ok} Autonomy disabled for agent ${c.id(opts.agent)}`);
       process.exit(1);
     }
   });
-  autonomy.command("trigger").description("Trigger a single heartbeat beat immediately").requiredOption("--agent <agentId>", "Agent ID").action(async (opts) => {
+  autonomy.command("trigger").description("Trigger a single heartbeat immediately").requiredOption("--agent <agentId>", "Agent ID").action(async (opts) => {
     const client = makeClient();
     const spinner = spin("Triggering heartbeat\u2026");
     try {
@@ -1257,6 +1257,13 @@ var import_fs3 = require("fs");
 var import_path3 = require("path");
 var import_child_process2 = require("child_process");
 var readline2 = __toESM(require("readline"));
+var pdfParse = require("pdf-parse/lib/pdf-parse.js");
+var managedProcesses = /* @__PURE__ */ new Map();
+function capBuffer(existing, chunk, maxBytes) {
+  const joined = existing + chunk;
+  if (joined.length <= maxBytes) return joined;
+  return "\u2026(truncated)\n" + joined.slice(-(maxBytes - 20));
+}
 var SKIP_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", ".cache", "__pycache__", ".next", "dist", "build", ".DS_Store"]);
 function buildDirSnapshot(dir, maxDepth = 2) {
   const lines = [`${dir}/`];
@@ -1335,27 +1342,59 @@ ${fileSection}
 
 | Tool | What it does |
 |------|-------------|
-| \`cli_list_directory\` | List files and folders at a path (default: session root) |
-| \`cli_read_file\` | Read the full contents of a file |
+| \`cli_list_directory\` | List files and folders at a path |
+| \`cli_read_file\` | Read a file (PDF and Word docs are extracted to text) |
 | \`cli_write_file\` | Write or overwrite a file (user confirmation required) |
-| \`cli_search_files\` | Find files matching a pattern, e.g. "*.ts" |
-| \`cli_run_command\` | Run a shell command and return output (user confirmation required) |
+| \`cli_search_files\` | Find files matching a pattern |
+| \`cli_run_command\` | Run a short command and return its output (user confirmation required) |
+| \`cli_start_process\` | Start a long-running command in the background; returns a processId immediately |
+| \`cli_wait_for_process\` | Block up to N seconds for a background process, then return current output |
+| \`cli_process_status\` | Instant non-blocking check on a background process |
+| \`cli_kill_process\` | Kill a running background process |
+| \`cli_list_processes\` | List all background processes started this session |
+
+### Choosing between run_command and start_process
+
+| Situation | Use |
+|-----------|-----|
+| Command finishes in under ~30s | \`cli_run_command\` |
+| Command may take minutes (npm install, build, scaffold) | \`cli_start_process\` + \`cli_wait_for_process\` |
+| Command needs live stdin (e.g. a REPL) | \`cli_run_command\` with \`"interactive": true\` |
 
-### Example \u2014 listing a directory
+### run_command options
+- \`timeout_seconds\` (default 120, max 300) \u2014 kill the process after N seconds
+- \`interactive\` (boolean) \u2014 connects the user's terminal stdin for commands that need input
 
-When the user asks "what's on my desktop?", call \`cli_list_directory\` with \`{"path": "Desktop"}\` immediately. Then show the result.
+### start_process + wait_for_process pattern
 
-### Example \u2014 reading a file
+For long commands like \`npx create-next-app@latest my-app --yes\`:
 
-Call \`cli_read_file\` with \`{"path": "Desktop/notes.txt"}\`. Then quote the content in your reply.
+1. Call \`cli_start_process\` \u2014 returns \`{processId, status: "running"}\` immediately. Tell the user it has started.
+2. Call \`cli_wait_for_process\` with \`{"processId": "...", "wait_seconds": 60}\` \u2014 blocks up to 60s then returns current stdout/status. Report progress to the user.
+3. Repeat step 2 until \`status\` is \`"done"\` or \`"error"\`.
+4. Report the final output to the user.
 
-### Example \u2014 writing a file
+Never hold the user in silence. Between each \`cli_wait_for_process\` call, tell them what you saw so far.
 
-Call \`cli_write_file\` with \`{"path": "output.txt", "content": "Hello"}\`. The user will be prompted to confirm.
+### Example \u2014 scaffolding a Next.js project
+
+\`\`\`
+cli_start_process: {"command": "npx", "args": ["create-next-app@latest", "my-app", "--yes"], "cwd": "Desktop"}
+\u2192 {processId: "proc_1a2b", status: "running"}
 
-### Example \u2014 running a command
+Tell user: "Started! Installing dependencies, this takes a minute or two. Checking in 60s\u2026"
 
-Call \`cli_run_command\` with \`{"command": "ls", "args": ["-la"]}\`. The user will be prompted to confirm.
+cli_wait_for_process: {"processId": "proc_1a2b", "wait_seconds": 60}
+\u2192 {status: "running", elapsedSec: 60, stdout: "Creating project...
+Installing packages\u2026"}
+
+Tell user: "Still installing \u2014 here's output so far: [stdout]. Checking again\u2026"
+
+cli_wait_for_process: {"processId": "proc_1a2b", "wait_seconds": 60}
+\u2192 {status: "done", exitCode: 0, elapsedSec: 93, stdout: "Success! Created my-app"}
+
+Tell user: "Done! Project created in Desktop/my-app"
+\`\`\`
 `;
 }
 var TOOL_CALL_RE = /```tool\s*\n([\s\S]*?)\n```/;
@@ -1421,6 +1460,76 @@ async function confirm(message, config, permissionKey) {
     });
   });
 }
+var OFFICE_EXTS = /* @__PURE__ */ new Set([".docx", ".doc", ".rtf", ".odt", ".pages"]);
+var PDF_EXTS = /* @__PURE__ */ new Set([".pdf"]);
+var UNREADABLE_BINARY_EXTS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".bmp",
+  ".ico",
+  ".webp",
+  ".tiff",
+  ".mp3",
+  ".mp4",
+  ".wav",
+  ".aac",
+  ".ogg",
+  ".flac",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".bz2",
+  ".7z",
+  ".rar",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".bin",
+  ".psd",
+  ".ai",
+  ".sketch",
+  ".figma",
+  ".xlsx",
+  ".xls",
+  ".pptx",
+  ".ppt"
+]);
+function extractViaCommand(cmd, cmdArgs) {
+  return new Promise((res) => {
+    (0, import_child_process2.execFile)(cmd, cmdArgs, { timeout: 3e4, maxBuffer: 2 * 1024 * 1024 }, (err, stdout) => {
+      if (err) res("");
+      else res(stdout.trim());
+    });
+  });
+}
+async function extractPdfText(abs) {
+  try {
+    const buffer = (0, import_fs3.readFileSync)(abs);
+    const data = await pdfParse(buffer);
+    const text2 = data.text?.trim();
+    if (text2) {
+      const MAX_CHARS = 15e4;
+      if (text2.length > MAX_CHARS) {
+        return text2.slice(0, MAX_CHARS) + `
+
+[\u2026truncated \u2014 showing first ${MAX_CHARS.toLocaleString()} characters of ${text2.length.toLocaleString()} total]`;
+      }
+      return text2;
+    }
+  } catch {
+  }
+  const text = await extractViaCommand("pdftotext", [abs, "-"]);
+  if (text) return text;
+  return `[Cannot extract PDF text: the file may be scanned/image-only or password-protected]`;
+}
+async function extractOfficeText(abs, ext) {
+  const text = await extractViaCommand("textutil", ["-stdout", "-cat", "txt", abs]);
+  if (text) return text;
+  return `[Cannot extract ${ext} text: textutil failed or is unavailable on this system]`;
+}
 async function toolReadFile(args, cfg) {
   const { path: userPath } = args;
   if (!userPath) throw new Error('read_file requires a "path" argument');
@@ -1429,6 +1538,18 @@ async function toolReadFile(args, cfg) {
   if (!(0, import_fs3.existsSync)(abs)) throw new Error(`File not found: ${userPath}`);
   const stat = (0, import_fs3.statSync)(abs);
   if (stat.isDirectory()) throw new Error(`"${userPath}" is a directory, not a file`);
+  const ext = (0, import_path3.extname)(abs).toLowerCase();
+  if (PDF_EXTS.has(ext)) {
+    if (stat.size > 5e7) throw new Error(`PDF too large to read (${Math.round(stat.size / 1e6)} MB). Max 50 MB.`);
+    return extractPdfText(abs);
+  }
+  if (OFFICE_EXTS.has(ext)) {
+    if (stat.size > 2e7) throw new Error(`Document too large to read (${Math.round(stat.size / 1e6)} MB). Max 20 MB.`);
+    return extractOfficeText(abs, ext);
+  }
+  if (UNREADABLE_BINARY_EXTS.has(ext)) {
+    throw new Error(`Cannot read binary file "${userPath}" (${ext} format). Only text, PDF, and Office documents are supported.`);
+  }
   if (stat.size > 5e5) throw new Error(`File too large to read (${Math.round(stat.size / 1024)} KB). Max 500 KB.`);
   return (0, import_fs3.readFileSync)(abs, "utf8");
 }
@@ -1487,11 +1608,12 @@ async function toolSearchFiles(args, cfg) {
   return results.length ? results.join("\n") : "No files found matching: " + pattern;
 }
 async function toolRunCommand(args, cfg) {
-  const { command, args: cmdArgs = [], cwd } = args;
+  const { command, args: cmdArgs = [], cwd, timeout_seconds, interactive } = args;
   if (!command || typeof command !== "string") throw new Error('run_command requires a "command" string');
   if (!Array.isArray(cmdArgs)) throw new Error('"args" must be an array of strings');
   const workDir = cwd ? safePath(cfg.rootDir, cwd) : cfg.rootDir;
   const preview = [command, ...cmdArgs].join(" ");
+  const timeoutMs = Math.min((typeof timeout_seconds === "number" ? timeout_seconds : 120) * 1e3, 3e5);
   const ok = await confirm(
     `Agent wants to run: \x1B[1m${preview}\x1B[0m
   \x1B[2min: ${workDir}\x1B[0m`,
@@ -1499,14 +1621,142 @@ async function toolRunCommand(args, cfg) {
     "run_command"
   );
   if (!ok) return "User denied command execution.";
+  if (interactive) {
+    return new Promise((resolve2) => {
+      const child = (0, import_child_process2.spawn)(command, cmdArgs.map(String), { cwd: workDir, stdio: "inherit" });
+      const timer = setTimeout(() => {
+        child.kill();
+        resolve2(`(command timed out after ${timeoutMs / 1e3}s)`);
+      }, timeoutMs);
+      child.on("close", (code) => {
+        clearTimeout(timer);
+        resolve2(`(command exited with code ${code ?? "unknown"})`);
+      });
+      child.on("error", (err) => {
+        clearTimeout(timer);
+        resolve2(`Error: ${err.message}`);
+      });
+    });
+  }
   return new Promise((resolve2) => {
-    (0, import_child_process2.execFile)(command, cmdArgs.map(String), { cwd: workDir, timeout: 3e4, maxBuffer: 1024 * 1024 }, (err, stdout, stderr) => {
+    (0, import_child_process2.execFile)(command, cmdArgs.map(String), { cwd: workDir, timeout: timeoutMs, maxBuffer: 1024 * 1024 }, (err, stdout, stderr) => {
       const out = [stdout, stderr].filter(Boolean).join("\n--- stderr ---\n");
       if (err && !out) return resolve2(`Error: ${err.message}`);
       resolve2(out || "(no output)");
     });
   });
 }
+async function toolStartProcess(args, cfg) {
+  const { command, args: cmdArgs = [], cwd } = args;
+  if (!command || typeof command !== "string") throw new Error('start_process requires a "command" string');
+  if (!Array.isArray(cmdArgs)) throw new Error('"args" must be an array of strings');
+  const workDir = cwd ? safePath(cfg.rootDir, cwd) : cfg.rootDir;
+  const preview = [command, ...cmdArgs].join(" ");
+  const ok = await confirm(
+    `Agent wants to start background process: \x1B[1m${preview}\x1B[0m
+  \x1B[2min: ${workDir}\x1B[0m`,
+    cfg,
+    "start_process"
+  );
+  if (!ok) return JSON.stringify({ error: "User denied process start." });
+  const id = `proc_${Date.now().toString(36)}`;
+  const child = (0, import_child_process2.spawn)(command, cmdArgs.map(String), {
+    cwd: workDir,
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: false
+  });
+  const proc = {
+    id,
+    command: preview,
+    status: "running",
+    exitCode: null,
+    stdout: "",
+    stderr: "",
+    startedAt: /* @__PURE__ */ new Date(),
+    endedAt: null,
+    child
+  };
+  child.stdout?.on("data", (chunk) => {
+    proc.stdout = capBuffer(proc.stdout, chunk.toString(), 2e5);
+  });
+  child.stderr?.on("data", (chunk) => {
+    proc.stderr = capBuffer(proc.stderr, chunk.toString(), 5e4);
+  });
+  child.on("close", (code) => {
+    proc.status = code === 0 ? "done" : "error";
+    proc.exitCode = code;
+    proc.endedAt = /* @__PURE__ */ new Date();
+  });
+  child.on("error", (err) => {
+    proc.status = "error";
+    proc.endedAt = /* @__PURE__ */ new Date();
+    proc.stderr = capBuffer(proc.stderr, `
+Spawn error: ${err.message}`, 5e4);
+  });
+  managedProcesses.set(id, proc);
+  cfg.appendLog({ type: "process_start", processId: id, command: preview, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+  return JSON.stringify({ processId: id, status: "running", command: preview });
+}
+function processSnapshot(proc) {
+  const elapsedSec = Math.round((Date.now() - proc.startedAt.getTime()) / 1e3);
+  const recentStdout = proc.stdout.length > 4e3 ? "\u2026(earlier output truncated)\n" + proc.stdout.slice(-4e3) : proc.stdout;
+  return JSON.stringify({
+    processId: proc.id,
+    command: proc.command,
+    status: proc.status,
+    exitCode: proc.exitCode,
+    elapsedSec,
+    stdout: recentStdout || "(no output yet)",
+    stderr: proc.stderr.slice(-1e3) || void 0
+  });
+}
+async function toolProcessStatus(args, _cfg) {
+  const { processId } = args;
+  if (!processId) throw new Error('process_status requires a "processId" argument');
+  const proc = managedProcesses.get(processId);
+  if (!proc) return JSON.stringify({ error: `No process found with id "${processId}"` });
+  return processSnapshot(proc);
+}
+async function toolWaitForProcess(args, _cfg) {
+  const { processId, wait_seconds = 60 } = args;
+  if (!processId) throw new Error('wait_for_process requires a "processId" argument');
+  const proc = managedProcesses.get(processId);
+  if (!proc) return JSON.stringify({ error: `No process found with id "${processId}"` });
+  if (proc.status !== "running") return processSnapshot(proc);
+  const maxWait = Math.min((typeof wait_seconds === "number" ? wait_seconds : 60) * 1e3, 12e4);
+  const deadline = Date.now() + maxWait;
+  await new Promise((resolve2) => {
+    const tick = setInterval(() => {
+      if (proc.status !== "running" || Date.now() >= deadline) {
+        clearInterval(tick);
+        resolve2();
+      }
+    }, 500);
+  });
+  return processSnapshot(proc);
+}
+async function toolKillProcess(args, cfg) {
+  const { processId } = args;
+  if (!processId) throw new Error('kill_process requires a "processId" argument');
+  const proc = managedProcesses.get(processId);
+  if (!proc) return JSON.stringify({ error: `No process found with id "${processId}"` });
+  if (proc.status !== "running") return JSON.stringify({ error: `Process "${processId}" is not running (status: ${proc.status})` });
+  proc.child.kill("SIGTERM");
+  proc.status = "killed";
+  proc.endedAt = /* @__PURE__ */ new Date();
+  cfg.appendLog({ type: "process_killed", processId, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+  return JSON.stringify({ processId, status: "killed" });
+}
+async function toolListProcesses(_args, _cfg) {
+  if (managedProcesses.size === 0) return JSON.stringify([]);
+  const list = [...managedProcesses.values()].map((p) => ({
+    processId: p.id,
+    command: p.command,
+    status: p.status,
+    elapsedSec: Math.round((Date.now() - p.startedAt.getTime()) / 1e3)
+  }));
+  return JSON.stringify(list);
+}
 async function runLocalTool(call, cfg) {
   const { tool, args } = call;
   cfg.appendLog({
@@ -1533,8 +1783,23 @@ async function runLocalTool(call, cfg) {
       case "run_command":
         result = await toolRunCommand(args, cfg);
         break;
+      case "start_process":
+        result = await toolStartProcess(args, cfg);
+        break;
+      case "process_status":
+        result = await toolProcessStatus(args, cfg);
+        break;
+      case "wait_for_process":
+        result = await toolWaitForProcess(args, cfg);
+        break;
+      case "kill_process":
+        result = await toolKillProcess(args, cfg);
+        break;
+      case "list_processes":
+        result = await toolListProcesses(args, cfg);
+        break;
       default:
-        result = `Unknown tool: "${tool}". Available: read_file, write_file, list_directory, search_files, run_command`;
+        result = `Unknown tool: "${tool}". Available: read_file, write_file, list_directory, search_files, run_command, start_process, wait_for_process, process_status, kill_process, list_processes`;
     }
   } catch (err) {
     result = `Error: ${err?.message ?? String(err)}`;
@@ -1775,12 +2040,13 @@ ${content}
         messages: [{ role: "user", content: userMessage }],
         ...cliContext && { cliContext }
       };
-      process.stdout.write(c.primary("agent") + c.dim(" \u203A "));
       if (opts.noStream) {
-        const spinner = spin("");
+        process.stdout.write(c.primary("agent") + c.dim(" \u203A "));
+        const spinner = spin("thinking\u2026");
         try {
           const result = await client.run.once(params);
           spinner.stop();
+          process.stdout.write(c.primary("agent") + c.dim(" \u203A "));
           const text = extractText(result);
           console.log(text);
           appendSessionLog(sessionId, {
@@ -1798,29 +2064,57 @@ ${sym.fail} ${c.error(err.message ?? String(err))}`);
         try {
           let hasOutput = false;
           let agentContent = "";
+          let toolStartMs = 0;
+          let lastToolName = "";
+          const thinkingSpinner = spin("thinking\u2026");
           for await (const event of client.agents.stream(params)) {
             if (event.type === "token") {
+              if (thinkingSpinner.isSpinning) {
+                thinkingSpinner.stop();
+                process.stdout.write(c.primary("agent") + c.dim(" \u203A "));
+              }
               const tok = event.content ?? "";
               process.stdout.write(tok);
               agentContent += tok;
               hasOutput = true;
             } else if (event.type === "cli_tool_request" && localToolsCfg) {
+              if (thinkingSpinner.isSpinning) thinkingSpinner.stop();
               const { requestId, tool: toolName, args } = event;
               const displayName = String(toolName).replace("cli_", "");
+              const argStr = toolArgSummary(displayName, args ?? {});
+              const isWaiting = displayName === "wait_for_process";
               if (hasOutput) {
                 process.stdout.write("\n");
                 hasOutput = false;
               }
-              process.stdout.write(c.dim(`  [local] ${displayName}\u2026`));
+              process.stdout.write(`  ${c.dim("\u2500")} ${c.bold(displayName)}${argStr ? "  " + c.dim(argStr) : ""}`);
+              const startMs = Date.now();
+              let elapsedSec = 0;
+              let elapsedInterval = null;
+              if (isWaiting) {
+                elapsedInterval = setInterval(() => {
+                  elapsedSec++;
+                  readline3.cursorTo(process.stdout, 0);
+                  process.stdout.write(`  ${c.dim("\u2500")} ${c.bold(displayName)}${argStr ? "  " + c.dim(argStr) : ""}  ${c.dim(elapsedSec + "s\u2026")}`);
+                }, 1e3);
+              }
               let result;
+              let toolOk = true;
               try {
-                const localToolName = String(toolName).replace("cli_", "");
-                result = await runLocalTool({ tool: localToolName, args: args ?? {} }, localToolsCfg);
-                process.stdout.write(c.dim(" \u2713\n"));
+                result = await runLocalTool({ tool: displayName, args: args ?? {} }, localToolsCfg);
               } catch (err) {
                 result = `Error: ${err?.message ?? String(err)}`;
-                process.stdout.write(c.dim(" \u2717\n"));
+                toolOk = false;
               }
+              if (elapsedInterval) clearInterval(elapsedInterval);
+              const elapsed = ((Date.now() - startMs) / 1e3).toFixed(1);
+              const preview = toolOk ? toolResultPreview(displayName, result) : "";
+              readline3.cursorTo(process.stdout, 0);
+              readline3.clearLine(process.stdout, 0);
+              const statusIcon = toolOk ? sym.ok : sym.fail;
+              const previewPart = preview ? `  ${c.dim(preview)}` : "";
+              process.stdout.write(`  ${c.dim("\u2500")} ${c.bold(displayName)}${argStr ? "  " + c.dim(argStr) : ""}  ${statusIcon}${previewPart}  ${c.dim("(" + elapsed + "s)")}
+`);
               appendSessionLog(sessionId, {
                 type: "local_tool_result",
                 tool: toolName,
@@ -1840,13 +2134,20 @@ ${sym.fail} ${c.error(err.message ?? String(err))}`);
                 console.error(c.warn(`
   [local] Failed to submit tool result: ${postErr?.message}`));
               }
+            } else if (event.type === "keepalive") {
             } else if (event.type === "toolStart") {
-              const name = event.toolName ?? "";
+              if (thinkingSpinner.isSpinning) thinkingSpinner.stop();
+              lastToolName = event.toolName ?? "";
+              toolStartMs = Date.now();
               if (hasOutput) process.stdout.write("\n");
-              process.stdout.write(c.dim(`  [tool] ${name}\u2026`));
+              process.stdout.write(`  ${c.dim("\u2500")} ${c.bold(lastToolName)}`);
               hasOutput = false;
             } else if (event.type === "toolEnd") {
-              process.stdout.write(c.dim(" done\n"));
+              const elapsed = ((Date.now() - toolStartMs) / 1e3).toFixed(1);
+              readline3.cursorTo(process.stdout, 0);
+              readline3.clearLine(process.stdout, 0);
+              process.stdout.write(`  ${c.dim("\u2500")} ${c.bold(lastToolName)}  ${sym.ok}  ${c.dim("(" + elapsed + "s)")}
+`);
               process.stdout.write(c.primary("agent") + c.dim(" \u203A "));
               hasOutput = false;
             } else if (event.type === "final") {
@@ -1883,12 +2184,14 @@ ${sym.fail} ${c.error(err.message ?? String(err))}`);
               }
               break;
             } else if (event.type === "error") {
+              if (thinkingSpinner.isSpinning) thinkingSpinner.stop();
               if (hasOutput) process.stdout.write("\n");
               console.error(`
 ${sym.fail} ${c.error(event.message ?? "Stream error")}`);
               break;
             }
           }
+          if (thinkingSpinner.isSpinning) thinkingSpinner.stop();
           process.stdout.write("\n");
           if (localToolsCfg && agentContent) {
             await handleLocalToolLoop(agentContent, localToolsCfg, client, agentId, sessionId, appendSessionLog);
@@ -1899,6 +2202,8 @@ ${sym.fail} ${c.error(event.message ?? "Stream error")}`);
         }
       }
       console.log();
+      readline3.cursorTo(process.stdout, 0);
+      readline3.clearLine(process.stdout, 0);
       rl.resume();
       rl.prompt();
     });
@@ -1922,16 +2227,25 @@ async function handleLocalToolLoop(agentText, cfg, client, agentId, sessionId, a
   }
   const toolCall = extractToolCall(agentText);
   if (!toolCall) return;
-  process.stdout.write(c.dim(`
-  [local] ${toolCall.tool}`));
+  const argStr = toolArgSummary(toolCall.tool, toolCall.args ?? {});
+  process.stdout.write(`
+  ${c.dim("\u2500")} ${c.bold(toolCall.tool)}${argStr ? "  " + c.dim(argStr) : ""}`);
+  const startMs = Date.now();
   let result;
+  let toolOk = true;
   try {
     result = await runLocalTool(toolCall, cfg);
-    process.stdout.write(c.dim(" \u2713\n"));
   } catch (err) {
     result = `Error: ${err?.message ?? String(err)}`;
-    process.stdout.write(c.dim(" \u2717\n"));
+    toolOk = false;
   }
+  const elapsed = ((Date.now() - startMs) / 1e3).toFixed(1);
+  const preview = toolOk ? toolResultPreview(toolCall.tool, result) : "";
+  readline3.cursorTo(process.stdout, 0);
+  readline3.clearLine(process.stdout, 0);
+  const previewPart = preview ? `  ${c.dim(preview)}` : "";
+  process.stdout.write(`  ${c.dim("\u2500")} ${c.bold(toolCall.tool)}${argStr ? "  " + c.dim(argStr) : ""}  ${toolOk ? sym.ok : sym.fail}${previewPart}  ${c.dim("(" + elapsed + "s)")}
+`);
   const resultMsg = `[Tool result: ${toolCall.tool}]
 \`\`\`
 ${result}
@@ -1946,6 +2260,8 @@ ${result}
   process.stdout.write(c.primary("agent") + c.dim(" \u203A "));
   let followContent = "";
   try {
+    let loopToolName = "";
+    let loopToolStartMs = 0;
     for await (const evt of client.agents.stream({
       agentId,
       sessionId,
@@ -1956,11 +2272,16 @@ ${result}
         process.stdout.write(tok);
         followContent += tok;
       } else if (evt.type === "toolStart") {
-        const name = evt.toolName ?? "";
+        loopToolName = evt.toolName ?? "";
+        loopToolStartMs = Date.now();
         if (followContent) process.stdout.write("\n");
-        process.stdout.write(c.dim(`  [tool] ${name}\u2026`));
+        process.stdout.write(`  ${c.dim("\u2500")} ${c.bold(loopToolName)}`);
       } else if (evt.type === "toolEnd") {
-        process.stdout.write(c.dim(" done\n"));
+        const elapsed2 = ((Date.now() - loopToolStartMs) / 1e3).toFixed(1);
+        readline3.cursorTo(process.stdout, 0);
+        readline3.clearLine(process.stdout, 0);
+        process.stdout.write(`  ${c.dim("\u2500")} ${c.bold(loopToolName)}  ${sym.ok}  ${c.dim("(" + elapsed2 + "s)")}
+`);
         process.stdout.write(c.primary("agent") + c.dim(" \u203A "));
       } else if (evt.type === "final") {
         const txt = extractText(evt?.payload);
@@ -1984,6 +2305,80 @@ ${sym.fail} ${c.error(evt.message ?? "Stream error")}`);
   }
   await handleLocalToolLoop(followContent, cfg, client, agentId, sessionId, appendLog, depth + 1);
 }
+function truncate(s, max) {
+  const str = String(s ?? "");
+  return str.length <= max ? str : str.slice(0, max - 1) + "\u2026";
+}
+function toolArgSummary(toolName, args) {
+  switch (toolName) {
+    case "read_file":
+      return truncate(args.path ?? "", 60);
+    case "write_file":
+      return truncate(args.path ?? "", 60);
+    case "delete_file":
+      return truncate(args.path ?? "", 60);
+    case "list_directory":
+      return truncate(args.path ?? ".", 60);
+    case "run_command":
+      return truncate(args.command ?? "", 60);
+    case "start_process":
+      return truncate(args.command ?? "", 60);
+    case "wait_for_process":
+      return truncate(args.process_id ?? "", 20);
+    case "process_status":
+      return truncate(args.process_id ?? "", 20);
+    case "kill_process":
+      return truncate(args.process_id ?? "", 20);
+    case "list_processes":
+      return "";
+    case "search_files": {
+      const parts = [args.pattern, args.query].filter(Boolean);
+      return truncate(parts.join(" "), 60);
+    }
+    default: {
+      const first = args.path ?? args.query ?? args.command ?? args.pattern ?? "";
+      return truncate(String(first), 60);
+    }
+  }
+}
+function toolResultPreview(toolName, result) {
+  if (!result || result.startsWith("Error:")) return "";
+  switch (toolName) {
+    case "read_file": {
+      const lines = result.split("\n").length;
+      return `${lines} lines`;
+    }
+    case "write_file":
+      return "written";
+    case "delete_file":
+      return "deleted";
+    case "list_directory": {
+      const count = result.split("\n").filter(Boolean).length;
+      return `${count} entries`;
+    }
+    case "run_command": {
+      const first = result.split("\n").find((l) => l.trim());
+      return first ? truncate(first.trim(), 50) : "done";
+    }
+    case "start_process": {
+      const match = result.match(/process[_\s-]?id[:\s]+([a-zA-Z0-9_-]+)/i) ?? result.match(/"id"[:\s]+"([^"]+)"/);
+      return match ? `pid ${match[1]}` : "started";
+    }
+    case "wait_for_process": {
+      if (/done|complete|exit/i.test(result)) return "done";
+      if (/running/i.test(result)) return "still running";
+      return truncate(result.split("\n")[0]?.trim() ?? "", 40);
+    }
+    case "search_files": {
+      const count = result.split("\n").filter(Boolean).length;
+      return `${count} match${count === 1 ? "" : "es"}`;
+    }
+    default: {
+      const first = result.split("\n").find((l) => l.trim());
+      return first ? truncate(first.trim(), 50) : "";
+    }
+  }
+}
 function extractText(payload) {
   if (!payload) return "";
   if (typeof payload === "string") return payload;
@@ -3279,7 +3674,7 @@ async function pickAgentInteractively(action) {
   return agentId;
 }
 var program = new import_commander16.Command();
-program.name("agc").description("Agent Commons CLI \u2014 interact with the Agent Commons platform").version("0.1.14", "-v, --version").action(async () => {
+program.name("agc").description("Agent Commons CLI \u2014 interact with the Agent Commons platform").version("0.1.17", "-v, --version").action(async () => {
   await interactiveMenu();
 });
 program.addCommand(loginCommand());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-commons/cli",
-  "version": "0.1.14",
+  "version": "0.1.17",
   "description": "Agent Commons CLI — chat, run, and manage agents from your terminal",
   "license": "MIT",
   "bin": {
@@ -11,15 +11,17 @@
     "dist"
   ],
   "dependencies": {
-    "commander": "^12.1.0",
+    "@types/pdf-parse": "^1.1.5",
     "chalk": "^5.3.0",
+    "commander": "^12.1.0",
     "ora": "^8.1.1",
-    "@agent-commons/sdk": "0.1.12"
+    "pdf-parse": "^1.1.1",
+    "@agent-commons/sdk": "0.1.13"
   },
   "devDependencies": {
+    "@types/node": "^22.10.2",
     "tsup": "^8.3.5",
-    "typescript": "^5.7.2",
-    "@types/node": "^22.10.2"
+    "typescript": "^5.7.2"
   },
   "engines": {
     "node": ">=18"