olakai-cli 0.6.7 → 0.7.0

package/dist/chunk-GXKHWBGO.js

@@ -0,0 +1,691 @@
+import {
+  getCursorHooksPath,
+  getPlugin,
+  getToolScope,
+  installCodexHooksConfig,
+  loadCodexConfig,
+  loadCursorConfig,
+  mergeCursorHooks,
+  readRegistry,
+  reconcileCurrentWorkspace,
+  runMonitorInstall,
+  upsertEntry,
+  writeCodexConfig,
+  writeCursorConfig
+} from "./chunk-75YQWZ4Q.js";
+import {
+  getAgent,
+  listActivity,
+  listMyAgents,
+  regenerateAgentApiKey,
+  validateMonitoringApiKey
+} from "./chunk-KNGRF4XU.js";
+import {
+  findConfiguredWorkspace,
+  getSettingsPath,
+  loadClaudeCodeConfig,
+  mergeHooksSettings,
+  readJsonFile,
+  writeClaudeCodeConfig,
+  writeJsonFile
+} from "./chunk-KY6OHQZW.js";
+import {
+  getValidToken
+} from "./chunk-AVB4N2UN.js";
+
+// src/monitor/doctor.ts
+import * as os2 from "os";
+
+// src/monitor/doctor-adapters.ts
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+var claudeCodeAdapter = {
+  tool: "claude-code",
+  displayName: "Claude Code",
+  configRelLabel: ".olakai/monitor-claude-code.json",
+  hooksLabel: ".claude/settings.json",
+  loadConfig: (root) => {
+    const c = loadClaudeCodeConfig(root, () => {
+    });
+    return c ?? null;
+  },
+  writeConfig: (root, config) => {
+    writeClaudeCodeConfig(root, {
+      agentId: config.agentId,
+      apiKey: config.apiKey,
+      agentName: config.agentName,
+      source: config.source,
+      createdAt: config.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+      monitoringEndpoint: config.monitoringEndpoint
+    });
+  },
+  repairHooks: (root) => {
+    const settingsPath = getSettingsPath(root);
+    const existing = readJsonFile(settingsPath) ?? {};
+    const merged = {
+      ...existing,
+      hooks: mergeHooksSettings(existing.hooks)
+    };
+    writeJsonFile(settingsPath, merged);
+  }
+};
+var codexAdapter = {
+  tool: "codex",
+  displayName: "OpenAI Codex CLI",
+  configRelLabel: ".olakai/monitor-codex.json",
+  hooksLabel: "~/.codex/config.toml",
+  loadConfig: (root) => loadCodexConfig(root) ?? null,
+  writeConfig: (root, config) => {
+    writeCodexConfig(root, {
+      agentId: config.agentId,
+      apiKey: config.apiKey,
+      agentName: config.agentName,
+      source: config.source,
+      createdAt: config.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+      monitoringEndpoint: config.monitoringEndpoint
+    });
+  },
+  repairHooks: () => {
+    installCodexHooksConfig();
+  }
+};
+var cursorAdapter = {
+  tool: "cursor",
+  displayName: "Cursor",
+  configRelLabel: ".olakai/monitor-cursor.json",
+  hooksLabel: "~/.cursor/hooks.json",
+  loadConfig: (root) => loadCursorConfig(root) ?? null,
+  writeConfig: (root, config) => {
+    writeCursorConfig(root, {
+      agentId: config.agentId,
+      apiKey: config.apiKey,
+      agentName: config.agentName,
+      source: config.source,
+      createdAt: config.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+      monitoringEndpoint: config.monitoringEndpoint
+    });
+  },
+  repairHooks: (_root, homeDir = os.homedir()) => {
+    const hooksPath = getCursorHooksPath(homeDir);
+    let existing = null;
+    try {
+      if (fs.existsSync(hooksPath)) {
+        existing = JSON.parse(
+          fs.readFileSync(hooksPath, "utf-8")
+        );
+      }
+    } catch {
+      existing = null;
+    }
+    const merged = mergeCursorHooks(existing);
+    const dir = path.dirname(hooksPath);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(hooksPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+  }
+};
+var ADAPTERS = {
+  "claude-code": claudeCodeAdapter,
+  codex: codexAdapter,
+  cursor: cursorAdapter
+};
+function getDoctorToolAdapter(tool) {
+  return ADAPTERS[tool];
+}
+
+// src/monitor/doctor.ts
+var SEVERITY = { ok: 0, warn: 1, fail: 2 };
+function worst(a, b) {
+  return SEVERITY[a] >= SEVERITY[b] ? a : b;
+}
+function sevenDaysAgoIso(now = /* @__PURE__ */ new Date()) {
+  return new Date(now.getTime() - 7 * 24 * 60 * 60 * 1e3).toISOString();
+}
+async function runCheckChain(target, opts = {}) {
+  const homeDir = opts.homeDir ?? os2.homedir();
+  const now = opts.now ?? /* @__PURE__ */ new Date();
+  const tool = target.tool;
+  const scope = getToolScope(tool);
+  const adapter = getDoctorToolAdapter(tool);
+  const checks = [];
+  let registry = readRegistry(homeDir);
+  let entry = registry.workspaces.find(
+    (e) => e.path === target.path && e.tool === tool
+  );
+  if (!entry) {
+    try {
+      reconcileCurrentWorkspace(target.path, homeDir);
+    } catch {
+    }
+    registry = readRegistry(homeDir);
+    entry = registry.workspaces.find(
+      (e) => e.path === target.path && e.tool === tool
+    );
+  }
+  if (entry) {
+    checks.push({
+      id: "registry-entry",
+      label: "Registry entry",
+      status: "ok",
+      detail: `Recorded in the machine registry as "${entry.agentName}".`,
+      fixable: false
+    });
+  } else {
+    checks.push({
+      id: "registry-entry",
+      label: "Registry entry",
+      status: "warn",
+      detail: "No machine-registry entry for this workspace+tool (and none could be adopted from disk).",
+      fixable: true
+    });
+  }
+  const config = adapter.loadConfig(target.path);
+  if (config && config.agentId && config.apiKey && config.monitoringEndpoint) {
+    checks.push({
+      id: "config-valid",
+      label: "Config file",
+      status: "ok",
+      detail: `${adapter.configRelLabel} is present and valid (agent ${config.agentId}).`,
+      fixable: false
+    });
+  } else if (config) {
+    checks.push({
+      id: "config-valid",
+      label: "Config file",
+      status: "fail",
+      detail: `${adapter.configRelLabel} is missing required fields (agentId/apiKey/endpoint).`,
+      fixable: true
+    });
+  } else {
+    const detail = scope === "global" ? `No ${adapter.configRelLabel} in this workspace. ${adapter.displayName} hooks are global, so any activity here is NOT attributed to an agent until you run 'olakai monitor init --tool ${tool}'.` : `No ${adapter.configRelLabel} \u2014 this workspace is not configured for monitoring.`;
+    checks.push({
+      id: "config-valid",
+      label: "Config file",
+      status: "fail",
+      detail,
+      fixable: false
+    });
+  }
+  let hooksConfigured = false;
+  let hooksStatusError = null;
+  try {
+    const status = await getPlugin(tool).status({ projectRoot: target.path });
+    hooksConfigured = status.hooksConfigured;
+  } catch (err) {
+    hooksStatusError = err instanceof Error ? err.message : String(err);
+  }
+  if (hooksStatusError) {
+    checks.push({
+      id: "hooks-installed",
+      label: "Hooks installed",
+      status: "warn",
+      detail: `Couldn't determine hook status (${hooksStatusError}).`,
+      fixable: true
+    });
+  } else if (hooksConfigured) {
+    if (scope === "global" && !config) {
+      checks.push({
+        id: "hooks-installed",
+        label: "Hooks installed",
+        status: "warn",
+        detail: `${adapter.displayName} hooks are installed globally (${adapter.hooksLabel}), but this workspace has no monitor config \u2014 events fired here silent-exit unattributed.`,
+        fixable: false
+      });
+    } else {
+      checks.push({
+        id: "hooks-installed",
+        label: "Hooks installed",
+        status: "ok",
+        detail: scope === "global" ? `Installed globally at ${adapter.hooksLabel}.` : `Installed at ${adapter.hooksLabel}.`,
+        fixable: true
+      });
+    }
+  } else {
+    checks.push({
+      id: "hooks-installed",
+      label: "Hooks installed",
+      status: "fail",
+      detail: `${adapter.displayName} hooks are not installed (${adapter.hooksLabel}). The tool will not report any activity.`,
+      fixable: true
+    });
+  }
+  if (!config || !config.agentId || !config.apiKey) {
+    checks.push({
+      id: "api-key-valid",
+      label: "API key valid",
+      status: "warn",
+      detail: "Skipped \u2014 no usable config to read the API key from.",
+      fixable: true
+    });
+    checks.push({
+      id: "agent-exists",
+      label: "Agent exists",
+      status: "warn",
+      detail: "Skipped \u2014 no agentId in config to resolve.",
+      fixable: false
+    });
+    checks.push({
+      id: "events-flowing",
+      label: "Events flowing",
+      status: "warn",
+      detail: "Skipped \u2014 no agentId in config to probe.",
+      fixable: false
+    });
+    return { checks, config, allGreen: false };
+  }
+  const validation = await validateMonitoringApiKey(
+    config.monitoringEndpoint,
+    config.apiKey
+  );
+  if (validation === null) {
+    checks.push({
+      id: "api-key-valid",
+      label: "API key valid",
+      status: "fail",
+      detail: "The configured API key did not authenticate (rejected, or the monitoring endpoint was unreachable).",
+      fixable: true
+    });
+  } else {
+    checks.push({
+      id: "api-key-valid",
+      label: "API key valid",
+      status: "ok",
+      detail: `Authenticates against ${config.monitoringEndpoint}.`,
+      fixable: false
+    });
+  }
+  let agentResolves = false;
+  try {
+    await getAgent(config.agentId);
+    agentResolves = true;
+    checks.push({
+      id: "agent-exists",
+      label: "Agent exists",
+      status: "ok",
+      detail: `Agent ${config.agentId} resolves on the backend.`,
+      fixable: false
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (/not found/i.test(message)) {
+      checks.push({
+        id: "agent-exists",
+        label: "Agent exists",
+        status: "fail",
+        detail: `Agent ${config.agentId} no longer exists on the backend (404).`,
+        fixable: true
+      });
+    } else if (/permission|forbidden|analyst|403/i.test(message)) {
+      try {
+        const mine = await listMyAgents();
+        if (mine.some((a) => a.id === config.agentId)) {
+          agentResolves = true;
+          checks.push({
+            id: "agent-exists",
+            label: "Agent exists",
+            status: "ok",
+            detail: `Agent ${config.agentId} exists on the backend (verified via account lens \u2014 you're the creator).`,
+            fixable: false
+          });
+        } else {
+          checks.push({
+            id: "agent-exists",
+            label: "Agent exists",
+            status: "warn",
+            detail: `Agent ${config.agentId} isn't in your account-lens listing (run 'olakai agents mine'). The config may be stale or belong to another user.`,
+            fixable: false
+          });
+        }
+      } catch (mineErr) {
+        const mineMsg = mineErr instanceof Error ? mineErr.message : String(mineErr);
+        checks.push({
+          id: "agent-exists",
+          label: "Agent exists",
+          status: "warn",
+          detail: `Couldn't verify agent ${config.agentId} (permission denied; account-lens lookup also failed: ${mineMsg}).`,
+          fixable: false
+        });
+      }
+    } else {
+      checks.push({
+        id: "agent-exists",
+        label: "Agent exists",
+        status: "warn",
+        detail: `Couldn't verify agent ${config.agentId} (${message}).`,
+        fixable: false
+      });
+    }
+  }
+  let lastEventAt;
+  if (!agentResolves) {
+    checks.push({
+      id: "events-flowing",
+      label: "Events flowing",
+      status: "warn",
+      detail: "Skipped \u2014 agent could not be resolved.",
+      fixable: false
+    });
+  } else if (!getValidToken()) {
+    checks.push({
+      id: "events-flowing",
+      label: "Events flowing",
+      status: "warn",
+      detail: "Skipped \u2014 not logged in (run 'olakai login' to enable this check).",
+      fixable: false
+    });
+  } else {
+    try {
+      const since = sevenDaysAgoIso(now);
+      const activity = await listActivity({
+        agentId: config.agentId,
+        since,
+        limit: 1
+      });
+      if (activity.prompts.length > 0) {
+        lastEventAt = activity.prompts[0].createdAt;
+        checks.push({
+          id: "events-flowing",
+          label: "Events flowing",
+          status: "ok",
+          detail: `Most recent event ${lastEventAt} (within the last 7 days).`,
+          fixable: false
+        });
+      } else {
+        checks.push({
+          id: "events-flowing",
+          label: "Events flowing",
+          status: "warn",
+          detail: "No events in the last 7 days. This is expected if the workspace has been idle; if you've been active, check hooks + API key.",
+          fixable: false
+        });
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      checks.push({
+        id: "events-flowing",
+        label: "Events flowing",
+        status: "warn",
+        detail: /403|forbidden|permission/i.test(message) ? "Couldn't verify \u2014 your token lacks activity read access." : `Couldn't probe activity (${message}).`,
+        fixable: false
+      });
+    }
+  }
+  const allGreen = checks.every((c) => c.status === "ok");
+  if (entry && (lastEventAt || allGreen)) {
+    try {
+      upsertEntry(
+        {
+          ...entry,
+          ...lastEventAt ? { lastEventAt } : {},
+          ...allGreen ? { lastVerifiedAt: now.toISOString() } : {}
+        },
+        homeDir
+      );
+    } catch {
+    }
+  }
+  return { checks, config, allGreen, lastEventAt };
+}
+async function runFixes(target, outcome, opts = {}) {
+  const homeDir = opts.homeDir ?? os2.homedir();
+  const tool = target.tool;
+  const adapter = getDoctorToolAdapter(tool);
+  const results = [];
+  const byId = /* @__PURE__ */ new Map();
+  for (const c of outcome.checks) byId.set(c.id, c);
+  const needsFix = (id) => {
+    const c = byId.get(id);
+    return Boolean(c && c.fixable && c.status !== "ok");
+  };
+  if (needsFix("registry-entry")) {
+    try {
+      const adopted = reconcileCurrentWorkspace(target.path, homeDir);
+      const has = adopted.some((e) => e.tool === tool);
+      results.push({
+        checkId: "registry-entry",
+        fixed: has,
+        detail: has ? "Adopted the on-disk config into the machine registry." : "Nothing to adopt \u2014 there's no on-disk config to register. Run 'olakai monitor init'."
+      });
+    } catch (err) {
+      results.push({
+        checkId: "registry-entry",
+        fixed: false,
+        detail: `Reconcile failed: ${err instanceof Error ? err.message : String(err)}`
+      });
+    }
+  }
+  if (needsFix("agent-exists")) {
+    if (!opts.recreateMissing) {
+      results.push({
+        checkId: "agent-exists",
+        fixed: false,
+        detail: `The configured agent no longer exists on the backend. Recreating it provisions a NEW agent \u2014 re-run with '--recreate-missing', or use 'olakai monitor repair --tool ${tool}'.`
+      });
+    } else {
+      try {
+        const result = await runMonitorInstall(tool, {
+          projectRoot: target.path,
+          interactive: opts.interactive ?? false
+        });
+        results.push({
+          checkId: "agent-exists",
+          fixed: true,
+          detail: `Recreated the self-monitor agent "${result.agentName}" (${result.agentId}) and rewrote the config + registry.`
+        });
+        byId.delete("config-valid");
+        byId.delete("api-key-valid");
+      } catch (err) {
+        results.push({
+          checkId: "agent-exists",
+          fixed: false,
+          detail: `Could not recreate the agent: ${err instanceof Error ? err.message : String(err)}. This needs a human (check 'olakai login' and your role).`
+        });
+      }
+    }
+  }
+  const relinkNeeded = needsFix("config-valid") || needsFix("api-key-valid");
+  if (relinkNeeded) {
+    const config = outcome.config;
+    if (!config || !config.agentId) {
+      results.push({
+        checkId: needsFix("config-valid") ? "config-valid" : "api-key-valid",
+        fixed: false,
+        detail: "Can't re-link \u2014 no agentId in config. Run 'olakai monitor init' to set up this workspace."
+      });
+    } else {
+      try {
+        const rotated = await regenerateAgentApiKey(config.agentId);
+        adapter.writeConfig(target.path, {
+          agentId: config.agentId,
+          apiKey: rotated.key,
+          agentName: config.agentName,
+          source: config.source,
+          createdAt: config.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+          monitoringEndpoint: config.monitoringEndpoint
+        });
+        const detail = "Rotated the agent API key and rewrote the workspace config. Other workspaces using the old key must re-init.";
+        if (needsFix("config-valid")) {
+          results.push({ checkId: "config-valid", fixed: true, detail });
+        }
+        if (needsFix("api-key-valid")) {
+          results.push({ checkId: "api-key-valid", fixed: true, detail });
+        }
+      } catch (err) {
+        const detail = `Key rotation failed: ${err instanceof Error ? err.message : String(err)}.`;
+        if (needsFix("config-valid")) {
+          results.push({ checkId: "config-valid", fixed: false, detail });
+        }
+        if (needsFix("api-key-valid")) {
+          results.push({ checkId: "api-key-valid", fixed: false, detail });
+        }
+      }
+    }
+  }
+  if (needsFix("hooks-installed")) {
+    try {
+      adapter.repairHooks(target.path);
+      results.push({
+        checkId: "hooks-installed",
+        fixed: true,
+        detail: `Re-merged ${adapter.displayName} hooks (${adapter.hooksLabel}).`
+      });
+    } catch (err) {
+      results.push({
+        checkId: "hooks-installed",
+        fixed: false,
+        detail: `Could not re-merge hooks: ${err instanceof Error ? err.message : String(err)}.`
+      });
+    }
+  }
+  return results;
+}
+function resolveTargets(opts) {
+  const cwd = opts.cwd ?? process.cwd();
+  const homeDir = opts.homeDir ?? os2.homedir();
+  if (opts.all) {
+    try {
+      reconcileCurrentWorkspace(cwd, homeDir);
+    } catch {
+    }
+    const registry = readRegistry(homeDir);
+    return registry.workspaces.map((e) => ({ path: e.path, tool: e.tool }));
+  }
+  const tool = opts.tool;
+  if (!tool) return [];
+  const root = findConfiguredWorkspace(cwd, [tool]) ?? cwd;
+  return [{ path: root, tool }];
+}
+async function buildReport(targets, opts = {}) {
+  const targetReports = [];
+  const outcomes = /* @__PURE__ */ new Map();
+  let overall = "ok";
+  for (const target of targets) {
+    const outcome = await runCheckChain(target, opts);
+    outcomes.set(targetKey(target), outcome);
+    const targetOverall = outcome.checks.reduce(
+      (acc, c) => worst(acc, c.status),
+      "ok"
+    );
+    overall = worst(overall, targetOverall);
+    const entry = findEntry(target, opts.homeDir);
+    targetReports.push({
+      path: target.path,
+      tool: target.tool,
+      scope: getToolScope(target.tool),
+      agentId: outcome.config?.agentId ?? entry?.agentId,
+      checks: outcome.checks,
+      overall: targetOverall
+    });
+  }
+  return { report: { targets: targetReports, overall }, outcomes };
+}
+function targetKey(target) {
+  return `${target.path}::${target.tool}`;
+}
+function findEntry(target, homeDir) {
+  const registry = readRegistry(homeDir ?? os2.homedir());
+  return registry.workspaces.find(
+    (e) => e.path === target.path && e.tool === target.tool
+  );
+}
+var ICON = {
+  ok: "\u2713",
+  // ✓
+  warn: "\u26A0",
+  // ⚠
+  fail: "\u2717"
+  // ✗
+};
+function formatReport(report) {
+  if (report.targets.length === 0) {
+    return "No monitored workspaces to check. Run 'olakai monitor init --tool <tool>' first.";
+  }
+  const lines = [];
+  for (const t of report.targets) {
+    lines.push(`${t.tool} \u2014 ${t.path} [${t.scope}]`);
+    for (const c of t.checks) {
+      lines.push(`  ${ICON[c.status]} ${c.label}: ${c.detail}`);
+    }
+    lines.push("");
+  }
+  const summary = report.overall === "ok" ? "All checks passed." : report.overall === "warn" ? "Some checks need attention (warnings). Run with --fix to repair fixable issues." : "Some checks failed. Run with --fix to repair fixable issues.";
+  lines.push(summary);
+  return lines.join("\n").trimEnd();
+}
+function formatFixResults(target, fixes) {
+  if (fixes.length === 0) {
+    return `${target.tool} \u2014 ${target.path}: nothing to fix.`;
+  }
+  const lines = [`${target.tool} \u2014 ${target.path}:`];
+  for (const f of fixes) {
+    lines.push(`  ${f.fixed ? ICON.ok : ICON.fail} ${f.checkId}: ${f.detail}`);
+  }
+  return lines.join("\n");
+}
+async function runDoctor(options) {
+  const targets = resolveTargets({
+    all: options.all,
+    tool: options.tool,
+    cwd: options.cwd,
+    homeDir: options.homeDir
+  });
+  const { report, outcomes } = await buildReport(targets, {
+    homeDir: options.homeDir,
+    now: options.now
+  });
+  if (!options.fix) {
+    return { report };
+  }
+  const fixes = [];
+  for (const target of targets) {
+    const outcome = outcomes.get(targetKey(target));
+    if (!outcome) continue;
+    const results = await runFixes(target, outcome, {
+      homeDir: options.homeDir,
+      interactive: options.interactive,
+      recreateMissing: options.recreateMissing
+    });
+    if (results.length > 0) {
+      fixes.push({ path: target.path, tool: target.tool, results });
+    }
+  }
+  const { report: afterReport } = await buildReport(targets, {
+    homeDir: options.homeDir,
+    now: options.now
+  });
+  return { report: afterReport, fixes };
+}
+function exitCodeForStatus(status) {
+  return status === "fail" ? 1 : 0;
+}
+function printDoctorResult(result, json) {
+  if (json) {
+    const payload = { report: result.report };
+    if (result.fixes) payload.fixes = result.fixes;
+    console.log(JSON.stringify(payload, null, 2));
+    return;
+  }
+  console.log(formatReport(result.report));
+  if (result.fixes && result.fixes.length > 0) {
+    console.log("");
+    console.log("Repairs:");
+    for (const f of result.fixes) {
+      console.log(formatFixResults({ path: f.path, tool: f.tool }, f.results));
+    }
+  }
+}
+
+export {
+  getDoctorToolAdapter,
+  runCheckChain,
+  runFixes,
+  resolveTargets,
+  buildReport,
+  targetKey,
+  formatReport,
+  formatFixResults,
+  runDoctor,
+  exitCodeForStatus,
+  printDoctorResult
+};
+//# sourceMappingURL=chunk-GXKHWBGO.js.map