@frontera-sdk/cli 1.46.6 → 1.46.7

package/src/forge/hosts.ts

@@ -0,0 +1,323 @@
+import { spawnSync } from 'node:child_process'
+
+import type {
+  ForgeEffort,
+  ForgeHostId,
+  ForgeHostInfo,
+  ForgeHostMode,
+  ForgeHostModel,
+  ForgeSessionView,
+} from '@frontera-sdk/forge-contracts'
+
+import { forgeEnv } from './env'
+
+/**
+ * What the daemon knows about each coding host without asking it much.
+ *
+ * Modes are the host's own: Claude Code's `permissionMode` values and Codex's
+ * sandbox/approval vocabulary, verbatim. Forge does not define a fourth set
+ * and map into it — the developer already knows their harness's modes, and a
+ * translation layer is only a place for the two to disagree.
+ *
+ * Model catalogs are a v1 stub: neither host exposes a cheap "list models"
+ * call, so these are the ids the hosts document today. Any id the client
+ * passes is accepted as-is (see `modelsFor`), which is how a newer model
+ * reaches the picker before this list learns about it.
+ */
+export interface HostDefinition {
+  id: ForgeHostId
+  label: string
+  bin: string
+  loginCommand: string
+  models: ForgeHostModel[]
+  defaultModel: string
+  modes: ForgeHostMode[]
+  defaultMode: string
+}
+
+/** Claude Code's effort levels, in the ids the platform's picker renders. */
+const CLAUDE_EFFORTS: ForgeEffort[] = ['low', 'medium', 'high', 'xhigh']
+const CLAUDE_DEFAULT_EFFORT: ForgeEffort = 'high'
+
+/**
+ * Claude Code's own mode picker, verbatim.
+ *
+ * Ids are the Agent SDK's `PermissionMode`; labels, descriptions and order are
+ * the ones Claude Code shows in its own menu. Forge writes none of this — a
+ * developer who switches between the CLI and this surface should not have to
+ * learn a second name for the same setting, and a third vocabulary is how one
+ * feature ends up explaining itself differently in every place it appears.
+ *
+ * `dontAsk` is the one SDK value left out: it denies anything not pre-approved,
+ * which needs an allow-list Forge has no UI for yet.
+ */
+const CLAUDE_MODES: ForgeHostMode[] = [
+  {
+    id: 'auto',
+    label: 'Auto',
+    description: 'Claude handles permission decisions',
+  },
+  {
+    id: 'default',
+    label: 'Manual',
+    description: 'Always ask before making changes',
+  },
+  {
+    id: 'acceptEdits',
+    label: 'Accept edits',
+    description: 'Automatically accept all file edits',
+  },
+  {
+    id: 'plan',
+    label: 'Plan',
+    description: 'Create a plan before making changes',
+  },
+  // Claude Code offers this as a separate "Enable" rather than a listed mode,
+  // and gives it no subtitle. Neither do we.
+  {
+    id: 'bypassPermissions',
+    label: 'Bypass permissions',
+  },
+]
+
+/**
+ * Codex's own sandbox modes, verbatim.
+ *
+ * Ids are its `--sandbox` values; labels and descriptions are the strings the
+ * Codex binary itself renders. Declarative until its adapter lands.
+ */
+const CODEX_MODES: ForgeHostMode[] = [
+  {
+    id: 'read-only',
+    label: 'Read Only',
+    description:
+      'Codex can read files in the current workspace. Approval is required to edit files or access the internet.',
+  },
+  {
+    id: 'workspace-write',
+    label: 'Default',
+    description:
+      'Codex can read and edit files in the current workspace, and run commands. Approval is required to access the internet or edit other files.',
+  },
+  {
+    id: 'danger-full-access',
+    label: 'Full Access',
+    description:
+      'Codex can edit files outside this workspace and access the internet without asking for approval. Exercise caution when using.',
+  },
+]
+
+export const HOSTS: Record<ForgeHostId, HostDefinition> = {
+  claude: {
+    id: 'claude',
+    label: 'Claude Code',
+    bin: 'claude',
+    loginCommand: 'claude auth login',
+    models: [
+      { id: 'claude-opus-5', label: 'Claude Opus 5', efforts: CLAUDE_EFFORTS, defaultEffort: CLAUDE_DEFAULT_EFFORT },
+      { id: 'claude-fable-5', label: 'Claude Fable 5', efforts: CLAUDE_EFFORTS, defaultEffort: CLAUDE_DEFAULT_EFFORT },
+      { id: 'claude-sonnet-5', label: 'Claude Sonnet 5', efforts: CLAUDE_EFFORTS, defaultEffort: CLAUDE_DEFAULT_EFFORT },
+      {
+        id: 'claude-haiku-4-5-20251001',
+        label: 'Claude Haiku 4.5',
+        efforts: CLAUDE_EFFORTS,
+        defaultEffort: CLAUDE_DEFAULT_EFFORT,
+      },
+    ],
+    defaultModel: 'claude-sonnet-5',
+    modes: CLAUDE_MODES,
+    defaultMode: 'auto',
+  },
+  codex: {
+    id: 'codex',
+    label: 'Codex',
+    bin: 'codex',
+    loginCommand: 'codex login',
+    models: [{ id: 'gpt-5-codex', label: 'GPT-5 Codex', efforts: ['low', 'medium', 'high'], defaultEffort: 'medium' }],
+    defaultModel: 'gpt-5-codex',
+    modes: CODEX_MODES,
+    defaultMode: 'workspace-write',
+  },
+}
+
+export const HOST_IDS = Object.keys(HOSTS) as ForgeHostId[]
+
+export function isHostId(value: unknown): value is ForgeHostId {
+  return typeof value === 'string' && value in HOSTS
+}
+
+/** Mode ids this host declares, for validation and for the 400 that names them. */
+export function modeIdsFor(id: ForgeHostId): string[] {
+  return HOSTS[id].modes.map((m) => m.id)
+}
+
+export function isHostMode(id: ForgeHostId, value: unknown): value is string {
+  return typeof value === 'string' && modeIdsFor(id).includes(value)
+}
+
+/** The catalog entry for a model id, when the host documents it. */
+export function hostModel(id: ForgeHostId, model: string | null): ForgeHostModel | null {
+  if (!model) return null
+  return HOSTS[id].models.find((m) => m.id === model) ?? null
+}
+
+/** The effort a freshly chosen model starts on; null when it takes none. */
+export function defaultEffortFor(id: ForgeHostId, model: string | null): string | null {
+  return hostModel(id, model)?.defaultEffort ?? null
+}
+
+export interface HostProbe {
+  installed: boolean
+  version?: string
+  authenticated?: boolean
+}
+
+/** A host CLI that hangs must not hang the readiness probe with it. */
+const PROBE_TIMEOUT_MS = 4_000
+const CACHE_TTL_MS = 60_000
+
+/**
+ * How a host binary is probed. Exported so a caller that must not touch the
+ * machine — every test of the daemon — can supply its own.
+ */
+export interface Exec {
+  (bin: string, args: string[]): { missing: boolean; ok: boolean; out: string }
+}
+
+const defaultExec: Exec = (bin, args) => {
+  const res = spawnSync(bin, args, {
+    encoding: 'utf8',
+    timeout: PROBE_TIMEOUT_MS,
+    env: forgeEnv() as NodeJS.ProcessEnv,
+  })
+  if (res.error && (res.error as NodeJS.ErrnoException).code === 'ENOENT') {
+    return { missing: true, ok: false, out: '' }
+  }
+  return { missing: false, ok: res.status === 0, out: `${res.stdout ?? ''}${res.stderr ?? ''}`.trim() }
+}
+
+function parseVersion(out: string): string | undefined {
+  return out.match(/\b(\d+\.\d+\.\d+)\b/)?.[1]
+}
+
+/**
+ * `claude auth status` prints JSON in recent builds and prose in older ones;
+ * either way exit 0 means a session exists. A non-zero exit is "unknown":
+ * the subcommand may simply not exist in this version, and reporting a
+ * signed-in developer as signed out would send them to a login they already
+ * did.
+ */
+function claudeAuth(exec: Exec): boolean | undefined {
+  const res = exec('claude', ['auth', 'status'])
+  if (res.missing) return undefined
+  const fromJson = authFromJson(res.out)
+  if (fromJson !== undefined) return fromJson
+  return res.ok ? true : undefined
+}
+
+function authFromJson(out: string): boolean | undefined {
+  const start = out.indexOf('{')
+  if (start === -1) return undefined
+  try {
+    const parsed = JSON.parse(out.slice(start)) as Record<string, unknown>
+    for (const key of ['loggedIn', 'isLoggedIn', 'authenticated', 'isAuthenticated']) {
+      if (typeof parsed[key] === 'boolean') return parsed[key] as boolean
+    }
+  } catch {
+    // Prose output; fall through to the exit code.
+  }
+  return undefined
+}
+
+/** `codex login status` exits non-zero when nobody is signed in. */
+function codexAuth(exec: Exec): boolean | undefined {
+  const res = exec('codex', ['login', 'status'])
+  if (res.missing) return undefined
+  return res.ok
+}
+
+export function probeHost(id: ForgeHostId, exec: Exec = defaultExec): HostProbe {
+  const host = HOSTS[id]
+  const version = exec(host.bin, ['--version'])
+  if (version.missing) return { installed: false }
+  const probe: HostProbe = { installed: true }
+  const v = parseVersion(version.out)
+  if (v) probe.version = v
+  const auth = id === 'claude' ? claudeAuth(exec) : codexAuth(exec)
+  if (auth !== undefined) probe.authenticated = auth
+  return probe
+}
+
+const cache = new Map<ForgeHostId, { at: number; probe: HostProbe }>()
+
+export function probeHostCached(id: ForgeHostId, exec?: Exec, now = Date.now()): HostProbe {
+  // The cache is keyed by host id alone, so it can only ever hold answers from
+  // the real machine. An injected `exec` asks a different question and neither
+  // reads that cache nor writes to it.
+  if (exec) return probeHost(id, exec)
+  const hit = cache.get(id)
+  if (hit && now - hit.at < CACHE_TTL_MS) return hit.probe
+  const probe = probeHost(id, exec)
+  cache.set(id, { at: now, probe })
+  return probe
+}
+
+export function hostInfo(id: ForgeHostId, exec?: Exec): ForgeHostInfo {
+  const host = HOSTS[id]
+  const probe = probeHostCached(id, exec)
+  return {
+    id,
+    label: host.label,
+    installed: probe.installed,
+    ...(probe.version ? { version: probe.version } : {}),
+    ...(probe.authenticated !== undefined ? { authenticated: probe.authenticated } : {}),
+    models: host.models,
+    defaultModel: host.defaultModel,
+    modes: host.modes,
+    defaultMode: host.defaultMode,
+    loginCommand: host.loginCommand,
+  }
+}
+
+/**
+ * Which harness a session opens with when nobody chose one.
+ *
+ * Claude Code first because its adapter is the one that works; a machine with
+ * only Codex still gets a session rather than an error it cannot act on.
+ */
+export function firstInstalledHostId(exec?: Exec): ForgeHostId | null {
+  const installed = listHosts(exec).filter((host) => host.installed)
+  return installed.find((host) => host.id === 'claude')?.id ?? installed[0]?.id ?? null
+}
+
+export function listHosts(exec?: Exec): ForgeHostInfo[] {
+  return HOST_IDS.map((id) => hostInfo(id, exec))
+}
+
+/**
+ * The host's catalog keyed by id, in the shape the platform's session payload
+ * uses — including the effort block the model picker reads — plus whatever the
+ * thread is actually set to, so a model chosen outside the catalog still
+ * renders with a name.
+ */
+export function modelsFor(id: ForgeHostId, current: string | null): ForgeSessionView['models'] {
+  const out: ForgeSessionView['models'] = {}
+  for (const m of HOSTS[id].models) {
+    out[m.id] = {
+      provider: id,
+      model: m.id,
+      name: m.label,
+      ...(m.efforts && m.efforts.length > 0
+        ? {
+            reasoning: {
+              style: 'effort' as const,
+              supportedEfforts: m.efforts,
+              ...(m.defaultEffort ? { defaultEffort: m.defaultEffort } : {}),
+            },
+          }
+        : {}),
+    }
+  }
+  if (current && !out[current]) out[current] = { provider: id, model: current, name: current }
+  return out
+}

