@pi-in-go/pigpen-acp 0.1.0

package/port/oracle/pi-acp/src/acp/auth-required.ts

@@ -0,0 +1,37 @@
+import { RequestError } from '@agentclientprotocol/sdk'
+import { getAuthMethods } from './auth.js'
+
+/**
+ * Best-effort detection of missing credentials / not-configured errors from pi/providers.
+ *
+ * We can't do a full provider-specific check here, so we look for common substrings.
+ */
+export function maybeAuthRequiredError(err: unknown): RequestError | null {
+  const msg = String((err as any)?.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
+
+  // Include terminal auth method options in error data.
+  return RequestError.authRequired(
+    {
+      authMethods: getAuthMethods()
+    },
+    'Configure an API key or log in with an OAuth provider.'
+  )
+}

package/port/oracle/pi-acp/src/acp/auth.ts

@@ -0,0 +1,59 @@
+import type { AuthMethod } from '@agentclientprotocol/sdk'
+
+export const PI_SETUP_METHOD_ID = 'pi_terminal_login'
+
+/**
+ * Zed (and some other clients) currently support "Terminal Auth" via an extension field
+ * in AuthMethod._meta, rather than the RFD "type/args/env" shape.
+ *
+ * We include BOTH for maximum compatibility:
+ *  - `_meta["terminal-auth"]`: used by Zed to render the "Authenticate" banner + button.
+ *  - `type/args/env`: registry-required shape.
+ */
+export function getAuthMethods(opts?: { supportsTerminalAuthMeta?: boolean }): AuthMethod[] {
+  const supportsTerminalAuthMeta = opts?.supportsTerminalAuthMeta ?? true
+
+  const method: any = {
+    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) {
+    // Best-effort launch spec for Zed's terminal-auth banner.
+    // Zed expects a full command+args (see mistral-vibe implementation).
+    const launch = terminalAuthLaunchSpec()
+
+    method._meta = {
+      ...(method._meta ?? {}),
+      'terminal-auth': {
+        ...launch,
+        label: 'Launch pi'
+      }
+    }
+  }
+
+  return [method as AuthMethod]
+}
+
+function terminalAuthLaunchSpec(): { command: string; args: string[] } {
+  // If we were launched as `node /path/to/dist/index.js`, reuse that.
+  // This is the most reliable in local dev and custom Zed configurations.
+  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'] }
+    }
+  }
+
+  // Fallback: assume `pi-acp` is on PATH.
+  return { command: 'pi-acp', args: ['--terminal-login'] }
+}

package/port/oracle/pi-acp/src/acp/paths.ts

@@ -0,0 +1,15 @@
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+/**
+ * Storage owned by the ACP adapter.
+ *
+ * We intentionally keep this separate from pi's own ~/.pi/agent/* directory.
+ */
+export function getPiAcpDir(): string {
+  return join(homedir(), '.pi', 'pi-acp')
+}
+
+export function getPiAcpSessionMapPath(): string {
+  return join(getPiAcpDir(), 'session-map.json')
+}

package/port/oracle/pi-acp/src/acp/pi-commands.ts

@@ -0,0 +1,59 @@
+import type { AvailableCommand } from '@agentclientprotocol/sdk'
+
+export type PiRpcCommandInfo = {
+  name?: unknown
+  description?: unknown
+  source?: unknown
+  location?: unknown
+  path?: unknown
+}
+
+function describeFallback(c: PiRpcCommandInfo): string {
+  const source = typeof c.source === 'string' ? c.source : ''
+  const location = typeof c.location === 'string' ? c.location : ''
+
+  const parts: string[] = []
+  if (source) parts.push(source)
+  if (location) parts.push(location)
+
+  return parts.length ? `(${parts.join(':')})` : '(command)'
+}
+
+export function toAvailableCommandsFromPiGetCommands(
+  data: unknown,
+  opts?: { enableSkillCommands?: boolean; includeExtensionCommands?: boolean }
+): {
+  commands: AvailableCommand[]
+  raw: PiRpcCommandInfo[]
+} {
+  const enableSkillCommands = opts?.enableSkillCommands ?? true
+  const includeExtensionCommands = opts?.includeExtensionCommands ?? false
+
+  const root: any = data
+  const commandsRaw: PiRpcCommandInfo[] = Array.isArray(root?.commands)
+    ? root.commands
+    : Array.isArray(root?.data?.commands)
+      ? root.data.commands
+      : []
+
+  const out: AvailableCommand[] = []
+
+  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 }
+}

