pi-usereq 0.48.0 → 0.50.0

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

@@ -1,65 +0,0 @@
-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

@@ -1,285 +0,0 @@
-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

@@ -1,321 +0,0 @@
-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);
-});