@kal-elsam/kairo-runtime 0.14.0 → 0.15.0

package/src/global/observability/fleet-activity.js

@@ -0,0 +1,197 @@
+/**
+ * Live OpenCode fleet activity from opencode.db (read-only).
+ * Parent→child sessions via session.parent_id — not token telemetry.
+ */
+import { access } from "node:fs/promises";
+import { constants as fsConstants } from "node:fs";
+import { join } from "node:path";
+import { resolveHomeDir } from "../paths.js";
+
+const DEFAULT_LIMIT = 40;
+const ACTIVE_WINDOW_MS = 15 * 60 * 1000;
+
+async function pathExists(path) {
+  try {
+    await access(path, fsConstants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function resolveOpenCodeDbPath(homeDir = resolveHomeDir()) {
+  return join(homeDir, ".local", "share", "opencode", "opencode.db");
+}
+
+export function parseSessionModel(raw) {
+  if (raw == null || raw === "") return { model: null, modelShort: null, providerId: null };
+  if (typeof raw === "object" && !Array.isArray(raw)) {
+    const id = typeof raw.id === "string" ? raw.id : null;
+    const providerID = typeof raw.providerID === "string" ? raw.providerID : null;
+    const model = id && providerID ? `${providerID}/${id}` : id;
+    return { model, modelShort: id, providerId: providerID };
+  }
+  if (typeof raw !== "string") return { model: null, modelShort: null, providerId: null };
+  try {
+    return parseSessionModel(JSON.parse(raw));
+  } catch {
+    const slash = raw.lastIndexOf("/");
+    return {
+      model: raw,
+      modelShort: slash >= 0 ? raw.slice(slash + 1) : raw,
+      providerId: slash >= 0 ? raw.slice(0, slash) : null
+    };
+  }
+}
+
+function sessionState(row, nowMs, activeWindowMs) {
+  if (row.time_archived) return "archived";
+  if (typeof row.time_updated === "number" && nowMs - row.time_updated <= activeWindowMs) {
+    return "active";
+  }
+  return "idle";
+}
+
+/**
+ * Pure mapper: DB rows → activity tree nodes.
+ */
+export function mapSessionRowsToActivity(rows = [], {
+  nowMs = Date.now(),
+  activeWindowMs = ACTIVE_WINDOW_MS
+} = {}) {
+  const sessions = rows.map((row) => {
+    const parsed = parseSessionModel(row.model);
+    return {
+      id: String(row.id),
+      parentId: row.parent_id ? String(row.parent_id) : null,
+      title: typeof row.title === "string" ? row.title : "",
+      agent: typeof row.agent === "string" ? row.agent : null,
+      model: parsed.model,
+      modelShort: parsed.modelShort,
+      providerId: parsed.providerId,
+      timeCreated: row.time_created ?? null,
+      timeUpdated: row.time_updated ?? null,
+      state: sessionState(row, nowMs, activeWindowMs),
+      platform: "opencode"
+    };
+  });
+
+  const byAgent = new Map();
+  for (const s of sessions) {
+    const key = s.agent ?? "unknown";
+    const prev = byAgent.get(key);
+    if (!prev || (s.timeUpdated ?? 0) > (prev.timeUpdated ?? 0)) {
+      byAgent.set(key, s);
+    }
+  }
+
+  const agents = [...byAgent.entries()]
+    .map(([id, session]) => ({
+      id,
+      state: session.state === "archived" ? "idle" : session.state,
+      model: session.model,
+      modelShort: session.modelShort,
+      sessionId: session.id,
+      parentId: session.parentId,
+      title: session.title,
+      timeUpdated: session.timeUpdated
+    }))
+    .sort((a, b) => {
+      if (a.state === "active" && b.state !== "active") return -1;
+      if (b.state === "active" && a.state !== "active") return 1;
+      return (b.timeUpdated ?? 0) - (a.timeUpdated ?? 0);
+    });
+
+  return {
+    platform: "opencode",
+    sessions,
+    agents,
+    activeCount: agents.filter((a) => a.state === "active").length,
+    source: "opencode.db"
+  };
+}
+
+function openReadonlyDb(dbPath, DatabaseSync) {
+  return new DatabaseSync(dbPath, { readOnly: true });
+}
+
+/**
+ * Read recent OpenCode sessions (read-only). Inject openDatabase for tests.
+ */
+export async function buildOpenCodeActivity({
+  homeDir = resolveHomeDir(),
+  limit = DEFAULT_LIMIT,
+  activeWindowMs = ACTIVE_WINDOW_MS,
+  nowMs = Date.now(),
+  exists = pathExists,
+  openDatabase = null,
+  DatabaseSync = null
+} = {}) {
+  const dbPath = resolveOpenCodeDbPath(homeDir);
+  if (!(await exists(dbPath))) {
+    return {
+      ok: true,
+      available: false,
+      note: "OpenCode session DB not found.",
+      dbPath,
+      platform: "opencode",
+      sessions: [],
+      agents: [],
+      activeCount: 0,
+      generatedAt: new Date(nowMs).toISOString()
+    };
+  }
+
+  let rows = [];
+  try {
+    let Database = DatabaseSync;
+    if (!Database) {
+      const prior = process.emitWarning;
+      process.emitWarning = function muted(warning, ...rest) {
+        const msg = typeof warning === "string" ? warning : (warning?.message ?? "");
+        if (/SQLite is an experimental feature/i.test(String(msg))) return;
+        return prior.apply(process, [warning, ...rest]);
+      };
+      try {
+        ({ DatabaseSync: Database } = await import("node:sqlite"));
+      } finally {
+        process.emitWarning = prior;
+      }
+    }
+    const open = openDatabase ?? ((path) => openReadonlyDb(path, Database));
+    const db = open(dbPath);
+    try {
+      const stmt = db.prepare(`
+        SELECT id, parent_id, title, agent, model, time_created, time_updated, time_archived
+        FROM session
+        ORDER BY time_updated DESC
+        LIMIT ?
+      `);
+      rows = stmt.all(Math.max(1, Math.min(Number(limit) || DEFAULT_LIMIT, 200)));
+    } finally {
+      db.close?.();
+    }
+  } catch (error) {
+    return {
+      ok: false,
+      available: false,
+      note: `Could not read OpenCode DB: ${error?.message ?? error}`,
+      dbPath,
+      platform: "opencode",
+      sessions: [],
+      agents: [],
+      activeCount: 0,
+      generatedAt: new Date(nowMs).toISOString()
+    };
+  }
+
+  const mapped = mapSessionRowsToActivity(rows, { nowMs, activeWindowMs });
+  return {
+    ok: true,
+    available: true,
+    note: "Live OpenCode sessions (declared parent→child). Not Cursor/Claude live.",
+    dbPath,
+    ...mapped,
+    generatedAt: new Date(nowMs).toISOString()
+  };
+}

package/src/global/observability/fleet-models-catalog.js

@@ -0,0 +1,137 @@
+/**
+ * Declared / known model catalogs per platform (read-only discovery).
+ * Not a live marketplace scrape — what is configured or known-safe on disk.
+ */
+import { readFile, readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { resolveHomeDir } from "../paths.js";
+import { parseCodexDefaultModel, parseFrontmatterModel } from "./fleet-platforms.js";
+
+export const CLAUDE_TIERS = Object.freeze(["opus", "sonnet", "haiku"]);
+
+export const CURSOR_AGENT_MODELS = Object.freeze(["inherit", "fast"]);
+
+async function readJson(path, read) {
+  try {
+    return JSON.parse(await read(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+async function collectOpenCodeModels(homeDir, read) {
+  const path = join(homeDir, ".config", "opencode", "opencode.json");
+  const config = await readJson(path, read);
+  const ids = new Set();
+  if (typeof config?.model === "string") ids.add(config.model);
+  for (const raw of Object.values(config?.agent ?? config?.agents ?? {})) {
+    if (typeof raw?.model === "string") ids.add(raw.model);
+  }
+  return {
+    platform: "opencode",
+    kind: "multi",
+    path,
+    available: [...ids].sort(),
+    enabled: typeof config?.model === "string" ? [config.model] : [],
+    note: "From opencode.json (declared agents + default)."
+  };
+}
+
+async function collectClaudeModels(homeDir, read, list = readdir) {
+  const settingsPath = join(homeDir, ".claude", "settings.json");
+  const settings = await readJson(settingsPath, read);
+  const enabled = [];
+  if (typeof settings?.model === "string") enabled.push(settings.model);
+  try {
+    const dir = join(homeDir, ".claude", "agents");
+    for (const name of await list(dir)) {
+      if (!name.endsWith(".md")) continue;
+      const meta = parseFrontmatterModel(await read(join(dir, name), "utf8"));
+      if (meta.model) enabled.push(meta.model);
+    }
+  } catch { /* missing */ }
+  return {
+    platform: "claude",
+    kind: "multi",
+    path: settingsPath,
+    available: [...CLAUDE_TIERS],
+    enabled: [...new Set(enabled)],
+    note: "Claude Code tiers (opus/sonnet/haiku) + agents frontmatter."
+  };
+}
+
+async function collectCodexModels(homeDir, read) {
+  const path = join(homeDir, ".codex", "config.toml");
+  let current = null;
+  try {
+    current = parseCodexDefaultModel(await read(path, "utf8"));
+  } catch { /* missing */ }
+  return {
+    platform: "codex",
+    kind: "single",
+    path,
+    available: current ? [current] : [],
+    enabled: current ? [current] : [],
+    note: "Single default model in config.toml (no per-phase minions)."
+  };
+}
+
+async function collectCursorModels(homeDir, read, list = readdir) {
+  const cliPath = join(homeDir, ".cursor", "cli-config.json");
+  const cli = await readJson(cliPath, read);
+  const cliModel = cli?.model?.modelId ?? cli?.model?.displayModelId ?? null;
+  const agentModels = new Set();
+  try {
+    const dir = join(homeDir, ".cursor", "agents");
+    for (const name of await list(dir)) {
+      if (!name.endsWith(".md")) continue;
+      const meta = parseFrontmatterModel(await read(join(dir, name), "utf8"));
+      if (meta.model) agentModels.add(meta.model);
+    }
+  } catch { /* missing */ }
+  return {
+    platform: "cursor",
+    kind: "multi",
+    path: join(homeDir, ".cursor", "agents"),
+    available: [...CURSOR_AGENT_MODELS, ...(cliModel ? [cliModel] : [])],
+    enabled: [...agentModels],
+    cliDefault: cliModel,
+    note: "Agent frontmatter usually inherit/fast. Auto chat model is IDE-managed (see cli-config)."
+  };
+}
+
+/**
+ * Catalog of available + enabled models for each tooling surface.
+ */
+export async function buildFleetModelsCatalog({
+  homeDir = resolveHomeDir(),
+  read = readFile,
+  list = readdir
+} = {}) {
+  const platforms = await Promise.all([
+    collectOpenCodeModels(homeDir, read),
+    collectClaudeModels(homeDir, read, list),
+    collectCodexModels(homeDir, read),
+    collectCursorModels(homeDir, read, list)
+  ]);
+  return {
+    ok: true,
+    kind: "catalog",
+    note: "Available = known/declared for that tool. Enabled = currently referenced on disk.",
+    platforms,
+    generatedAt: new Date().toISOString()
+  };
+}
+
+export function formatFleetModelsText(catalog) {
+  const lines = ["Fleet models (available · enabled)", ""];
+  for (const p of catalog.platforms ?? []) {
+    lines.push(`${p.platform} · ${p.kind}${p.cliDefault ? ` · cli ${p.cliDefault}` : ""}`);
+    lines.push(`  available · ${(p.available ?? []).join(", ") || "—"}`);
+    lines.push(`  enabled   · ${(p.enabled ?? []).join(", ") || "—"}`);
+    if (p.note) lines.push(`  ${p.note}`);
+    lines.push("");
+  }
+  lines.push(catalog.note ?? "");
+  return lines.join("\n").trimEnd();
+}

package/src/global/observability/fleet-platforms.js

@@ -0,0 +1,166 @@
+/**
+ * Declared fleets for Claude / Codex / Cursor agents (public configs only).
+ */
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+
+const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---/;
+
+export function parseFrontmatterModel(raw) {
+  const text = String(raw ?? "");
+  const match = text.match(FRONTMATTER_RE);
+  if (!match) return { model: null, name: null };
+  const block = match[1];
+  const modelLine = block.match(/^model:\s*(.+)$/m);
+  const nameLine = block.match(/^name:\s*(.+)$/m);
+  const model = modelLine ? modelLine[1].trim().replace(/^["']|["']$/g, "") : null;
+  const name = nameLine ? nameLine[1].trim().replace(/^["']|["']$/g, "") : null;
+  return { model, name };
+}
+
+export function replaceFrontmatterModel(raw, nextModel) {
+  const text = String(raw ?? "");
+  const match = text.match(FRONTMATTER_RE);
+  if (!match) {
+    throw new Error("Agent file has no YAML frontmatter to update.");
+  }
+  const block = match[1];
+  let nextBlock;
+  if (/^model:\s*.+$/m.test(block)) {
+    nextBlock = block.replace(/^model:\s*.+$/m, `model: ${nextModel}`);
+  } else {
+    nextBlock = `${block.trimEnd()}\nmodel: ${nextModel}`;
+  }
+  return text.replace(FRONTMATTER_RE, `---\n${nextBlock}\n---`);
+}
+
+export function parseCodexDefaultModel(tomlText) {
+  const match = String(tomlText ?? "").match(/^\s*model\s*=\s*"([^"]+)"/m);
+  return match ? match[1] : null;
+}
+
+export function replaceCodexDefaultModel(tomlText, nextModel) {
+  const text = String(tomlText ?? "");
+  if (!/^\s*model\s*=\s*"[^"]*"/m.test(text)) {
+    throw new Error("Codex config.toml has no top-level model = \"...\" line.");
+  }
+  return text.replace(/^\s*model\s*=\s*"[^"]*"/m, `model = "${nextModel}"`);
+}
+
+function minionRole(id) {
+  if (id === "sdd-apply") return "executor";
+  if (id === "sdd-explore") return "explorer";
+  if (id === "sdd-verify") return "verifier";
+  return id.startsWith("sdd-") ? "specialist" : "minion";
+}
+
+async function listAgentFiles(dir, read = readFile, list = readdir) {
+  try {
+    const names = await list(dir);
+    const out = [];
+    for (const name of names) {
+      if (!name.endsWith(".md")) continue;
+      const path = join(dir, name);
+      const raw = await read(path, "utf8");
+      const meta = parseFrontmatterModel(raw);
+      const id = meta.name || name.replace(/\.md$/, "");
+      if (!id.startsWith("sdd-")) continue;
+      out.push({
+        id,
+        model: meta.model,
+        modelShort: meta.model,
+        role: minionRole(id),
+        mode: "subagent",
+        path,
+        opaque: meta.model === "inherit" || meta.model == null
+      });
+    }
+    return out.sort((a, b) => a.id.localeCompare(b.id));
+  } catch {
+    return [];
+  }
+}
+
+export async function buildClaudeFleet({ homeDir, read = readFile, list = readdir } = {}) {
+  const settingsPath = join(homeDir, ".claude", "settings.json");
+  let defaultModel = null;
+  try {
+    const settings = JSON.parse(await read(settingsPath, "utf8"));
+    defaultModel = typeof settings?.model === "string" ? settings.model : null;
+  } catch {
+    defaultModel = null;
+  }
+  const minions = await listAgentFiles(join(homeDir, ".claude", "agents"), read, list);
+  return {
+    platform: "claude",
+    orchestrator: {
+      id: "default",
+      model: defaultModel,
+      modelShort: defaultModel,
+      mode: "primary",
+      opaque: false
+    },
+    minions: minions.map((m) => ({
+      ...m,
+      model: m.model ?? defaultModel,
+      modelShort: m.modelShort ?? defaultModel,
+      opaque: false
+    })),
+    opaque: false,
+    writable: true,
+    note: "Declared Claude settings + agent frontmatter models.",
+    source: "claude"
+  };
+}
+
+export async function buildCodexFleet({ homeDir, read = readFile } = {}) {
+  const configPath = join(homeDir, ".codex", "config.toml");
+  let model = null;
+  try {
+    model = parseCodexDefaultModel(await read(configPath, "utf8"));
+  } catch {
+    model = null;
+  }
+  return {
+    platform: "codex",
+    orchestrator: {
+      id: "default",
+      model,
+      modelShort: model,
+      mode: "primary",
+      opaque: model == null
+    },
+    minions: [],
+    opaque: model == null,
+    writable: true,
+    configPath,
+    note: "Codex default model from ~/.codex/config.toml (no parent→child live topology).",
+    source: "codex"
+  };
+}
+
+export async function buildCursorAgentsFleet({ homeDir, read = readFile, list = readdir } = {}) {
+  const minions = await listAgentFiles(join(homeDir, ".cursor", "agents"), read, list);
+  return {
+    platform: "cursor",
+    orchestrator: {
+      id: "auto",
+      model: null,
+      modelShort: null,
+      mode: "primary",
+      opaque: true
+    },
+    minions: minions.map((m) => ({
+      id: m.id,
+      model: m.model,
+      modelShort: m.modelShort,
+      role: m.role,
+      mode: "subagent",
+      opaque: true
+    })),
+    opaque: true,
+    writable: false,
+    note: "Cursor Auto is IDE-managed. Subagents typically use model: inherit — change models in Cursor UI.",
+    source: "cursor-agents"
+  };
+}