pi-acp 0.0.17 → 0.0.19

package/dist/index.js

@@ -5,21 +5,109 @@ 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;
+  }
+};
+var ESC = String.fromCharCode(27);
+var CSI = String.fromCharCode(155);
+var ANSI_ESCAPE_REGEX = new RegExp(
+  `[${ESC}${CSI}][[\\]()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]`,
+  "g"
+);
+function stripAnsi(s) {
+  return s.replace(ANSI_ESCAPE_REGEX, "");
+}
 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 +117,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 +139,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 +153,36 @@ var PiRpcProcess = class _PiRpcProcess {
       stdio: "pipe",
       env: process.env
     });
+    try {
+      await new Promise((resolve3, reject) => {
+        const onSpawn = () => {
+          cleanup();
+          resolve3();
+        };
+        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,8 +204,23 @@ var PiRpcProcess = class _PiRpcProcess {
       this.eventHandlers = this.eventHandlers.filter((h) => h !== handler);
     };
   }
-  async prompt(message, attachments = []) {
-    const res = await this.request({ type: "prompt", message, attachments });
+  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, images = []) {
+    const res = await this.request({ type: "prompt", message, images });
     if (!res.success) throw new Error(`pi prompt failed: ${res.error ?? JSON.stringify(res.data)}`);
   }
   async abort() {
@@ -144,18 +283,28 @@ var PiRpcProcess = class _PiRpcProcess {
     if (!res.success) throw new Error(`pi get_messages failed: ${res.error ?? JSON.stringify(res.data)}`);
     return res.data;
   }
+  async getCommands() {
+    const res = await this.request({ type: "get_commands" });
+    if (!res.success) throw new Error(`pi get_commands failed: ${res.error ?? JSON.stringify(res.data)}`);
+    return res.data;
+  }
   request(cmd) {
     const id = crypto.randomUUID();
     const withId = { ...cmd, id };
     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);
-        }
-      });
+    return new Promise((resolve3, reject) => {
+      this.pending.set(id, { resolve: resolve3, reject });
+      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 +528,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 +564,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 +590,8 @@ var PiAcpSession = class {
   sessionId;
   cwd;
   mcpServers;
+  startupInfo = null;
+  startupInfoSent = false;
   proc;
   conn;
   fileCommands;
@@ -459,10 +624,33 @@ var PiAcpSession = class {
     this.fileCommands = opts.fileCommands ?? [];
     this.proc.onEvent((ev) => this.handlePiEvent(ev));
   }
-  async prompt(message, attachments = []) {
+  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, images = []) {
+    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 };
+    const turnPromise = new Promise((resolve3, reject) => {
+      const queued = { message: expandedMessage, images, resolve: resolve3, reject };
       if (this.pendingTurn) {
         this.turnQueue.push(queued);
         this.emit({
@@ -521,10 +709,15 @@ var PiAcpSession = class {
       sessionUpdate: "session_info_update",
       _meta: { piAcp: { queueDepth: this.turnQueue.length, running: true } }
     });
-    this.proc.prompt(t.message, t.attachments).catch((err) => {
+    this.proc.prompt(t.message, t.images).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 +921,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;
@@ -740,13 +1172,9 @@ function normalizePiAssistantText(content) {
 }
 
 // src/acp/translate/prompt.ts
-function guessFileNameFromMime(mimeType) {
-  const ext = mimeType === "image/png" ? "png" : mimeType === "image/jpeg" ? "jpg" : mimeType === "image/webp" ? "webp" : "bin";
-  return `attachment.${ext}`;
-}
 function promptToPiMessage(blocks) {
   let message = "";
-  const attachments = [];
+  const images = [];
   for (const b of blocks) {
     switch (b.type) {
       case "text":
@@ -757,15 +1185,10 @@ function promptToPiMessage(blocks) {
 [Context] ${b.uri}`;
         break;
       case "image": {
-        const id = b.uri ?? crypto.randomUUID();
-        const size = Buffer.byteLength(b.data, "base64");
-        attachments.push({
-          id,
+        images.push({
           type: "image",
-          fileName: guessFileNameFromMime(b.mimeType),
           mimeType: b.mimeType,
-          size,
-          content: b.data
+          data: b.data
         });
         break;
       }
@@ -798,15 +1221,166 @@ ${r.text}`;
         break;
     }
   }
-  return { message, attachments };
+  return { message, images };
+}
+
+// src/acp/pi-settings.ts
+import { existsSync as existsSync2, readFileSync as readFileSync5 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join4, resolve as resolve2 } from "path";
+function isObject(x) {
+  return Boolean(x) && typeof x === "object" && !Array.isArray(x);
+}
+function deepMerge(a, b) {
+  const out = { ...a };
+  for (const [k, v] of Object.entries(b)) {
+    const av = out[k];
+    if (isObject(av) && isObject(v)) out[k] = deepMerge(av, v);
+    else out[k] = v;
+  }
+  return out;
+}
+function readJsonFile(path) {
+  try {
+    if (!existsSync2(path)) return {};
+    const raw = readFileSync5(path, "utf-8");
+    const data = JSON.parse(raw);
+    return isObject(data) ? data : {};
+  } catch {
+    return {};
+  }
+}
+function getAgentDir() {
+  return process.env.PI_CODING_AGENT_DIR ? resolve2(process.env.PI_CODING_AGENT_DIR) : join4(homedir4(), ".pi", "agent");
+}
+function getEnableSkillCommands(cwd) {
+  const globalSettingsPath = join4(getAgentDir(), "settings.json");
+  const projectSettingsPath = resolve2(cwd, ".pi", "settings.json");
+  const global = readJsonFile(globalSettingsPath);
+  const project = readJsonFile(projectSettingsPath);
+  const merged = deepMerge(global, project);
+  const direct = merged.enableSkillCommands;
+  if (typeof direct === "boolean") return direct;
+  const nested = isObject(merged.skills) ? merged.skills.enableSkillCommands : void 0;
+  if (typeof nested === "boolean") return nested;
+  return true;
+}
+
+// src/acp/pi-commands.ts
+function describeFallback(c) {
+  const source = typeof c.source === "string" ? c.source : "";
+  const location = typeof c.location === "string" ? c.location : "";
+  const parts = [];
+  if (source) parts.push(source);
+  if (location) parts.push(location);
+  return parts.length ? `(${parts.join(":")})` : "(command)";
+}
+function toAvailableCommandsFromPiGetCommands(data, opts) {
+  const enableSkillCommands = opts?.enableSkillCommands ?? true;
+  const includeExtensionCommands = opts?.includeExtensionCommands ?? false;
+  const root = data;
+  const commandsRaw = Array.isArray(root?.commands) ? root.commands : Array.isArray(root?.data?.commands) ? root.data.commands : [];
+  const out = [];
+  for (const c of commandsRaw) {
+    const name = typeof c?.name === "string" ? c.name.trim() : "";
+    if (!name) continue;
+    const source = typeof c?.source === "string" ? c.source : "";
+    if (!includeExtensionCommands && source === "extension") continue;
+    if (!enableSkillCommands && name.startsWith("skill:")) continue;
+    const desc = typeof c?.description === "string" ? c.description.trim() : "";
+    out.push({
+      name,
+      description: desc || describeFallback(c)
+    });
+  }
+  return { commands: out, raw: commandsRaw };
 }
 
 // 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 existsSync4, readFileSync as readFileSync7, realpathSync, readdirSync as readdirSync3, statSync as statSync2 } from "fs";
+import { join as join6, dirname as dirname2, basename } from "path";
 import { spawnSync } from "child_process";
+
+// src/pi-auth/status.ts
+import { existsSync as existsSync3, readFileSync as readFileSync6 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join5 } from "path";
+function safeReadJson(path) {
+  try {
+    if (!existsSync3(path)) return null;
+    const raw = readFileSync6(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 homedir5();
+    if (envDir.startsWith("~/")) return homedir5() + envDir.slice(1);
+    return envDir;
+  }
+  return join5(homedir5(), ".pi", "agent");
+}
+function hasAnyPiAuthConfigured() {
+  const agentDir = getPiAgentDir2();
+  const authPath = join5(agentDir, "auth.json");
+  const auth = safeReadJson(authPath);
+  if (auth && typeof auth === "object" && Object.keys(auth).length > 0) return true;
+  const modelsPath = join5(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 +1432,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 +1448,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,37 +1461,92 @@ 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 enableSkillCommands = getEnableSkillCommands(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,
-        update: {
-          sessionUpdate: "available_commands_update",
-          availableCommands: mergeCommands(toAvailableCommands(fileCommands), builtinAvailableCommands())
+      void (async () => {
+        try {
+          const pi = await session.proc.getCommands();
+          const { commands } = toAvailableCommandsFromPiGetCommands(pi, {
+            enableSkillCommands,
+            includeExtensionCommands: false
+          });
+          await this.conn.sessionUpdate({
+            sessionId: session.sessionId,
+            update: {
+              sessionUpdate: "available_commands_update",
+              availableCommands: mergeCommands(commands, builtinAvailableCommands())
+            }
+          });
+          return;
+        } catch {
         }
-      });
+        await this.conn.sessionUpdate({
+          sessionId: session.sessionId,
+          update: {
+            sessionUpdate: "available_commands_update",
+            availableCommands: mergeCommands(toAvailableCommands(fileCommands), builtinAvailableCommands())
+          }
+        });
+      })();
     }, 0);
     return response;
   }
@@ -919,8 +1555,8 @@ var PiAcpAgent = class {
   }
   async prompt(params) {
     const session = this.sessions.get(params.sessionId);
-    const { message, attachments } = promptToPiMessage(params.prompt);
-    if (attachments.length === 0 && message.trimStart().startsWith("/")) {
+    const { message, images } = promptToPiMessage(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);
@@ -1065,8 +1701,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 = join6(pkgRoot, "CHANGELOG.md");
+              if (existsSync4(p)) return p;
             }
           } catch {
           }
@@ -1074,8 +1710,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 = join6(root, "@mariozechner", "pi-coding-agent", "CHANGELOG.md");
+              if (existsSync4(p)) return p;
             }
           } catch {
           }
@@ -1094,7 +1730,7 @@ ${JSON.stringify(stats, null, 2)}`;
         }
         let text = "";
         try {
-          text = readFileSync4(changelogPath, "utf-8");
+          text = readFileSync7(changelogPath, "utf-8");
         } catch (e) {
           await this.conn.sessionUpdate({
             sessionId: session.sessionId,
@@ -1120,7 +1756,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 || !existsSync4(sessionFile)) {
           await this.conn.sessionUpdate({
             sessionId: session.sessionId,
             update: {
@@ -1134,7 +1770,7 @@ ${JSON.stringify(stats, null, 2)}`;
           return { stopReason: "end_turn" };
         }
         try {
-          const raw = readFileSync4(sessionFile, "utf-8");
+          const raw = readFileSync7(sessionFile, "utf-8");
           if (raw.trim().length === 0) {
             await this.conn.sessionUpdate({
               sessionId: session.sessionId,
@@ -1162,7 +1798,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 = join6(session.cwd, `pi-session-${safeSessionId}.html`);
         let resultPath = "";
         try {
           const result2 = await session.proc.exportHtml(outputPath);
@@ -1243,7 +1879,7 @@ ${JSON.stringify(stats, null, 2)}`;
         return { stopReason: "end_turn" };
       }
     }
-    const result = await session.prompt(message, attachments);
+    const result = await session.prompt(message, images);
     const stopReason = result === "error" ? session.wasCancelRequested() ? "cancelled" : "end_turn" : result;
     return { stopReason };
   }
@@ -1251,19 +1887,48 @@ ${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 enableSkillCommands = getEnableSkillCommands(params.cwd);
     const session = this.sessions.getOrCreate(params.sessionId, {
       cwd: params.cwd,
       mcpServers: params.mcpServers,
@@ -1274,7 +1939,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,22 +1969,72 @@ ${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({
-        sessionId: session.sessionId,
-        update: {
-          sessionUpdate: "available_commands_update",
-          availableCommands: mergeCommands(toAvailableCommands(fileCommands), builtinAvailableCommands())
+      void (async () => {
+        try {
+          const pi = await proc.getCommands();
+          const { commands } = toAvailableCommandsFromPiGetCommands(pi, {
+            enableSkillCommands,
+            includeExtensionCommands: false
+          });
+          await this.conn.sessionUpdate({
+            sessionId: session.sessionId,
+            update: {
+              sessionUpdate: "available_commands_update",
+              availableCommands: mergeCommands(commands, builtinAvailableCommands())
+            }
+          });
+          return;
+        } catch {
         }
-      });
+        await this.conn.sessionUpdate({
+          sessionId: session.sessionId,
+          update: {
+            sessionUpdate: "available_commands_update",
+            availableCommands: mergeCommands(toAvailableCommands(fileCommands), builtinAvailableCommands())
+          }
+        });
+      })();
     }, 0);
     return response;
   }
@@ -1344,7 +2059,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 +2067,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 +2137,149 @@ 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 = join6(opts.cwd, "AGENTS.md");
+  if (existsSync4(contextPath)) contextItems.push(contextPath);
+  addSection("Context", contextItems);
+  const skillsItems = [];
+  const pushSkillFromRoot = (root) => {
+    try {
+      for (const e of readdirSync3(root)) {
+        const p = join6(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 = join6(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 = join6(getAgentDir(), "skills");
+  pushSkillFromRoot(globalSkillsDir);
+  const legacyAgentsSkillsDir = join6(process.env.HOME ?? "", ".agents", "skills");
+  pushSkillFromRoot(legacyAgentsSkillsDir);
+  const projectSkillsDir = join6(opts.cwd, ".pi", "skills");
+  pushSkillFromRoot(projectSkillsDir);
+  addSection("Skills", skillsItems);
+  const promptsItems = [];
+  const promptsDir = join6(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 = join6(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(join6(extDir, f));
+  } catch {
+  }
+  try {
+    const settingsPath = join6(process.env.HOME ?? "", ".pi", "agent", "settings.json");
+    const settings = JSON.parse(readFileSync7(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 = join6(dir, "package.json");
+      if (existsSync4(p)) {
+        const json = JSON.parse(readFileSync7(p, "utf-8"));
         return { name: json?.name, version: json?.version };
       }
       dir = dirname2(dir);
@@ -1439,13 +2290,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((resolve3) => {
+      if (process.stdout.destroyed || !process.stdout.writable) return resolve3();
+      try {
+        process.stdout.write(chunk, (err) => {
+          void err;
+          resolve3();
+        });
+      } catch {
+        resolve3();
+      }
     });
   }
 });
@@ -1461,4 +2330,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