package/src/forge/http.ts

@@ -0,0 +1,74 @@
+import type { ForgeEnvelope, ForgeErrorEnvelope } from '@frontera-sdk/forge-contracts'
+
+/**
+ * A request the daemon refuses, with the status it answers. Thrown from route
+ * handlers so the one place that renders errors is the dispatcher, the same
+ * way the CLI's own shell owns exit codes.
+ */
+export class ForgeHttpError extends Error {
+  readonly status: number
+  readonly code: string
+
+  constructor(status: number, message: string, code?: string) {
+    super(message)
+    this.name = 'ForgeHttpError'
+    this.status = status
+    this.code = code ?? defaultCode(status)
+  }
+}
+
+function defaultCode(status: number): string {
+  switch (status) {
+    case 400:
+      return 'BAD_REQUEST'
+    case 401:
+      return 'UNAUTHORIZED'
+    case 403:
+      return 'FORBIDDEN'
+    case 404:
+      return 'NOT_FOUND'
+    case 409:
+      return 'CONFLICT'
+    case 501:
+      return 'NOT_IMPLEMENTED'
+    default:
+      return 'INTERNAL_ERROR'
+  }
+}
+
+export function okBody<T>(data: T): ForgeEnvelope<T> {
+  return { data, message: 'Success', error: false }
+}
+
+export function errorBody(message: string, code: string): ForgeErrorEnvelope {
+  return { error: true, message, code }
+}
+
+export function json(body: unknown, init: ResponseInit & { headers?: Record<string, string> } = {}): Response {
+  return new Response(JSON.stringify(body), {
+    ...init,
+    headers: { 'content-type': 'application/json', ...(init.headers ?? {}) },
+  })
+}
+
+export function badRequest(message: string): ForgeHttpError {
+  return new ForgeHttpError(400, message)
+}
+
+export function notFound(what: string): ForgeHttpError {
+  return new ForgeHttpError(404, `${what} not found`)
+}
+
+/** Read a JSON body, refusing anything that is not an object. */
+export async function readJson<T extends object>(req: Request): Promise<T> {
+  let parsed: unknown
+  try {
+    parsed = await req.json()
+  } catch {
+    throw badRequest('body must be JSON')
+  }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw badRequest('body must be a JSON object')
+  }
+  return parsed as T
+}

