@frontera-sdk/cli 1.46.6 → 1.47.0

package/src/forge/sessions.ts

@@ -0,0 +1,49 @@
+import type { ForgeSessionView } from '@frontera-sdk/forge-contracts'
+
+import { FORGE_DISABLED_CAPABILITIES } from './protocol'
+
+import { HOSTS, modelsFor } from './hosts'
+import type { StoredThread } from './store'
+
+/**
+ * A Forge thread presented as a platform session, so `SessionPageContent`
+ * and the session hooks render it without knowing they are talking to a
+ * daemon. Only the fields those components read carry real values; the rest
+ * are the platform's neutral defaults.
+ *
+ * The permission mode travels under `forge.mode` in the host's own vocabulary,
+ * alongside the host's full list — there is no platform-side mode to map onto.
+ */
+export function sessionView(thread: StoredThread, activeRunId: string | null): ForgeSessionView {
+  const host = HOSTS[thread.host]
+  return {
+    id: thread.id,
+    title: thread.title,
+    preview: null,
+    status: thread.archived ? 'archived' : 'active',
+    pinned: false,
+    pinnedAt: null,
+    modelMode: thread.model,
+    runtime: 'forge',
+    activeRunId,
+    activePlan: null,
+    agentName: 'forge',
+    agentConfigId: null,
+    agentDisplayName: 'Forge',
+    models: modelsFor(thread.host, thread.model),
+    labels: [],
+    workspaceId: null,
+    createdAt: thread.createdAt,
+    updatedAt: thread.updatedAt,
+    forge: {
+      projectId: thread.projectId,
+      host: thread.host,
+      hostLabel: host.label,
+      mode: thread.mode,
+      modes: host.modes,
+      effort: thread.effort,
+      hostSessionId: thread.hostSessionId,
+      disabled: FORGE_DISABLED_CAPABILITIES,
+    },
+  }
+}

package/src/forge/store.ts

