pi-acp 0.0.14 → 0.0.16

package/dist/index.js

@@ -5,21 +5,103 @@ import { AgentSideConnection, ndJsonStream } from "@agentclientprotocol/sdk";
 
 // src/acp/agent.ts
 import {
-  RequestError as RequestError2
+  RequestError as RequestError3
 } from "@agentclientprotocol/sdk";
 
+// src/acp/auth.ts
+var PI_SETUP_METHOD_ID = "pi_terminal_login";
+function getAuthMethods(opts) {
+  const supportsTerminalAuthMeta = opts?.supportsTerminalAuthMeta ?? true;
+  const method = {
+    id: PI_SETUP_METHOD_ID,
+    name: "Launch pi in the terminal",
+    description: "Start pi in an interactive terminal to configure API keys or login",
+    // Registry-required fields
+    type: "terminal",
+    args: ["--terminal-login"],
+    env: {}
+  };
+  if (supportsTerminalAuthMeta) {
+    const launch = terminalAuthLaunchSpec();
+    method._meta = {
+      ...method._meta ?? {},
+      "terminal-auth": {
+        ...launch,
+        label: "Launch pi"
+      }
+    };
+  }
+  return [method];
+}
+function terminalAuthLaunchSpec() {
+  const argv0 = process.argv[0] || "node";
+  const argv1 = process.argv[1];
+  if (argv1 && argv0) {
+    const isNode = argv0.includes("node");
+    const isJs = argv1.endsWith(".js");
+    if (isNode && isJs) {
+      return { command: argv0, args: [argv1, "--terminal-login"] };
+    }
+  }
+  return { command: "pi-acp", args: ["--terminal-login"] };
+}
+
 // src/acp/session.ts
+import { RequestError as RequestError2 } from "@agentclientprotocol/sdk";
+
+// src/acp/auth-required.ts
 import { RequestError } from "@agentclientprotocol/sdk";
+function maybeAuthRequiredError(err) {
+  const msg = String(err?.message ?? err ?? "");
+  const s = msg.toLowerCase();
+  const patterns = [
+    "api key",
+    "apikey",
+    "missing key",
+    "no key",
+    "not configured",
+    "unauthorized",
+    "authentication",
+    "permission denied",
+    "forbidden",
+    "401",
+    "403"
+  ];
+  const hit = patterns.some((p) => s.includes(p));
+  if (!hit) return null;
+  return RequestError.authRequired(
+    {
+      authMethods: getAuthMethods()
+    },
+    "Configure an API key or log in with an OAuth provider."
+  );
+}
+
+// src/acp/session.ts
 import { readFileSync as readFileSync3 } from "fs";
 import { isAbsolute, resolve as resolvePath } from "path";
 
 // src/pi-rpc/process.ts
 import { spawn } from "child_process";
 import * as readline from "readline";
