v1.2.0: SquireOptions.keepStdinOpen for follow-up stdin input

The .send() API has existed since v1.0 but was unusable in practice:
start() unconditionally calls child.stdin.end() right after writing the
initial prompt, so any later send() throws ADAPTER_UNSUPPORTED_FEATURE
because stdin is already closed. That defeats the point of the API for
CLIs that DO accept follow-up input — Claude Code's
`--input-format stream-json` mode being the motivating case (a host
needs to deliver tool_result for AskUserQuestion mid-turn).

Adds an opt-in `keepStdinOpen` flag on SquireOptions. When set, start()
writes the initial prompt but leaves stdin open, so the host can call
.send(followup) until the child exits. Off by default — every existing
one-shot caller is unchanged.

Includes a test that drives the new path end-to-end: spawn a child that
reads stdin lines, start() with the first line, send() two more lines,
sentinel exits the child, assert assembled output matches what was
delivered across all three writes.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: PythonLuvr

CHANGELOG.md

@@ -8,6 +8,12 @@ The v1.0 public API surface (everything exported from `src/index.ts`) is frozen.
 
 ## [Unreleased]
 
+## [1.2.0] - 2026-05-23
+
+### Added
+- `SquireOptions.keepStdinOpen`: when set, `start()` writes the initial prompt but does NOT close the child's stdin afterwards, so the host can deliver follow-up messages via `.send()` (e.g. a `tool_result` for a CLI that asked the user a question mid-turn). Off by default — existing one-shot callers are unchanged. Pairs with `--input-format stream-json` on the Claude Code CLI; other binaries' contracts vary.
+- Test coverage for the new option: `keepStdinOpen: send() works after start() to deliver follow-up input`.
+
 ## [1.1.0] - 2026-05-19
 
 ### Added

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pythonluvr/squire",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "General-purpose runtime for spawning CLI AI agents (Claude Code, Codex, Gemini CLI) as subprocesses with structured event streaming, MCP tool forwarding, and permission auto-setup.",
   "license": "MIT",
   "type": "module",

src/options.ts

@@ -87,4 +87,15 @@ export interface SquireOptions {
    * own per-CLI output parsing.
    */
   adapter?: string;
+  /**
+   * When true, write the initial prompt to the child's stdin but do NOT
+   * close stdin afterwards. Lets the host deliver follow-up messages via
+   * `.send()` (e.g. a `tool_result` for a CLI that exposed a question to
+   * the user mid-turn). Off by default — most one-shot CLIs expect stdin
+   * to close so they can flush and exit.
+   *
+   * The target CLI must accept follow-up input. For Claude Code that is
+   * `--input-format stream-json`; for other binaries see their own docs.
+   */
+  keepStdinOpen?: boolean;
 }

src/squire.ts

@@ -133,10 +133,16 @@ export class Squire extends EventEmitter {
       else opts.signal.addEventListener("abort", onAbort, { once: true });
     }
 
-    // Pipe stdin
+    // Pipe stdin. When `keepStdinOpen` is set, write the initial prompt
+    // but DON'T close stdin: the host plans to deliver follow-up messages
+    // via `.send()` (e.g. a `tool_result` for a CLI that asked the user a
+    // question mid-turn). Default is one-shot: write, end, let the CLI
+    // flush and exit.
     try {
       child.stdin?.write(prompt);
-      child.stdin?.end();
+      if (!this.options.keepStdinOpen) {
+        child.stdin?.end();
+      }
     } catch {
       // EPIPE if child died before consuming stdin. Surfaces via exit handler.
     }

tests/squire.test.ts

@@ -222,6 +222,45 @@ test("prompt passes through stdin to the child", async () => {
   }
 });
 
+test("keepStdinOpen: send() works after start() to deliver follow-up input", async () => {
+  // Child reads stdin lines, echoes each prefixed, exits on a sentinel line.
+  // Without keepStdinOpen the child would see EOF after the initial prompt
+  // and the .send() below would throw.
+  const code = [
+    "process.stdin.setEncoding('utf8');",
+    "let buf='';",
+    "process.stdin.on('data', c => {",
+    "  buf += c;",
+    "  let i;",
+    "  while ((i = buf.indexOf('\\n')) !== -1) {",
+    "    const line = buf.slice(0, i); buf = buf.slice(i + 1);",
+    "    if (line === 'BYE') { process.stdout.write('done'); process.exit(0); }",
+    "    process.stdout.write('got:' + line + '|');",
+    "  }",
+    "});",
+  ].join("");
+  const squire = new Squire({
+    binary: process.execPath,
+    args: ["-e", code],
+    keepStdinOpen: true,
+  });
+  const events: SquireEvent[] = [];
+  squire.on("event", (e: SquireEvent) => events.push(e));
+  // Start with the initial line; do NOT await yet, the child stays alive
+  // waiting for more stdin.
+  const done = squire.start("hello\n");
+  // Give the child a tick to register the data handler before we send more.
+  await new Promise((r) => setTimeout(r, 50));
+  await squire.send("world\n");
+  await squire.send("BYE\n");
+  await done;
+  const stop = events.find((e) => e.type === "message_stop");
+  assert.ok(stop);
+  if (stop?.type === "message_stop") {
+    assert.equal(stop.assembled, "got:hello|got:world|done");
+  }
+});
+
 test("autoSetup: writeSettings=false skips the merge", async () => {
   // No setttings file is written because writeSettings is explicitly off.
   const squire = new Squire({