feat(cli): NDJSON stdin protocol, list subcommands, modularize run.ts

apps/cli/scripts/test-stdin-stream.ts

@@ -27,6 +27,16 @@ async function main() {
 	console.log("[wrapper] Type a message and press Enter to send it.")
 	console.log("[wrapper] Type /exit to close stdin and let the CLI finish.")
 
+	let requestCounter = 0
+	let hasStartedTask = false
+
+	const sendCommand = (payload: Record<string, unknown>) => {
+		if (child.stdin?.destroyed) {
+			return
+		}
+		child.stdin?.write(JSON.stringify(payload) + "\n")
+	}
+
 	const rl = readline.createInterface({
 		input: process.stdin,
 		output: process.stdout,
@@ -36,14 +46,22 @@ async function main() {
 	rl.on("line", (line) => {
 		if (line.trim() === "/exit") {
 			console.log("[wrapper] Closing stdin...")
+			sendCommand({
+				command: "shutdown",
+				requestId: `shutdown-${Date.now()}-${++requestCounter}`,
+			})
 			child.stdin?.end()
 			rl.close()
 			return
 		}
 
-		if (!child.stdin?.destroyed) {
-			child.stdin?.write(`${line}\n`)
-		}
+		const command = hasStartedTask ? "message" : "start"
+		sendCommand({
+			command,
+			requestId: `${command}-${Date.now()}-${++requestCounter}`,
+			prompt: line,
+		})
+		hasStartedTask = true
 	})
 
 	const onSignal = (signal: NodeJS.Signals) => {

apps/cli/src/agent/__tests__/json-event-emitter-control.test.ts

@@ -0,0 +1,170 @@
+import { Writable } from "stream"
+
+import { JsonEventEmitter } from "../json-event-emitter.js"
+
+function createMockStdout(): { stdout: NodeJS.WriteStream; lines: () => Record<string, unknown>[] } {
+	const chunks: string[] = []
+
+	const writable = new Writable({
+		write(chunk, _encoding, callback) {
+			chunks.push(chunk.toString())
+			callback()
+		},
+	}) as unknown as NodeJS.WriteStream
+
+	// Each write is a JSON line terminated by \n
+	const lines = () =>
+		chunks
+			.join("")
+			.split("\n")
+			.filter((l) => l.length > 0)
+			.map((l) => JSON.parse(l) as Record<string, unknown>)
+
+	return { stdout: writable, lines }
+}
+
+describe("JsonEventEmitter control events", () => {
+	describe("emitControl", () => {
+		it("emits an ack event with type control", () => {
+			const { stdout, lines } = createMockStdout()
+			const emitter = new JsonEventEmitter({ mode: "stream-json", stdout })
+
+			emitter.emitControl({
+				subtype: "ack",
+				requestId: "req-1",
+				command: "start",
+				content: "starting task",
+				code: "accepted",
+				success: true,
+			})
+
+			const output = lines()
+			expect(output).toHaveLength(1)
+			expect(output[0]!).toMatchObject({
+				type: "control",
+				subtype: "ack",
+				requestId: "req-1",
+				command: "start",
+				content: "starting task",
+				code: "accepted",
+				success: true,
+			})
+			expect(output[0]!.done).toBeUndefined()
+		})
+
+		it("sets done: true for done events", () => {
+			const { stdout, lines } = createMockStdout()
+			const emitter = new JsonEventEmitter({ mode: "stream-json", stdout })
+
+			emitter.emitControl({
+				subtype: "done",
+				requestId: "req-2",
+				command: "start",
+				content: "task completed",
+				code: "task_completed",
+				success: true,
+			})
+
+			const output = lines()
+			expect(output[0]!).toMatchObject({ type: "control", subtype: "done", done: true })
+		})
+
+		it("does not set done for error events", () => {
+			const { stdout, lines } = createMockStdout()
+			const emitter = new JsonEventEmitter({ mode: "stream-json", stdout })
+
+			emitter.emitControl({
+				subtype: "error",
+				requestId: "req-3",
+				command: "start",
+				content: "something went wrong",
+				code: "task_error",
+				success: false,
+			})
+
+			const output = lines()
+			expect(output[0]!.done).toBeUndefined()
+			expect(output[0]!.success).toBe(false)
+		})
+	})
+
+	describe("requestIdProvider", () => {
+		it("injects requestId from provider when event has none", () => {
+			const { stdout, lines } = createMockStdout()
+			const emitter = new JsonEventEmitter({
+				mode: "stream-json",
+				stdout,
+				requestIdProvider: () => "injected-id",
+			})
+
+			emitter.emitControl({ subtype: "ack", content: "test" })
+
+			const output = lines()
+			expect(output[0]!.requestId).toBe("injected-id")
+		})
+
+		it("keeps explicit requestId when provider also returns one", () => {
+			const { stdout, lines } = createMockStdout()
+			const emitter = new JsonEventEmitter({
+				mode: "stream-json",
+				stdout,
+				requestIdProvider: () => "provider-id",
+			})
+
+			emitter.emitControl({ subtype: "ack", requestId: "explicit-id", content: "test" })
+
+			const output = lines()
+			expect(output[0]!.requestId).toBe("explicit-id")
+		})
+
+		it("omits requestId when provider returns undefined and event has none", () => {
+			const { stdout, lines } = createMockStdout()
+			const emitter = new JsonEventEmitter({
+				mode: "stream-json",
+				stdout,
+				requestIdProvider: () => undefined,
+			})
+
+			emitter.emitControl({ subtype: "ack", content: "test" })
+
+			const output = lines()
+			expect(output[0]!).not.toHaveProperty("requestId")
+		})
+	})
+
+	describe("emitInit", () => {
+		it("emits system init with default schema values", () => {
+			const { stdout, lines } = createMockStdout()
+			const emitter = new JsonEventEmitter({ mode: "stream-json", stdout })
+
+			// emitInit requires a client — we call emitControl to test init-like fields instead.
+			// emitInit is called internally by attach(), so we test the init fields via options.
+			// Instead, directly verify the constructor defaults by emitting a control event
+			// and checking that the emitter was created with correct defaults.
+
+			// We can't call emitInit without a client, but we can verify the options
+			// were stored correctly by checking what emitControl produces.
+			emitter.emitControl({ subtype: "ack", content: "test" })
+
+			// The control event itself doesn't include schema fields, but at least
+			// we verify the emitter was constructed successfully with defaults.
+			const output = lines()
+			expect(output).toHaveLength(1)
+		})
+
+		it("accepts custom schemaVersion, protocol, and capabilities", () => {
+			const { stdout } = createMockStdout()
+
+			// Should not throw when constructed with custom values
+			const emitter = new JsonEventEmitter({
+				mode: "stream-json",
+				stdout,
+				schemaVersion: 2,
+				protocol: "custom-protocol",
+				capabilities: ["stdin:start", "stdin:message"],
+			})
+
+			expect(emitter).toBeDefined()
+		})
+	})
+})

apps/cli/src/agent/json-event-emitter.ts

@@ -16,7 +16,7 @@
 
 import type { ClineMessage } from "@roo-code/types"
 
-import type { JsonEvent, JsonEventCost, JsonFinalOutput } from "@/types/json-events.js"
+import type { JsonEvent, JsonEventCost, JsonEventQueueItem, JsonFinalOutput } from "@/types/json-events.js"
 
 import type { ExtensionClient } from "./extension-client.js"
 import type { AgentStateChangeEvent, TaskCompletedEvent } from "./events.js"
@@ -30,6 +30,14 @@ export interface JsonEventEmitterOptions {
 	mode: "json" | "stream-json"
 	/** Output stream (defaults to process.stdout) */
 	stdout?: NodeJS.WriteStream
+	/** Optional request id provider for correlating stream events */
+	requestIdProvider?: () => string | undefined
+	/** Transport schema version emitted in system:init */
+	schemaVersion?: number
+	/** Transport protocol identifier emitted in system:init */
+	protocol?: string
+	/** Supported stdin protocol capabilities emitted in system:init */
+	capabilities?: string[]
 }
 
 /**
@@ -89,17 +97,33 @@ export class JsonEventEmitter {
 	private events: JsonEvent[] = []
 	private unsubscribers: (() => void)[] = []
 	private lastCost: JsonEventCost | undefined
+	private requestIdProvider: () => string | undefined
+	private schemaVersion: number
+	private protocol: string
+	private capabilities: string[]
 	private seenMessageIds = new Set<number>()
 	// Track previous content for delta computation
 	private previousContent = new Map<number, string>()
 	// Track the completion result content
 	private completionResultContent: string | undefined
+	// Track the latest assistant text as a fallback for result.content.
+	private lastAssistantText: string | undefined
 	// The first non-partial "say:text" per task is the echoed user prompt.
 	private expectPromptEchoAsUser = true
 
 	constructor(options: JsonEventEmitterOptions) {
 		this.mode = options.mode
 		this.stdout = options.stdout ?? process.stdout
+		this.requestIdProvider = options.requestIdProvider ?? (() => undefined)
+		this.schemaVersion = options.schemaVersion ?? 1
+		this.protocol = options.protocol ?? "roo-cli-stream"
+		this.capabilities = options.capabilities ?? [
+			"stdin:start",
+			"stdin:message",
+			"stdin:cancel",
+			"stdin:ping",
+			"stdin:shutdown",
+		]
 	}
 
 	/**
@@ -120,6 +144,48 @@ export class JsonEventEmitter {
 			type: "system",
 			subtype: "init",
 			content: "Task started",
+			schemaVersion: this.schemaVersion,
+			protocol: this.protocol,
+			capabilities: this.capabilities,
+		})
+	}
+
+	emitControl(event: {
+		subtype: "ack" | "done" | "error"
+		requestId?: string
+		command?: string
+		taskId?: string
+		content?: string
+		success?: boolean
+		code?: string
+	}): void {
+		this.emitEvent({
+			type: "control",
+			subtype: event.subtype,
+			requestId: event.requestId,
+			command: event.command,
+			taskId: event.taskId,
+			content: event.content,
+			success: event.success,
+			code: event.code,
+			done: event.subtype === "done" ? true : undefined,
+		})
+	}
+
+	emitQueue(event: {
+		subtype: "snapshot" | "enqueued" | "dequeued" | "drained" | "updated"
+		taskId?: string
+		content?: string
+		queueDepth: number
+		queue: JsonEventQueueItem[]
+	}): void {
+		this.emitEvent({
+			type: "queue",
+			subtype: event.subtype,
+			taskId: event.taskId,
+			content: event.content,
+			queueDepth: event.queueDepth,
+			queue: event.queue,
 		})
 	}
 
@@ -248,6 +314,9 @@ export class JsonEventEmitter {
 					}
 				} else {
 					this.emitEvent(this.buildTextEvent("assistant", msg.ts, contentToSend, isDone))
+					if (msg.text) {
+						this.lastAssistantText = msg.text
+					}
 				}
 				break
 
@@ -387,7 +456,7 @@ export class JsonEventEmitter {
 	 */
 	private handleTaskCompleted(event: TaskCompletedEvent): void {
 		// Use tracked completion result content, falling back to event message
-		const resultContent = this.completionResultContent || event.message?.text
+		const resultContent = this.completionResultContent || event.message?.text || this.lastAssistantText
 
 		this.emitEvent({
 			type: "result",
@@ -421,10 +490,13 @@ export class JsonEventEmitter {
 	 * For json mode: accumulate for final output
 	 */
 	private emitEvent(event: JsonEvent): void {
-		this.events.push(event)
+		const requestId = event.requestId ?? this.requestIdProvider()
+		const payload = requestId ? { ...event, requestId } : event
+
+		this.events.push(payload)
 
 		if (this.mode === "stream-json") {
-			this.outputLine(event)
+			this.outputLine(payload)
 		}
 	}
 
@@ -466,6 +538,7 @@ export class JsonEventEmitter {
 		this.seenMessageIds.clear()
 		this.previousContent.clear()
 		this.completionResultContent = undefined
+		this.lastAssistantText = undefined
 		this.expectPromptEchoAsUser = true
 	}
 }

apps/cli/src/commands/cli/__tests__/list.test.ts

@@ -0,0 +1,29 @@
+import { parseFormat } from "../list.js"
+
+describe("parseFormat", () => {
+	it("defaults to json when undefined", () => {
+		expect(parseFormat(undefined)).toBe("json")
+	})
+
+	it("returns json for 'json'", () => {
+		expect(parseFormat("json")).toBe("json")
+	})
+
+	it("returns text for 'text'", () => {
+		expect(parseFormat("text")).toBe("text")
+	})
+
+	it("is case-insensitive", () => {
+		expect(parseFormat("JSON")).toBe("json")
+		expect(parseFormat("Text")).toBe("text")
+		expect(parseFormat("TEXT")).toBe("text")
+	})
+
+	it("throws on invalid format", () => {
+		expect(() => parseFormat("xml")).toThrow('Invalid format: xml. Must be "json" or "text".')
+	})
+
+	it("throws on empty string", () => {
+		expect(() => parseFormat("")).toThrow("Invalid format")
+	})
+})