@tagma/sdk 0.2.1 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tagma/sdk",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "type": "module",
   "workspaces": [
     "plugins/*"

package/src/drivers/claude-code.ts

@@ -151,24 +151,28 @@ export const ClaudeCodeDriver: DriverPlugin = {
     const tools = resolveTools(permissions);
     const permissionMode = resolvePermissionMode(permissions);
 
+    // Pass the prompt via stdin instead of as a -p argument value. On Windows,
+    // multi-line strings in CLI arguments break cmd.exe argument parsing when
+    // the executable is a .cmd wrapper — newlines cause all subsequent flags
+    // (--output-format, --model, etc.) to be silently dropped.
+    const stdin = task.prompt!;
+
     const args: string[] = [
       'claude',
-      '-p', task.prompt!,
+      '-p',  // no value — prompt is piped via stdin
       '--model', model,
       '--allowedTools', tools,
       '--permission-mode', permissionMode,
       '--output-format', 'json',
-      '--verbose',
+      // NOTE: do NOT use --verbose here. It changes stdout from a single JSON
+      // result object to a JSON event-stream array, breaking parseResult's
+      // session_id extraction (needed for continue_from) and normalizedOutput.
+      // The engine already captures stdout/stderr for pipeline logs.
       // Pin to project+local settings only; don't inherit arbitrary user-level
       // config (hooks, MCP servers, etc.) into pipeline automation.
       '--setting-sources', 'project,local',
     ];
 
-    const profile = task.agent_profile ?? track.agent_profile;
-    if (profile) {
-      args.push('--append-system-prompt', profile);
-    }
-
     // If the task runs in a subdirectory of the project, grant read/edit
     // access to the project root via --add-dir so Claude can still see
     // shared files (configs, types, etc.) outside task.cwd.
@@ -185,12 +189,29 @@ export const ClaudeCodeDriver: DriverPlugin = {
       }
     }
 
-    return { args, cwd: effectiveCwd, env: resolveGitBashEnv() };
+    // --append-system-prompt MUST be last: its value may contain newlines,
+    // and on Windows cmd.exe can silently drop any flags that follow a
+    // newline-containing argument.
+    const profile = task.agent_profile ?? track.agent_profile;
+    if (profile) {
+      args.push('--append-system-prompt', profile);
+    }
+
+    return { args, cwd: effectiveCwd, env: resolveGitBashEnv(), stdin };
   },
 
   parseResult(stdout: string): DriverResultMeta {
     try {
-      const json = JSON.parse(stdout);
+      let json = JSON.parse(stdout);
+
+      // --verbose produces a JSON array of events; extract the final "result"
+      // event so session_id and normalizedOutput are correctly populated.
+      if (Array.isArray(json)) {
+        const resultEvent = json.findLast((e: Record<string, unknown>) => e.type === 'result');
+        if (!resultEvent) return { normalizedOutput: stdout };
+        json = resultEvent;
+      }
+
       // Extract canonical text: strip JSON envelope so downstream drivers
       // get the actual AI response, not metadata
       const normalizedOutput = json.result ?? json.text ?? json.content ?? stdout;

package/src/runner.ts

@@ -6,6 +6,24 @@ import { shellArgs } from './utils';
 // Delay before escalating SIGTERM to SIGKILL when killing a timed-out process.
 const SIGKILL_DELAY_MS = 3_000;
 
+/**
+ * On Windows, proc.kill('SIGTERM') / proc.kill('SIGKILL') only terminate the
+ * direct child process. When the child is a .cmd/.bat wrapper (e.g. claude.cmd),
+ * cmd.exe spawns the real process as a grandchild — proc.kill misses it entirely.
+ * `taskkill /F /T /PID` kills the entire process tree rooted at the given PID.
+ */
+function killProcessTree(pid: number): void {
+  if (process.platform !== 'win32') return;
+  try {
+    Bun.spawnSync(['taskkill', '/F', '/T', '/PID', String(pid)], {
+      stdout: 'ignore',
+      stderr: 'ignore',
+    });
+  } catch {
+    /* best-effort — process may have already exited */
+  }
+}
+
 export interface RunOptions {
   readonly timeoutMs?: number;
   readonly signal?: AbortSignal; // pipeline-level abort
@@ -128,15 +146,22 @@ export async function runSpawn(
   const killGracefully = () => {
     if (killedByUs) return;
     killedByUs = true;
-    proc.kill('SIGTERM');
-    // If the child ignores SIGTERM, escalate to SIGKILL after 3 s.
-    forceTimer = setTimeout(() => {
-      try {
-        proc.kill('SIGKILL');
-      } catch {
-        /* already exited */
-      }
-    }, SIGKILL_DELAY_MS);
+
+    if (process.platform === 'win32') {
+      // On Windows, kill the entire process tree via taskkill. This handles
+      // .cmd wrappers and nested child processes that proc.kill() misses.
+      killProcessTree(proc.pid);
+    } else {
+      proc.kill('SIGTERM');
+      // If the child ignores SIGTERM, escalate to SIGKILL after 3 s.
+      forceTimer = setTimeout(() => {
+        try {
+          proc.kill('SIGKILL');
+        } catch {
+          /* already exited */
+        }
+      }, SIGKILL_DELAY_MS);
+    }
   };
 
   if (timeoutMs && timeoutMs > 0) {