pi-usereq 0.6.0 → 0.10.0

package/pi.dev-src/pi-mono/coding-agent/test/rpc-jsonl.test.ts

@@ -0,0 +1,65 @@
+import { Readable } from "node:stream";
+import { describe, expect, test } from "vitest";
+import { attachJsonlLineReader, serializeJsonLine } from "../src/modes/rpc/jsonl.js";
+
+describe("RPC JSONL framing", () => {
+	test("serializes strict JSONL records without escaping Unicode separators", () => {
+		const line = serializeJsonLine({ text: "a\u2028b\u2029c" });
+
+		expect(line).toContain("a\u2028b\u2029c");
+		expect(line.endsWith("\n")).toBe(true);
+		expect(JSON.parse(line.trim())).toEqual({ text: "a\u2028b\u2029c" });
+	});
+
+	test("splits on LF only and preserves U+2028/U+2029 inside payloads", async () => {
+		const lines: string[] = [];
+		const stream = Readable.from([serializeJsonLine({ text: "a\u2028b\u2029c" })]);
+
+		const done = new Promise<void>((resolve) => {
+			stream.on("end", resolve);
+		});
+
+		attachJsonlLineReader(stream, (line) => {
+			lines.push(line);
+		});
+
+		await done;
+
+		expect(lines).toHaveLength(1);
+		expect(JSON.parse(lines[0])).toEqual({ text: "a\u2028b\u2029c" });
+	});
+
+	test("handles CRLF-delimited input", async () => {
+		const lines: string[] = [];
+		const stream = Readable.from([Buffer.from('{"a":1}\r\n{"b":2}\r\n')]);
+
+		const done = new Promise<void>((resolve) => {
+			stream.on("end", resolve);
+		});
+
+		attachJsonlLineReader(stream, (line) => {
+			lines.push(line);
+		});
+
+		await done;
+
+		expect(lines).toEqual(['{"a":1}', '{"b":2}']);
+	});
+
+	test("emits a final line without trailing LF", async () => {
+		const lines: string[] = [];
+		const stream = Readable.from([Buffer.from('{"a":1}')]);
+
+		const done = new Promise<void>((resolve) => {
+			stream.on("end", resolve);
+		});
+
+		attachJsonlLineReader(stream, (line) => {
+			lines.push(line);
+		});
+
+		await done;
+
+		expect(lines).toEqual(['{"a":1}']);
+	});
+});

package/pi.dev-src/pi-mono/coding-agent/test/rpc-prompt-response-semantics.test.ts