package/src/forge/log.ts

@@ -0,0 +1,53 @@
+import { appendFileSync, existsSync, mkdirSync, statSync, writeFileSync } from 'node:fs'
+import { dirname } from 'node:path'
+
+export interface Logger {
+  info(message: string): void
+  warn(message: string): void
+  error(message: string): void
+}
+
+/**
+ * Truncate rather than rotate. The file exists so a "Forge stopped working"
+ * report can attach something; nobody needs last month's daemon chatter, and
+ * a rotation scheme is more code than the value it protects.
+ */
+const MAX_BYTES = 5 * 1024 * 1024
+
+/** How often the size check runs — a stat per line would dominate the write. */
+const CHECK_EVERY = 50
+
+export function createLogger(
+  file: string | null,
+  streams: { err(chunk: string): void } = { err: (chunk) => process.stderr.write(chunk) },
+): Logger {
+  let writes = 0
+  if (file) {
+    try {
+      mkdirSync(dirname(file), { recursive: true })
+    } catch {
+      file = null
+    }
+  }
+
+  const write = (level: string, message: string): void => {
+    streams.err(`[forge] ${message}\n`)
+    if (!file) return
+    try {
+      if (writes++ % CHECK_EVERY === 0 && existsSync(file) && statSync(file).size > MAX_BYTES) {
+        writeFileSync(file, '')
+      }
+      appendFileSync(file, `${new Date().toISOString()} ${level} ${message}\n`)
+    } catch {
+      // Logging must never take the daemon down.
+    }
+  }
+
+  return {
+    info: (m) => write('info', m),
+    warn: (m) => write('warn', m),
+    error: (m) => write('error', m),
+  }
+}
+
+export const silentLogger: Logger = { info() {}, warn() {}, error() {} }