@kidsinai/kids-client 0.0.2 → 0.0.4

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@kidsinai/kids-client",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "type": "module",
   "description": "Own-client TUI for Kids OpenCode — talks to local `opencode serve` via @opencode-ai/sdk v2 with kid-warm rendering, mission progress, permission dialog, and stderr-tail audit pipeline.",
   "license": "MIT",

package/src/core/env-reload.ts

@@ -0,0 +1,26 @@
+/**
+ * Re-read ~/.config/kids-opencode/env after the setup wizard saves it,
+ * and inject the values into process.env. This lets the SAME process
+ * continue with the new LLM key — no `kids-opencode` re-run needed.
+ */
+
+import { readFileSync, existsSync } from "node:fs"
+import { join } from "node:path"
+
+export function reloadEnvFile(configDir: string): Record<string, string> {
+  const path = join(configDir, "env")
+  if (!existsSync(path)) return {}
+  const out: Record<string, string> = {}
+  for (const raw of readFileSync(path, "utf8").split("\n")) {
+    const line = raw.trim()
+    if (!line || line.startsWith("#")) continue
+    const eq = line.indexOf("=")
+    if (eq <= 0) continue
+    const key = line.slice(0, eq).trim()
+    let value = line.slice(eq + 1).trim()
+    if (value.startsWith('"') && value.endsWith('"')) value = value.slice(1, -1)
+    out[key] = value
+    process.env[key] = value
+  }
+  return out
+}

package/src/core/env.ts

@@ -50,7 +50,7 @@ export function readEnv(): KidsClientEnv {
   }
 }
 
