@teammates/cli 0.2.7 → 0.2.8

package/dist/adapters/cli-proxy.d.ts

@@ -16,15 +16,33 @@
  */
 import type { AgentAdapter, InstalledService, RosterEntry } from "../adapter.js";
 import type { SandboxLevel, TaskResult, TeammateConfig } from "../types.js";
+/** Structured result from spawning an agent subprocess. */
+export interface SpawnResult {
+    /** Combined stdout + stderr (for backward compat / display) */
+    output: string;
+    /** stdout only */
+    stdout: string;
+    /** stderr only */
+    stderr: string;
+    /** Process exit code (null if killed by signal) */
+    exitCode: number | null;
+    /** Signal that killed the process (null if exited normally) */
+    signal: string | null;
+    /** Whether the process was killed by our timeout */
+    timedOut: boolean;
+    /** Path to the debug log file, if one was written */
+    debugFile?: string;
+}
 export interface AgentPreset {
     /** Display name */
     name: string;
     /** Binary / command to spawn */
     command: string;
-    /** Build CLI args. `promptFile` is a temp file path, `prompt` is the raw text. */
+    /** Build CLI args. `promptFile` is a temp file path, `prompt` is the raw text, `debugFile` is an optional path for agent debug logs. */
     buildArgs(ctx: {
         promptFile: string;
         prompt: string;
+        debugFile?: string;
     }, teammate: TeammateConfig, options: CliProxyOptions): string[];
     /** Extra env vars to set (e.g. FORCE_COLOR) */
     env?: Record<string, string>;
@@ -34,6 +52,8 @@ export interface AgentPreset {
     shell?: boolean;
     /** Whether to pipe the prompt via stdin instead of as a CLI argument */
     stdinPrompt?: boolean;
+    /** Whether this preset supports a debug log file (--debug-file) */
+    supportsDebugFile?: boolean;
     /** Optional output parser — transforms raw stdout into clean agent output */
     parseOutput?(raw: string): string;
 }

package/dist/adapters/cli-proxy.js

@@ -24,14 +24,17 @@ export const PRESETS = {
     claude: {
         name: "claude",
         command: "claude",
-        buildArgs(_ctx, _teammate, options) {
+        buildArgs(ctx, _teammate, options) {
             const args = ["-p", "--verbose", "--dangerously-skip-permissions"];
             if (options.model)
                 args.push("--model", options.model);
+            if (ctx.debugFile)
+                args.push("--debug-file", ctx.debugFile);
             return args;
         },
         env: { FORCE_COLOR: "1", CLAUDECODE: "" },
         stdinPrompt: true,
+        supportsDebugFile: true,
     },
     codex: {
         name: "codex",
@@ -167,12 +170,20 @@ export class CliProxyAdapter {
         await writeFile(promptFile, fullPrompt, "utf-8");
         this.pendingTempFiles.add(promptFile);
         try {
-            const rawOutput = await this.spawnAndProxy(teammate, promptFile, fullPrompt);
+            const spawn = await this.spawnAndProxy(teammate, promptFile, fullPrompt);
             const output = this.preset.parseOutput
-                ? this.preset.parseOutput(rawOutput)
-                : rawOutput;
+                ? this.preset.parseOutput(spawn.output)
+                : spawn.output;
             const teammateNames = this.roster.map((r) => r.name);
-            return parseResult(teammate.name, output, teammateNames, prompt);
+            const result = parseResult(teammate.name, output, teammateNames, prompt);
+            result.diagnostics = {
+                exitCode: spawn.exitCode,
+                signal: spawn.signal,
+                stderr: spawn.stderr,
+                timedOut: spawn.timedOut,
+                debugFile: spawn.debugFile,
+            };
+            return result;
         }
         finally {
             this.pendingTempFiles.delete(promptFile);
@@ -291,8 +302,12 @@ export class CliProxyAdapter {
      */
     spawnAndProxy(teammate, promptFile, fullPrompt) {
         return new Promise((resolve, reject) => {
+            // Generate a debug log file path if the preset supports it
+            const debugFile = this.preset.supportsDebugFile
+                ? join(tmpdir(), `teammates-debug-${teammate.name}-${Date.now()}.log`)
+                : undefined;
             const args = [
-                ...this.preset.buildArgs({ promptFile, prompt: fullPrompt }, teammate, this.options),
+                ...this.preset.buildArgs({ promptFile, prompt: fullPrompt, debugFile }, teammate, this.options),
                 ...(this.options.extraFlags ?? []),
             ];
             const command = this.options.commandPath ?? this.preset.command;
@@ -352,12 +367,13 @@ export class CliProxyAdapter {
                 process.stdin.resume();
                 process.stdin.on("data", onUserInput);
             }
-            const captured = [];
+            const stdoutBufs = [];
+            const stderrBufs = [];
             child.stdout?.on("data", (chunk) => {
-                captured.push(chunk);
+                stdoutBufs.push(chunk);
             });
             child.stderr?.on("data", (chunk) => {
-                captured.push(chunk);
+                stderrBufs.push(chunk);
             });
             const cleanup = () => {
                 clearTimeout(timeoutTimer);
@@ -367,15 +383,22 @@ export class CliProxyAdapter {
                     process.stdin.removeListener("data", onUserInput);
                 }
             };
-            child.on("close", (_code) => {
+            child.on("close", (code, signal) => {
                 cleanup();
-                const output = Buffer.concat(captured).toString("utf-8");
-                if (killed) {
-                    resolve(`${output}\n\n[TIMEOUT] Agent process killed after ${timeout}ms`);
-                }
-                else {
-                    resolve(output);
-                }
+                const stdout = Buffer.concat(stdoutBufs).toString("utf-8");
+                const stderr = Buffer.concat(stderrBufs).toString("utf-8");
+                const output = stdout + (stderr ? `\n${stderr}` : "");
+                resolve({
+                    output: killed
+                        ? `${output}\n\n[TIMEOUT] Agent process killed after ${timeout}ms`
+                        : output,
+                    stdout,
+                    stderr,
+                    exitCode: code,
+                    signal: signal ?? null,
+                    timedOut: killed,
+                    debugFile,
+                });
             });
             child.on("error", (err) => {
                 cleanup();

package/dist/cli.js

@@ -2275,6 +2275,9 @@ Do NOT modify any other teammate's files. Only edit your own SOUL.md and daily l
                 }
             }
         });
+        this.chatView.on("copy", (text) => {
+            this.doCopy(text);
+        });
         this.chatView.on("link", (url) => {
             const quoted = JSON.stringify(url);
             const cmd = process.platform === "darwin"
@@ -2695,6 +2698,19 @@ Do NOT modify any other teammate's files. Only edit your own SOUL.md and daily l
                 else {
                     this.feedLine(tp.muted("  (no response text — the agent may have only performed tool actions)"));
                     this.feedLine(tp.muted(`  Use /debug ${event.result.teammate} to view full output`));
+                    // Show diagnostic hints for empty responses
+                    const diag = event.result.diagnostics;
+                    if (diag) {
+                        if (diag.exitCode !== 0 && diag.exitCode !== null) {
+                            this.feedLine(tp.warning(`  ⚠ Process exited with code ${diag.exitCode}`));
+                        }
+                        if (diag.signal) {
+                            this.feedLine(tp.warning(`  ⚠ Process killed by signal: ${diag.signal}`));
+                        }
+                        if (diag.debugFile) {
+                            this.feedLine(tp.muted(`  Debug log: ${diag.debugFile}`));
+                        }
+                    }
                 }
                 // Render handoffs
                 const handoffs = event.result.handoffs;
@@ -2984,6 +3000,31 @@ Do NOT modify any other teammate's files. Only edit your own SOUL.md and daily l
                 if (result.handoffs.length > 0) {
                     lines.push(`**Handoffs:** ${result.handoffs.map((h) => `@${h.to}`).join(", ")}`);
                 }
+                // Process diagnostics — exit code, signal, stderr
+                const diag = result.diagnostics;
+                if (diag) {
+                    lines.push("");
+                    lines.push("### Process");
+                    lines.push(`**Exit code:** ${diag.exitCode ?? "(killed by signal)"}`);
+                    if (diag.signal)
+                        lines.push(`**Signal:** ${diag.signal}`);
+                    if (diag.timedOut)
+                        lines.push(`**Timed out:** yes`);
+                    if (diag.debugFile)
+                        lines.push(`**Debug log:** ${diag.debugFile}`);
+                    // Show stderr separately — this is where tool call output and errors go
+                    if (diag.stderr.trim()) {
+                        lines.push("");
+                        lines.push("<details><summary>stderr</summary>");
+                        lines.push("");
+                        lines.push(diag.stderr);
+                        lines.push("");
+                        lines.push("</details>");
+                    }
+                    else {
+                        lines.push(`**stderr:** (empty)`);
+                    }
+                }
                 lines.push("");
                 lines.push("<details><summary>Raw output</summary>");
                 lines.push("");

package/dist/types.d.ts

@@ -68,6 +68,19 @@ export interface TaskResult {
     handoffs: HandoffEnvelope[];
     /** Raw output from the agent */
     rawOutput?: string;
+    /** Process diagnostics for debugging empty/failed responses */
+    diagnostics?: {
+        /** Process exit code (null if killed by signal) */
+        exitCode: number | null;
+        /** Signal that killed the process (null if exited normally) */
+        signal: string | null;
+        /** stderr output (separate from stdout) */
+        stderr: string;
+        /** Whether the process was killed by timeout */
+        timedOut: boolean;
+        /** Path to the agent's debug log file, if written */
+        debugFile?: string;
+    };
 }
 /** Task assignment to a teammate */
 export interface TaskAssignment {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teammates/cli",
-  "version": "0.2.7",
+  "version": "0.2.8",
   "description": "Agent-agnostic CLI for teammates. Routes tasks, manages handoffs, and plugs into any coding agent backend.",
   "type": "module",
   "main": "dist/index.js",