@open-code-review/cli 1.10.4 → 1.11.0

package/dist/lib/db/index.js

@@ -1,9 +1,8 @@
-import { createRequire as _cjsReq } from "module"; const require = _cjsReq(import.meta.url);
-
 // src/lib/db/index.ts
 import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "node:fs";
 import { dirname as dirname2, join as join2 } from "node:path";
 import { createRequire } from "node:module";
+import { spawnSync } from "node:child_process";
 import initSqlJs from "sql.js";
 
 // src/lib/db/migrations.ts
@@ -261,6 +260,73 @@ var MIGRATIONS = [
       ALTER TABLE command_executions ADD COLUMN uid TEXT;
       CREATE UNIQUE INDEX idx_command_executions_uid ON command_executions(uid);
     `
+  },
+  {
+    version: 10,
+    description: "Add agent_sessions journal for per-instance lifecycle tracking",
+    sql: `
+      CREATE TABLE agent_sessions (
+        id TEXT PRIMARY KEY,
+        workflow_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE RESTRICT,
+        vendor TEXT NOT NULL,
+        vendor_session_id TEXT,
+        persona TEXT,
+        instance_index INTEGER,
+        name TEXT,
+        resolved_model TEXT,
+        phase TEXT,
+        status TEXT NOT NULL CHECK(status IN ('spawning', 'running', 'done', 'crashed', 'cancelled', 'orphaned')),
+        pid INTEGER,
+        started_at TEXT NOT NULL DEFAULT (datetime('now')),
+        last_heartbeat_at TEXT NOT NULL DEFAULT (datetime('now')),
+        ended_at TEXT,
+        exit_code INTEGER,
+        notes TEXT
+      );
+      CREATE INDEX idx_agent_sessions_workflow ON agent_sessions(workflow_id);
+      CREATE INDEX idx_agent_sessions_status_heartbeat ON agent_sessions(status, last_heartbeat_at);
+    `
+  },
+  {
+    version: 11,
+    description: "Unify agent_sessions into command_executions \u2014 every spawned process is one execution row",
+    sql: `
+      -- Extend command_executions with the journaling fields previously on agent_sessions.
+      -- A NULL workflow_id is allowed because some commands (e.g. sync-reviewers,
+      -- create-reviewer) don't tie to a review workflow. Existing rows get NULL by default.
+      ALTER TABLE command_executions ADD COLUMN workflow_id TEXT REFERENCES sessions(id) ON DELETE RESTRICT;
+      -- parent_id = the dashboard-spawn that's the "Tech Lead" parent of an AI-spawned
+      -- session-instance row. NULL for top-level dashboard spawns.
+      ALTER TABLE command_executions ADD COLUMN parent_id INTEGER REFERENCES command_executions(id);
+      -- Vendor metadata (claude | opencode | gemini | \u2026). NULL for non-AI commands.
+      ALTER TABLE command_executions ADD COLUMN vendor TEXT;
+      -- The underlying CLI's own session id, captured from stream events.
+      -- Used for resume / handoff. Hidden from users (ocr exposes its own id only).
+      ALTER TABLE command_executions ADD COLUMN vendor_session_id TEXT;
+      -- Persona/instance metadata for AI sub-agents (set when the AI calls
+      -- ocr session start-instance). NULL for the parent dashboard spawn.
+      ALTER TABLE command_executions ADD COLUMN persona TEXT;
+      ALTER TABLE command_executions ADD COLUMN instance_index INTEGER;
+      ALTER TABLE command_executions ADD COLUMN name TEXT;
+      -- Resolved model string passed to --model post-alias-expansion.
+      ALTER TABLE command_executions ADD COLUMN resolved_model TEXT;
+      -- Liveness heartbeat. Bumped on every state event the AI emits.
+      -- Stale rows past the threshold are reclassified to orphaned (exit_code=-3).
+      ALTER TABLE command_executions ADD COLUMN last_heartbeat_at TEXT;
+      -- Free-form annotations (sweep notes, host-CLI capability warnings, etc).
+      ALTER TABLE command_executions ADD COLUMN notes TEXT;
+      CREATE INDEX idx_command_executions_workflow ON command_executions(workflow_id);
+      CREATE INDEX idx_command_executions_parent ON command_executions(parent_id);
+      CREATE INDEX idx_command_executions_heartbeat ON command_executions(last_heartbeat_at);
+
+      -- The agent_sessions table is retired. Phase 1 was a parallel journal that
+      -- this migration consolidates. We drop the table outright \u2014 the only existing
+      -- consumers are the cli helpers and tests, which are updated alongside this
+      -- migration. No production deployments have agent_sessions data worth migrating.
+      DROP INDEX IF EXISTS idx_agent_sessions_workflow;
+      DROP INDEX IF EXISTS idx_agent_sessions_status_heartbeat;
+      DROP TABLE IF EXISTS agent_sessions;
+    `
   }
 ];
 function ensureSchemaVersionTable(db) {
@@ -432,6 +498,287 @@ function getLatestEventId(db) {
   return typeof val === "number" ? val : 0;
 }
 
+// src/lib/db/agent-sessions.ts
+var ORPHAN_EXIT_CODE = -3;
+var CANCELLED_EXIT_CODE = -2;
+var NOTE_ORPHAN_PREFIX = "orphaned by liveness sweep";
+function rowToAgentSession(row) {
+  return {
+    // The OCR-owned id is the `uid` column. Fall back to the integer
+    // primary key for legacy command_executions rows without a uid.
+    id: row.uid ?? String(row.id),
+    workflow_id: row.workflow_id ?? "",
+    vendor: row.vendor ?? "",
+    vendor_session_id: row.vendor_session_id,
+    persona: row.persona,
+    instance_index: row.instance_index,
+    name: row.name,
+    resolved_model: row.resolved_model,
+    phase: null,
+    status: deriveStatus(row),
+    pid: row.pid,
+    started_at: row.started_at,
+    last_heartbeat_at: row.last_heartbeat_at ?? row.started_at,
+    ended_at: row.finished_at,
+    exit_code: row.exit_code,
+    notes: row.notes
+  };
+}
+function deriveStatus(row) {
+  if (row.finished_at === null) {
+    return "running";
+  }
+  if (row.exit_code === ORPHAN_EXIT_CODE) return "orphaned";
+  if (row.exit_code === CANCELLED_EXIT_CODE) return "cancelled";
+  if (row.exit_code === 0) return "done";
+  return "crashed";
+}
+function insertAgentSession(db, params) {
+  const {
+    id,
+    workflow_id,
+    vendor,
+    persona = null,
+    instance_index = null,
+    name = null,
+    resolved_model = null,
+    pid = null,
+    notes = null
+  } = params;
+  const command = persona && instance_index !== null ? `session-instance:${persona}-${instance_index}` : "session-instance";
+  db.run(
+    `INSERT INTO command_executions
+       (uid, command, args, workflow_id, vendor, persona, instance_index, name,
+        resolved_model, pid, notes, last_heartbeat_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))`,
+    [
+      id,
+      command,
+      null,
+      workflow_id,
+      vendor,
+      persona,
+      instance_index,
+      name,
+      resolved_model,
+      pid,
+      notes
+    ]
+  );
+}
+function getAgentSession(db, id) {
+  const row = resultToRow(
+    db.exec(
+      `SELECT * FROM command_executions WHERE uid = ? AND last_heartbeat_at IS NOT NULL`,
+      [id]
+    )
+  );
+  return row ? rowToAgentSession(row) : void 0;
+}
+function listAgentSessionsForWorkflow(db, workflowId) {
+  const rows = resultToRows(
+    db.exec(
+      `SELECT * FROM command_executions
+       WHERE workflow_id = ? AND last_heartbeat_at IS NOT NULL
+       ORDER BY started_at ASC, id ASC`,
+      [workflowId]
+    )
+  );
+  return rows.map(rowToAgentSession);
+}
+function getLatestAgentSessionWithVendorId(db, workflowId) {
+  const row = resultToRow(
+    db.exec(
+      `SELECT * FROM command_executions
+       WHERE workflow_id = ? AND vendor_session_id IS NOT NULL
+       ORDER BY started_at DESC, id DESC
+       LIMIT 1`,
+      [workflowId]
+    )
+  );
+  return row ? rowToAgentSession(row) : void 0;
+}
+function bumpAgentSessionHeartbeat(db, id) {
+  db.run(
+    `UPDATE command_executions
+       SET last_heartbeat_at = datetime('now')
+       WHERE uid = ?`,
+    [id]
+  );
+}
+function setAgentSessionVendorId(db, id, vendorSessionId) {
+  const existing = getAgentSession(db, id);
+  if (!existing) {
+    throw new Error(`Agent session not found: ${id}`);
+  }
+  if (existing.vendor_session_id && existing.vendor_session_id !== vendorSessionId) {
+    throw new Error(
+      `Agent session ${id} already bound to vendor session ${existing.vendor_session_id}; refusing to rebind to ${vendorSessionId}`
+    );
+  }
+  db.run(
+    `UPDATE command_executions
+       SET vendor_session_id = ?,
+           last_heartbeat_at = datetime('now')
+       WHERE uid = ?`,
+    [vendorSessionId, id]
+  );
+}
+function bindVendorSessionIdOpportunistically(db, vendorSessionId) {
+  const alreadyBound = resultToRow(
+    db.exec(
+      `SELECT c.uid FROM command_executions c
+       INNER JOIN sessions s ON s.id = c.workflow_id
+       WHERE c.vendor_session_id = ?
+       LIMIT 1`,
+      [vendorSessionId]
+    )
+  );
+  if (alreadyBound?.uid) return alreadyBound.uid;
+  const candidate = resultToRow(
+    db.exec(
+      `SELECT c.uid, c.id FROM command_executions c
+       INNER JOIN sessions s ON s.id = c.workflow_id
+       WHERE c.finished_at IS NULL
+         AND c.vendor_session_id IS NULL
+         AND c.last_heartbeat_at IS NOT NULL
+         AND s.status = 'active'
+       ORDER BY c.started_at DESC, c.id DESC
+       LIMIT 1`
+    )
+  );
+  if (!candidate) return null;
+  db.run(
+    `UPDATE command_executions
+       SET vendor_session_id = ?,
+           last_heartbeat_at = datetime('now')
+       WHERE id = ?`,
+    [vendorSessionId, candidate.id]
+  );
+  return candidate.uid ?? String(candidate.id);
+}
+function recordVendorSessionIdForExecution(db, executionId, vendorSessionId) {
+  db.run(
+    `UPDATE command_executions
+        SET vendor_session_id = COALESCE(vendor_session_id, ?),
+            last_heartbeat_at = datetime('now')
+      WHERE id = ?`,
+    [vendorSessionId, executionId]
+  );
+}
+function linkDashboardInvocationToWorkflow(db, dashboardUid, workflowId) {
+  db.run(
+    `UPDATE command_executions
+        SET workflow_id = COALESCE(workflow_id, ?),
+            last_heartbeat_at = COALESCE(last_heartbeat_at, datetime('now'))
+      WHERE uid = ?`,
+    [workflowId, dashboardUid]
+  );
+}
+function setAgentSessionStatus(db, id, status, options = {}) {
+  const { exitCode, note, setEndedAt } = options;
+  const isTerminal = status === "done" || status === "crashed" || status === "cancelled" || status === "orphaned";
+  const stampEnded = setEndedAt ?? isTerminal;
+  let resolvedExit;
+  if (exitCode !== void 0) {
+    resolvedExit = exitCode;
+  } else if (status === "done") {
+    resolvedExit = 0;
+  } else if (status === "cancelled") {
+    resolvedExit = CANCELLED_EXIT_CODE;
+  } else if (status === "orphaned") {
+    resolvedExit = ORPHAN_EXIT_CODE;
+  } else if (status === "crashed") {
+    resolvedExit = 1;
+  } else {
+    resolvedExit = null;
+  }
+  const finishedClause = stampEnded ? ", finished_at = datetime('now')" : "";
+  if (note !== void 0) {
+    db.run(
+      `UPDATE command_executions
+         SET exit_code = ?,
+             notes = COALESCE(notes || char(10), '') || ?
+             ${finishedClause}
+         WHERE uid = ?`,
+      [resolvedExit, note, id]
+    );
+  } else {
+    db.run(
+      `UPDATE command_executions
+         SET exit_code = ?
+             ${finishedClause}
+         WHERE uid = ?`,
+      [resolvedExit, id]
+    );
+  }
+}
+function updateAgentSession(db, id, params) {
+  const setClauses = [];
+  const values = [];
+  if (params.vendor_session_id !== void 0) {
+    setClauses.push("vendor_session_id = ?");
+    values.push(params.vendor_session_id);
+  }
+  if (params.status !== void 0) {
+    setAgentSessionStatus(db, id, params.status, {
+      exitCode: params.exit_code ?? void 0,
+      note: params.notes ?? void 0
+    });
+    return;
+  }
+  if (params.pid !== void 0) {
+    setClauses.push("pid = ?");
+    values.push(params.pid);
+  }
+  if (params.ended_at !== void 0) {
+    setClauses.push("finished_at = ?");
+    values.push(params.ended_at);
+  }
+  if (params.exit_code !== void 0) {
+    setClauses.push("exit_code = ?");
+    values.push(params.exit_code);
+  }
+  if (params.notes !== void 0) {
+    setClauses.push("notes = ?");
+    values.push(params.notes);
+  }
+  if (setClauses.length === 0) return;
+  values.push(id);
+  db.run(
+    `UPDATE command_executions SET ${setClauses.join(", ")} WHERE uid = ?`,
+    values
+  );
+}
+function sweepStaleAgentSessions(db, thresholdSeconds) {
+  const staleSql = `
+    SELECT uid, id FROM command_executions
+    WHERE finished_at IS NULL
+      AND last_heartbeat_at IS NOT NULL
+      AND (julianday('now') - julianday(last_heartbeat_at)) * 86400 > ?
+  `;
+  const stale = resultToRows(
+    db.exec(staleSql, [thresholdSeconds])
+  );
+  if (stale.length === 0) {
+    return { orphanedIds: [] };
+  }
+  const note = `${NOTE_ORPHAN_PREFIX} (threshold ${thresholdSeconds}s)`;
+  db.run(
+    `UPDATE command_executions
+       SET finished_at = datetime('now'),
+           exit_code = ?,
+           notes = COALESCE(notes || char(10), '') || ?
+     WHERE finished_at IS NULL
+       AND last_heartbeat_at IS NOT NULL
+       AND (julianday('now') - julianday(last_heartbeat_at)) * 86400 > ?`,
+    [ORPHAN_EXIT_CODE, note, thresholdSeconds]
+  );
+  return {
+    orphanedIds: stale.map((row) => row.uid ?? String(row.id))
+  };
+}
+
 // src/lib/db/command-log.ts
 import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
@@ -590,6 +937,35 @@ async function ensureDatabase(ocrDir) {
   saveDatabase(db, dbPath);
   return db;
 }
+function walCheckpointTruncate(dbPath) {
+  if (!existsSync2(dbPath)) {
+    return "skipped";
+  }
+  try {
+    const probe = spawnSync("sqlite3", ["-version"], {
+      stdio: "ignore",
+      timeout: 2e3
+    });
+    if (probe.status !== 0) {
+      return "skipped";
+    }
+  } catch {
+    return "skipped";
+  }
+  try {
+    const result = spawnSync(
+      "sqlite3",
+      [dbPath, "PRAGMA wal_checkpoint(TRUNCATE);"],
+      {
+        stdio: "ignore",
+        timeout: 5e3
+      }
+    );
+    return result.status === 0 ? "checkpointed" : "failed";
+  } catch {
+    return "failed";
+  }
+}
 function closeDatabase(dbPath) {
   const db = connections.get(dbPath);
   if (db) {
@@ -607,27 +983,40 @@ export {
   MIGRATIONS,
   appendCommandLog,
   applyPragmas,
+  bindVendorSessionIdOpportunistically,
+  bumpAgentSessionHeartbeat,
   cacheDir,
   closeAllDatabases,
   closeDatabase,
   commandLogPath,
   ensureDatabase,
   generateCommandUid,
+  getAgentSession,
   getAllSessions,
   getDb,
   getEventsForSession,
   getLatestActiveSession,
+  getLatestAgentSessionWithVendorId,
   getLatestEventId,
   getSession,
+  insertAgentSession,
   insertEvent,
   insertSession,
+  linkDashboardInvocationToWorkflow,
+  listAgentSessionsForWorkflow,
   locateWasm,
   openDatabase,
   readCommandLog,
+  recordVendorSessionIdForExecution,
   replayCommandLog,
   resultToRow,
   resultToRows,
   runMigrations,
   saveDatabase,
-  updateSession
+  setAgentSessionStatus,
+  setAgentSessionVendorId,
+  sweepStaleAgentSessions,
+  updateAgentSession,
+  updateSession,
+  walCheckpointTruncate
 };

package/dist/lib/models.js

@@ -0,0 +1,85 @@
+// ../shared/platform/src/index.ts
+import {
+  execFile,
+  execFileSync,
+  spawn
+} from "node:child_process";
+import { promisify } from "node:util";
+var execFilePromise = promisify(execFile);
+var isWindows = process.platform === "win32";
+function execBinary(binary, args, opts) {
+  return execFileSync(binary, args, {
+    ...opts,
+    shell: isWindows
+  });
+}
+
+// src/lib/models.ts
+var BUNDLED_CLAUDE_MODELS = [
+  { id: "claude-opus-4-7", displayName: "Claude Opus 4.7" },
+  { id: "claude-sonnet-4-6", displayName: "Claude Sonnet 4.6" },
+  { id: "claude-haiku-4-5-20251001", displayName: "Claude Haiku 4.5" }
+];
+var BUNDLED_OPENCODE_MODELS = [
+  { id: "anthropic/claude-opus-4-7", provider: "anthropic" },
+  { id: "anthropic/claude-sonnet-4-6", provider: "anthropic" },
+  { id: "anthropic/claude-haiku-4-5-20251001", provider: "anthropic" }
+];
+function detectActiveVendor() {
+  for (const vendor of ["claude", "opencode"]) {
+    try {
+      execBinary(vendor, ["--version"], {
+        encoding: "utf-8",
+        timeout: 3e3,
+        stdio: ["ignore", "pipe", "ignore"]
+      });
+      return vendor;
+    } catch {
+    }
+  }
+  return null;
+}
+function tryNativeEnumeration(vendor) {
+  try {
+    const output = execBinary(vendor, ["models", "--json"], {
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const parsed = JSON.parse(output);
+    if (!Array.isArray(parsed)) return null;
+    const models = [];
+    for (const item of parsed) {
+      if (typeof item === "string") {
+        models.push({ id: item });
+      } else if (typeof item === "object" && item !== null && "id" in item && typeof item.id === "string") {
+        const obj = item;
+        const desc = { id: obj.id };
+        if (typeof obj.displayName === "string") desc.displayName = obj.displayName;
+        if (typeof obj.provider === "string") desc.provider = obj.provider;
+        if (Array.isArray(obj.tags)) {
+          desc.tags = obj.tags.filter((t) => typeof t === "string");
+        }
+        models.push(desc);
+      }
+    }
+    return models.length > 0 ? models : null;
+  } catch {
+    return null;
+  }
+}
+function bundledForVendor(vendor) {
+  if (vendor === "claude") return BUNDLED_CLAUDE_MODELS;
+  return BUNDLED_OPENCODE_MODELS;
+}
+function listModelsForVendor(vendor) {
+  const native = tryNativeEnumeration(vendor);
+  if (native) {
+    return { vendor, source: "native", models: native };
+  }
+  return { vendor, source: "bundled", models: bundledForVendor(vendor) };
+}
+export {
+  detectActiveVendor,
+  listModelsForVendor
+};

package/dist/lib/runtime-config.js

@@ -0,0 +1,39 @@
+// src/lib/runtime-config.ts
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+var DEFAULT_AGENT_HEARTBEAT_SECONDS = 60;
+function getAgentHeartbeatSeconds(ocrDir) {
+  const configPath = join(ocrDir, "config.yaml");
+  if (!existsSync(configPath)) {
+    return DEFAULT_AGENT_HEARTBEAT_SECONDS;
+  }
+  let content;
+  try {
+    content = readFileSync(configPath, "utf-8");
+  } catch {
+    return DEFAULT_AGENT_HEARTBEAT_SECONDS;
+  }
+  const blockMatch = content.match(
+    /^runtime:\s*\n(?:\s+[^\n]*\n)*?\s+agent_heartbeat_seconds:\s*([^\s#\n]+)/m
+  );
+  const inlineMatch = content.match(
+    /^runtime:\s*\{[^}]*\bagent_heartbeat_seconds:\s*([^\s,}]+)/m
+  );
+  const raw = blockMatch?.[1] ?? inlineMatch?.[1];
+  if (!raw) {
+    return DEFAULT_AGENT_HEARTBEAT_SECONDS;
+  }
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed <= 0 || !Number.isInteger(parsed)) {
+    process.stderr.write(
+      `[ocr] runtime.agent_heartbeat_seconds is not a positive integer (got "${raw}"); falling back to ${DEFAULT_AGENT_HEARTBEAT_SECONDS}s.
+`
+    );
+    return DEFAULT_AGENT_HEARTBEAT_SECONDS;
+  }
+  return parsed;
+}
+export {
+  DEFAULT_AGENT_HEARTBEAT_SECONDS,
+  getAgentHeartbeatSeconds
+};