package/port/oracle/pi-acp/src/acp/pi-sessions.ts

@@ -0,0 +1,333 @@
+import { readdirSync, readFileSync, statSync, openSync, readSync, closeSync, existsSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join, resolve, isAbsolute } from 'node:path'
+
+export type PiSessionListItem = {
+  sessionId: string
+  cwd: string
+  title: string | null
+  updatedAt: string | null
+  sessionFile: string
+}
+
+const DEFAULT_TAIL_BYTES = 256 * 1024
+const DEFAULT_HEAD_BYTES = 64 * 1024
+
+function getPiAgentDir(): string {
+  // pi supports overriding config dir via PI_CODING_AGENT_DIR.
+  // See pi README.
+  return process.env.PI_CODING_AGENT_DIR ? resolve(process.env.PI_CODING_AGENT_DIR) : join(homedir(), '.pi', 'agent')
+}
+
+function readSessionDirFromSettings(agentDir: string): string | null {
+  const settingsPath = join(agentDir, 'settings.json')
+  try {
+    if (!existsSync(settingsPath)) return null
+    const raw = readFileSync(settingsPath, 'utf8')
+    const data = JSON.parse(raw) as unknown
+    if (!data || typeof data !== 'object' || Array.isArray(data)) return null
+
+    const sessionDir = (data as Record<string, unknown>).sessionDir
+    if (typeof sessionDir !== 'string' || !sessionDir.trim()) return null
+
+    return isAbsolute(sessionDir) ? sessionDir : resolve(agentDir, sessionDir)
+  } catch {
+    return null
+  }
+}
+
+export function getPiSessionsDir(): string {
+  const agentDir = getPiAgentDir()
+  return readSessionDirFromSettings(agentDir) ?? join(agentDir, 'sessions')
+}
+
+function walkJsonlFiles(dir: string, out: string[]) {
+  let entries: import('node:fs').Dirent[]
+  try {
+    // Force string names.
+    entries = readdirSync(dir, { withFileTypes: true, encoding: 'utf8' }) as unknown as import('node:fs').Dirent[]
+  } catch {
+    return
+  }
+
+  for (const e of entries) {
+    const name = typeof (e as any).name === 'string' ? (e as any).name : String((e as any).name)
+    const p = join(dir, name)
+    if (e.isDirectory()) walkJsonlFiles(p, out)
+    else if (e.isFile() && name.endsWith('.jsonl')) out.push(p)
+  }
+}
+
+function readFirstLine(path: string): string | null {
+  // Avoid reading the whole file.
+  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 {
+      // ignore
+    }
+  }
+}
+
+function readTail(path: string, tailBytes = DEFAULT_TAIL_BYTES): string {
+  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 {
+      // ignore
+    }
+  }
+}
+
+function parseSessionHeader(firstLine: string): { sessionId: string; cwd: string } | null {
+  try {
+    const obj = JSON.parse(firstLine) as any
+    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: string): string | null {
+  // Try to find the *latest* session_info entry (stores the user-provided name).
+  // We scan backwards line-by-line.
+  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) as any
+      if (obj?.type === 'session_info' && typeof obj?.name === 'string' && obj.name.trim()) {
+        return obj.name.trim()
+      }
+    } catch {
+      // ignore
+    }
+  }
+  return null
+}
+
+function scanSessionInfoNameFromFile(path: string): string | null {
+  // Fallback when the session_info entry is older than our tail window.
+  // Scan the whole file line-by-line and remember the last session_info.name.
+  const fd = openSync(path, 'r')
+  try {
+    const buf = Buffer.alloc(256 * 1024)
+    let leftover = ''
+    let offset = 0
+    let lastName: string | null = 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) as any
+          if (obj?.type === 'session_info' && typeof obj?.name === 'string' && obj.name.trim()) {
+            lastName = obj.name.trim()
+          }
+        } catch {
+          // ignore
+        }
+      }
+    }
+
+    // Best-effort: parse leftover if it was a full line without trailing newline.
+    const tailLine = leftover.trim()
+    if (tailLine) {
+      try {
+        const obj = JSON.parse(tailLine) as any
+        if (obj?.type === 'session_info' && typeof obj?.name === 'string' && obj.name.trim()) {
+          lastName = obj.name.trim()
+        }
+      } catch {
+        // ignore
+      }
+    }
+
+    return lastName
+  } catch {
+    return null
+  } finally {
+    try {
+      closeSync(fd)
+    } catch {
+      // ignore
+    }
+  }
+}
+
+function pickUpdatedAtFromTail(tail: string): string | null {
+  // pi's `/resume` effectively orders sessions by last *message* activity.
+  // We scan backwards and pick the timestamp of the most recent entry with type === "message".
+  const lines = tail.split(/\r?\n/)
+
+  // 1) Prefer the most recent message entry.
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i].trim()
+    if (!line) continue
+    try {
+      const obj = JSON.parse(line) as any
+      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 {
+      // ignore
+    }
+  }
+
+  // 2) Fallback: any valid timestamp (covers sessions that somehow have no messages).
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i].trim()
+    if (!line) continue
+    try {
+      const obj = JSON.parse(line) as any
+      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 {
+      // ignore
+    }
+  }
+
+  return null
+}
+
+function pickFallbackTitleFromHead(path: string): string | null {
+  // Fallback to first user message.
+  // NOTE: we keep this simple: read a small head chunk and parse line-by-line.
+  try {
+    const raw = readFileSync(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) as any
+        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: any) => c?.type === 'text' && typeof c?.text === 'string')
+            if (t?.text) return String(t.text).slice(0, 80)
+          }
+        }
+      } catch {
+        // ignore
+      }
+
+      // Avoid scanning extremely large files fully.
+      // If we didn't find a user message in the first ~2000 lines, give up.
+      // (Most sessions have it early.)
+      if (lines.length > 2000) break
+    }
+  } catch {
+    // ignore
+  }
+
+  return null
+}
+
+export function listPiSessions(): PiSessionListItem[] {
+  const sessionsDir = getPiSessionsDir()
+  const files: string[] = []
+  walkJsonlFiles(sessionsDir, files)
+
+  const items: PiSessionListItem[] = []
+
+  for (const file of files) {
+    const first = readFirstLine(file)
+    if (!first) continue
+    const header = parseSessionHeader(first)
+    if (!header) continue
+
+    let updatedAt: string | null = null
+
+    let title: string | null = null
+    try {
+      const tail = readTail(file)
+      title = pickTitleFromTail(tail)
+      updatedAt = pickUpdatedAtFromTail(tail)
+    } catch {
+      // ignore
+    }
+
+    // If the session was named early and grew large, it may fall outside of the tail window.
+    if (!title) {
+      title = scanSessionInfoNameFromFile(file)
+    }
+
+    // Fallback for updatedAt when we couldn't parse timestamps from tail.
+    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
+    })
+  }
+
+  // Sort most recent first.
+  items.sort((a, b) => {
+    const aa = a.updatedAt ?? ''
+    const bb = b.updatedAt ?? ''
+    return bb.localeCompare(aa)
+  })
+
+  return items
+}
+
+export function findPiSession(sessionId: string): PiSessionListItem | null {
+  const all = listPiSessions()
+  return all.find(s => s.sessionId === sessionId) ?? null
+}
+
+export function findPiSessionFile(sessionId: string): string | null {
+  return findPiSession(sessionId)?.sessionFile ?? null
+}