+var PiRpcSpawnError = class extends Error {
+  /** Underlying spawn error code, e.g. ENOENT, EACCES */
+  code;
+  constructor(message, opts) {
+    super(message);
+    this.name = "PiRpcSpawnError";
+    this.code = opts?.code;
+    this.cause = opts?.cause;
+  }
+};
+function stripAnsi(s) {
+  return s.replace(/[\u001B\u009B][[\]()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, "");
+}
 var PiRpcProcess = class _PiRpcProcess {
   child;
   pending = /* @__PURE__ */ new Map();
   eventHandlers = [];
+  preludeLines = [];
   constructor(child) {
     this.child = child;
     const rl = readline.createInterface({ input: child.stdout });
@@ -29,6 +111,8 @@ var PiRpcProcess = class _PiRpcProcess {
       try {
         msg = JSON.parse(line);
       } catch {
+        const cleaned = stripAnsi(String(line)).trimEnd();
+        if (cleaned) this.preludeLines.push(cleaned);
         return;
       }
       if (msg?.type === "response") {
@@ -49,6 +133,10 @@ var PiRpcProcess = class _PiRpcProcess {
       for (const [, p] of this.pending) p.reject(err);
       this.pending.clear();
     });
+    child.on("error", (err) => {
+      for (const [, p] of this.pending) p.reject(err);
+      this.pending.clear();
+    });
   }
   static async spawn(params) {
     const cmd = params.piCommand ?? "pi";
@@ -59,6 +147,36 @@ var PiRpcProcess = class _PiRpcProcess {
       stdio: "pipe",
       env: process.env
     });
+    try {
+      await new Promise((resolve2, reject) => {
+        const onSpawn = () => {
+          cleanup();
+          resolve2();
+        };
+        const onError = (err) => {
+          cleanup();
+          reject(err);
+        };
+        const cleanup = () => {
+          child.off("spawn", onSpawn);
+          child.off("error", onError);
+        };
+        child.once("spawn", onSpawn);
+        child.once("error", onError);
+      });
+    } catch (e) {
+      const code = typeof e?.code === "string" ? e.code : void 0;
+      if (code === "ENOENT") {
+        throw new PiRpcSpawnError(
+          `Could not start pi: executable not found (command: ${cmd}). Pi needs to be installed before it can run in ACP clients. Install it via \`npm install -g @mariozechner/pi-coding-agent\` or ensure \`pi\` is on your PATH. Then try again.`,
+          { code, cause: e }
+        );
+      }
+      if (code === "EACCES") {
+        throw new PiRpcSpawnError(`Could not start pi: permission denied (command: ${cmd}).`, { code, cause: e });
+      }
+      throw new PiRpcSpawnError(`Could not start pi (command: ${cmd}).`, { code, cause: e });
+    }
     child.stderr.on("data", () => {
     });
     const proc = new _PiRpcProcess(child);
@@ -80,6 +198,21 @@ var PiRpcProcess = class _PiRpcProcess {
       this.eventHandlers = this.eventHandlers.filter((h) => h !== handler);
     };
   }
+  dispose(signal = "SIGTERM") {
+    if (this.child.killed) return;
+    try {
+      this.child.kill(signal);
+    } catch {
+    }
+  }
+  /**
+   * Human-readable stdout lines emitted before RPC NDJSON begins (e.g. Context/Skills/Extensions info).
+   * Themes are typically noisy/less useful for ACP, so callers can filter as needed.
+   */
+  consumePreludeLines() {
+    const lines = this.preludeLines.splice(0, this.preludeLines.length);
+    return lines;
+  }
   async prompt(message, attachments = []) {
     const res = await this.request({ type: "prompt", message, attachments });
     if (!res.success) throw new Error(`pi prompt failed: ${res.error ?? JSON.stringify(res.data)}`);
@@ -150,12 +283,17 @@ var PiRpcProcess = class _PiRpcProcess {
     const line = JSON.stringify(withId) + "\n";
     return new Promise((resolve2, reject) => {
       this.pending.set(id, { resolve: resolve2, reject });
-      this.child.stdin.write(line, (err) => {
-        if (err) {
-          this.pending.delete(id);
-          reject(err);
-        }
-      });
+      try {
+        this.child.stdin.write(line, (err) => {
+          if (err) {
+            this.pending.delete(id);
+            reject(err);
+          }
+        });
+      } catch (e) {
+        this.pending.delete(id);
+        reject(e);
+      }
     });
   }
 };
@@ -379,10 +517,24 @@ var SessionManager = class {
     return this.sessions.get(sessionId);
   }
   async create(params) {
-    const proc = await PiRpcProcess.spawn({
-      cwd: params.cwd
-    });
-    const state = await proc.getState();
+    let proc;
+    try {
+      proc = await PiRpcProcess.spawn({
+        cwd: params.cwd,
+        piCommand: params.piCommand
+      });
+    } catch (e) {
+      if (e instanceof PiRpcSpawnError) {
+        throw RequestError2.internalError({ code: e.code }, e.message);
+      }
+      throw e;
+    }
+    let state = null;
+    try {
+      state = await proc.getState();
+    } catch {
+      state = null;
+    }
     const sessionId = typeof state?.sessionId === "string" ? state.sessionId : crypto.randomUUID();
     const sessionFile = typeof state?.sessionFile === "string" ? state.sessionFile : null;
     if (sessionFile) {
@@ -401,7 +553,7 @@ var SessionManager = class {
   }
   get(sessionId) {
     const s = this.sessions.get(sessionId);
-    if (!s) throw RequestError.invalidParams(`Unknown sessionId: ${sessionId}`);
+    if (!s) throw RequestError2.invalidParams(`Unknown sessionId: ${sessionId}`);
     return s;
   }
   /**
@@ -427,6 +579,8 @@ var PiAcpSession = class {
   sessionId;
   cwd;
   mcpServers;
+  startupInfo = null;
+  startupInfoSent = false;
   proc;
   conn;
   fileCommands;
@@ -459,7 +613,30 @@ var PiAcpSession = class {
     this.fileCommands = opts.fileCommands ?? [];
     this.proc.onEvent((ev) => this.handlePiEvent(ev));
   }
+  setStartupInfo(text) {
+    this.startupInfo = text;
+  }
+  /**
+   * Best-effort attempt to send startup info outside of a prompt turn.
+   * Some clients (e.g. Zed) may only render agent messages once the UI is ready;
+   * callers can invoke this shortly after session/new returns.
+   */
+  sendStartupInfoIfPending() {
+    if (this.startupInfoSent || !this.startupInfo) return;
+    this.startupInfoSent = true;
+    this.emit({
+      sessionUpdate: "agent_message_chunk",
+      content: { type: "text", text: this.startupInfo }
+    });
+  }
   async prompt(message, attachments = []) {
+    if (!this.startupInfoSent && this.startupInfo) {
+      this.startupInfoSent = true;
+      this.emit({
+        sessionUpdate: "agent_message_chunk",
+        content: { type: "text", text: this.startupInfo }
+      });
+    }
     const expandedMessage = expandSlashCommand(message, this.fileCommands);
     const turnPromise = new Promise((resolve2, reject) => {
       const queued = { message: expandedMessage, attachments, resolve: resolve2, reject };
@@ -523,8 +700,13 @@ var PiAcpSession = class {
     });
     this.proc.prompt(t.message, t.attachments).catch((err) => {
       void this.flushEmits().finally(() => {
-        const reason = this.cancelRequested ? "cancelled" : "error";
-        this.pendingTurn?.resolve(reason);
+        const authErr = maybeAuthRequiredError(err);
+        if (authErr) {
+          this.pendingTurn?.reject(authErr);
+        } else {
+          const reason = this.cancelRequested ? "cancelled" : "error";
+          this.pendingTurn?.resolve(reason);
+        }
         this.pendingTurn = null;
         this.inAgentLoop = false;
         this.emit({
@@ -728,6 +910,245 @@ function toToolKind(toolName) {
   }
 }
 
+// src/acp/pi-sessions.ts
+import { readdirSync as readdirSync2, readFileSync as readFileSync4, statSync, openSync, readSync, closeSync } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
+var DEFAULT_TAIL_BYTES = 256 * 1024;
+var DEFAULT_HEAD_BYTES = 64 * 1024;
+function getPiAgentDir() {
+  return process.env.PI_CODING_AGENT_DIR ?? join3(homedir3(), ".pi", "agent");
+}
+function getPiSessionsDir() {
+  return join3(getPiAgentDir(), "sessions");
+}
+function walkJsonlFiles(dir, out) {
+  let entries;
+  try {
+    entries = readdirSync2(dir, { withFileTypes: true, encoding: "utf8" });
+  } catch {
+    return;
+  }
+  for (const e of entries) {
+    const name = typeof e.name === "string" ? e.name : String(e.name);
+    const p = join3(dir, name);
+    if (e.isDirectory()) walkJsonlFiles(p, out);
+    else if (e.isFile() && name.endsWith(".jsonl")) out.push(p);
+  }
+}
+function readFirstLine(path) {
+  const fd = openSync(path, "r");
+  try {
+    const buf = Buffer.alloc(DEFAULT_HEAD_BYTES);
+    const n = readSync(fd, buf, 0, buf.length, 0);
+    if (n <= 0) return null;
+    const s = buf.subarray(0, n).toString("utf-8");
+    const idx = s.indexOf("\n");
+    return idx === -1 ? s.trim() : s.slice(0, idx).trim();
+  } catch {
+    return null;
+  } finally {
+    try {
+      closeSync(fd);
+    } catch {
+    }
+  }
+}
+function readTail(path, tailBytes = DEFAULT_TAIL_BYTES) {
+  const st = statSync(path);
+  const start = Math.max(0, st.size - tailBytes);
+  const len = st.size - start;
+  const fd = openSync(path, "r");
+  try {
+    const buf = Buffer.alloc(len);
+    const n = readSync(fd, buf, 0, buf.length, start);
+    return buf.subarray(0, n).toString("utf-8");
+  } finally {
+    try {
+      closeSync(fd);
+    } catch {
+    }
+  }
+}
+function parseSessionHeader(firstLine) {
+  try {
+    const obj = JSON.parse(firstLine);
+    if (obj?.type !== "session") return null;
+    const sessionId = typeof obj?.id === "string" ? obj.id : null;
+    const cwd = typeof obj?.cwd === "string" ? obj.cwd : null;
+    if (!sessionId || !cwd) return null;
+    return { sessionId, cwd };
+  } catch {
+    return null;
+  }
+}
+function pickTitleFromTail(tail) {
+  const lines = tail.split(/\r?\n/);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i].trim();
+    if (!line) continue;
+    try {
+      const obj = JSON.parse(line);
+      if (obj?.type === "session_info" && typeof obj?.name === "string" && obj.name.trim()) {
+        return obj.name.trim();
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function scanSessionInfoNameFromFile(path) {
+  const fd = openSync(path, "r");
+  try {
+    const buf = Buffer.alloc(256 * 1024);
+    let leftover = "";
+    let offset = 0;
+    let lastName = null;
+    while (true) {
+      const n = readSync(fd, buf, 0, buf.length, offset);
+      if (n <= 0) break;
+      offset += n;
+      const chunk = leftover + buf.subarray(0, n).toString("utf8");
+      const lines = chunk.split(/\r?\n/);
+      leftover = lines.pop() ?? "";
+      for (const line0 of lines) {
+        const line = line0.trim();
+        if (!line) continue;
+        try {
+          const obj = JSON.parse(line);
+          if (obj?.type === "session_info" && typeof obj?.name === "string" && obj.name.trim()) {
+            lastName = obj.name.trim();
+          }
+        } catch {
+        }
+      }
+    }
+    const tailLine = leftover.trim();
+    if (tailLine) {
+      try {
+        const obj = JSON.parse(tailLine);
+        if (obj?.type === "session_info" && typeof obj?.name === "string" && obj.name.trim()) {
+          lastName = obj.name.trim();
+        }
+      } catch {
+      }
+    }
+    return lastName;
+  } catch {
+    return null;
+  } finally {
+    try {
+      closeSync(fd);
+    } catch {
+    }
+  }
+}
+function pickUpdatedAtFromTail(tail) {
+  const lines = tail.split(/\r?\n/);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i].trim();
+    if (!line) continue;
+    try {
+      const obj = JSON.parse(line);
+      if (obj?.type !== "message") continue;
+      const ts = typeof obj?.timestamp === "string" ? obj.timestamp : null;
+      if (!ts) continue;
+      const d = new Date(ts);
+      if (Number.isFinite(d.getTime())) return d.toISOString();
+    } catch {
+    }
+  }
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i].trim();
+    if (!line) continue;
+    try {
+      const obj = JSON.parse(line);
+      const ts = typeof obj?.timestamp === "string" ? obj.timestamp : null;
+      if (!ts) continue;
+      const d = new Date(ts);
+      if (Number.isFinite(d.getTime())) return d.toISOString();
+    } catch {
+    }
+  }
+  return null;
+}
+function pickFallbackTitleFromHead(path) {
+  try {
+    const raw = readFileSync4(path, { encoding: "utf8" });
+    const lines = raw.split(/\r?\n/);
+    for (const line0 of lines) {
+      const line = line0.trim();
+      if (!line) continue;
+      try {
+        const obj = JSON.parse(line);
+        if (obj?.type === "message" && obj?.message?.role === "user") {
+          const content = obj?.message?.content;
+          if (typeof content === "string") return content.slice(0, 80);
+          if (Array.isArray(content)) {
+            const t = content.find((c) => c?.type === "text" && typeof c?.text === "string");
+            if (t?.text) return String(t.text).slice(0, 80);
+          }
+        }
+      } catch {
+      }
+      if (lines.length > 2e3) break;
+    }
+  } catch {
+  }
+  return null;
+}
+function listPiSessions() {
+  const sessionsDir = getPiSessionsDir();
+  const files = [];
+  walkJsonlFiles(sessionsDir, files);
+  const items = [];
+  for (const file of files) {
+    const first = readFirstLine(file);
+    if (!first) continue;
+    const header = parseSessionHeader(first);
+    if (!header) continue;
+    let updatedAt = null;
+    let title = null;
+    try {
+      const tail = readTail(file);
+      title = pickTitleFromTail(tail);
+      updatedAt = pickUpdatedAtFromTail(tail);
+    } catch {
+    }
+    if (!title) {
+      title = scanSessionInfoNameFromFile(file);
+    }
+    if (!updatedAt) {
+      try {
+        updatedAt = statSync(file).mtime.toISOString();
+      } catch {
+        updatedAt = null;
+      }
+    }
+    if (!title) {
+      title = pickFallbackTitleFromHead(file);
+    }
+    items.push({
+      sessionId: header.sessionId,
+      cwd: header.cwd,
+      title,
+      updatedAt,
+      sessionFile: file
+    });
+  }
+  items.sort((a, b) => {
+    const aa = a.updatedAt ?? "";
+    const bb = b.updatedAt ?? "";
+    return bb.localeCompare(aa);
+  });
+  return items;
+}
+function findPiSessionFile(sessionId) {
+  const all = listPiSessions();
+  const found = all.find((s) => s.sessionId === sessionId);
+  return found?.sessionFile ?? null;
+}
+
 // src/acp/translate/pi-messages.ts
 function normalizePiMessageText(content) {
   if (typeof content === "string") return content;
@@ -803,10 +1224,89 @@ ${r.text}`;
 
 // src/acp/agent.ts
 import { isAbsolute as isAbsolute2 } from "path";
-import { existsSync as existsSync2, readFileSync as readFileSync4, realpathSync } from "fs";
-import { join as join3, dirname as dirname2 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync6, realpathSync, readdirSync as readdirSync3, statSync as statSync2 } from "fs";
+import { join as join5, dirname as dirname2, basename } from "path";
 import { spawnSync } from "child_process";
+
+// src/pi-auth/status.ts
+import { existsSync as existsSync2, readFileSync as readFileSync5 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join4 } from "path";
+function safeReadJson(path) {
+  try {
+    if (!existsSync2(path)) return null;
+    const raw = readFileSync5(path, "utf-8");
+    if (!raw.trim()) return null;
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function getPiAgentDir2() {
+  const envDir = process.env.PI_CODING_AGENT_DIR;
+  if (envDir) {
+    if (envDir === "~") return homedir4();
+    if (envDir.startsWith("~/")) return homedir4() + envDir.slice(1);
+    return envDir;
+  }
+  return join4(homedir4(), ".pi", "agent");
+}
+function hasAnyPiAuthConfigured() {
+  const agentDir = getPiAgentDir2();
+  const authPath = join4(agentDir, "auth.json");
+  const auth = safeReadJson(authPath);
+  if (auth && typeof auth === "object" && Object.keys(auth).length > 0) return true;
+  const modelsPath = join4(agentDir, "models.json");
+  const models = safeReadJson(modelsPath);
+  const providers = models?.providers;
+  if (providers && typeof providers === "object") {
+    for (const p of Object.values(providers)) {
+      if (p && typeof p === "object" && typeof p.apiKey === "string" && p.apiKey.trim()) {
+        return true;
+      }
+    }
+  }
+  const envVars = [
+    "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
+    "COPILOT_GITHUB_TOKEN",
+    "GH_TOKEN",
+    "GITHUB_TOKEN",
+    // Anthropic oauth
+    "ANTHROPIC_OAUTH_TOKEN",
+    "ANTHROPIC_API_KEY"
+  ];
+  for (const k of envVars) {
+    const v = process.env[k];
+    if (typeof v === "string" && v.trim()) return true;
+  }
+  return false;
+}
+
+// src/acp/agent.ts
 import { fileURLToPath } from "url";
+function booleanEnv(name, defaultValue) {
+  const raw = process.env[name];
+  if (raw == null) return defaultValue;
+  const v = String(raw).trim().toLowerCase();
+  if (v === "true") return true;
+  if (v === "false") return false;
+  return defaultValue;
+}
 function builtinAvailableCommands() {
   return [
     {
@@ -858,8 +1358,11 @@ var PiAcpAgent = class {
   conn;
   sessions = new SessionManager();
   store = new SessionStore();
-  constructor(conn) {
+  // Remember recent session cwd and use it as the default filter.
+  lastSessionCwd = null;
+  constructor(conn, _config) {
     this.conn = conn;
+    void _config;
   }
   async initialize(params) {
     const supportedVersion = 1;
@@ -871,7 +1374,11 @@ var PiAcpAgent = class {
         title: "pi ACP adapter",
         version: pkg.version ?? "0.0.0"
       },
-      authMethods: [],
+      // Zed currently uses ClientCapabilities._meta["terminal-auth"] to decide whether to show
+      // the "Authenticate" banner/button. If not supported, we still return the method for the registry.
+      authMethods: getAuthMethods({
+        supportsTerminalAuthMeta: params?.clientCapabilities?._meta?.["terminal-auth"] === true
+      }),
       agentCapabilities: {
         loadSession: true,
         mcpCapabilities: { http: false, sse: false },
@@ -880,29 +1387,65 @@ var PiAcpAgent = class {
           audio: false,
           embeddedContext: false
         },
-        sessionCapabilities: {}
+        sessionCapabilities: {
+          // **UNSTABLE** ACP capability used by Zed's codex-acp adapter.
+          // Enables a native session picker in clients that support it.
+          list: {}
+        }
       }
     };
   }
   async newSession(params) {
     if (!isAbsolute2(params.cwd)) {
-      throw RequestError2.invalidParams(`cwd must be an absolute path: ${params.cwd}`);
+      throw RequestError3.invalidParams(`cwd must be an absolute path: ${params.cwd}`);
+    }
+    this.lastSessionCwd = params.cwd;
+    if (!hasAnyPiAuthConfigured()) {
+      throw RequestError3.authRequired(
+        { authMethods: getAuthMethods() },
+        "Configure an API key or log in with an OAuth provider."
+      );
     }
     const fileCommands = loadSlashCommands(params.cwd);
     const session = await this.sessions.create({
       cwd: params.cwd,
       mcpServers: params.mcpServers,
       conn: this.conn,
-      fileCommands
+      fileCommands,
+      piCommand: process.env.PI_ACP_PI_COMMAND
     });
+    let rawModelsCount = 0;
+    try {
+      const data = await session.proc.getAvailableModels();
+      rawModelsCount = Array.isArray(data?.models) ? data.models.length : 0;
+    } catch {
+    }
+    if (rawModelsCount === 0) {
+      try {
+        session.proc.dispose?.();
+      } catch {
+      }
+      throw RequestError3.authRequired(
+        { authMethods: getAuthMethods() },
+        "Configure an API key or log in with an OAuth provider."
+      );
+    }
     const models = await getModelState(session.proc);
     const thinking = await getThinkingState(session.proc);
+    const showStartupInfo = booleanEnv("PI_ACP_STARTUP_INFO", true);
+    const preludeText = showStartupInfo ? buildStartupInfo({ cwd: params.cwd, fileCommands }) : "";
+    if (preludeText) session.setStartupInfo(preludeText);
     const response = {
       sessionId: session.sessionId,
       models,
       modes: thinking,
-      _meta: {}
+      _meta: {
+        piAcp: {
+          startupInfo: preludeText || null
+        }
+      }
     };
+    if (showStartupInfo) setTimeout(() => session.sendStartupInfoIfPending(), 0);
     setTimeout(() => {
       void this.conn.sessionUpdate({
         sessionId: session.sessionId,
@@ -1065,8 +1608,8 @@ ${JSON.stringify(stats, null, 2)}`;
             if (piPath) {
               const resolved = realpathSync(piPath);
               const pkgRoot = dirname2(dirname2(resolved));
-              const p = join3(pkgRoot, "CHANGELOG.md");
-              if (existsSync2(p)) return p;
+              const p = join5(pkgRoot, "CHANGELOG.md");
+              if (existsSync3(p)) return p;
             }
           } catch {
           }
@@ -1074,8 +1617,8 @@ ${JSON.stringify(stats, null, 2)}`;
             const npmRoot = spawnSync("npm", ["root", "-g"], { encoding: "utf-8" });
             const root = String(npmRoot.stdout ?? "").trim();
             if (root) {
-              const p = join3(root, "@mariozechner", "pi-coding-agent", "CHANGELOG.md");
-              if (existsSync2(p)) return p;
+              const p = join5(root, "@mariozechner", "pi-coding-agent", "CHANGELOG.md");
+              if (existsSync3(p)) return p;
             }
           } catch {
           }
@@ -1094,7 +1637,7 @@ ${JSON.stringify(stats, null, 2)}`;
         }
         let text = "";
         try {
-          text = readFileSync4(changelogPath, "utf-8");
+          text = readFileSync6(changelogPath, "utf-8");
         } catch (e) {
           await this.conn.sessionUpdate({
             sessionId: session.sessionId,
@@ -1120,7 +1663,7 @@ ${JSON.stringify(stats, null, 2)}`;
         const state = await session.proc.getState();
         const sessionFile = typeof state?.sessionFile === "string" ? state.sessionFile : null;
         const messageCount = typeof state?.messageCount === "number" ? state.messageCount : 0;
-        if (!sessionFile || messageCount === 0 || !existsSync2(sessionFile)) {
+        if (!sessionFile || messageCount === 0 || !existsSync3(sessionFile)) {
           await this.conn.sessionUpdate({
             sessionId: session.sessionId,
             update: {
@@ -1134,7 +1677,7 @@ ${JSON.stringify(stats, null, 2)}`;
           return { stopReason: "end_turn" };
         }
         try {
-          const raw = readFileSync4(sessionFile, "utf-8");
+          const raw = readFileSync6(sessionFile, "utf-8");
           if (raw.trim().length === 0) {
             await this.conn.sessionUpdate({
               sessionId: session.sessionId,
@@ -1162,7 +1705,7 @@ ${JSON.stringify(stats, null, 2)}`;
           return { stopReason: "end_turn" };
         }
         const safeSessionId = session.sessionId.replace(/[^a-zA-Z0-9_-]/g, "_");
-        const outputPath = join3(session.cwd, `pi-session-${safeSessionId}.html`);
+        const outputPath = join5(session.cwd, `pi-session-${safeSessionId}.html`);
         let resultPath = "";
         try {
           const result2 = await session.proc.exportHtml(outputPath);
@@ -1251,18 +1794,46 @@ ${JSON.stringify(stats, null, 2)}`;
     const session = this.sessions.get(params.sessionId);
     await session.cancel();
   }
+  async unstable_listSessions(params) {
+    const all = listPiSessions();
+    const effectiveCwd = params.cwd ?? this.lastSessionCwd;
+    const filtered = effectiveCwd ? all.filter((s) => s.cwd === effectiveCwd) : all;
+    const offset = params.cursor ? Number.parseInt(params.cursor, 10) : 0;
+    const start = Number.isFinite(offset) && offset > 0 ? offset : 0;
+    const PAGE_SIZE = 50;
+    const page = filtered.slice(start, start + PAGE_SIZE);
+    const sessions = page.map((s) => ({
+      sessionId: s.sessionId,
+      cwd: s.cwd,
+      title: s.title,
+      updatedAt: s.updatedAt
+    }));
+    const nextCursor = start + PAGE_SIZE < filtered.length ? String(start + PAGE_SIZE) : null;
+    return { sessions, nextCursor, _meta: {} };
+  }
   async loadSession(params) {
     if (!isAbsolute2(params.cwd)) {
-      throw RequestError2.invalidParams(`cwd must be an absolute path: ${params.cwd}`);
+      throw RequestError3.invalidParams(`cwd must be an absolute path: ${params.cwd}`);
     }
+    this.lastSessionCwd = params.cwd;
     const stored = this.store.get(params.sessionId);
-    if (!stored) {
-      throw RequestError2.invalidParams(`Unknown sessionId: ${params.sessionId}`);
+    const sessionFile = stored?.sessionFile ?? findPiSessionFile(params.sessionId);
+    if (!sessionFile) {
+      throw RequestError3.invalidParams(`Unknown sessionId: ${params.sessionId}`);
+    }
+    let proc;
+    try {
+      proc = await PiRpcProcess.spawn({
+        cwd: params.cwd,
+        sessionPath: sessionFile,
+        piCommand: process.env.PI_ACP_PI_COMMAND
+      });
+    } catch (e) {
+      if (e?.name === "PiRpcSpawnError") {
+        throw RequestError3.internalError({ code: e?.code }, String(e?.message ?? e));
+      }
+      throw e;
     }
-    const proc = await PiRpcProcess.spawn({
-      cwd: params.cwd,
-      sessionPath: stored.sessionFile
-    });
     const fileCommands = loadSlashCommands(params.cwd);
     const session = this.sessions.getOrCreate(params.sessionId, {
       cwd: params.cwd,
@@ -1274,7 +1845,7 @@ ${JSON.stringify(stats, null, 2)}`;
     this.store.upsert({
       sessionId: params.sessionId,
       cwd: params.cwd,
-      sessionFile: stored.sessionFile
+      sessionFile
     });
     const data = await proc.getMessages();
     const messages = Array.isArray(data?.messages) ? data.messages : [];
@@ -1304,13 +1875,45 @@ ${JSON.stringify(stats, null, 2)}`;
           });
         }
       }
+      if (role === "toolResult") {
+        const toolName = String(m?.toolName ?? "tool");
+        const toolCallId = String(m?.toolCallId ?? crypto.randomUUID());
+        const isError = Boolean(m?.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 models = await getModelState(proc);
     const thinking = await getThinkingState(proc);
     const response = {
       models,
       modes: thinking,
-      _meta: {}
+      _meta: {
+        piAcp: {
+          startupInfo: null
+        }
+      }
     };
     setTimeout(() => {
       void this.conn.sessionUpdate({
@@ -1344,7 +1947,7 @@ ${JSON.stringify(stats, null, 2)}`;
       }
     }
     if (!provider || !modelId) {
-      throw RequestError2.invalidParams(`Unknown modelId: ${params.modelId}`);
+      throw RequestError3.invalidParams(`Unknown modelId: ${params.modelId}`);
     }
     await session.proc.setModel(provider, modelId);
   }
@@ -1352,7 +1955,7 @@ ${JSON.stringify(stats, null, 2)}`;
     const session = this.sessions.get(params.sessionId);
     const mode = String(params.modeId);
     if (!isThinkingLevel(mode)) {
-      throw RequestError2.invalidParams(`Unknown modeId: ${mode}`);
+      throw RequestError3.invalidParams(`Unknown modeId: ${mode}`);
     }
     await session.proc.setThinkingLevel(mode);
     void this.conn.sessionUpdate({
@@ -1422,13 +2025,147 @@ async function getModelState(proc) {
     currentModelId
   };
 }
+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 buildStartupInfo(opts) {
+  void opts.fileCommands;
+  const md = [];
+  let updateNotice = null;
+  try {
+    const piVersion = spawnSync("pi", ["--version"], { encoding: "utf-8" });
+    const installed = String(piVersion.stdout ?? "").trim().replace(/^v/i, "");
+    if (installed) {
+      md.push(`pi v${installed}`);
+      md.push("---");
+      md.push("");
+      try {
+        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) && isSemver(installed) && compareSemver(latest, installed) > 0) {
+          updateNotice = `New version available: v${latest} (installed v${installed}). Run: \`npm i -g @mariozechner/pi-coding-agent\``;
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  const addSection = (title, items) => {
+    const cleaned = items.map((s) => s.trim()).filter(Boolean);
+    if (!cleaned.length) return;
+    md.push(`## ${title}`);
+    for (const item of cleaned) md.push(`- ${item}`);
+    md.push("");
+  };
+  const contextItems = [];
+  const contextPath = join5(opts.cwd, "AGENTS.md");
+  if (existsSync3(contextPath)) contextItems.push(contextPath);
+  addSection("Context", contextItems);
+  const skillsItems = [];
+  const pushSkillFromRoot = (root) => {
+    try {
+      for (const e of readdirSync3(root)) {
+        const p = join5(root, e);
+        try {
+          const st = statSync2(p);
+          if (st.isFile() && e.toLowerCase().endsWith(".md")) {
+            skillsItems.push(p);
+          }
+        } catch {
+        }
+      }
+      const stack = [root];
+      while (stack.length) {
+        const dir = stack.pop();
+        let entries = [];
+        try {
+          entries = readdirSync3(dir);
+        } catch {
+          continue;
+        }
+        for (const name of entries) {
+          if (name === "node_modules" || name === ".git") continue;
+          const p = join5(dir, name);
+          let st;
+          try {
+            st = statSync2(p);
+          } catch {
+            continue;
+          }
+          if (st.isDirectory()) {
+            stack.push(p);
+          } else if (st.isFile() && name === "SKILL.md") {
+            skillsItems.push(p);
+          }
+        }
+      }
+    } catch {
+    }
+  };
+  const globalSkillsDir = join5(process.env.HOME ?? "", ".pi", "agent", "skills");
+  pushSkillFromRoot(globalSkillsDir);
+  const projectSkillsDir = join5(opts.cwd, ".pi", "skills");
+  pushSkillFromRoot(projectSkillsDir);
+  addSection("Skills", skillsItems);
+  const promptsItems = [];
+  const promptsDir = join5(process.env.HOME ?? "", ".pi", "agent", "prompts");
+  try {
+    const prompts = readdirSync3(promptsDir).filter((f) => f.endsWith(".md"));
+    for (const f of prompts) promptsItems.push(`/${basename(f, ".md")}`);
+  } catch {
+  }
+  addSection("Prompts", promptsItems);
+  const extItems = [];
+  const extDir = join5(process.env.HOME ?? "", ".pi", "agent", "extensions");
+  try {
+    const exts = readdirSync3(extDir).filter((f) => f.endsWith(".ts") || f.endsWith(".js"));
+    for (const f of exts) extItems.push(join5(extDir, f));
+  } catch {
+  }
+  try {
+    const settingsPath = join5(process.env.HOME ?? "", ".pi", "agent", "settings.json");
+    const settings = JSON.parse(readFileSync6(settingsPath, "utf-8"));
+    const pkgs = Array.isArray(settings?.packages) ? settings.packages : [];
+    for (const pkg2 of pkgs) {
+      const s = String(pkg2);
+      if (s.startsWith("npm:")) {
+        extItems.push(`${s}
+  - index.ts`);
+      } else {
+        extItems.push(s);
+      }
+    }
+  } catch {
+  }
+  addSection("Extensions", extItems);
+  if (updateNotice) {
+    md.push("---");
+    md.push(updateNotice);
+    md.push("");
+  }
+  return md.join("\n").trim() + "\n";
+}
 function readNearestPackageJson(metaUrl) {
   try {
     let dir = dirname2(fileURLToPath(metaUrl));
     for (let i = 0; i < 6; i++) {
-      const p = join3(dir, "package.json");
-      if (existsSync2(p)) {
-        const json = JSON.parse(readFileSync4(p, "utf-8"));
+      const p = join5(dir, "package.json");
+      if (existsSync3(p)) {
+        const json = JSON.parse(readFileSync6(p, "utf-8"));
         return { name: json?.name, version: json?.version };
       }
       dir = dirname2(dir);
@@ -1439,13 +2176,31 @@ function readNearestPackageJson(metaUrl) {
 }
 
 // src/index.ts
+if (process.argv.includes("--terminal-login")) {
+  const { spawnSync: spawnSync2 } = await import("child_process");
+  const cmd = process.env.PI_ACP_PI_COMMAND ?? "pi";
+  const res = spawnSync2(cmd, [], { stdio: "inherit", env: process.env });
+  if (res.error && res.error.code === "ENOENT") {
+    process.stderr.write(
+      `pi-acp: could not start pi (command not found: ${cmd}). Install it 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);
+}
 var input = new WritableStream({
   write(chunk) {
-    return new Promise((resolve2, reject) => {
-      process.stdout.write(chunk, (err) => {
-        if (err) reject(err);
-        else resolve2();
-      });
+    return new Promise((resolve2) => {
+      if (process.stdout.destroyed || !process.stdout.writable) return resolve2();
+      try {
+        process.stdout.write(chunk, (err) => {
+          void err;
+          resolve2();
+        });
+      } catch {
+        resolve2();
+      }
     });
   }
 });
@@ -1461,4 +2216,10 @@ new AgentSideConnection((conn) => new PiAcpAgent(conn), stream);
 process.stdin.resume();
 process.on("SIGINT", () => process.exit(0));
 process.on("SIGTERM", () => process.exit(0));
+process.stdout.on("error", () => {
+  try {
+    process.exit(0);
+  } catch {
+  }
+});
 //# sourceMappingURL=index.js.map