@plaited/acp-harness 0.4.1 → 0.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plaited/acp-harness",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "CLI tool for capturing agent trajectories from ACP-compatible agents",
   "license": "ISC",
   "engines": {

package/src/headless-session-manager.ts

@@ -153,24 +153,37 @@ export const createSessionManager = (config: SessionManagerConfig) => {
     // Build command for first turn or if no process exists
     if (!session.process || session.process.killed) {
       const args = buildCommand(session, promptText)
-      // First turn: prompt is in command line, use 'ignore' for stdin
-      // Some CLIs (like Claude) hang when stdin is piped but not written to
+
+      // Choose stdin mode based on schema configuration
+      const stdinMode = schema.prompt.stdin ? 'pipe' : 'ignore'
+
       session.process = Bun.spawn(args, {
         cwd: session.cwd,
-        stdin: 'ignore',
+        stdin: stdinMode,
         stdout: 'pipe',
         stderr: 'inherit',
       })
+
+      // If using stdin, write the prompt
+      if (schema.prompt.stdin && session.process) {
+        writePromptToStdin(session.process, promptText)
+      }
     } else {
       // Subsequent turns: spawn new process with resume flag
-      // (stdin-based multi-turn not currently supported)
       const args = buildCommand(session, promptText)
+      const stdinMode = schema.prompt.stdin ? 'pipe' : 'ignore'
+
       session.process = Bun.spawn(args, {
         cwd: session.cwd,
-        stdin: 'ignore',
+        stdin: stdinMode,
         stdout: 'pipe',
         stderr: 'inherit',
       })
+
+      // If using stdin, write the prompt
+      if (schema.prompt.stdin && session.process) {
+        writePromptToStdin(session.process, promptText)
+      }
     }
 
     return collectOutput(session, outputParser, onUpdate, timeout)
@@ -188,15 +201,21 @@ export const createSessionManager = (config: SessionManagerConfig) => {
     const fullPrompt = session.history?.buildPrompt(promptText) ?? promptText
 
     // Build and spawn command
-    // Use 'ignore' for stdin - prompt is passed via command line flag
     const args = buildCommand(session, fullPrompt)
+    const stdinMode = schema.prompt.stdin ? 'pipe' : 'ignore'
+
     session.process = Bun.spawn(args, {
       cwd: session.cwd,
-      stdin: 'ignore',
+      stdin: stdinMode,
       stdout: 'pipe',
       stderr: 'inherit',
     })
 
+    // If using stdin, write the prompt
+    if (schema.prompt.stdin && session.process) {
+      writePromptToStdin(session.process, fullPrompt)
+    }
+
     const result = await collectOutput(session, outputParser, onUpdate, timeout)
 
     // Store in history for next turn
@@ -214,8 +233,10 @@ export const createSessionManager = (config: SessionManagerConfig) => {
   const buildCommand = (session: Session, promptText: string): string[] => {
     const args = [...schema.command]
 
-    // Add output format flags
-    args.push(schema.output.flag, schema.output.value)
+    // Add output format flags (only if non-empty)
+    if (schema.output.flag) {
+      args.push(schema.output.flag, schema.output.value)
+    }
 
     // Add auto-approve flags
     if (schema.autoApprove) {
@@ -232,12 +253,14 @@ export const createSessionManager = (config: SessionManagerConfig) => {
       args.push(schema.resume.flag, session.cliSessionId)
     }
 
-    // Add prompt flag and text
-    if (schema.prompt.flag) {
-      args.push(schema.prompt.flag, promptText)
-    } else {
-      // Positional argument (no flag)
-      args.push(promptText)
+    // Add prompt flag and text (skip if using stdin)
+    if (!schema.prompt.stdin) {
+      if (schema.prompt.flag) {
+        args.push(schema.prompt.flag, promptText)
+      } else {
+        // Positional argument (no flag)
+        args.push(promptText)
+      }
     }
 
     return args
@@ -299,6 +322,32 @@ const generateSessionId = (): string => {
   return `sess_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`
 }
 
+/**
+ * Writes a prompt to a process stdin stream.
+ *
+ * @remarks
+ * Uses Bun's FileSink API to write text to the process stdin.
+ * The FileSink type provides `write()` and `flush()` methods for
+ * efficient stream writing without async overhead.
+ *
+ * Type guard ensures stdin is a FileSink (not a file descriptor number)
+ * before attempting to write. This handles Bun's subprocess stdin types:
+ * - `'pipe'` → FileSink with write/flush methods
+ * - `'ignore'` → null (not writable)
+ * - number → file descriptor (not a FileSink)
+ *
+ * @param process - Subprocess with stdin stream
+ * @param prompt - Prompt text to write
+ *
+ * @internal
+ */
+const writePromptToStdin = (process: Subprocess, prompt: string): void => {
+  if (process.stdin && typeof process.stdin !== 'number') {
+    process.stdin.write(`${prompt}\n`)
+    process.stdin.flush()
+  }
+}
+
 /**
  * Collects output from a running process.
  *

package/src/headless.schemas.ts

@@ -79,13 +79,25 @@ export type OutputEventMapping = z.infer<typeof OutputEventMappingSchema>
 
 /**
  * Schema for how to pass prompts to the CLI.
+ *
+ * @remarks
+ * Three modes are supported:
+ * 1. **Flag-based**: `flag: "-p"` - Pass prompt via command-line flag
+ * 2. **Positional**: `flag: ""` - Pass prompt as positional argument
+ * 3. **Stdin**: `stdin: true` - Write prompt to stdin (command should include `-` or equivalent)
  */
-export const PromptConfigSchema = z.object({
-  /** Flag to pass prompt (e.g., "-p", "--prompt"). Omit for stdin. */
-  flag: z.string().optional(),
-  /** Format for stdin input in stream mode */
-  stdinFormat: z.enum(['text', 'json']).optional(),
-})
+export const PromptConfigSchema = z
+  .object({
+    /** Flag to pass prompt (e.g., "-p", "--prompt"). Empty string for positional. */
+    flag: z.string().optional(),
+    /** Use stdin to pass prompt instead of command args */
+    stdin: z.boolean().optional(),
+    /** Format for stdin input in stream mode */
+    stdinFormat: z.enum(['text', 'json']).optional(),
+  })
+  .refine((data) => !(data.flag && data.stdin), {
+    message: "Cannot specify both 'flag' and 'stdin' modes - use either flag-based or stdin mode, not both",
+  })
 
 /** Prompt configuration type */
 export type PromptConfig = z.infer<typeof PromptConfigSchema>

package/src/tests/headless.spec.ts

@@ -118,6 +118,59 @@ describe('HeadlessAdapterSchema', () => {
     })
   })
 
+  describe('stdin mode configuration', () => {
+    test('validates schema with stdin: true', () => {
+      const stdinSchema = {
+        version: 1,
+        name: 'stdin-agent',
+        command: ['agent', 'exec', '-'],
+        sessionMode: 'stream',
+        prompt: { stdin: true },
+        output: { flag: '--format', value: 'json' },
+        outputEvents: [],
+        result: { matchPath: '$.type', matchValue: 'done', contentPath: '$.text' },
+      }
+      const result = HeadlessAdapterSchema.safeParse(stdinSchema)
+      expect(result.success).toBe(true)
+    })
+
+    test('validates schema with stdin: false', () => {
+      const stdinSchema = {
+        version: 1,
+        name: 'stdin-agent',
+        command: ['agent'],
+        sessionMode: 'stream',
+        prompt: { stdin: false, flag: '-p' },
+        output: { flag: '--format', value: 'json' },
+        outputEvents: [],
+        result: { matchPath: '$.type', matchValue: 'done', contentPath: '$.text' },
+      }
+      const result = HeadlessAdapterSchema.safeParse(stdinSchema)
+      expect(result.success).toBe(true)
+    })
+
+    test('validates schema with positional prompt and - in command', () => {
+      const stdinSchema = {
+        version: 1,
+        name: 'codex-like',
+        command: ['codex', 'exec', '--json', '-'],
+        sessionMode: 'iterative',
+        prompt: { stdin: true },
+        output: { flag: '', value: '' },
+        outputEvents: [
+          {
+            match: { path: '$.item.type', value: 'agent_message' },
+            emitAs: 'message',
+            extract: { content: '$.item.text' },
+          },
+        ],
+        result: { matchPath: '$.type', matchValue: 'turn.completed', contentPath: '$.usage.output_tokens' },
+      }
+      const result = HeadlessAdapterSchema.safeParse(stdinSchema)
+      expect(result.success).toBe(true)
+    })
+  })
+
   describe('invalid schemas', () => {
     test('rejects missing version', () => {
       const invalid = { ...validClaudeSchema, version: undefined }
@@ -143,6 +196,22 @@ describe('HeadlessAdapterSchema', () => {
       expect(result.success).toBe(false)
     })
 
+    test('rejects both flag and stdin specified', () => {
+      const invalid = {
+        ...validClaudeSchema,
+        prompt: {
+          flag: '-p',
+          stdin: true,
+        },
+      }
+      const result = HeadlessAdapterSchema.safeParse(invalid)
+      expect(result.success).toBe(false)
+      // Type assertion after checking success is false
+      const error = (result as { success: false; error: { issues: Array<{ message: string }> } }).error
+      expect(error.issues.length).toBeGreaterThan(0)
+      expect(error.issues[0]!.message).toContain("Cannot specify both 'flag' and 'stdin' modes")
+    })
+
     test('rejects invalid emitAs type', () => {
       const invalid = {
         ...validClaudeSchema,