-export function validateEnv(env: KidsClientEnv): { ok: true } | { ok: false; reason: string; variant: "config_missing" | "auth_failed" } {
+export function validateEnv(env: KidsClientEnv): { ok: true } | { ok: false; reason: string; variant: "config_missing" | "auth_failed" | "needs_setup" } {
   if (!env.opencodeServerPassword) {
     return {
       ok: false,
@@ -58,11 +58,18 @@ export function validateEnv(env: KidsClientEnv): { ok: true } | { ok: false; rea
       variant: "config_missing",
     }
   }
-  if (!env.bypassGateway && !env.deeprouterApiKey) {
+  // Accept any supported provider's API key, not just DeepRouter. The
+  // setup wizard writes whatever the parent picked into ~/.config/kids-opencode/env
+  // which the wrapper sources before exec.
+  const hasAnyKey =
+    env.deeprouterApiKey
+    || process.env.ANTHROPIC_API_KEY
+    || process.env.OPENAI_API_KEY
+  if (!env.bypassGateway && !hasAnyKey) {
     return {
       ok: false,
-      reason: "DEEPROUTER_API_KEY is empty. Run `kids-opencode register` first, or set KIDS_LLM_BYPASS_GATEWAY=1 with a provider key for dogfood.",
-      variant: "auth_failed",
+      reason: "No LLM provider key found. The first-run setup wizard will walk you through this.",
+      variant: "needs_setup",
     }
   }
   return { ok: true }

package/src/core/opencode-installer.ts

@@ -0,0 +1,82 @@
+/**
+ * In-TUI installer for the upstream `opencode` CLI binary.
+ *
+ * The kid (or their parent) should never have to drop back to a shell
+ * prompt and paste a `curl ... | sh` line. If the AI engine isn't
+ * installed when the wizard starts, we run the installer ourselves and
+ * stream its progress to the SetupScreen.
+ */
+
+import { spawn } from "node:child_process"
+import { existsSync } from "node:fs"
+import { homedir } from "node:os"
+import { join } from "node:path"
+
+/** True if the upstream opencode binary is on PATH or in its standard install location. */
+export function hasOpencodeBinary(): boolean {
+  // PATH lookup (POSIX). `which` and `command -v` aren't reliable as
+  // child_process commands without a shell, so just check $PATH dirs.
+  const pathDirs = (process.env.PATH ?? "").split(":")
+  const candidates = [
+    ...pathDirs.map((d) => join(d, "opencode")),
+    join(homedir(), ".opencode", "bin", "opencode"),
+    "/usr/local/bin/opencode",
+    "/opt/homebrew/bin/opencode",
+  ]
+  return candidates.some((p) => existsSync(p))
+}
+
+export interface InstallResult {
+  ok: boolean
+  error?: string
+}
+
+/**
+ * Run the upstream installer in a subprocess, streaming each output line
+ * to `onProgress`. Resolves when the subprocess exits.
+ *
+ * Uses /bin/sh + curl pipe to match upstream's official install command.
+ * The whole thing typically takes 15-45 seconds depending on network.
+ */
+export function installOpencode(onProgress: (line: string) => void): Promise<InstallResult> {
+  return new Promise((resolve) => {
+    const child = spawn("sh", ["-c", "curl -fsSL https://opencode.ai/install | sh"], {
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env },
+    })
+
+    const handleStream = (stream: NodeJS.ReadableStream): void => {
+      let buf = ""
+      stream.on("data", (chunk: Buffer | string) => {
+        buf += chunk.toString()
+        let nl: number
+        while ((nl = buf.indexOf("\n")) >= 0) {
+          const line = buf.slice(0, nl)
+          buf = buf.slice(nl + 1)
+          const trimmed = line.replace(/\r/g, "").trim()
+          if (trimmed) onProgress(trimmed)
+        }
+      })
+    }
+    if (child.stdout) handleStream(child.stdout)
+    if (child.stderr) handleStream(child.stderr)
+
+    child.on("error", (err) => {
+      resolve({ ok: false, error: err.message })
+    })
+    child.on("close", (code) => {
+      if (code === 0) {
+        // Make sure the new bin dir is on PATH for the remainder of THIS run,
+        // so subsequent calls (postinstall plugin registration etc.) can find
+        // opencode without waiting for a shell restart.
+        const newBin = join(homedir(), ".opencode", "bin")
+        if (!process.env.PATH?.includes(newBin)) {
+          process.env.PATH = `${newBin}:${process.env.PATH ?? ""}`
+        }
+        resolve({ ok: true })
+      } else {
+        resolve({ ok: false, error: `installer exited with code ${code}` })
+      }
+    })
+  })
+}

package/src/core/setup.ts

@@ -0,0 +1,185 @@
+/**
+ * First-run setup wizard backend.
+ *
+ * Writes:
+ *   ~/.config/kids-opencode/env          (KEY=value, chmod 600)
+ *   ~/.config/kids-opencode/opencode.json (provider + model rewritten)
+ *
+ * The env file is sourced by bin/kids-opencode before exec'ing
+ * kids-client, so the LLM key becomes available to the AI engine
+ * (which reads it via opencode.json's `{env:NAME}` interpolation) without
+ * polluting the user's shell rc.
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync, chmodSync } from "node:fs"
+import { dirname, join } from "node:path"
+
+export type ProviderId = "anthropic" | "openai" | "deeprouter"
+
+export interface ProviderChoice {
+  id: ProviderId
+  label: string
+  hint: string
+  envVar: string
+  apiKeyUrl: string
+  /** opencode.json provider block to use. apiKey defaults to "{env:<envVar>}". */
+  config: (envVar: string) => Record<string, unknown>
+  /** Default model id for this provider. */
+  defaultModel: string
+}
+
+export const PROVIDERS: ProviderChoice[] = [
+  {
+    id: "anthropic",
+    label: "Anthropic Claude (recommended)",
+    hint: "Best for ages 12+. ~$5/month for typical kid use.",
+    envVar: "ANTHROPIC_API_KEY",
+    apiKeyUrl: "https://console.anthropic.com/settings/keys",
+    config: (env) => ({
+      anthropic: { apiKey: `{env:${env}}` },
+    }),
+    defaultModel: "anthropic/claude-3-5-sonnet-20241022",
+  },
+  {
+    id: "openai",
+    label: "OpenAI GPT-4",
+    hint: "Also works. ~$5-10/month for typical kid use.",
+    envVar: "OPENAI_API_KEY",
+    apiKeyUrl: "https://platform.openai.com/api-keys",
+    config: (env) => ({
+      openai: { apiKey: `{env:${env}}` },
+    }),
+    defaultModel: "openai/gpt-4o",
+  },
+  {
+    id: "deeprouter",
+    label: "DeepRouter (Airbotix's own gateway)",
+    hint: "Not yet live for public use; recommended for staff dogfood only.",
+    envVar: "DEEPROUTER_API_KEY",
+    apiKeyUrl: "https://app.airbotix.ai/portal/wallet",
+    config: (env) => ({
+      deeprouter: {
+        type: "openai-compatible",
+        baseURL: "https://api.deeprouter.ai/v1",
+        apiKey: `{env:${env}}`,
+      },
+    }),
+    defaultModel: "deeprouter/claude-3-5-sonnet",
+  },
+]
+
+export function findProvider(id: ProviderId): ProviderChoice {
+  const p = PROVIDERS.find((p) => p.id === id)
+  if (!p) throw new Error(`unknown provider: ${id}`)
+  return p
+}
+
+export interface SaveOptions {
+  configDir: string
+  provider: ProviderId
+  apiKey: string
+}
+
+/**
+ * Persist the user's choice. Idempotent — re-running overwrites with the
+ * latest. The env file is line-based KEY=value; we preserve unrelated
+ * lines so multi-provider setups don't lose state.
+ */
+export function saveSetup(opts: SaveOptions): void {
+  const provider = findProvider(opts.provider)
+  ensureConfigDir(opts.configDir)
+
+  // 1. Write the env file with the provider's key.
+  const envPath = join(opts.configDir, "env")
+  const existing = readEnvFile(envPath)
+  existing[provider.envVar] = opts.apiKey
+  writeEnvFile(envPath, existing)
+
+  // 2. Rewrite opencode.json provider section.
+  const configPath = join(opts.configDir, "opencode.json")
+  const config = readJsonOrEmpty(configPath)
+  config.provider = provider.config(provider.envVar)
+  config.model = provider.defaultModel
+  if (!config.permission) {
+    config.permission = {
+      default: "ask",
+      tools: { read: "ask", write: "ask", edit: "ask", glob: "ask", grep: "ask", webfetch: "ask" },
+    }
+  }
+  if (!config.agent) {
+    config.agent = { tools: ["read", "write", "edit", "glob", "grep", "webfetch"] }
+  }
+  if (!Array.isArray(config.plugin)) {
+    config.plugin = ["@kidsinai/kids-opencode-plugin"]
+  }
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf8")
+  chmodSync(configPath, 0o600)
+}
+
+/** True if the user already has a valid key for any supported provider. */
+export function hasAnyProviderKey(configDir: string): boolean {
+  const env = readEnvFile(join(configDir, "env"))
+  if (env.ANTHROPIC_API_KEY || env.OPENAI_API_KEY || env.DEEPROUTER_API_KEY) return true
+  // Also accept keys present in the parent shell env (advanced users).
+  return !!(
+    process.env.ANTHROPIC_API_KEY
+    || process.env.OPENAI_API_KEY
+    || process.env.DEEPROUTER_API_KEY
+  )
+}
+
+/** Crude check of API key shape — refuses obvious typos. */
+export function looksLikeApiKey(provider: ProviderId, key: string): boolean {
+  const trimmed = key.trim()
+  if (trimmed.length < 20) return false
+  switch (provider) {
+    case "anthropic":  return trimmed.startsWith("sk-ant-")
+    case "openai":     return trimmed.startsWith("sk-") || trimmed.startsWith("sk-proj-")
+    case "deeprouter": return trimmed.length >= 24
+  }
+}
+
+// ─── internals ────────────────────────────────────────────────────────────
+
+function ensureConfigDir(dir: string): void {
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true })
+  try { chmodSync(dir, 0o700) } catch { /* not fatal */ }
+}
+
+function readEnvFile(path: string): Record<string, string> {
+  if (!existsSync(path)) return {}
+  const out: Record<string, string> = {}
+  for (const raw of readFileSync(path, "utf8").split("\n")) {
+    const line = raw.trim()
+    if (!line || line.startsWith("#")) continue
+    const eq = line.indexOf("=")
+    if (eq <= 0) continue
+    const key = line.slice(0, eq).trim()
+    let value = line.slice(eq + 1).trim()
+    if (value.startsWith('"') && value.endsWith('"')) value = value.slice(1, -1)
+    out[key] = value
+  }
+  return out
+}
+
+function writeEnvFile(path: string, vars: Record<string, string>): void {
+  ensureConfigDir(dirname(path))
+  const lines: string[] = [
+    "# Generated by kids-opencode setup wizard. Edit at your own risk.",
+    "# The wrapper sources this file before launching the AI engine.",
+  ]
+  for (const [k, v] of Object.entries(vars)) {
+    lines.push(`${k}="${v}"`)
+  }
+  writeFileSync(path, lines.join("\n") + "\n", "utf8")
+  try { chmodSync(path, 0o600) } catch { /* not fatal */ }
+}
+
+function readJsonOrEmpty(path: string): Record<string, unknown> {
+  if (!existsSync(path)) return {}
+  try {
+    return JSON.parse(readFileSync(path, "utf8")) as Record<string, unknown>
+  } catch {
+    return {}
+  }
+}

package/src/core/store.ts

@@ -9,6 +9,7 @@
 
 export type Screen =
   | { kind: "loading"; message?: string }
+  | { kind: "setup" }
   | { kind: "startup" }
   | { kind: "mission" }
   | { kind: "help" }