zooid 0.11.2 → 0.12.0

package/src/commands/init/sniff.ts

@@ -1,30 +1,61 @@
-import { existsSync } from 'node:fs'
+import { existsSync, readFileSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
-import { findSimplePreset } from './registry.js'
+import { findSimplePreset, PI_AUTH_FILE, PI_SETTINGS_FILE } from './registry.js'
 
 export interface SniffResult {
   found: boolean
-  /** Absolute path that satisfied the sniff (the config directory). */
+  /** Absolute path that satisfied the sniff (the config directory, or file for pi). */
   path?: string
 }
 
 /**
- * Checks whether the operator's per-CLI config directory exists. NEVER reads
- * any file inside — only `existsSync` on the dir. One rule covers Linux,
- * macOS Keychain, and OS keyring without per-backend logic. The edge case
- * where the dir exists but the operator isn't actually logged in is accepted;
- * the spawned shim will surface a clearer error on first turn.
+ * Checks whether the operator's per-CLI config directory (or, for pi, the
+ * credential file) exists. NEVER reads any file inside — only `existsSync`.
+ * One rule covers Linux, macOS Keychain, and OS keyring without per-backend
+ * logic. The edge case where the dir exists but the operator isn't actually
+ * logged in is accepted; the spawned shim will surface a clearer error on
+ * first turn.
  *
  * `home` is overridable for tests.
  */
 export function sniffCredentials(
-  preset: 'claude' | 'codex',
+  preset: 'claude' | 'codex' | 'pi',
   home: string = homedir(),
 ): SniffResult {
-  const meta = findSimplePreset(preset)
-  if (!meta) return { found: false }
-  const full = join(home, meta.credentialDir)
+  // pi's credential is a file (auth.json), not a directory; existsSync covers
+  // both, so the only difference is which relative path we join.
+  const rel = preset === 'pi' ? PI_AUTH_FILE : findSimplePreset(preset)?.credentialDir
+  if (!rel) return { found: false }
+  const full = join(home, rel)
   if (existsSync(full)) return { found: true, path: full }
   return { found: false }
 }
+
+export interface PiDefaults {
+  provider: string
+  model: string
+  /** Absolute path the pair came from, so the wizard can say where. */
+  source: string
+}
+
+/**
+ * Reads the operator's global pi defaults. A pair they already run
+ * interactively is verified by use, which beats any pin this repo could guess.
+ *
+ * Returns undefined unless BOTH keys are present — half a pair cannot boot pi.
+ * Never throws: a corrupt personal config must not abort onboarding.
+ */
+export function sniffPiDefaults(home: string = homedir()): PiDefaults | undefined {
+  const source = join(home, PI_SETTINGS_FILE)
+  try {
+    const raw = JSON.parse(readFileSync(source, 'utf8')) as Record<string, unknown>
+    const provider = raw.defaultProvider
+    const model = raw.defaultModel
+    if (typeof provider !== 'string' || !provider) return undefined
+    if (typeof model !== 'string' || !model) return undefined
+    return { provider, model, source }
+  } catch {
+    return undefined
+  }
+}

package/src/commands/init.ts

@@ -1,4 +1,5 @@
-import { existsSync, mkdirSync, readdirSync, writeFileSync } from 'node:fs'
+import { existsSync, mkdirSync, readdirSync, symlinkSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
 import { dirname, join, resolve } from 'node:path'
 import {
   generateAgentsMd,
@@ -8,22 +9,28 @@ import {
   generateGitignore,
   generateOpencodeJson,
   generateOpencodeReadme,
+  generatePiSettings,
   generateZooidYaml,
 } from './init/generators.js'
 import {
   findOpencodeProvider,
+  findPiProvider,
   findSimplePreset,
+  PI_AGENT_DIR,
+  PI_AUTH_FILE,
+  PI_DEFAULT_MODEL,
+  PI_DEFAULT_PROVIDER,
 } from './init/registry.js'
-import { sniffCredentials } from './init/sniff.js'
+import { sniffCredentials, sniffPiDefaults } from './init/sniff.js'
 
 export interface InitOptions {
   dir: string
-  preset: 'claude' | 'codex' | 'opencode'
-  /** Required for claude/codex; ignored for opencode. */
+  preset: 'claude' | 'codex' | 'opencode' | 'pi'
+  /** Required for claude/codex/pi; ignored for opencode. */
   auth?: 'subscription' | 'api-key'
   /** Optional model pin. Omitted by default — the harness uses its own default. */
   model?: string
-  /** opencode provider id; defaults to `opencode-go` in the wizard. */
+  /** opencode/pi provider id; defaults to `opencode-go` for opencode. */
   provider?: string
   /** Required on api-key path; required for opencode. */
   apiKey?: string
@@ -31,6 +38,8 @@ export interface InitOptions {
   force?: boolean
   /** Required with `force` to overwrite existing files. */
   overwrite?: boolean
+  /** Overridable for tests; defaults to os.homedir(). */
+  home?: string
 }
 
 interface WriteSpec {
@@ -66,6 +75,7 @@ export async function runInit(opts: InitOptions): Promise<void> {
   }
 
   const writes: WriteSpec[] = []
+  let piInherited: { provider: string; model: string; source: string } | undefined
 
   if (opts.preset === 'claude' || opts.preset === 'codex') {
     if (!opts.auth) throw new Error('--auth (subscription|api-key) is required for claude/codex')
@@ -123,6 +133,47 @@ export async function runInit(opts: InitOptions): Promise<void> {
         content: generateEnv({ envVar: providerMeta!.apiKeyEnvVar, value: opts.apiKey! }),
       })
     }
+  } else if (opts.preset === 'pi') {
+    // Same binary as claude/codex, because pi has the same two tiers. The
+    // difference is that the api-key side also needs a provider.
+    if (!opts.auth) throw new Error('--auth (subscription|api-key) is required for pi')
+    if (opts.auth === 'subscription' && !sniffCredentials('pi', opts.home).found) {
+      throw new Error(
+        'no pi login found — run `pi` and /login first, or use --auth api-key',
+      )
+    }
+    if (opts.auth === 'api-key' && !opts.provider) {
+      throw new Error('--provider is required for pi --auth api-key')
+    }
+    const providerMeta = opts.provider ? findPiProvider(opts.provider) : undefined
+    if (opts.provider && !providerMeta) throw new Error(`unknown pi provider: ${opts.provider}`)
+
+    // Inherit before pinning: a pair the operator already runs interactively is
+    // verified by use. Explicit flags still win over an inherited value.
+    const inherited = sniffPiDefaults(opts.home)
+    const provider = opts.provider ?? inherited?.provider ?? PI_DEFAULT_PROVIDER
+    const model = opts.model ?? inherited?.model ?? PI_DEFAULT_MODEL
+    const settingsProvider = opts.model ? provider : (inherited?.provider ?? provider)
+
+    writes.push({ path: 'zooid.yaml', content: generateZooidYaml({ preset: 'pi' }) })
+    writes.push({ path: 'agents/zooid-assistant/AGENTS.md', content: generateAgentsMd() })
+    writes.push({
+      path: `agents/zooid-assistant/${PI_AGENT_DIR}/settings.json`,
+      content: generatePiSettings({ provider: settingsProvider, model }),
+    })
+
+    // PI_CODING_AGENT_DIR is relative on purpose: the agent's cwd is
+    // agents/<name> locally and /workspace in a container, and those are the
+    // same directory, so one value is correct under both runtimes (spike 1.1).
+    const envLines = [`PI_CODING_AGENT_DIR=${PI_AGENT_DIR}`]
+    // Only the api-key path writes a key. The subscription path shares the
+    // operator's auth.json instead (below) and writes no credential here.
+    if (opts.auth === 'api-key' && opts.apiKey) {
+      envLines.push(`${providerMeta!.apiKeyEnvVar}=${opts.apiKey}`)
+    }
+    writes.push({ path: '.env', content: envLines.join('\n') + '\n' })
+
+    piInherited = inherited
   } else {
     throw new Error(`unknown preset: ${String(opts.preset)}`)
   }
@@ -152,5 +203,40 @@ export async function runInit(opts: InitOptions): Promise<void> {
     }
   }
 
+  if (opts.preset === 'pi') {
+    if (piInherited) {
+      console.log(
+        `✓ Inherited defaultProvider=${piInherited.provider} defaultModel=${piInherited.model} from ${piInherited.source}`,
+      )
+    } else {
+      console.log(
+        `✓ Pinned defaultProvider=${PI_DEFAULT_PROVIDER} defaultModel=${PI_DEFAULT_MODEL} (pi's own default returns an empty turn)`,
+      )
+    }
+    const s = sniffCredentials('pi', opts.home)
+    if (opts.auth === 'subscription' && s.found) {
+      // Symlink, not copy: pi rotates OAuth tokens via temp-file-and-rename
+      // (spike 1.2), which a symlink survives because it names a path, not an
+      // inode. Host-path only — this wizard only ever scaffolds `runtime:
+      // local`, so the operator's real ~/.pi/agent/auth.json is the same file
+      // the local agent process resolves against.
+      const authSource = join(opts.home ?? homedir(), PI_AUTH_FILE)
+      const linkPath = join(dir, `agents/zooid-assistant/${PI_AGENT_DIR}/auth.json`)
+      if (!existsSync(linkPath)) {
+        mkdirSync(dirname(linkPath), { recursive: true })
+        symlinkSync(authSource, linkPath)
+      }
+      console.log(
+        `✓ Shared pi login from ${s.path} — the agent uses your subscription via a symlink at ${PI_AGENT_DIR}/auth.json`,
+      )
+    } else if (s.found) {
+      console.log(
+        `✓ Found pi login at ${s.path} — the agent gets its own config at ${PI_AGENT_DIR}/ and will not touch it`,
+      )
+    } else {
+      console.warn(`⚠ No pi login detected — the agent uses its own API key from .env`)
+    }
+  }
+
   console.log('\nNext: zooid dev')
 }