package/port/oracle/pi-acp/src/acp/pi-settings.ts

@@ -0,0 +1,75 @@
+import { existsSync, readFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join, resolve } from 'node:path'
+
+function isObject(x: unknown): x is Record<string, unknown> {
+  return Boolean(x) && typeof x === 'object' && !Array.isArray(x)
+}
+
+function deepMerge(a: Record<string, unknown>, b: Record<string, unknown>): Record<string, unknown> {
+  const out: Record<string, unknown> = { ...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: string): Record<string, unknown> {
+  try {
+    if (!existsSync(path)) return {}
+    const raw = readFileSync(path, 'utf-8')
+    const data = JSON.parse(raw)
+    return isObject(data) ? data : {}
+  } catch {
+    return {}
+  }
+}
+
+function getMergedSettings(cwd: string): Record<string, unknown> {
+  const globalSettingsPath = join(getAgentDir(), 'settings.json')
+  const projectSettingsPath = resolve(cwd, '.pi', 'settings.json')
+
+  const global = readJsonFile(globalSettingsPath)
+  const project = readJsonFile(projectSettingsPath)
+  return deepMerge(global, project)
+}
+
+export function getAgentDir(): string {
+  return process.env.PI_CODING_AGENT_DIR ? resolve(process.env.PI_CODING_AGENT_DIR) : join(homedir(), '.pi', 'agent')
+}
+
+/**
+ * Mirror pi settings semantics (global + project merge, project overrides global).
+ * Only returns the bits we currently need.
+ */
+export function getEnableSkillCommands(cwd: string): boolean {
+  const merged = getMergedSettings(cwd)
+
+  const direct = merged.enableSkillCommands
+  if (typeof direct === 'boolean') return direct
+
+  // Back-compat: some versions used skills.enableSkillCommands
+  const nested = isObject(merged.skills) ? merged.skills.enableSkillCommands : undefined
+  if (typeof nested === 'boolean') return nested
+
+  return true
+}
+
+/**
+ * Mirror pi's quietStartup setting: if true, pi suppresses the verbose startup prelude.
+ * We use it to decide whether to synthesize + emit our own "startup info" message.
+ */
+export function getQuietStartup(cwd: string): boolean {
+  const merged = getMergedSettings(cwd)
+
+  const direct = merged.quietStartup
+  if (typeof direct === 'boolean') return direct
+
+  // Back-compat: some versions used quietStart
+  const legacy = (merged as any).quietStart
+  if (typeof legacy === 'boolean') return legacy
+
+  return false
+}

package/port/oracle/pi-acp/src/acp/session-store.ts

@@ -0,0 +1,68 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { dirname } from 'node:path'
+import { getPiAcpSessionMapPath } from './paths.js'
+
+export type StoredSession = {
+  sessionId: string
+  cwd: string
+  sessionFile: string
+  updatedAt: string
+}
+
+type SessionMapFile = {
+  version: 1
+  sessions: Record<string, StoredSession>
+}
+
+function ensureParentDir(path: string) {
+  mkdirSync(dirname(path), { recursive: true })
+}
+
+function loadFile(path: string): SessionMapFile {
+  try {
+    const raw = readFileSync(path, 'utf-8')
+    const parsed = JSON.parse(raw) as SessionMapFile
+    if (parsed?.version !== 1 || typeof parsed.sessions !== 'object' || !parsed.sessions) {
+      return { version: 1, sessions: {} }
+    }
+    return parsed
+  } catch {
+    return { version: 1, sessions: {} }
+  }
+}
+
+function saveFile(path: string, data: SessionMapFile): void {
+  ensureParentDir(path)
+  writeFileSync(path, JSON.stringify(data, null, 2) + '\n', 'utf-8')
+}
+
+export class SessionStore {
+  private readonly path: string
+
+  constructor(path = getPiAcpSessionMapPath()) {
+    this.path = path
+  }
+
+  get(sessionId: string): StoredSession | null {
+    const db = loadFile(this.path)
+    return db.sessions[sessionId] ?? null
+  }
+
+  upsert(entry: { sessionId: string; cwd: string; sessionFile: string }): void {
+    const db = loadFile(this.path)
+    db.sessions[entry.sessionId] = {
+      sessionId: entry.sessionId,
+      cwd: entry.cwd,
+      sessionFile: entry.sessionFile,
+      updatedAt: new Date().toISOString()
+    }
+    saveFile(this.path, db)
+  }
+
+  delete(sessionId: string): void {
+    const db = loadFile(this.path)
+    if (!db.sessions[sessionId]) return
+    delete db.sessions[sessionId]
+    saveFile(this.path, db)
+  }
+}