@@ -0,0 +1,285 @@
+import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Agent } from "@mariozechner/pi-agent-core";
+import {
+	type AssistantMessage,
+	type AssistantMessageEvent,
+	EventStream,
+	getModel,
+	type Model,
+} from "@mariozechner/pi-ai";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { AgentSession } from "../src/core/agent-session.js";
+import type { AgentSessionRuntime } from "../src/core/agent-session-runtime.js";
+import { AuthStorage } from "../src/core/auth-storage.js";
+import { ModelRegistry } from "../src/core/model-registry.js";
+import { SessionManager } from "../src/core/session-manager.js";
+import { SettingsManager } from "../src/core/settings-manager.js";
+import { runRpcMode } from "../src/modes/rpc/rpc-mode.js";
+import { createTestResourceLoader } from "./utilities.js";
+
+const rpcIo = vi.hoisted(() => ({
+	outputLines: [] as string[],
+	lineHandler: undefined as ((line: string) => void) | undefined,
+}));
+
+vi.mock("../src/core/output-guard.js", () => ({
+	takeOverStdout: vi.fn(),
+	writeRawStdout: (line: string) => {
+		rpcIo.outputLines.push(line);
+	},
+}));
+
+vi.mock("../src/modes/interactive/theme/theme.js", () => ({ theme: {} }));
+
+vi.mock("../src/modes/rpc/jsonl.js", () => ({
+	attachJsonlLineReader: vi.fn((_stream: NodeJS.ReadableStream, onLine: (line: string) => void) => {
+		rpcIo.lineHandler = onLine;
+		return () => {};
+	}),
+	serializeJsonLine: (value: unknown) => `${JSON.stringify(value)}\n`,
+}));
+
+class MockAssistantStream extends EventStream<AssistantMessageEvent, AssistantMessage> {
+	constructor() {
+		super(
+			(event) => event.type === "done" || event.type === "error",
+			(event) => {
+				if (event.type === "done") return event.message;
+				if (event.type === "error") return event.error;
+				throw new Error("Unexpected event type");
+			},
+		);
+	}
+}
+
+function createAssistantMessage(text: string): AssistantMessage {
+	return {
+		role: "assistant",
+		content: [{ type: "text", text }],
+		api: "anthropic-messages",
+		provider: "anthropic",
+		model: "claude-sonnet-4-5",
+		usage: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			totalTokens: 0,
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+		},
+		stopReason: "stop",
+		timestamp: Date.now(),
+	};
+}
+
+type ParsedOutputLine = Record<string, unknown>;
+
+function parseOutputLines(outputLines: string[]): ParsedOutputLine[] {
+	return outputLines
+		.flatMap((line) => line.split("\n"))
+		.filter((line) => line.trim().length > 0)
+		.map((line) => JSON.parse(line) as ParsedOutputLine);
+}
+
+function getPromptResponses(outputLines: string[], id: string): ParsedOutputLine[] {
+	return parseOutputLines(outputLines).filter(
+		(record) => record.id === id && record.type === "response" && record.command === "prompt",
+	);
+}
+
+function sleep(ms: number): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function createRuntimeHost(options: { withAuth: boolean; responseDelayMs: number; model?: Model<any> }): {
+	runtimeHost: AgentSessionRuntime;
+	cleanup: () => Promise<void>;
+} {
+	const tempDir = join(tmpdir(), `pi-rpc-prompt-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+	mkdirSync(tempDir, { recursive: true });
+
+	const model = options.model ?? getModel("anthropic", "claude-sonnet-4-5");
+	if (!model) {
+		throw new Error("Test model not found");
+	}
+
+	const agent = new Agent({
+		getApiKey: () => "test-key",
+		initialState: {
+			model,
+			systemPrompt: "Test",
+			tools: [],
+		},
+		streamFn: (_model, _context, _options) => {
+			const stream = new MockAssistantStream();
+			queueMicrotask(() => {
+				stream.push({ type: "start", partial: createAssistantMessage("") });
+				setTimeout(() => {
+					stream.push({ type: "done", reason: "stop", message: createAssistantMessage("done") });
+				}, options.responseDelayMs);
+			});
+			return stream;
+		},
+	});
+
+	const sessionManager = SessionManager.inMemory();
+	const settingsManager = SettingsManager.create(tempDir, tempDir);
+	const authStorage = AuthStorage.create(join(tempDir, "auth.json"));
+	const modelRegistry = ModelRegistry.create(authStorage, tempDir);
+	if (options.withAuth) {
+		authStorage.setRuntimeApiKey("anthropic", "test-key");
+	}
+
+	const session = new AgentSession({
+		agent,
+		sessionManager,
+		settingsManager,
+		cwd: tempDir,
+		modelRegistry,
+		resourceLoader: createTestResourceLoader(),
+	});
+
+	const runtimeHost = {
+		session,
+		newSession: vi.fn(async () => ({ cancelled: true })),
+		switchSession: vi.fn(async () => ({ cancelled: true })),
+		fork: vi.fn(async () => ({ cancelled: true, selectedText: "" })),
+		dispose: vi.fn(async () => {}),
+	} as unknown as AgentSessionRuntime;
+
+	return {
+		runtimeHost,
+		cleanup: async () => {
+			try {
+				if (session.isStreaming) {
+					await session.abort();
+				}
+			} catch {
+				// ignore test cleanup failures
+			}
+			session.dispose();
+			if (existsSync(tempDir)) {
+				rmSync(tempDir, { recursive: true });
+			}
+		},
+	};
+}
+
+async function startRpcMode(options: { withAuth: boolean; responseDelayMs: number; model?: Model<any> }): Promise<{
+	lineHandler: (line: string) => void;
+	cleanup: () => Promise<void>;
+}> {
+	rpcIo.outputLines = [];
+	rpcIo.lineHandler = undefined;
+
+	const { runtimeHost, cleanup } = createRuntimeHost(options);
+	void runRpcMode(runtimeHost);
+	await vi.waitFor(() => expect(rpcIo.lineHandler).toBeDefined());
+
+	return { lineHandler: rpcIo.lineHandler!, cleanup };
+}
+
+describe("RPC prompt response semantics", () => {
+	afterEach(() => {
+		rpcIo.outputLines = [];
+		rpcIo.lineHandler = undefined;
+	});
+
+	it("emits one failure response when prompt preflight rejects", async () => {
+		const { lineHandler, cleanup } = await startRpcMode({
+			withAuth: false,
+			responseDelayMs: 0,
+			model: {
+				id: "fake-model",
+				name: "Fake Model",
+				api: "openai-completions",
+				provider: "fake-provider",
+				baseUrl: "https://example.invalid",
+				reasoning: false,
+				input: [],
+				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+				contextWindow: 0,
+				maxTokens: 0,
+			},
+		});
+
+		try {
+			lineHandler(JSON.stringify({ id: "b1", type: "prompt", message: "Hello" }));
+
+			await vi.waitFor(() => {
+				const responses = getPromptResponses(rpcIo.outputLines, "b1");
+				expect(responses).toHaveLength(1);
+				expect(responses[0]).toMatchObject({
+					id: "b1",
+					type: "response",
+					command: "prompt",
+					success: false,
+					error: expect.stringContaining(
+						"No API key found for fake-provider.\n\nUse /login or set an API key environment variable. See ",
+					),
+				});
+			});
+		} finally {
+			await cleanup();
+		}
+	});
+
+	it("emits one success response when prompt preflight succeeds", async () => {
+		const { lineHandler, cleanup } = await startRpcMode({ withAuth: true, responseDelayMs: 0 });
+
+		try {
+			lineHandler(JSON.stringify({ id: "b2", type: "prompt", message: "Hello" }));
+
+			await vi.waitFor(() => {
+				const responses = getPromptResponses(rpcIo.outputLines, "b2");
+				expect(responses).toHaveLength(1);
+				expect(responses[0]).toMatchObject({
+					id: "b2",
+					type: "response",
+					command: "prompt",
+					success: true,
+				});
+			});
+		} finally {
+			await cleanup();
+		}
+	});
+
+	it("emits one success response when prompt is queued during streaming", async () => {
+		const { lineHandler, cleanup } = await startRpcMode({ withAuth: true, responseDelayMs: 100 });
+
+		try {
+			lineHandler(JSON.stringify({ id: "b3-start", type: "prompt", message: "Start" }));
+			await vi.waitFor(() => {
+				expect(getPromptResponses(rpcIo.outputLines, "b3-start")).toHaveLength(1);
+			});
+
+			rpcIo.outputLines = [];
+			lineHandler(
+				JSON.stringify({
+					id: "b3",
+					type: "prompt",
+					message: "Queue this",
+					streamingBehavior: "followUp",
+				}),
+			);
+
+			await vi.waitFor(() => {
+				const responses = getPromptResponses(rpcIo.outputLines, "b3");
+				expect(responses).toHaveLength(1);
+				expect(responses[0]).toMatchObject({
+					id: "b3",
+					type: "response",
+					command: "prompt",
+					success: true,
+				});
+			});
+
+			await sleep(150);
+		} finally {
+			await cleanup();
+		}
+	});
+});

package/pi.dev-src/pi-mono/coding-agent/test/rpc.test.ts

@@ -0,0 +1,321 @@
+import { existsSync, readdirSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { AgentEvent } from "@mariozechner/pi-agent-core";
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { RpcClient } from "../src/modes/rpc/rpc-client.js";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+/**
+ * RPC mode tests.
+ */
+describe.skipIf(!process.env.ANTHROPIC_API_KEY && !process.env.ANTHROPIC_OAUTH_TOKEN)("RPC mode", () => {
+	let client: RpcClient;
+	let sessionDir: string;
+
+	beforeEach(() => {
+		sessionDir = join(tmpdir(), `pi-rpc-test-${Date.now()}`);
+		client = new RpcClient({
+			cliPath: join(__dirname, "..", "dist", "cli.js"),
+			cwd: join(__dirname, ".."),
+			env: { PI_CODING_AGENT_DIR: sessionDir },
+			provider: "anthropic",
+			model: "claude-sonnet-4-5",
+		});
+	});
+
+	afterEach(async () => {
+		await client.stop();
+		if (sessionDir && existsSync(sessionDir)) {
+			rmSync(sessionDir, { recursive: true });
+		}
+	});
+
+	test("should get state", async () => {
+		await client.start();
+		const state = await client.getState();
+
+		expect(state.model).toBeDefined();
+		expect(state.model?.provider).toBe("anthropic");
+		expect(state.model?.id).toBe("claude-sonnet-4-5");
+		expect(state.isStreaming).toBe(false);
+		expect(state.messageCount).toBe(0);
+	}, 30000);
+
+	test("should save messages to session file", async () => {
+		await client.start();
+
+		// Send prompt and wait for completion
+		const events = await client.promptAndWait("Reply with just the word 'hello'");
+
+		// Should have message events
+		const messageEndEvents = events.filter((e) => e.type === "message_end");
+		expect(messageEndEvents.length).toBeGreaterThanOrEqual(2); // user + assistant
+
+		// Wait for file writes
+		await new Promise((resolve) => setTimeout(resolve, 200));
+
+		// Verify session file
+		const sessionsPath = join(sessionDir, "sessions");
+		expect(existsSync(sessionsPath)).toBe(true);
+
+		const sessionDirs = readdirSync(sessionsPath);
+		expect(sessionDirs.length).toBeGreaterThan(0);
+
+		const cwdSessionDir = join(sessionsPath, sessionDirs[0]);
+		const sessionFiles = readdirSync(cwdSessionDir).filter((f) => f.endsWith(".jsonl"));
+		expect(sessionFiles.length).toBe(1);
+
+		const sessionContent = readFileSync(join(cwdSessionDir, sessionFiles[0]), "utf8");
+		const entries = sessionContent
+			.trim()
+			.split("\n")
+			.map((line) => JSON.parse(line));
+
+		// First entry should be session header
+		expect(entries[0].type).toBe("session");
+
+		// Should have user and assistant messages
+		const messages = entries.filter((e: { type: string }) => e.type === "message");
+		expect(messages.length).toBeGreaterThanOrEqual(2);
+
+		const roles = messages.map((m: { message: { role: string } }) => m.message.role);
+		expect(roles).toContain("user");
+		expect(roles).toContain("assistant");
+	}, 90000);
+
+	test("should handle manual compaction", async () => {
+		await client.start();
+
+		// First send a prompt to have messages to compact
+		await client.promptAndWait("Say hello");
+
+		// Compact
+		const result = await client.compact();
+		expect(result.summary).toBeDefined();
+		expect(result.tokensBefore).toBeGreaterThan(0);
+
+		// Wait for file writes
+		await new Promise((resolve) => setTimeout(resolve, 200));
+
+		// Verify compaction in session file
+		const sessionsPath = join(sessionDir, "sessions");
+		const sessionDirs = readdirSync(sessionsPath);
+		const cwdSessionDir = join(sessionsPath, sessionDirs[0]);
+		const sessionFiles = readdirSync(cwdSessionDir).filter((f) => f.endsWith(".jsonl"));
+		const sessionContent = readFileSync(join(cwdSessionDir, sessionFiles[0]), "utf8");
+		const entries = sessionContent
+			.trim()
+			.split("\n")
+			.map((line) => JSON.parse(line));
+
+		const compactionEntries = entries.filter((e: { type: string }) => e.type === "compaction");
+		expect(compactionEntries.length).toBe(1);
+		expect(compactionEntries[0].summary).toBeDefined();
+	}, 120000);
+
+	test("should execute bash command", async () => {
+		await client.start();
+
+		const result = await client.bash("echo hello");
+		expect(result.output.trim()).toBe("hello");
+		expect(result.exitCode).toBe(0);
+		expect(result.cancelled).toBe(false);
+	}, 30000);
+
+	test("should add bash output to context", async () => {
+		await client.start();
+
+		// First send a prompt to initialize session
+		await client.promptAndWait("Say hi");
+
+		// Run bash command
+		const uniqueValue = `test-${Date.now()}`;
+		await client.bash(`echo ${uniqueValue}`);
+
+		// Wait for file writes
+		await new Promise((resolve) => setTimeout(resolve, 200));
+
+		// Verify bash message in session
+		const sessionsPath = join(sessionDir, "sessions");
+		const sessionDirs = readdirSync(sessionsPath);
+		const cwdSessionDir = join(sessionsPath, sessionDirs[0]);
+		const sessionFiles = readdirSync(cwdSessionDir).filter((f) => f.endsWith(".jsonl"));
+		const sessionContent = readFileSync(join(cwdSessionDir, sessionFiles[0]), "utf8");
+		const entries = sessionContent
+			.trim()
+			.split("\n")
+			.map((line) => JSON.parse(line));
+
+		const bashMessages = entries.filter(
+			(e: { type: string; message?: { role: string } }) =>
+				e.type === "message" && e.message?.role === "bashExecution",
+		);
+		expect(bashMessages.length).toBe(1);
+		expect(bashMessages[0].message.output).toContain(uniqueValue);
+	}, 90000);
+
+	test("should include bash output in LLM context", async () => {
+		await client.start();
+
+		// Run a bash command with a unique value
+		const uniqueValue = `unique-${Date.now()}`;
+		await client.bash(`echo ${uniqueValue}`);
+
+		// Ask the LLM what the output was
+		const events = await client.promptAndWait(
+			"What was the exact output of the echo command I just ran? Reply with just the value, nothing else.",
+		);
+
+		// Find assistant's response
+		const messageEndEvents = events.filter((e) => e.type === "message_end") as AgentEvent[];
+		const assistantMessage = messageEndEvents.find(
+			(e) => e.type === "message_end" && e.message?.role === "assistant",
+		) as any;
+
+		expect(assistantMessage).toBeDefined();
+
+		const textContent = assistantMessage.message.content.find((c: any) => c.type === "text");
+		expect(textContent?.text).toContain(uniqueValue);
+	}, 90000);
+
+	test("should set and get thinking level", async () => {
+		await client.start();
+
+		// Set thinking level
+		await client.setThinkingLevel("high");
+
+		// Verify via state
+		const state = await client.getState();
+		expect(state.thinkingLevel).toBe("high");
+	}, 30000);
+
+	test("should cycle thinking level", async () => {
+		await client.start();
+
+		// Get initial level
+		const initialState = await client.getState();
+		const initialLevel = initialState.thinkingLevel;
+
+		// Cycle
+		const result = await client.cycleThinkingLevel();
+		expect(result).toBeDefined();
+		expect(result!.level).not.toBe(initialLevel);
+
+		// Verify via state
+		const newState = await client.getState();
+		expect(newState.thinkingLevel).toBe(result!.level);
+	}, 30000);
+
+	test("should get available models", async () => {
+		await client.start();
+
+		const models = await client.getAvailableModels();
+		expect(models.length).toBeGreaterThan(0);
+
+		// All models should have required fields
+		for (const model of models) {
+			expect(model.provider).toBeDefined();
+			expect(model.id).toBeDefined();
+			expect(model.contextWindow).toBeGreaterThan(0);
+			expect(typeof model.reasoning).toBe("boolean");
+		}
+	}, 30000);
+
+	test("should get session stats", async () => {
+		await client.start();
+
+		// Send a prompt first
+		await client.promptAndWait("Hello");
+
+		const stats = await client.getSessionStats();
+		expect(stats.sessionFile).toBeDefined();
+		expect(stats.sessionId).toBeDefined();
+		expect(stats.userMessages).toBeGreaterThanOrEqual(1);
+		expect(stats.assistantMessages).toBeGreaterThanOrEqual(1);
+	}, 90000);
+
+	test("should create new session", async () => {
+		await client.start();
+
+		// Send a prompt
+		await client.promptAndWait("Hello");
+
+		// Verify messages exist
+		let state = await client.getState();
+		expect(state.messageCount).toBeGreaterThan(0);
+
+		// New session
+		await client.newSession();
+
+		// Verify messages cleared
+		state = await client.getState();
+		expect(state.messageCount).toBe(0);
+	}, 90000);
+
+	test("should export to HTML", async () => {
+		await client.start();
+
+		// Send a prompt first
+		await client.promptAndWait("Hello");
+
+		// Export
+		const result = await client.exportHtml();
+		expect(result.path).toBeDefined();
+		expect(result.path.endsWith(".html")).toBe(true);
+		expect(existsSync(result.path)).toBe(true);
+	}, 90000);
+
+	test("should get last assistant text", async () => {
+		await client.start();
+
+		// Initially null
+		let text = await client.getLastAssistantText();
+		expect(text).toBeUndefined();
+
+		// Send prompt
+		await client.promptAndWait("Reply with just: test123");
+
+		// Should have text now
+		text = await client.getLastAssistantText();
+		expect(text).toContain("test123");
+	}, 90000);
+
+	test("should set and get session name", async () => {
+		await client.start();
+
+		// Initially undefined
+		let state = await client.getState();
+		expect(state.sessionName).toBeUndefined();
+
+		// Send a prompt first - session files are only written after first assistant message
+		await client.promptAndWait("Reply with just 'ok'");
+
+		// Set name
+		await client.setSessionName("my-test-session");
+
+		// Verify via state
+		state = await client.getState();
+		expect(state.sessionName).toBe("my-test-session");
+
+		// Wait for file writes
+		await new Promise((resolve) => setTimeout(resolve, 200));
+
+		// Verify session_info entry in session file
+		const sessionsPath = join(sessionDir, "sessions");
+		const sessionDirs = readdirSync(sessionsPath);
+		const cwdSessionDir = join(sessionsPath, sessionDirs[0]);
+		const sessionFiles = readdirSync(cwdSessionDir).filter((f) => f.endsWith(".jsonl"));
+		const sessionContent = readFileSync(join(cwdSessionDir, sessionFiles[0]), "utf8");
+		const entries = sessionContent
+			.trim()
+			.split("\n")
+			.map((line) => JSON.parse(line));
+
+		const sessionInfoEntries = entries.filter((e: { type: string }) => e.type === "session_info");
+		expect(sessionInfoEntries.length).toBe(1);
+		expect(sessionInfoEntries[0].name).toBe("my-test-session");
+	}, 60000);
+});