@victor-software-house/pi-acp 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1579 @@
+#!/usr/bin/env node
+import { homedir, platform } from "node:os";
+import { AgentSideConnection, RequestError, ndJsonStream } from "@agentclientprotocol/sdk";
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { SessionManager, VERSION, createAgentSession } from "@mariozechner/pi-coding-agent";
+import * as z from "zod";
+//#region src/pi-auth/status.ts
+/**
+* Detect whether the user has any pi authentication configured.
+*
+* Checks three sources:
+* 1. auth.json (API keys, OAuth credentials)
+* 2. models.json custom provider apiKey entries
+* 3. Known provider environment variables
+*/
+const modelsConfigSchema = z.object({ providers: z.record(z.string().trim(), z.object({ apiKey: z.string().trim().optional() })).optional() });
+function agentDir() {
+	const env = process.env.PI_CODING_AGENT_DIR;
+	if (env === void 0) return join(homedir(), ".pi", "agent");
+	if (env === "~") return homedir();
+	if (env.startsWith("~/")) return homedir() + env.slice(1);
+	return env;
+}
+function readJsonFile(path) {
+	try {
+		if (!existsSync(path)) return null;
+		const raw = readFileSync(path, "utf-8").trim();
+		if (!raw) return null;
+		return JSON.parse(raw);
+	} catch {
+		return null;
+	}
+}
+function hasAuthJson() {
+	const data = readJsonFile(join(agentDir(), "auth.json"));
+	return typeof data === "object" && data !== null && Object.keys(data).length > 0;
+}
+function hasCustomProviderKey() {
+	const raw = readJsonFile(join(agentDir(), "models.json"));
+	const result = modelsConfigSchema.safeParse(raw);
+	if (!result.success || !result.data.providers) return false;
+	return Object.values(result.data.providers).some((provider) => typeof provider.apiKey === "string" && provider.apiKey.trim().length > 0);
+}
+/** Environment variables that indicate a configured provider API key. */
+const PROVIDER_ENV_VARS = [
+	"ANTHROPIC_API_KEY",
+	"ANTHROPIC_OAUTH_TOKEN",
+	"OPENAI_API_KEY",
+	"AZURE_OPENAI_API_KEY",
+	"GEMINI_API_KEY",
+	"GROQ_API_KEY",
+	"CEREBRAS_API_KEY",
+	"XAI_API_KEY",
+	"OPENROUTER_API_KEY",
+	"AI_GATEWAY_API_KEY",
+	"ZAI_API_KEY",
+	"MISTRAL_API_KEY",
+	"MINIMAX_API_KEY",
+	"MINIMAX_CN_API_KEY",
+	"HF_TOKEN",
+	"OPENCODE_API_KEY",
+	"KIMI_API_KEY",
+	"COPILOT_GITHUB_TOKEN",
+	"GH_TOKEN",
+	"GITHUB_TOKEN"
+];
+function hasProviderEnvVar() {
+	return PROVIDER_ENV_VARS.some((key) => {
+		const val = process.env[key];
+		return typeof val === "string" && val.trim().length > 0;
+	});
+}
+function hasPiAuthConfigured() {
+	return hasAuthJson() || hasCustomProviderKey() || hasProviderEnvVar();
+}
+//#endregion
+//#region src/acp/auth.ts
+const AUTH_METHOD_ID = "pi_terminal_login";
+function buildAuthMethods(opts) {
+	const supportsTerminalAuthMeta = opts?.supportsTerminalAuthMeta ?? true;
+	const method = {
+		id: AUTH_METHOD_ID,
+		name: "Launch pi in the terminal",
+		description: "Start pi in an interactive terminal to configure API keys or login",
+		type: "terminal",
+		args: ["--terminal-login"],
+		env: {}
+	};
+	if (supportsTerminalAuthMeta) {
+		const launch = resolveTerminalLaunchCommand();
+		method._meta = { "terminal-auth": {
+			...launch,
+			label: "Launch pi"
+		} };
+	}
+	return [method];
+}
+function resolveTerminalLaunchCommand() {
+	const argv0 = process.argv[0] ?? "node";
+	const argv1 = process.argv[1];
+	if (argv1 !== void 0 && argv0.includes("node") && argv1.endsWith(".js")) return {
+		command: argv0,
+		args: [argv1, "--terminal-login"]
+	};
+	return {
+		command: "pi-acp",
+		args: ["--terminal-login"]
+	};
+}
+//#endregion
+//#region src/acp/pi-settings.ts
+/**
+* Read pi settings from global and project config files.
+*
+* Settings are merged: project overrides global.
+* Paths follow pi-mono conventions:
+*   Global: ~/.pi/agent/settings.json
+*   Project: <cwd>/.pi/settings.json
+*/
+const piSettingsSchema = z.object({
+	enableSkillCommands: z.boolean().optional(),
+	quietStartup: z.boolean().optional(),
+	quietStart: z.boolean().optional(),
+	skills: z.object({ enableSkillCommands: z.boolean().optional() }).optional()
+});
+function isRecord(x) {
+	return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+function merge(base, override) {
+	const result = { ...base };
+	for (const [key, val] of Object.entries(override)) {
+		const existing = result[key];
+		if (isRecord(existing) && isRecord(val)) result[key] = merge(existing, val);
+		else result[key] = val;
+	}
+	return result;
+}
+function readJson(path) {
+	try {
+		if (!existsSync(path)) return {};
+		const data = JSON.parse(readFileSync(path, "utf-8"));
+		return isRecord(data) ? data : {};
+	} catch {
+		return {};
+	}
+}
+function piAgentDir() {
+	return process.env.PI_CODING_AGENT_DIR !== void 0 ? resolve(process.env.PI_CODING_AGENT_DIR) : join(homedir(), ".pi", "agent");
+}
+function resolvedSettings(cwd) {
+	const globalPath = join(piAgentDir(), "settings.json");
+	const projectPath = resolve(cwd, ".pi", "settings.json");
+	const merged = merge(readJson(globalPath), readJson(projectPath));
+	const result = piSettingsSchema.safeParse(merged);
+	return result.success ? result.data : {};
+}
+function skillCommandsEnabled(cwd) {
+	const settings = resolvedSettings(cwd);
+	if (typeof settings.enableSkillCommands === "boolean") return settings.enableSkillCommands;
+	if (typeof settings.skills?.enableSkillCommands === "boolean") return settings.skills.enableSkillCommands;
+	return true;
+}
+function quietStartupEnabled(cwd) {
+	const settings = resolvedSettings(cwd);
+	if (typeof settings.quietStartup === "boolean") return settings.quietStartup;
+	if (typeof settings.quietStart === "boolean") return settings.quietStart;
+	return false;
+}
+//#endregion
+//#region src/acp/translate/pi-tools.ts
+/**
+* Extract displayable text from a pi tool result.
+*
+* Pi tool results have varying shapes depending on the tool. This function
+* tries content blocks first, then falls back to details fields (diff, stdout/stderr),
+* and finally JSON serialization as a last resort.
+*/
+const textBlockSchema = z.object({
+	type: z.literal("text"),
+	text: z.string()
+});
+const toolDetailsSchema = z.object({
+	diff: z.string().optional(),
+	stdout: z.string().optional(),
+	stderr: z.string().optional(),
+	output: z.string().optional(),
+	exitCode: z.number().optional(),
+	code: z.number().optional()
+});
+const toolResultSchema = z.object({
+	content: z.array(z.unknown()).optional(),
+	details: toolDetailsSchema.optional(),
+	stdout: z.string().optional(),
+	stderr: z.string().optional(),
+	output: z.string().optional(),
+	exitCode: z.number().optional(),
+	code: z.number().optional()
+});
+function toolResultToText(result) {
+	if (result === null || result === void 0 || typeof result !== "object") return "";
+	const parsed = toolResultSchema.safeParse(result);
+	if (!parsed.success) try {
+		return JSON.stringify(result, null, 2);
+	} catch {
+		return String(result);
+	}
+	const r = parsed.data;
+	if (r.content !== void 0) {
+		const texts = r.content.map((block) => textBlockSchema.safeParse(block)).filter((res) => res.success).map((res) => res.data.text);
+		if (texts.length > 0) return texts.join("");
+	}
+	const d = r.details;
+	const diff = d?.diff;
+	if (diff !== void 0 && diff.trim() !== "") return diff;
+	const stdout = d?.stdout ?? r.stdout ?? d?.output ?? r.output;
+	const stderr = d?.stderr ?? r.stderr;
+	const exitCode = d?.exitCode ?? r.exitCode ?? d?.code ?? r.code;
+	const hasStdout = stdout !== void 0 && stdout.trim() !== "";
+	const hasStderr = stderr !== void 0 && stderr.trim() !== "";
+	if (hasStdout || hasStderr) {
+		const parts = [];
+		if (hasStdout) parts.push(stdout);
+		if (hasStderr) parts.push(`stderr:\n${stderr}`);
+		if (exitCode !== void 0) parts.push(`exit code: ${exitCode}`);
+		return parts.join("\n\n").trimEnd();
+	}
+	try {
+		return JSON.stringify(result, null, 2);
+	} catch {
+		return String(result);
+	}
+}
+//#endregion
+//#region src/acp/session.ts
+function findUniqueLineNumber(text, needle) {
+	if (!needle) return void 0;
+	const first = text.indexOf(needle);
+	if (first < 0) return void 0;
+	if (text.indexOf(needle, first + needle.length) >= 0) return void 0;
+	let line = 1;
+	for (let i = 0; i < first; i++) if (text.charCodeAt(i) === 10) line++;
+	return line;
+}
+function resolveToolPath(args, cwd, line) {
+	const p = args.path;
+	if (p === void 0) return void 0;
+	return [{
+		path: isAbsolute(p) ? p : resolve(cwd, p),
+		...typeof line === "number" ? { line } : {}
+	}];
+}
+function toToolKind(toolName) {
+	switch (toolName) {
+		case "read": return "read";
+		case "write":
+		case "edit": return "edit";
+		case "bash": return "execute";
+		default: return "other";
+	}
+}
+/**
+* Map pi assistant stopReason to ACP StopReason.
+* pi: "stop" | "length" | "toolUse" | "error" | "aborted"
+* ACP: "end_turn" | "cancelled" | "max_tokens" | "error"
+*/
+function mapPiStopReason(piReason) {
+	switch (piReason) {
+		case "stop":
+		case "toolUse": return "end_turn";
+		case "length": return "max_tokens";
+		case "aborted": return "cancelled";
+		case "error": return "error";
+		default: return "end_turn";
+	}
+}
+function extractToolCallFromPartial(ame) {
+	if (!("partial" in ame)) return void 0;
+	const block = ame.partial.content["contentIndex" in ame ? ame.contentIndex : 0];
+	if (block && "type" in block && block.type === "toolCall") return block;
+}
+function parseToolInput(tc) {
+	return tc.arguments;
+}
+const toolArgsSchema = z.object({
+	path: z.string().optional(),
+	oldText: z.string().optional()
+}).loose();
+function toToolArgs(raw) {
+	const result = toolArgsSchema.safeParse(raw);
+	return result.success ? result.data : {};
+}
+var SessionManager$1 = class {
+	sessions = /* @__PURE__ */ new Map();
+	disposeAll() {
+		for (const id of this.sessions.keys()) this.close(id);
+	}
+	maybeGet(sessionId) {
+		return this.sessions.get(sessionId);
+	}
+	close(sessionId) {
+		const s = this.sessions.get(sessionId);
+		if (!s) return;
+		try {
+			s.dispose();
+		} catch {}
+		this.sessions.delete(sessionId);
+	}
+	closeAllExcept(keepSessionId) {
+		for (const id of this.sessions.keys()) if (id !== keepSessionId) this.close(id);
+	}
+	register(session) {
+		this.sessions.set(session.sessionId, session);
+	}
+	get(sessionId) {
+		const s = this.sessions.get(sessionId);
+		if (!s) throw RequestError.invalidParams(`Unknown sessionId: ${sessionId}`);
+		return s;
+	}
+};
+var PiAcpSession = class {
+	sessionId;
+	cwd;
+	mcpServers;
+	piSession;
+	startupInfo = null;
+	startupInfoSent = false;
+	conn;
+	cancelRequested = false;
+	pendingTurn = null;
+	currentToolCalls = /* @__PURE__ */ new Map();
+	editSnapshots = /* @__PURE__ */ new Map();
+	lastAssistantStopReason = null;
+	lastEmit = Promise.resolve();
+	unsubscribe;
+	constructor(opts) {
+		this.sessionId = opts.sessionId;
+		this.cwd = opts.cwd;
+		this.mcpServers = opts.mcpServers;
+		this.piSession = opts.piSession;
+		this.conn = opts.conn;
+		this.unsubscribe = this.piSession.subscribe((ev) => this.handlePiEvent(ev));
+	}
+	dispose() {
+		this.unsubscribe?.();
+		this.piSession.dispose();
+	}
+	setStartupInfo(text) {
+		this.startupInfo = text;
+	}
+	sendStartupInfoIfPending() {
+		if (this.startupInfoSent || this.startupInfo === null) return;
+		this.startupInfoSent = true;
+		this.emit({
+			sessionUpdate: "agent_message_chunk",
+			content: {
+				type: "text",
+				text: this.startupInfo
+			}
+		});
+	}
+	async prompt(message, images = []) {
+		const turnPromise = new Promise((resolve, reject) => {
+			this.cancelRequested = false;
+			this.pendingTurn = {
+				resolve,
+				reject
+			};
+		});
+		const imageContents = Array.isArray(images) ? images.filter((img) => typeof img === "object" && img !== null && "type" in img && img.type === "image") : [];
+		this.piSession.prompt(message, { images: imageContents }).catch(() => {
+			this.flushEmits().finally(() => {
+				const reason = this.cancelRequested ? "cancelled" : "error";
+				this.pendingTurn?.resolve(reason);
+				this.pendingTurn = null;
+			});
+		});
+		return turnPromise;
+	}
+	async cancel() {
+		this.cancelRequested = true;
+		await this.piSession.abort();
+	}
+	wasCancelRequested() {
+		return this.cancelRequested;
+	}
+	emit(update) {
+		this.lastEmit = this.lastEmit.then(() => this.conn.sessionUpdate({
+			sessionId: this.sessionId,
+			update
+		})).catch(() => {});
+	}
+	async flushEmits() {
+		await this.lastEmit;
+	}
+	handlePiEvent(ev) {
+		if (!isAgentEvent(ev)) return;
+		switch (ev.type) {
+			case "message_update":
+				this.handleMessageUpdate(ev.assistantMessageEvent);
+				break;
+			case "message_end":
+				this.handleMessageEnd(ev.message);
+				break;
+			case "tool_execution_start":
+				this.handleToolStart(ev.toolCallId, ev.toolName, toToolArgs(ev.args));
+				break;
+			case "tool_execution_update":
+				this.handleToolUpdate(ev.toolCallId, ev.partialResult);
+				break;
+			case "tool_execution_end":
+				this.handleToolEnd(ev.toolCallId, ev.result, ev.isError);
+				break;
+			case "agent_end":
+				this.handleAgentEnd();
+				break;
+			default: break;
+		}
+	}
+	handleMessageUpdate(ame) {
+		if (ame.type === "text_delta") {
+			this.emit({
+				sessionUpdate: "agent_message_chunk",
+				content: {
+					type: "text",
+					text: ame.delta
+				}
+			});
+			return;
+		}
+		if (ame.type === "thinking_delta") {
+			this.emit({
+				sessionUpdate: "agent_thought_chunk",
+				content: {
+					type: "text",
+					text: ame.delta
+				}
+			});
+			return;
+		}
+		if (ame.type === "toolcall_start" || ame.type === "toolcall_delta" || ame.type === "toolcall_end") {
+			const toolCall = ame.type === "toolcall_end" ? ame.toolCall : extractToolCallFromPartial(ame);
+			if (!toolCall) return;
+			const rawInput = parseToolInput(toolCall);
+			const locations = resolveToolPath(rawInput, this.cwd);
+			const existingStatus = this.currentToolCalls.get(toolCall.id);
+			const status = existingStatus ?? "pending";
+			if (!existingStatus) {
+				this.currentToolCalls.set(toolCall.id, "pending");
+				this.emit({
+					sessionUpdate: "tool_call",
+					toolCallId: toolCall.id,
+					title: toolCall.name,
+					kind: toToolKind(toolCall.name),
+					status,
+					...locations ? { locations } : {},
+					rawInput
+				});
+			} else this.emit({
+				sessionUpdate: "tool_call_update",
+				toolCallId: toolCall.id,
+				status,
+				...locations ? { locations } : {},
+				rawInput
+			});
+		}
+	}
+	handleMessageEnd(msg) {
+		if ("role" in msg && msg.role === "assistant") this.lastAssistantStopReason = msg.stopReason;
+	}
+	handleToolStart(toolCallId, toolName, args) {
+		let line;
+		if (toolName === "edit" && args.path !== void 0) try {
+			const abs = isAbsolute(args.path) ? args.path : resolve(this.cwd, args.path);
+			const oldText = readFileSync(abs, "utf8");
+			this.editSnapshots.set(toolCallId, {
+				path: abs,
+				oldText
+			});
+			line = findUniqueLineNumber(oldText, args.oldText ?? "");
+		} catch {}
+		const locations = resolveToolPath(args, this.cwd, line);
+		if (!this.currentToolCalls.has(toolCallId)) {
+			this.currentToolCalls.set(toolCallId, "in_progress");
+			this.emit({
+				sessionUpdate: "tool_call",
+				toolCallId,
+				title: toolName,
+				kind: toToolKind(toolName),
+				status: "in_progress",
+				...locations ? { locations } : {},
+				rawInput: args
+			});
+		} else {
+			this.currentToolCalls.set(toolCallId, "in_progress");
+			this.emit({
+				sessionUpdate: "tool_call_update",
+				toolCallId,
+				status: "in_progress",
+				...locations ? { locations } : {},
+				rawInput: args
+			});
+		}
+	}
+	handleToolUpdate(toolCallId, partialResult) {
+		const text = toolResultToText(partialResult);
+		this.emit({
+			sessionUpdate: "tool_call_update",
+			toolCallId,
+			status: "in_progress",
+			content: text ? [{
+				type: "content",
+				content: {
+					type: "text",
+					text
+				}
+			}] : null,
+			rawOutput: partialResult
+		});
+	}
+	handleToolEnd(toolCallId, result, isError) {
+		const text = toolResultToText(result);
+		const snapshot = this.editSnapshots.get(toolCallId);
+		let content = null;
+		if (!isError && snapshot) try {
+			const newText = readFileSync(snapshot.path, "utf8");
+			if (newText !== snapshot.oldText) content = [{
+				type: "diff",
+				path: snapshot.path,
+				oldText: snapshot.oldText,
+				newText
+			}, ...text ? [{
+				type: "content",
+				content: {
+					type: "text",
+					text
+				}
+			}] : []];
+		} catch {}
+		if (!content && text) content = [{
+			type: "content",
+			content: {
+				type: "text",
+				text
+			}
+		}];
+		this.emit({
+			sessionUpdate: "tool_call_update",
+			toolCallId,
+			status: isError ? "failed" : "completed",
+			content,
+			rawOutput: result
+		});
+		this.currentToolCalls.delete(toolCallId);
+		this.editSnapshots.delete(toolCallId);
+	}
+	handleAgentEnd() {
+		this.flushEmits().finally(() => {
+			const reason = this.cancelRequested ? "cancelled" : mapPiStopReason(this.lastAssistantStopReason);
+			this.lastAssistantStopReason = null;
+			this.pendingTurn?.resolve(reason);
+			this.pendingTurn = null;
+		});
+	}
+};
+/**
+* Type guard to narrow AgentSessionEvent to the AgentEvent subset
+* (the variants we handle). Session-specific events like auto_compaction
+* are ignored.
+*/
+function isAgentEvent(ev) {
+	return ev.type === "message_update" || ev.type === "message_end" || ev.type === "tool_execution_start" || ev.type === "tool_execution_update" || ev.type === "tool_execution_end" || ev.type === "agent_end";
+}
+//#endregion
+//#region src/acp/translate/pi-messages.ts
+function isTextBlock(block) {
+	if (typeof block !== "object" || block === null) return false;
+	return "type" in block && block.type === "text" && "text" in block && typeof block.text === "string";
+}
+function extractUserMessageText(content) {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content.filter(isTextBlock).map((b) => b.text).join("");
+}
+function extractAssistantText(content) {
+	if (!Array.isArray(content)) return "";
+	return content.filter(isTextBlock).map((b) => b.text).join("");
+}
+//#endregion
+//#region src/acp/translate/prompt.ts
+function acpPromptToPiMessage(blocks) {
+	let message = "";
+	const images = [];
+	for (const block of blocks) switch (block.type) {
+		case "text":
+			message += block.text;
+			break;
+		case "resource_link":
+			message += `\n[Context] ${block.uri}`;
+			break;
+		case "image":
+			images.push({
+				type: "image",
+				mimeType: block.mimeType,
+				data: block.data
+			});
+			break;
+		case "resource": {
+			const resource = block.resource;
+			const uri = resource.uri;
+			const mime = resource.mimeType ?? null;
+			if ("text" in resource) message += `\n[Embedded Context] ${uri} (${mime ?? "text/plain"})\n${resource.text}`;
+			else if ("blob" in resource) {
+				const bytes = Buffer.byteLength(resource.blob, "base64");
+				message += `\n[Embedded Context] ${uri} (${mime ?? "application/octet-stream"}, ${bytes} bytes)`;
+			} else message += `\n[Embedded Context] ${uri}`;
+			break;
+		}
+		case "audio": {
+			const bytes = Buffer.byteLength(block.data, "base64");
+			message += `\n[Audio] (${block.mimeType}, ${bytes} bytes) not supported`;
+			break;
+		}
+		default: break;
+	}
+	return {
+		message,
+		images
+	};
+}
+//#endregion
+//#region src/acp/agent.ts
+function builtinAvailableCommands() {
+	return [
+		{
+			name: "compact",
+			description: "Manually compact the session context",
+			input: { hint: "optional custom instructions" }
+		},
+		{
+			name: "autocompact",
+			description: "Toggle automatic context compaction",
+			input: { hint: "on|off|toggle" }
+		},
+		{
+			name: "export",
+			description: "Export session to an HTML file in the session cwd"
+		},
+		{
+			name: "session",
+			description: "Show session stats (messages, tokens, cost, session file)"
+		},
+		{
+			name: "name",
+			description: "Set session display name",
+			input: { hint: "<name>" }
+		},
+		{
+			name: "steering",
+			description: "Get/set pi steering message delivery mode",
+			input: { hint: "(no args to show) all | one-at-a-time" }
+		},
+		{
+			name: "follow-up",
+			description: "Get/set pi follow-up message delivery mode",
+			input: { hint: "(no args to show) all | one-at-a-time" }
+		},
+		{
+			name: "changelog",
+			description: "Show pi changelog"
+		}
+	];
+}
+function mergeCommands(a, b) {
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const c of [...a, ...b]) {
+		if (seen.has(c.name)) continue;
+		seen.add(c.name);
+		out.push(c);
+	}
+	return out;
+}
+function parseArgs(input) {
+	const args = [];
+	let current = "";
+	let quote = null;
+	for (const ch of input) if (quote !== null) if (ch === quote) quote = null;
+	else current += ch;
+	else if (ch === "\"" || ch === "'") quote = ch;
+	else if (ch === " " || ch === "	") {
+		if (current !== "") {
+			args.push(current);
+			current = "";
+		}
+	} else current += ch;
+	if (current !== "") args.push(current);
+	return args;
+}
+const pkg = readNearestPackageJson(import.meta.url);
+var PiAcpAgent = class {
+	conn;
+	sessions = new SessionManager$1();
+	dispose() {
+		this.sessions.disposeAll();
+	}
+	constructor(conn, _config) {
+		this.conn = conn;
+	}
+	async initialize(params) {
+		const supportedVersion = 1;
+		const requested = params.protocolVersion;
+		return {
+			protocolVersion: requested === supportedVersion ? requested : supportedVersion,
+			agentInfo: {
+				name: pkg.name,
+				title: "pi ACP adapter",
+				version: pkg.version
+			},
+			authMethods: buildAuthMethods({ supportsTerminalAuthMeta: params.clientCapabilities?._meta?.["terminal-auth"] === true }),
+			agentCapabilities: {
+				loadSession: true,
+				mcpCapabilities: {
+					http: false,
+					sse: false
+				},
+				promptCapabilities: {
+					image: true,
+					audio: false,
+					embeddedContext: false
+				},
+				sessionCapabilities: { list: {} }
+			}
+		};
+	}
+	async newSession(params) {
+		if (!isAbsolute(params.cwd)) throw RequestError.invalidParams(`cwd must be an absolute path: ${params.cwd}`);
+		if (!hasPiAuthConfigured()) throw RequestError.authRequired({ authMethods: buildAuthMethods() }, "Configure an API key or log in with an OAuth provider.");
+		let result;
+		try {
+			result = await createAgentSession({ cwd: params.cwd });
+		} catch (e) {
+			const msg = e instanceof Error ? e.message : String(e);
+			throw RequestError.internalError({}, `Failed to create pi session: ${msg}`);
+		}
+		const piSession = result.session;
+		if (piSession.modelRegistry.getAvailable().length === 0) {
+			piSession.dispose();
+			throw RequestError.authRequired({ authMethods: buildAuthMethods() }, "Configure an API key or log in with an OAuth provider.");
+		}
+		const session = new PiAcpSession({
+			sessionId: piSession.sessionManager.getSessionId(),
+			cwd: params.cwd,
+			mcpServers: params.mcpServers,
+			piSession,
+			conn: this.conn
+		});
+		this.sessions.register(session);
+		const quietStartup = quietStartupEnabled(params.cwd);
+		const updateNotice = buildUpdateNotice();
+		const preludeText = quietStartup ? updateNotice !== null ? `${updateNotice}\n` : "" : buildStartupInfo({
+			cwd: params.cwd,
+			updateNotice
+		});
+		if (preludeText) session.setStartupInfo(preludeText);
+		this.sessions.closeAllExcept(session.sessionId);
+		const modes = buildThinkingModes(piSession);
+		const models = buildModelState(piSession);
+		const configOptions = buildConfigOptions(modes, models);
+		const response = {
+			sessionId: session.sessionId,
+			configOptions,
+			modes,
+			models,
+			_meta: { piAcp: { startupInfo: preludeText || null } }
+		};
+		if (preludeText) setTimeout(() => session.sendStartupInfoIfPending(), 0);
+		const enableSkillCommands = skillCommandsEnabled(params.cwd);
+		setTimeout(() => {
+			(async () => {
+				try {
+					const commands = buildCommandList(piSession, enableSkillCommands);
+					await this.conn.sessionUpdate({
+						sessionId: session.sessionId,
+						update: {
+							sessionUpdate: "available_commands_update",
+							availableCommands: mergeCommands(commands, builtinAvailableCommands())
+						}
+					});
+				} catch {}
+			})();
+		}, 0);
+		return response;
+	}
+	async authenticate(_params) {}
+	async prompt(params) {
+		const session = this.sessions.get(params.sessionId);
+		const { message, images } = acpPromptToPiMessage(params.prompt);
+		if (images.length === 0 && message.trimStart().startsWith("/")) {
+			const trimmed = message.trim();
+			const space = trimmed.indexOf(" ");
+			const cmd = space === -1 ? trimmed.slice(1) : trimmed.slice(1, space);
+			const args = parseArgs(space === -1 ? "" : trimmed.slice(space + 1));
+			const handled = await this.handleBuiltinCommand(session, cmd, args);
+			if (handled) return handled;
+		}
+		const result = await session.prompt(message, images);
+		return { stopReason: result === "error" ? "end_turn" : result };
+	}
+	async cancel(params) {
+		await this.sessions.get(params.sessionId).cancel();
+	}
+	async listSessions(params) {
+		const cwd = params.cwd;
+		const sessions = (cwd !== void 0 && cwd !== null ? await SessionManager.list(cwd) : await SessionManager.listAll()).map((s) => ({
+			id: s.id,
+			cwd: s.cwd,
+			name: s.name ?? "",
+			modified: s.modified,
+			messageCount: s.messageCount
+		}));
+		if (params.cursor !== void 0 && params.cursor !== null) {
+			const parsed = Number.parseInt(params.cursor, 10);
+			if (!Number.isFinite(parsed) || parsed < 0) throw RequestError.invalidParams(`Invalid cursor: ${params.cursor}`);
+		}
+		const start = params.cursor !== void 0 && params.cursor !== null ? Number.parseInt(params.cursor, 10) : 0;
+		const PAGE_SIZE = 50;
+		return {
+			sessions: sessions.slice(start, start + PAGE_SIZE).map((s) => ({
+				sessionId: s.id,
+				cwd: s.cwd,
+				title: s.name ?? null,
+				updatedAt: s.modified.toISOString()
+			})),
+			nextCursor: start + PAGE_SIZE < sessions.length ? String(start + PAGE_SIZE) : null,
+			_meta: {}
+		};
+	}
+	async loadSession(params) {
+		if (!isAbsolute(params.cwd)) throw RequestError.invalidParams(`cwd must be an absolute path: ${params.cwd}`);
+		this.sessions.close(params.sessionId);
+		const sessionFile = findPiSessionFile(params.sessionId);
+		if (sessionFile === null) throw RequestError.invalidParams(`Unknown sessionId: ${params.sessionId}`);
+		let result;
+		try {
+			const sm = SessionManager.open(sessionFile);
+			result = await createAgentSession({
+				cwd: params.cwd,
+				sessionManager: sm
+			});
+		} catch (e) {
+			const msg = e instanceof Error ? e.message : String(e);
+			throw RequestError.internalError({}, `Failed to load pi session: ${msg}`);
+		}
+		const piSession = result.session;
+		const session = new PiAcpSession({
+			sessionId: params.sessionId,
+			cwd: params.cwd,
+			mcpServers: params.mcpServers,
+			piSession,
+			conn: this.conn
+		});
+		this.sessions.register(session);
+		this.sessions.closeAllExcept(session.sessionId);
+		const messages = piSession.messages;
+		for (const m of messages) {
+			if (!("role" in m)) continue;
+			if (m.role === "user") {
+				const text = extractUserMessageText(m.content);
+				if (text) await this.conn.sessionUpdate({
+					sessionId: session.sessionId,
+					update: {
+						sessionUpdate: "user_message_chunk",
+						content: {
+							type: "text",
+							text
+						}
+					}
+				});
+			}
+			if (m.role === "assistant") {
+				const text = extractAssistantText(m.content);
+				if (text) await this.conn.sessionUpdate({
+					sessionId: session.sessionId,
+					update: {
+						sessionUpdate: "agent_message_chunk",
+						content: {
+							type: "text",
+							text
+						}
+					}
+				});
+			}
+			if (m.role === "toolResult") {
+				const tr = m;
+				const toolName = tr.toolName;
+				const toolCallId = tr.toolCallId;
+				const isError = tr.isError;
+				await this.conn.sessionUpdate({
+					sessionId: session.sessionId,
+					update: {
+						sessionUpdate: "tool_call",
+						toolCallId,
+						title: toolName,
+						kind: toolName === "read" ? "read" : toolName === "write" || toolName === "edit" ? "edit" : "other",
+						status: "completed",
+						rawInput: null,
+						rawOutput: m
+					}
+				});
+				const text = toolResultToText(m);
+				await this.conn.sessionUpdate({
+					sessionId: session.sessionId,
+					update: {
+						sessionUpdate: "tool_call_update",
+						toolCallId,
+						status: isError ? "failed" : "completed",
+						content: text ? [{
+							type: "content",
+							content: {
+								type: "text",
+								text
+							}
+						}] : null,
+						rawOutput: m
+					}
+				});
+			}
+		}
+		const modes = buildThinkingModes(piSession);
+		const models = buildModelState(piSession);
+		const configOptions = buildConfigOptions(modes, models);
+		const enableSkillCommands = skillCommandsEnabled(params.cwd);
+		setTimeout(() => {
+			(async () => {
+				try {
+					const commands = buildCommandList(piSession, enableSkillCommands);
+					await this.conn.sessionUpdate({
+						sessionId: session.sessionId,
+						update: {
+							sessionUpdate: "available_commands_update",
+							availableCommands: mergeCommands(commands, builtinAvailableCommands())
+						}
+					});
+				} catch {}
+			})();
+		}, 0);
+		return {
+			configOptions,
+			modes,
+			models,
+			_meta: { piAcp: { startupInfo: null } }
+		};
+	}
+	async setSessionMode(params) {
+		const session = this.sessions.get(params.sessionId);
+		const mode = String(params.modeId);
+		if (!isThinkingLevel(mode)) throw RequestError.invalidParams(`Unknown modeId: ${mode}`);
+		session.piSession.setThinkingLevel(mode);
+		this.conn.sessionUpdate({
+			sessionId: session.sessionId,
+			update: {
+				sessionUpdate: "current_mode_update",
+				currentModeId: mode
+			}
+		});
+		this.emitConfigOptionUpdate(session);
+		return {};
+	}
+	async unstable_setSessionModel(params) {
+		const session = this.sessions.get(params.sessionId);
+		let provider = null;
+		let modelId = null;
+		if (params.modelId.includes("/")) {
+			const [p, ...rest] = params.modelId.split("/");
+			provider = p ?? null;
+			modelId = rest.join("/");
+		} else modelId = params.modelId;
+		if (provider === null) {
+			const found = session.piSession.modelRegistry.getAvailable().find((m) => m.id === modelId);
+			if (found) {
+				provider = found.provider;
+				modelId = found.id;
+			}
+		}
+		if (provider === null || modelId === null) throw RequestError.invalidParams(`Unknown modelId: ${params.modelId}`);
+		const model = session.piSession.modelRegistry.getAvailable().find((m) => m.provider === provider && m.id === modelId);
+		if (!model) throw RequestError.invalidParams(`Unknown modelId: ${params.modelId}`);
+		await session.piSession.setModel(model);
+		this.emitConfigOptionUpdate(session);
+	}
+	async setSessionConfigOption(params) {
+		const session = this.sessions.get(params.sessionId);
+		const configId = String(params.configId);
+		const value = String(params.value);
+		if (configId === "model") {
+			let provider = null;
+			let modelId = null;
+			if (value.includes("/")) {
+				const [p, ...rest] = value.split("/");
+				provider = p ?? null;
+				modelId = rest.join("/");
+			} else modelId = value;
+			if (provider === null) {
+				const found = session.piSession.modelRegistry.getAvailable().find((m) => m.id === modelId);
+				if (found) {
+					provider = found.provider;
+					modelId = found.id;
+				}
+			}
+			if (provider === null || modelId === null) throw RequestError.invalidParams(`Unknown model: ${value}`);
+			const model = session.piSession.modelRegistry.getAvailable().find((m) => m.provider === provider && m.id === modelId);
+			if (!model) throw RequestError.invalidParams(`Unknown model: ${value}`);
+			await session.piSession.setModel(model);
+		} else if (configId === "thought_level") {
+			if (!isThinkingLevel(value)) throw RequestError.invalidParams(`Unknown thinking level: ${value}`);
+			session.piSession.setThinkingLevel(value);
+		} else throw RequestError.invalidParams(`Unknown config option: ${configId}`);
+		return { configOptions: buildConfigOptions(buildThinkingModes(session.piSession), buildModelState(session.piSession)) };
+	}
+	emitConfigOptionUpdate(session) {
+		const configOptions = buildConfigOptions(buildThinkingModes(session.piSession), buildModelState(session.piSession));
+		this.conn.sessionUpdate({
+			sessionId: session.sessionId,
+			update: {
+				sessionUpdate: "config_option_update",
+				configOptions
+			}
+		});
+	}
+	async handleBuiltinCommand(session, cmd, args) {
+		const piSession = session.piSession;
+		if (cmd === "compact") {
+			const customInstructions = args.join(" ").trim() || void 0;
+			const res = await piSession.compact(customInstructions);
+			const text = [`Compaction completed.${customInstructions !== void 0 && customInstructions !== "" ? " (custom instructions applied)" : ""}`, typeof res?.tokensBefore === "number" ? `Tokens before: ${res.tokensBefore}` : null].filter(Boolean).join("\n") + (res?.summary ? `\n\n${res.summary}` : "");
+			await this.conn.sessionUpdate({
+				sessionId: session.sessionId,
+				update: {
+					sessionUpdate: "agent_message_chunk",
+					content: {
+						type: "text",
+						text
+					}
+				}
+			});
+			return { stopReason: "end_turn" };
+		}
+		if (cmd === "session") {
+			const stats = piSession.getSessionStats();
+			const lines = [];
+			if (stats.sessionId !== void 0 && stats.sessionId !== "") lines.push(`Session: ${stats.sessionId}`);
+			if (stats.sessionFile !== void 0 && stats.sessionFile !== "") lines.push(`Session file: ${stats.sessionFile}`);
+			lines.push(`Messages: ${stats.totalMessages}`);
+			lines.push(`Cost: ${stats.cost}`);
+			const t = stats.tokens;
+			const parts = [];
+			if (t.input) parts.push(`in ${t.input}`);
+			if (t.output) parts.push(`out ${t.output}`);
+			if (t.cacheRead) parts.push(`cache read ${t.cacheRead}`);
+			if (t.cacheWrite) parts.push(`cache write ${t.cacheWrite}`);
+			if (t.total) parts.push(`total ${t.total}`);
+			if (parts.length > 0) lines.push(`Tokens: ${parts.join(", ")}`);
+			const text = lines.join("\n");
+			await this.conn.sessionUpdate({
+				sessionId: session.sessionId,
+				update: {
+					sessionUpdate: "agent_message_chunk",
+					content: {
+						type: "text",
+						text
+					}
+				}
+			});
+			return { stopReason: "end_turn" };
+		}
+		if (cmd === "name") {
+			const name = args.join(" ").trim();
+			if (!name) {
+				await this.conn.sessionUpdate({
+					sessionId: session.sessionId,
+					update: {
+						sessionUpdate: "agent_message_chunk",
+						content: {
+							type: "text",
+							text: "Usage: /name <name>"
+						}
+					}
+				});
+				return { stopReason: "end_turn" };
+			}
+			piSession.setSessionName(name);
+			await this.conn.sessionUpdate({
+				sessionId: session.sessionId,
+				update: {
+					sessionUpdate: "session_info_update",
+					title: name,
+					updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+				}
+			});
+			await this.conn.sessionUpdate({
+				sessionId: session.sessionId,
+				update: {
+					sessionUpdate: "agent_message_chunk",
+					content: {
+						type: "text",
+						text: `Session name set: ${name}`
+					}
+				}
+			});
+			return { stopReason: "end_turn" };
+		}
+		if (cmd === "steering") {
+			const modeRaw = String(args[0] ?? "").toLowerCase();
+			if (!modeRaw) {
+				await this.conn.sessionUpdate({
+					sessionId: session.sessionId,
+					update: {
+						sessionUpdate: "agent_message_chunk",
+						content: {
+							type: "text",
+							text: `Steering mode: ${piSession.steeringMode}`
+						}
+					}
+				});
+				return { stopReason: "end_turn" };
+			}
+			if (modeRaw !== "all" && modeRaw !== "one-at-a-time") {
+				await this.conn.sessionUpdate({
+					sessionId: session.sessionId,
+					update: {
+						sessionUpdate: "agent_message_chunk",
+						content: {
+							type: "text",
+							text: "Usage: /steering all | /steering one-at-a-time"
+						}
+					}
+				});
+				return { stopReason: "end_turn" };
+			}
+			piSession.setSteeringMode(modeRaw);
+			await this.conn.sessionUpdate({
+				sessionId: session.sessionId,
+				update: {
+					sessionUpdate: "agent_message_chunk",
+					content: {
+						type: "text",
+						text: `Steering mode set to: ${modeRaw}`
+					}
+				}
+			});
+			return { stopReason: "end_turn" };
+		}
+		if (cmd === "follow-up") {
+			const modeRaw = String(args[0] ?? "").toLowerCase();
+			if (!modeRaw) {
+				await this.conn.sessionUpdate({
+					sessionId: session.sessionId,
+					update: {
+						sessionUpdate: "agent_message_chunk",
+						content: {
+							type: "text",
+							text: `Follow-up mode: ${piSession.followUpMode}`
+						}
+					}
+				});
+				return { stopReason: "end_turn" };
+			}
+			if (modeRaw !== "all" && modeRaw !== "one-at-a-time") {
+				await this.conn.sessionUpdate({
+					sessionId: session.sessionId,
+					update: {
+						sessionUpdate: "agent_message_chunk",
+						content: {
+							type: "text",
+							text: "Usage: /follow-up all | /follow-up one-at-a-time"
+						}
+					}
+				});
+				return { stopReason: "end_turn" };
+			}
+			piSession.setFollowUpMode(modeRaw);
+			await this.conn.sessionUpdate({
+				sessionId: session.sessionId,
+				update: {
+					sessionUpdate: "agent_message_chunk",
+					content: {
+						type: "text",
+						text: `Follow-up mode set to: ${modeRaw}`
+					}
+				}
+			});
+			return { stopReason: "end_turn" };
+		}
+		if (cmd === "autocompact") {
+			const mode = (args[0] ?? "toggle").toLowerCase();
+			let enabled = null;
+			if (mode === "on" || mode === "true" || mode === "enable") enabled = true;
+			else if (mode === "off" || mode === "false" || mode === "disable") enabled = false;
+			if (enabled === null) enabled = !piSession.autoCompactionEnabled;
+			piSession.setAutoCompactionEnabled(enabled);
+			await this.conn.sessionUpdate({
+				sessionId: session.sessionId,
+				update: {
+					sessionUpdate: "agent_message_chunk",
+					content: {
+						type: "text",
+						text: `Auto-compaction ${enabled ? "enabled" : "disabled"}.`
+					}
+				}
+			});
+			return { stopReason: "end_turn" };
+		}
+		if (cmd === "changelog") {
+			const changelogPath = findChangelog();
+			if (changelogPath === null) {
+				await this.conn.sessionUpdate({
+					sessionId: session.sessionId,
+					update: {
+						sessionUpdate: "agent_message_chunk",
+						content: {
+							type: "text",
+							text: "Changelog not found."
+						}
+					}
+				});
+				return { stopReason: "end_turn" };
+			}
+			let text = "";
+			try {
+				text = readFileSync(changelogPath, "utf-8");
+			} catch (e) {
+				const msg = e instanceof Error ? e.message : String(e);
+				await this.conn.sessionUpdate({
+					sessionId: session.sessionId,
+					update: {
+						sessionUpdate: "agent_message_chunk",
+						content: {
+							type: "text",
+							text: `Failed to read changelog: ${msg}`
+						}
+					}
+				});
+				return { stopReason: "end_turn" };
+			}
+			const maxChars = 2e4;
+			if (text.length > maxChars) text = `${text.slice(0, maxChars)}\n\n...(truncated)...`;
+			await this.conn.sessionUpdate({
+				sessionId: session.sessionId,
+				update: {
+					sessionUpdate: "agent_message_chunk",
+					content: {
+						type: "text",
+						text
+					}
+				}
+			});
+			return { stopReason: "end_turn" };
+		}
+		if (cmd === "export") {
+			if (piSession.messages.length === 0) {
+				await this.conn.sessionUpdate({
+					sessionId: session.sessionId,
+					update: {
+						sessionUpdate: "agent_message_chunk",
+						content: {
+							type: "text",
+							text: "Nothing to export yet. Send a prompt first."
+						}
+					}
+				});
+				return { stopReason: "end_turn" };
+			}
+			try {
+				const safeSessionId = session.sessionId.replace(/[^a-zA-Z0-9_-]/g, "_");
+				const outputPath = join(session.cwd, `pi-session-${safeSessionId}.html`);
+				const resultPath = await piSession.exportToHtml(outputPath);
+				await this.conn.sessionUpdate({
+					sessionId: session.sessionId,
+					update: {
+						sessionUpdate: "agent_message_chunk",
+						content: {
+							type: "text",
+							text: "Session exported: "
+						}
+					}
+				});
+				await this.conn.sessionUpdate({
+					sessionId: session.sessionId,
+					update: {
+						sessionUpdate: "agent_message_chunk",
+						content: {
+							type: "resource_link",
+							name: `pi-session-${safeSessionId}.html`,
+							uri: `file://${resultPath}`,
+							mimeType: "text/html",
+							title: "Session exported"
+						}
+					}
+				});
+			} catch (e) {
+				const msg = e instanceof Error ? e.message : String(e);
+				await this.conn.sessionUpdate({
+					sessionId: session.sessionId,
+					update: {
+						sessionUpdate: "agent_message_chunk",
+						content: {
+							type: "text",
+							text: `Export failed: ${msg}`
+						}
+					}
+				});
+			}
+			return { stopReason: "end_turn" };
+		}
+		return null;
+	}
+};
+function isThinkingLevel(x) {
+	return x === "off" || x === "minimal" || x === "low" || x === "medium" || x === "high" || x === "xhigh";
+}
+function buildThinkingModes(piSession) {
+	const levels = piSession.getAvailableThinkingLevels();
+	return {
+		currentModeId: piSession.thinkingLevel,
+		availableModes: levels.map((id) => ({
+			id,
+			name: `Thinking: ${id}`,
+			description: null
+		}))
+	};
+}
+function buildModelState(piSession) {
+	const available = piSession.modelRegistry.getAvailable();
+	const current = piSession.model;
+	const availableModels = available.map((m) => ({
+		modelId: `${m.provider}/${m.id}`,
+		name: `${m.provider}/${m.name ?? m.id}`,
+		description: null
+	}));
+	let currentModelId = "default";
+	if (current !== void 0) currentModelId = `${current.provider}/${current.id}`;
+	else if (availableModels.length > 0 && availableModels[0] !== void 0) currentModelId = availableModels[0].modelId;
+	return {
+		availableModels,
+		currentModelId
+	};
+}
+function buildConfigOptions(modes, models) {
+	return [{
+		id: "model",
+		name: "Model",
+		description: "AI model to use",
+		category: "model",
+		type: "select",
+		currentValue: models.currentModelId,
+		options: models.availableModels.map((m) => ({
+			value: m.modelId,
+			name: m.name,
+			description: m.description ?? null
+		}))
+	}, {
+		id: "thought_level",
+		name: "Thinking Level",
+		description: "Reasoning depth for models that support it",
+		category: "thought_level",
+		type: "select",
+		currentValue: modes.currentModeId,
+		options: modes.availableModes.map((m) => ({
+			value: m.id,
+			name: m.name,
+			description: m.description ?? null
+		}))
+	}];
+}
+function buildCommandList(piSession, enableSkillCommands) {
+	const commands = [];
+	for (const template of piSession.promptTemplates) commands.push({
+		name: template.name,
+		description: template.description ?? `(prompt)`
+	});
+	if (enableSkillCommands) {
+		const skills = piSession.resourceLoader.getSkills();
+		for (const skill of skills.skills) commands.push({
+			name: `skill:${skill.name}`,
+			description: skill.description ?? `(skill)`
+		});
+	}
+	const runner = piSession.extensionRunner;
+	if (runner) for (const { command } of runner.getRegisteredCommandsWithPaths()) commands.push({
+		name: command.name,
+		description: command.description ?? `(extension)`
+	});
+	return commands;
+}
+function findPiSessionFile(sessionId) {
+	const sessionsDir = join(piAgentDir(), "sessions");
+	if (!existsSync(sessionsDir)) return null;
+	const walkJsonl = (dir) => {
+		let entries;
+		try {
+			entries = readdirSync(dir);
+		} catch {
+			return null;
+		}
+		for (const name of entries) {
+			const p = join(dir, name);
+			try {
+				const st = statSync(p);
+				if (st.isDirectory()) {
+					const found = walkJsonl(p);
+					if (found !== void 0) return found;
+				} else if (st.isFile() && name.endsWith(".jsonl")) try {
+					const firstLine = readFileSync(p, "utf8").split("\n")[0];
+					if (firstLine === void 0) continue;
+					const header = JSON.parse(firstLine);
+					if (typeof header === "object" && header !== null && "type" in header && header.type === "session" && "id" in header && header.id === sessionId) return p;
+				} catch {}
+			} catch {}
+		}
+		return null;
+	};
+	return walkJsonl(sessionsDir);
+}
+function buildUpdateNotice() {
+	try {
+		const installed = VERSION;
+		if (!installed || !isSemver(installed)) return null;
+		const latestRes = spawnSync("npm", [
+			"view",
+			"@mariozechner/pi-coding-agent",
+			"version"
+		], {
+			encoding: "utf-8",
+			timeout: 800
+		});
+		const latest = String(latestRes.stdout ?? "").trim().replace(/^v/i, "");
+		if (!latest || !isSemver(latest)) return null;
+		if (compareSemver(latest, installed) <= 0) return null;
+		return `New version available: v${latest} (installed v${installed}). Run: \`npm i -g @mariozechner/pi-coding-agent\``;
+	} catch {
+		return null;
+	}
+}
+function buildStartupInfo(opts) {
+	const md = [];
+	if (VERSION) {
+		md.push(`pi v${VERSION}`);
+		md.push("---");
+		md.push("");
+	}
+	const addSection = (title, items) => {
+		const cleaned = items.map((s) => s.trim()).filter(Boolean);
+		if (cleaned.length === 0) return;
+		md.push(`## ${title}`);
+		for (const item of cleaned) md.push(`- ${item}`);
+		md.push("");
+	};
+	const contextItems = [];
+	const contextPath = join(opts.cwd, "AGENTS.md");
+	if (existsSync(contextPath)) contextItems.push(contextPath);
+	addSection("Context", contextItems);
+	if (opts.updateNotice !== void 0 && opts.updateNotice !== null) {
+		md.push("---");
+		md.push(opts.updateNotice);
+		md.push("");
+	}
+	return `${md.join("\n").trim()}\n`;
+}
+function findChangelog() {
+	try {
+		const which = spawnSync(process.platform === "win32" ? "where" : "which", ["pi"], { encoding: "utf-8" });
+		const piPath = String(which.stdout ?? "").split(/\r?\n/)[0]?.trim();
+		if (piPath !== void 0 && piPath !== "") {
+			const p = join(dirname(dirname(realpathSync(piPath))), "CHANGELOG.md");
+			if (existsSync(p)) return p;
+		}
+	} catch {}
+	try {
+		const npmRoot = spawnSync("npm", ["root", "-g"], { encoding: "utf-8" });
+		const root = String(npmRoot.stdout ?? "").trim();
+		if (root) {
+			const p = join(root, "@mariozechner", "pi-coding-agent", "CHANGELOG.md");
+			if (existsSync(p)) return p;
+		}
+	} catch {}
+	return null;
+}
+function isSemver(v) {
+	return /^\d+\.\d+\.\d+(?:[-+].+)?$/.test(v);
+}
+function compareSemver(a, b) {
+	const pa = a.split(/[.-]/).slice(0, 3).map((n) => Number(n));
+	const pb = b.split(/[.-]/).slice(0, 3).map((n) => Number(n));
+	for (let i = 0; i < 3; i++) {
+		const da = pa[i] ?? 0;
+		const db = pb[i] ?? 0;
+		if (da > db) return 1;
+		if (da < db) return -1;
+	}
+	return 0;
+}
+function readNearestPackageJson(metaUrl) {
+	const fallback = {
+		name: "pi-acp",
+		version: "0.0.0"
+	};
+	try {
+		let dir = dirname(fileURLToPath(metaUrl));
+		for (let i = 0; i < 6; i++) {
+			const p = join(dir, "package.json");
+			if (existsSync(p)) {
+				const raw = JSON.parse(readFileSync(p, "utf-8"));
+				if (typeof raw !== "object" || raw === null) return fallback;
+				return {
+					name: "name" in raw && typeof raw.name === "string" ? raw.name : fallback.name,
+					version: "version" in raw && typeof raw.version === "string" ? raw.version : fallback.version
+				};
+			}
+			dir = dirname(dir);
+		}
+	} catch {}
+	return fallback;
+}
+//#endregion
+//#region src/index.ts
+if (process.argv.includes("--terminal-login")) {
+	const { spawnSync } = await import("node:child_process");
+	const isWindows = platform() === "win32";
+	const cmd = process.env.PI_ACP_PI_COMMAND ?? (isWindows ? "pi.cmd" : "pi");
+	const res = spawnSync(cmd, [], {
+		stdio: "inherit",
+		env: process.env
+	});
+	if (res.error && "code" in res.error && res.error.code === "ENOENT") {
+		process.stderr.write(`pi-acp: could not start pi (command not found: ${cmd}). Install via \`npm install -g @mariozechner/pi-coding-agent\` or ensure \`pi\` is on your PATH.
+`);
+		process.exit(1);
+	}
+	process.exit(typeof res.status === "number" ? res.status : 1);
+}
+const agent = new AgentSideConnection((conn) => new PiAcpAgent(conn), ndJsonStream(new WritableStream({ write(chunk) {
+	return new Promise((resolve) => {
+		if (process.stdout.destroyed || !process.stdout.writable) {
+			resolve();
+			return;
+		}
+		try {
+			process.stdout.write(chunk, () => resolve());
+		} catch {
+			resolve();
+		}
+	});
+} }), new ReadableStream({ start(controller) {
+	process.stdin.on("data", (chunk) => controller.enqueue(new Uint8Array(chunk)));
+	process.stdin.on("end", () => controller.close());
+	process.stdin.on("error", (err) => controller.error(err));
+} })));
+function shutdown() {
+	try {
+		if ("agent" in agent) {
+			const inner = agent.agent;
+			if (typeof inner === "object" && inner !== null && "dispose" in inner && typeof inner.dispose === "function") inner.dispose();
+		}
+	} catch {}
+	process.exit(0);
+}
+process.stdin.on("end", shutdown);
+process.stdin.on("close", shutdown);
+process.stdin.resume();
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
+process.stdout.on("error", () => process.exit(0));
+//#endregion
+export {};
+
+//# sourceMappingURL=index.mjs.map