@@ -0,0 +1,427 @@
+import { Database } from 'bun:sqlite'
+import { mkdirSync } from 'node:fs'
+import { dirname } from 'node:path'
+
+import type { ForgeHostId, ForgeProject, ForgeThread, ForgeThreadStatus } from '@frontera-sdk/forge-contracts'
+import type { UIMessage } from 'ai'
+
+/**
+ * Local state the daemon owns. Nothing here is uploaded to the platform.
+ *
+ * Synchronous on purpose: bun:sqlite is synchronous, the daemon serves one
+ * developer, and every query is a point lookup or a short list. An async
+ * facade would add await sites without adding concurrency.
+ */
+
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS projects (
+  id TEXT PRIMARY KEY,
+  root TEXT NOT NULL UNIQUE,
+  name TEXT NOT NULL,
+  profile TEXT,
+  app_slug TEXT,
+  git INTEGER NOT NULL DEFAULT 0,
+  workspace_id TEXT,
+  created_at TEXT NOT NULL,
+  last_opened_at TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS threads (
+  id TEXT PRIMARY KEY,
+  project_id TEXT NOT NULL,
+  host TEXT NOT NULL,
+  model TEXT,
+  mode TEXT NOT NULL,
+  effort TEXT,
+  title TEXT,
+  status TEXT NOT NULL,
+  host_session_id TEXT,
+  active_run_id TEXT,
+  archived INTEGER NOT NULL DEFAULT 0,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS threads_project ON threads(project_id, updated_at);
+CREATE TABLE IF NOT EXISTS messages (
+  id TEXT PRIMARY KEY,
+  thread_id TEXT NOT NULL,
+  seq INTEGER NOT NULL,
+  role TEXT NOT NULL,
+  json TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS messages_thread ON messages(thread_id, seq);
+CREATE TABLE IF NOT EXISTS runs (
+  id TEXT PRIMARY KEY,
+  thread_id TEXT NOT NULL,
+  status TEXT NOT NULL,
+  started_at TEXT NOT NULL,
+  finished_at TEXT,
+  error TEXT
+);
+`
+
+interface ProjectRow {
+  id: string
+  root: string
+  name: string
+  profile: string | null
+  app_slug: string | null
+  git: number
+  workspace_id: string | null
+  created_at: string
+  last_opened_at: string
+}
+
+interface ThreadRow {
+  id: string
+  project_id: string
+  host: string
+  model: string | null
+  mode: string | null
+  effort: string | null
+  /** Only on stores created before host-native modes; see the migration. */
+  runtime_mode?: string
+  title: string | null
+  status: string
+  host_session_id: string | null
+  active_run_id: string | null
+  archived: number
+  created_at: string
+  updated_at: string
+}
+
+interface MessageRow {
+  id: string
+  seq: number
+  json: string
+}
+
+interface RunRow {
+  id: string
+  thread_id: string
+  status: string
+  started_at: string
+  finished_at: string | null
+  error: string | null
+}
+
+/** A thread as stored: the wire shape plus the archive flag sessions expose. */
+export interface StoredThread extends ForgeThread {
+  archived: boolean
+}
+
+export type RunStatus = 'running' | 'completed' | 'error' | 'cancelled'
+
+export interface StoredRun {
+  id: string
+  threadId: string
+  status: RunStatus
+  startedAt: string
+  finishedAt: string | null
+  error: string | null
+}
+
+export interface NewProject {
+  root: string
+  name: string
+  profile: string | null
+  appSlug: string | null
+  git: boolean
+  workspaceId?: string | null
+}
+
+export interface NewThread {
+  projectId: string
+  host: ForgeHostId
+  model: string | null
+  /** Host-native permission mode id. */
+  mode: string
+  effort: string | null
+  title: string | null
+}
+
+export type ThreadPatch = Partial<
+  Pick<StoredThread, 'title' | 'model' | 'mode' | 'effort' | 'status' | 'hostSessionId' | 'activeRunId' | 'archived'>
+>
+
+/**
+ * What a pre-modes store called this mode. Only written to keep the old
+ * NOT NULL `runtime_mode` column satisfied on a database this daemon
+ * inherited; nothing reads it back.
+ */
+function legacyRuntimeMode(mode: string): string {
+  switch (mode) {
+    case 'acceptEdits':
+      return 'auto-accept-edits'
+    case 'bypassPermissions':
+      return 'full-access'
+    default:
+      return 'approval-required'
+  }
+}
+
+function now(): string {
+  return new Date().toISOString()
+}
+
+function projectFromRow(row: ProjectRow): ForgeProject {
+  return {
+    id: row.id,
+    root: row.root,
+    name: row.name,
+    profile: row.profile,
+    appSlug: row.app_slug,
+    git: row.git === 1,
+    workspaceId: row.workspace_id,
+    createdAt: row.created_at,
+    lastOpenedAt: row.last_opened_at,
+  }
+}
+
+function threadFromRow(row: ThreadRow): StoredThread {
+  return {
+    id: row.id,
+    projectId: row.project_id,
+    host: row.host as ForgeHostId,
+    model: row.model,
+    mode: row.mode ?? 'default',
+    effort: row.effort,
+    title: row.title,
+    status: row.status as ForgeThreadStatus,
+    hostSessionId: row.host_session_id,
+    activeRunId: row.active_run_id,
+    archived: row.archived === 1,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+  }
+}
+
+function runFromRow(row: RunRow): StoredRun {
+  return {
+    id: row.id,
+    threadId: row.thread_id,
+    status: row.status as RunStatus,
+    startedAt: row.started_at,
+    finishedAt: row.finished_at,
+    error: row.error,
+  }
+}
+
+export class ForgeStore {
+  private readonly db: Database
+  /** A store from before host-native modes still carries a NOT NULL column. */
+  private readonly hasLegacyRuntimeMode: boolean
+
+  constructor(path: string) {
+    if (path !== ':memory:') mkdirSync(dirname(path), { recursive: true })
+    this.db = new Database(path, { create: true })
+    if (path !== ':memory:') this.db.exec('PRAGMA journal_mode = WAL')
+    this.db.exec(SCHEMA)
+    // Additive migration for stores created before workspace-managed folders.
+    try {
+      this.db.exec('ALTER TABLE projects ADD COLUMN workspace_id TEXT')
+    } catch {
+      // Column already present.
+    }
+    // Additive migration for stores created before host-native modes, when a
+    // thread carried a Forge `runtime_mode` instead of the host's own id.
+    try {
+      this.db.exec('ALTER TABLE threads ADD COLUMN mode TEXT')
+    } catch {
+      // Column already present.
+    }
+    try {
+      this.db.exec('ALTER TABLE threads ADD COLUMN effort TEXT')
+    } catch {
+      // Column already present.
+    }
+    try {
+      this.db.exec(
+        "UPDATE threads SET mode = CASE runtime_mode"
+          + " WHEN 'approval-required' THEN 'default'"
+          + " WHEN 'auto-accept-edits' THEN 'acceptEdits'"
+          + " WHEN 'auto' THEN 'acceptEdits'"
+          + " WHEN 'full-access' THEN 'bypassPermissions'"
+          + " ELSE 'default' END WHERE mode IS NULL",
+      )
+    } catch {
+      // No `runtime_mode` column: this store was created with `mode` already.
+    }
+    this.hasLegacyRuntimeMode = this.db
+      .query<{ name: string }, []>('PRAGMA table_info(threads)')
+      .all()
+      .some((c) => c.name === 'runtime_mode')
+  }
+
+  close(): void {
+    this.db.close()
+  }
+
+  // -- projects -------------------------------------------------------------
+
+  listProjects(): ForgeProject[] {
+    return this.db
+      .query<ProjectRow, []>('SELECT * FROM projects ORDER BY last_opened_at DESC')
+      .all()
+      .map(projectFromRow)
+  }
+
+  getProject(id: string): ForgeProject | null {
+    const row = this.db.query<ProjectRow, [string]>('SELECT * FROM projects WHERE id = ?').get(id)
+    return row ? projectFromRow(row) : null
+  }
+
+  projectByWorkspace(workspaceId: string): ForgeProject | null {
+    const row = this.db.query<ProjectRow, [string]>('SELECT * FROM projects WHERE workspace_id = ?').get(workspaceId)
+    return row ? projectFromRow(row) : null
+  }
+
+  projectByRoot(root: string): ForgeProject | null {
+    const row = this.db.query<ProjectRow, [string]>('SELECT * FROM projects WHERE root = ?').get(root)
+    return row ? projectFromRow(row) : null
+  }
+
+  insertProject(input: NewProject): ForgeProject {
+    const ts = now()
+    const id = crypto.randomUUID()
+    this.db
+      .query('INSERT INTO projects (id, root, name, profile, app_slug, git, workspace_id, created_at, last_opened_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)')
+      .run(id, input.root, input.name, input.profile, input.appSlug, input.git ? 1 : 0, input.workspaceId ?? null, ts, ts)
+    return this.getProject(id)!
+  }
+
+  /** Re-detect the parts that can change underneath us: git, app, profile. */
+  refreshProject(id: string, input: Pick<NewProject, 'profile' | 'appSlug' | 'git'>): ForgeProject {
+    this.db
+      .query('UPDATE projects SET profile = ?, app_slug = ?, git = ?, last_opened_at = ? WHERE id = ?')
+      .run(input.profile, input.appSlug, input.git ? 1 : 0, now(), id)
+    return this.getProject(id)!
+  }
+
+  deleteProject(id: string): void {
+    const threads = this.db.query<{ id: string }, [string]>('SELECT id FROM threads WHERE project_id = ?').all(id)
+    for (const t of threads) this.deleteThread(t.id)
+    this.db.query('DELETE FROM projects WHERE id = ?').run(id)
+  }
+
+  // -- threads --------------------------------------------------------------
+
+  listThreads(projectId: string): StoredThread[] {
+    return this.db
+      .query<ThreadRow, [string]>('SELECT * FROM threads WHERE project_id = ? ORDER BY updated_at DESC')
+      .all(projectId)
+      .map(threadFromRow)
+  }
+
+  getThread(id: string): StoredThread | null {
+    const row = this.db.query<ThreadRow, [string]>('SELECT * FROM threads WHERE id = ?').get(id)
+    return row ? threadFromRow(row) : null
+  }
+
+  insertThread(input: NewThread): StoredThread {
+    const ts = now()
+    const id = crypto.randomUUID()
+    const legacy = this.hasLegacyRuntimeMode
+    this.db
+      .query(
+        `INSERT INTO threads (id, project_id, host, model, mode, effort, title, status, host_session_id, active_run_id, archived, created_at, updated_at${legacy ? ', runtime_mode' : ''}) `
+          + `VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL, 0, ?, ?${legacy ? ', ?' : ''})`,
+      )
+      .run(
+        id,
+        input.projectId,
+        input.host,
+        input.model,
+        input.mode,
+        input.effort,
+        input.title,
+        'idle',
+        ts,
+        ts,
+        ...(legacy ? [legacyRuntimeMode(input.mode)] : []),
+      )
+    return this.getThread(id)!
+  }
+
+  updateThread(id: string, patch: ThreadPatch): StoredThread {
+    const sets: string[] = []
+    const values: Array<string | number | null> = []
+    const put = (column: string, value: string | number | null) => {
+      sets.push(`${column} = ?`)
+      values.push(value)
+    }
+    if (patch.title !== undefined) put('title', patch.title)
+    if (patch.model !== undefined) put('model', patch.model)
+    if (patch.mode !== undefined) {
+      put('mode', patch.mode)
+      if (this.hasLegacyRuntimeMode) put('runtime_mode', legacyRuntimeMode(patch.mode))
+    }
+    if (patch.effort !== undefined) put('effort', patch.effort)
+    if (patch.status !== undefined) put('status', patch.status)
+    if (patch.hostSessionId !== undefined) put('host_session_id', patch.hostSessionId)
+    if (patch.activeRunId !== undefined) put('active_run_id', patch.activeRunId)
+    if (patch.archived !== undefined) put('archived', patch.archived ? 1 : 0)
+    put('updated_at', now())
+    values.push(id)
+    this.db.query(`UPDATE threads SET ${sets.join(', ')} WHERE id = ?`).run(...values)
+    const thread = this.getThread(id)
+    if (!thread) throw new Error(`thread ${id} vanished during update`)
+    return thread
+  }
+
+  deleteThread(id: string): void {
+    this.db.query('DELETE FROM messages WHERE thread_id = ?').run(id)
+    this.db.query('DELETE FROM runs WHERE thread_id = ?').run(id)
+    this.db.query('DELETE FROM threads WHERE id = ?').run(id)
+  }
+
+  // -- messages -------------------------------------------------------------
+
+  listMessages(threadId: string): UIMessage[] {
+    return this.db
+      .query<MessageRow, [string]>('SELECT id, seq, json FROM messages WHERE thread_id = ? ORDER BY seq ASC')
+      .all(threadId)
+      .map((row) => JSON.parse(row.json) as UIMessage)
+  }
+
+  appendMessage(threadId: string, message: UIMessage): number {
+    const last = this.db
+      .query<{ seq: number | null }, [string]>('SELECT MAX(seq) AS seq FROM messages WHERE thread_id = ?')
+      .get(threadId)
+    const seq = (last?.seq ?? -1) + 1
+    this.db
+      .query('INSERT INTO messages (id, thread_id, seq, role, json) VALUES (?, ?, ?, ?, ?)')
+      .run(message.id, threadId, seq, message.role, JSON.stringify(message))
+    return seq
+  }
+
+  // -- runs -----------------------------------------------------------------
+
+  insertRun(id: string, threadId: string): StoredRun {
+    this.db
+      .query('INSERT INTO runs (id, thread_id, status, started_at) VALUES (?, ?, ?, ?)')
+      .run(id, threadId, 'running', now())
+    return this.getRun(id)!
+  }
+
+  finishRun(id: string, status: Exclude<RunStatus, 'running'>, error: string | null): void {
+    this.db.query('UPDATE runs SET status = ?, finished_at = ?, error = ? WHERE id = ?').run(status, now(), error, id)
+  }
+
+  getRun(id: string): StoredRun | null {
+    const row = this.db.query<RunRow, [string]>('SELECT * FROM runs WHERE id = ?').get(id)
+    return row ? runFromRow(row) : null
+  }
+
+  /**
+   * Runs the previous daemon left open. Their journals lived in memory, so
+   * there is nothing to resume — the honest state is "interrupted".
+   */
+  reapOrphanRuns(): number {
+    const open = this.db.query<{ id: string; thread_id: string }, []>("SELECT id, thread_id FROM runs WHERE status = 'running'").all()
+    for (const run of open) {
+      this.finishRun(run.id, 'error', 'the daemon stopped while this run was live')
+      this.db.query("UPDATE threads SET status = 'idle', active_run_id = NULL WHERE id = ?").run(run.thread_id)
+    }
+    return open.length
+  }
+}

package/src/forge/terminals.ts

@@ -0,0 +1,220 @@
+import type { ForgeCreateTerminalInput, ForgeProject, ForgeTerminal, ForgeTerminalServerMessage } from '@frontera-sdk/forge-contracts'
+
+import { basename } from 'node:path'
+
+import { forgeEnv } from './env'
+import { ForgeHttpError, badRequest } from './http'
+import type { Logger } from './log'
+
+/**
+ * Daemon-owned PTYs. The renderer is a byte pipe: it sends keystrokes and
+ * resizes, it receives output. A socket that attaches late gets the recent
+ * scrollback replayed so the terminal is not blank after a reload.
+ *
+ * A session shows several of these as tabs, so creation order is the order
+ * the tabs appear: the map is insertion-ordered and never re-sorted, which is
+ * what `ORDER BY created_at` would give a table-backed list.
+ *
+ * Bun's PTY support (`Bun.spawn` with `terminal`) is not available on
+ * Windows; that platform waits for a ConPTY path.
+ */
+
+/** How much recent output a freshly attached socket receives. */
+const SCROLLBACK_BYTES = 200 * 1024
+
+const DEFAULT_COLS = 80
+const DEFAULT_ROWS = 24
+
+export interface TerminalClient {
+  sendBytes(bytes: Uint8Array): void
+  sendJson(message: ForgeTerminalServerMessage): void
+}
+
+class RingBuffer {
+  private chunks: Uint8Array[] = []
+  private bytes = 0
+
+  push(chunk: Uint8Array): void {
+    this.chunks.push(chunk)
+    this.bytes += chunk.byteLength
+    while (this.bytes > SCROLLBACK_BYTES && this.chunks.length > 1) {
+      const dropped = this.chunks.shift()!
+      this.bytes -= dropped.byteLength
+    }
+  }
+
+  snapshot(): Uint8Array {
+    const out = new Uint8Array(this.bytes)
+    let offset = 0
+    for (const chunk of this.chunks) {
+      out.set(chunk, offset)
+      offset += chunk.byteLength
+    }
+    return out
+  }
+}
+
+interface Live {
+  info: ForgeTerminal
+  proc: Bun.Subprocess
+  scrollback: RingBuffer
+  clients: Set<TerminalClient>
+}
+
+/** The tab label: an explicit one, else the command, else the shell's name. */
+function titleFor(input: ForgeCreateTerminalInput, shell: string): string {
+  const explicit = input.title?.trim()
+  if (explicit) return explicit
+  const command = input.command?.trim()
+  if (command) return command
+  return basename(shell)
+}
+
+export class TerminalManager {
+  private readonly terminals = new Map<string, Live>()
+
+  constructor(private readonly log: Logger) {}
+
+  /** Creation order. `threadId` narrows to one session's tabs. */
+  list(threadId?: string | null): ForgeTerminal[] {
+    const all = [...this.terminals.values()].map((t) => t.info)
+    return threadId ? all.filter((t) => t.threadId === threadId) : all
+  }
+
+  get(id: string): ForgeTerminal | null {
+    return this.terminals.get(id)?.info ?? null
+  }
+
+  create(input: ForgeCreateTerminalInput, project: ForgeProject): ForgeTerminal {
+    if (process.platform === 'win32') {
+      throw new ForgeHttpError(501, 'terminals are not available on Windows yet', 'NOT_IMPLEMENTED')
+    }
+    const cols = Math.max(2, Math.floor(input.cols ?? DEFAULT_COLS))
+    const rows = Math.max(1, Math.floor(input.rows ?? DEFAULT_ROWS))
+    const shell = process.env.SHELL || '/bin/zsh'
+    const id = crypto.randomUUID()
+
+    let live: Live | null = null
+    let proc: Bun.Subprocess
+    try {
+      proc = Bun.spawn([shell, '-l'], {
+        cwd: project.root,
+        env: forgeEnv({ TERM: 'xterm-256color', COLORTERM: 'truecolor' }),
+        terminal: {
+          cols,
+          rows,
+          name: 'xterm-256color',
+          data: (_terminal, bytes) => {
+            if (!live) return
+            // The PTY reuses its buffer; keep our own copy.
+            const copy = new Uint8Array(bytes)
+            live.scrollback.push(copy)
+            for (const client of live.clients) client.sendBytes(copy)
+          },
+        },
+      })
+    } catch (err) {
+      throw badRequest(`could not start ${shell}: ${err instanceof Error ? err.message : String(err)}`)
+    }
+
+    const info: ForgeTerminal = {
+      id,
+      projectId: project.id,
+      threadId: input.threadId ?? null,
+      cwd: project.root,
+      shell,
+      title: titleFor(input, shell),
+      pid: proc.pid,
+      cols,
+      rows,
+      exited: false,
+      exitCode: null,
+      createdAt: new Date().toISOString(),
+    }
+    live = { info, proc, scrollback: new RingBuffer(), clients: new Set() }
+    this.terminals.set(id, live)
+
+    void proc.exited
+      .then((code) => this.onExit(id, Number.isInteger(code) ? code : null))
+      .catch(() => this.onExit(id, null))
+
+    if (input.command) {
+      // Let the shell finish its rc files before the command lands; a write
+      // during startup is read fine, but the echo interleaves with the prompt.
+      setTimeout(() => {
+        try {
+          proc.terminal?.write(`${input.command}\n`)
+        } catch {
+          // Exited before it could read.
+        }
+      }, 150)
+    }
+
+    this.log.info(`terminal ${id} opened in ${project.root} (pid ${proc.pid})`)
+    return info
+  }
+
+  /** Rename a tab. Null when the terminal is gone. */
+  rename(id: string, title: string): ForgeTerminal | null {
+    const live = this.terminals.get(id)
+    if (!live) return null
+    live.info.title = title
+    return live.info
+  }
+
+  attach(id: string, client: TerminalClient): boolean {
+    const live = this.terminals.get(id)
+    if (!live) return false
+    live.clients.add(client)
+    const replay = live.scrollback.snapshot()
+    if (replay.byteLength > 0) client.sendBytes(replay)
+    if (live.info.exited) client.sendJson({ type: 'exit', exitCode: live.info.exitCode })
+    return true
+  }
+
+  detach(id: string, client: TerminalClient): void {
+    this.terminals.get(id)?.clients.delete(client)
+  }
+
+  write(id: string, data: string | Uint8Array): void {
+    const live = this.terminals.get(id)
+    if (!live || live.info.exited) return
+    live.proc.terminal?.write(data)
+  }
+
+  resize(id: string, cols: number, rows: number): void {
+    const live = this.terminals.get(id)
+    if (!live || live.info.exited) return
+    if (!Number.isFinite(cols) || !Number.isFinite(rows) || cols < 2 || rows < 1) return
+    live.info.cols = Math.floor(cols)
+    live.info.rows = Math.floor(rows)
+    live.proc.terminal?.resize(live.info.cols, live.info.rows)
+  }
+
+  kill(id: string): boolean {
+    const live = this.terminals.get(id)
+    if (!live) return false
+    if (!live.info.exited) {
+      try {
+        live.proc.kill('SIGHUP')
+      } catch {
+        // Already gone.
+      }
+    }
+    this.terminals.delete(id)
+    return true
+  }
+
+  killAll(): void {
+    for (const id of [...this.terminals.keys()]) this.kill(id)
+  }
+
+  private onExit(id: string, exitCode: number | null): void {
+    const live = this.terminals.get(id)
+    if (!live || live.info.exited) return
+    live.info.exited = true
+    live.info.exitCode = exitCode
+    for (const client of live.clients) client.sendJson({ type: 'exit', exitCode })
+    this.log.info(`terminal ${id} exited (${exitCode ?? 'signal'})`)
+  }
+}