olakai-cli 0.1.13 → 0.1.14

package/dist/index.js

@@ -1928,15 +1928,15 @@ function formatActivityTable(data) {
     return;
   }
   const headers = ["ID", "AGENT", "APP", "MODEL", "TOKENS", "TIME(ms)", "RISK", "STATUS"];
-  const rows = data.prompts.map((prompt) => [
-    prompt.id.slice(0, 12) + "...",
-    prompt.agentName || (prompt.agentId ? prompt.agentId.slice(0, 12) + "..." : "-"),
-    prompt.app.slice(0, 12),
-    prompt.modelId?.slice(0, 15) || "-",
-    String(prompt.tokens),
-    String(prompt.requestTime),
-    prompt.isHighRisk ? "Yes" : "No",
-    prompt.decorationStatus.slice(0, 10)
+  const rows = data.prompts.map((prompt2) => [
+    prompt2.id.slice(0, 12) + "...",
+    prompt2.agentName || (prompt2.agentId ? prompt2.agentId.slice(0, 12) + "..." : "-"),
+    prompt2.app.slice(0, 12),
+    prompt2.modelId?.slice(0, 15) || "-",
+    String(prompt2.tokens),
+    String(prompt2.requestTime),
+    prompt2.isHighRisk ? "Yes" : "No",
+    prompt2.decorationStatus.slice(0, 10)
   ]);
   const widths = headers.map(
     (h, i) => Math.max(h.length, ...rows.map((r) => r[i].length))
@@ -1952,51 +1952,51 @@ function formatActivityTable(data) {
     console.log(`Use --offset ${data.offset + data.limit} to see more results`);
   }
 }
-function formatActivityDetail(prompt) {
-  console.log(`ID:           ${prompt.id}`);
-  console.log(`Created:      ${prompt.createdAt}`);
-  console.log(`Agent:        ${prompt.agentName || "-"} (${prompt.agentId || "-"})`);
-  console.log(`Workflow:     ${prompt.workflowName || "-"} (${prompt.workflowId || "-"})`);
-  if (prompt.taskExecutionId) {
-    console.log(`Task Exec ID: ${prompt.taskExecutionId}`);
-  }
-  console.log(`App:          ${prompt.app}`);
-  console.log(`Model:        ${prompt.modelId || "-"} (${prompt.modelType || "-"})`);
-  console.log(`Tokens:       ${prompt.tokens}`);
-  console.log(`Request Time: ${prompt.requestTime}ms`);
-  console.log(`High Risk:    ${prompt.isHighRisk ? "Yes" : "No"}`);
-  console.log(`Blocked:      ${prompt.blocked ? "Yes" : "No"}`);
-  console.log(`Status:       ${prompt.decorationStatus}`);
-  if (prompt.sensitivity && prompt.sensitivity.length > 0) {
-    console.log(`Sensitivity:  ${prompt.sensitivity.join(", ")}`);
-  }
-  if (prompt.analytics) {
+function formatActivityDetail(prompt2) {
+  console.log(`ID:           ${prompt2.id}`);
+  console.log(`Created:      ${prompt2.createdAt}`);
+  console.log(`Agent:        ${prompt2.agentName || "-"} (${prompt2.agentId || "-"})`);
+  console.log(`Workflow:     ${prompt2.workflowName || "-"} (${prompt2.workflowId || "-"})`);
+  if (prompt2.taskExecutionId) {
+    console.log(`Task Exec ID: ${prompt2.taskExecutionId}`);
+  }
+  console.log(`App:          ${prompt2.app}`);
+  console.log(`Model:        ${prompt2.modelId || "-"} (${prompt2.modelType || "-"})`);
+  console.log(`Tokens:       ${prompt2.tokens}`);
+  console.log(`Request Time: ${prompt2.requestTime}ms`);
+  console.log(`High Risk:    ${prompt2.isHighRisk ? "Yes" : "No"}`);
+  console.log(`Blocked:      ${prompt2.blocked ? "Yes" : "No"}`);
+  console.log(`Status:       ${prompt2.decorationStatus}`);
+  if (prompt2.sensitivity && prompt2.sensitivity.length > 0) {
+    console.log(`Sensitivity:  ${prompt2.sensitivity.join(", ")}`);
+  }
+  if (prompt2.analytics) {
     console.log("");
     console.log("Analytics:");
-    console.log(`  Task:       ${prompt.analytics.task || "-"}`);
-    console.log(`  Subtask:    ${prompt.analytics.subtask || "-"}`);
-    console.log(`  Time Saved: ${prompt.analytics.timesaved_minutes ?? "-"} minutes`);
-    console.log(`  Risk Score: ${prompt.analytics.riskassessment_dangerousity ?? "-"}`);
+    console.log(`  Task:       ${prompt2.analytics.task || "-"}`);
+    console.log(`  Subtask:    ${prompt2.analytics.subtask || "-"}`);
+    console.log(`  Time Saved: ${prompt2.analytics.timesaved_minutes ?? "-"} minutes`);
+    console.log(`  Risk Score: ${prompt2.analytics.riskassessment_dangerousity ?? "-"}`);
   }
-  if (prompt.kpiData && Object.keys(prompt.kpiData).length > 0) {
+  if (prompt2.kpiData && Object.keys(prompt2.kpiData).length > 0) {
     console.log("");
     console.log("KPIs:");
-    for (const [key, value] of Object.entries(prompt.kpiData)) {
+    for (const [key, value] of Object.entries(prompt2.kpiData)) {
       console.log(`  ${key}: ${value}`);
     }
   }
-  if (prompt.prompt !== void 0) {
+  if (prompt2.prompt !== void 0) {
     console.log("");
     console.log("Prompt:");
     console.log("---");
-    console.log(prompt.prompt.slice(0, 1e3) + (prompt.prompt.length > 1e3 ? "..." : ""));
+    console.log(prompt2.prompt.slice(0, 1e3) + (prompt2.prompt.length > 1e3 ? "..." : ""));
     console.log("---");
   }
-  if (prompt.response !== void 0) {
+  if (prompt2.response !== void 0) {
     console.log("");
     console.log("Response:");
     console.log("---");
-    console.log(prompt.response.slice(0, 1e3) + (prompt.response.length > 1e3 ? "..." : ""));
+    console.log(prompt2.response.slice(0, 1e3) + (prompt2.response.length > 1e3 ? "..." : ""));
     console.log("---");
   }
 }
@@ -2072,11 +2072,11 @@ async function listCommand5(options) {
 }
 async function getCommand5(id, options) {
   try {
-    const prompt = await getActivity(id, options.includeContent);
+    const prompt2 = await getActivity(id, options.includeContent);
     if (options.json) {
-      console.log(JSON.stringify(prompt, null, 2));
+      console.log(JSON.stringify(prompt2, null, 2));
     } else {
-      formatActivityDetail(prompt);
+      formatActivityDetail(prompt2);
     }
   } catch (error) {
     console.error(
@@ -2182,6 +2182,416 @@ function registerActivityCommand(program2) {
   activity.command("sessions").description("Inspect chat/session decoration status for troubleshooting").requiredOption("--agent-id <id>", "Agent ID (required)").option("--since <date>", "Start date (ISO format)").option("--until <date>", "End date (ISO format)").option("--limit <n>", "Results per page", "20").option("--offset <n>", "Skip first N results", "0").option("--json", "Output as JSON").action(sessionsCommand);
 }
 
+// src/commands/monitor.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as readline from "readline";
+var CLAUDE_DIR = ".claude";
+var SETTINGS_FILE = "settings.json";
+var MONITOR_CONFIG_FILE = "olakai-monitor.json";
+var OLAKAI_HOOK_MARKER = "olakai monitor hook";
+var HOOK_DEFINITIONS = {
+  Stop: [
+    {
+      matcher: "",
+      hooks: [
+        {
+          type: "command",
+          command: "olakai monitor hook stop"
+        }
+      ]
+    }
+  ]
+};
+function prompt(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+function findProjectRoot(startDir) {
+  let dir = startDir ?? process.cwd();
+  while (true) {
+    if (fs2.existsSync(path2.join(dir, CLAUDE_DIR))) {
+      return dir;
+    }
+    const parent = path2.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return startDir ?? process.cwd();
+}
+function getClaudeDir(projectRoot) {
+  return path2.join(projectRoot, CLAUDE_DIR);
+}
+function getSettingsPath(projectRoot) {
+  return path2.join(getClaudeDir(projectRoot), SETTINGS_FILE);
+}
+function getMonitorConfigPath(projectRoot) {
+  return path2.join(getClaudeDir(projectRoot), MONITOR_CONFIG_FILE);
+}
+function readJsonFile(filePath) {
+  try {
+    if (!fs2.existsSync(filePath)) return null;
+    const content = fs2.readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function writeJsonFile(filePath, data) {
+  const dir = path2.dirname(filePath);
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
+  }
+  fs2.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+function loadMonitorConfig(projectRoot) {
+  const root = projectRoot ?? findProjectRoot();
+  return readJsonFile(getMonitorConfigPath(root));
+}
+function readStdin(timeoutMs = 3e3) {
+  return new Promise((resolve) => {
+    if (process.stdin.isTTY) {
+      resolve("");
+      return;
+    }
+    let data = "";
+    const timer = setTimeout(() => {
+      process.stdin.removeAllListeners();
+      process.stdin.destroy();
+      resolve(data);
+    }, timeoutMs);
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => {
+      clearTimeout(timer);
+      resolve(data);
+    });
+    process.stdin.on("error", () => {
+      clearTimeout(timer);
+      resolve(data);
+    });
+  });
+}
+async function initCommand() {
+  const token = getValidToken();
+  if (!token) {
+    console.error("Not logged in. Run 'olakai login' first.");
+    process.exit(1);
+  }
+  console.log("Setting up Claude Code monitoring for this workspace...\n");
+  const projectRoot = process.cwd();
+  const dirName = path2.basename(projectRoot);
+  let agent;
+  const choice = await prompt(
+    "Create a new agent or use an existing one? (new/existing) [new]: "
+  );
+  if (choice.toLowerCase() === "existing" || choice.toLowerCase() === "e") {
+    const agents = await listAgents();
+    if (agents.length === 0) {
+      console.log("No agents found. Creating a new one instead.\n");
+      agent = await createNewAgent(dirName);
+    } else {
+      console.log("\nAvailable agents:");
+      for (let i = 0; i < agents.length; i++) {
+        console.log(`  ${i + 1}. ${agents[i].name} (${agents[i].id.slice(0, 12)}...)`);
+      }
+      const selection = await prompt(`
+Select agent (1-${agents.length}): `);
+      const idx = parseInt(selection, 10) - 1;
+      if (isNaN(idx) || idx < 0 || idx >= agents.length) {
+        console.error("Invalid selection.");
+        process.exit(1);
+      }
+      agent = await getAgent(agents[idx].id);
+      if (!agent.apiKey?.key && !agent.apiKey?.isActive) {
+        console.log(
+          "\nThis agent has no active API key. Please create a new agent instead,"
+        );
+        console.log("or generate an API key via the Olakai dashboard.\n");
+        const createNew = await prompt("Create a new agent? (y/n) [y]: ");
+        if (createNew.toLowerCase() !== "n") {
+          agent = await createNewAgent(dirName);
+        } else {
+          process.exit(1);
+        }
+      }
+    }
+  } else {
+    agent = await createNewAgent(dirName);
+  }
+  let apiKey = agent.apiKey?.key;
+  if (!apiKey) {
+    console.log(
+      "\nThe API key for this agent is not available (it is only shown once at creation)."
+    );
+    apiKey = await prompt("Paste the API key for this agent: ");
+    if (!apiKey) {
+      console.error("API key is required for monitoring.");
+      process.exit(1);
+    }
+  }
+  const claudeDir = getClaudeDir(projectRoot);
+  if (!fs2.existsSync(claudeDir)) {
+    fs2.mkdirSync(claudeDir, { recursive: true });
+  }
+  const settingsPath = getSettingsPath(projectRoot);
+  const existingSettings = readJsonFile(settingsPath) ?? {};
+  const mergedHooks = {
+    ...existingSettings.hooks ?? {}
+  };
+  for (const [event, entries] of Object.entries(HOOK_DEFINITIONS)) {
+    const existing = mergedHooks[event] ?? [];
+    const filtered = existing.filter(
+      (e) => !e.hooks.some((h) => h.command.includes(OLAKAI_HOOK_MARKER))
+    );
+    mergedHooks[event] = [...filtered, ...entries];
+  }
+  const updatedSettings = {
+    ...existingSettings,
+    hooks: mergedHooks
+  };
+  writeJsonFile(settingsPath, updatedSettings);
+  const monitoringEndpoint = `${getBaseUrl()}/api/monitoring/prompt`;
+  const monitorConfig = {
+    agentId: agent.id,
+    apiKey,
+    agentName: agent.name,
+    source: "claude-code",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    monitoringEndpoint
+  };
+  const monitorConfigPath = getMonitorConfigPath(projectRoot);
+  writeJsonFile(monitorConfigPath, monitorConfig);
+  fs2.chmodSync(monitorConfigPath, 384);
+  console.log("");
+  console.log(`\u2713 Agent "${agent.name}" configured (ID: ${agent.id})`);
+  if (agent.apiKey?.key) {
+    console.log("\u2713 API key generated");
+  }
+  console.log(`\u2713 Claude Code hooks configured in ${CLAUDE_DIR}/${SETTINGS_FILE}`);
+  console.log(`\u2713 Monitor config saved to ${CLAUDE_DIR}/${MONITOR_CONFIG_FILE}`);
+  console.log("");
+  console.log(
+    "Monitoring is now active. Claude Code will report activity to Olakai"
+  );
+  console.log(
+    `on each turn. View activity at: ${getBaseUrl()}/dashboard`
+  );
+  console.log("");
+  console.log(
+    `\u26A0 Ensure ${CLAUDE_DIR}/${MONITOR_CONFIG_FILE} is in your .gitignore (it contains your API key)`
+  );
+  console.log("");
+  console.log("To check status:  olakai monitor status");
+  console.log("To disable:       olakai monitor disable");
+}
+async function createNewAgent(defaultName) {
+  const nameInput = await prompt(
+    `Agent name [${defaultName}]: `
+  );
+  const agentName = nameInput || defaultName;
+  const agent = await createAgent({
+    name: agentName,
+    description: `Claude Code local agent for ${agentName}`,
+    role: "WORKER",
+    createApiKey: true,
+    category: "CODING",
+    source: "CLAUDE_CODE"
+  });
+  return agent;
+}
+async function hookCommand(event) {
+  try {
+    const config = loadMonitorConfig();
+    if (!config) {
+      return;
+    }
+    const stdinData = await readStdin(3e3);
+    let eventData = {};
+    if (stdinData) {
+      try {
+        eventData = JSON.parse(stdinData);
+      } catch {
+        return;
+      }
+    }
+    const payload = buildPayload(event, eventData, config);
+    if (!payload) {
+      return;
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 5e3);
+    try {
+      await fetch(config.monitoringEndpoint, {
+        method: "POST",
+        headers: {
+          "x-api-key": config.apiKey,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify([payload]),
+        signal: controller.signal
+      });
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  } catch {
+  }
+}
+function buildPayload(event, eventData, config) {
+  const sessionId = eventData.session_id ?? `claude-code-${Date.now()}`;
+  switch (event) {
+    case "stop": {
+      return {
+        prompt: eventData.prompt ?? "",
+        response: eventData.response ?? "",
+        chatId: sessionId,
+        source: config.source,
+        modelName: eventData.model,
+        tokens: eventData.total_tokens_in !== void 0 && eventData.total_tokens_out !== void 0 ? eventData.total_tokens_in + eventData.total_tokens_out : void 0,
+        requestTime: eventData.duration_api_ms,
+        customData: {
+          hookEvent: "Stop",
+          stopReason: eventData.stop_reason ?? "",
+          totalTokensIn: eventData.total_tokens_in ?? 0,
+          totalTokensOut: eventData.total_tokens_out ?? 0,
+          totalCost: eventData.total_cost ?? 0,
+          durationMs: eventData.duration_ms ?? 0,
+          numTurns: eventData.num_turns ?? 0
+        }
+      };
+    }
+    default:
+      return null;
+  }
+}
+async function statusCommand(options) {
+  const projectRoot = findProjectRoot();
+  const config = loadMonitorConfig(projectRoot);
+  if (!config) {
+    console.log("Monitoring is not configured for this workspace.");
+    console.log("Run 'olakai monitor init' to set up monitoring.");
+    process.exit(1);
+  }
+  const settings = readJsonFile(getSettingsPath(projectRoot));
+  const hooksPresent = settings?.hooks ? Object.values(settings.hooks).some(
+    (entries) => entries.some(
+      (e) => e.hooks.some((h) => h.command.includes(OLAKAI_HOOK_MARKER))
+    )
+  ) : false;
+  if (options.json) {
+    console.log(
+      JSON.stringify(
+        {
+          ...config,
+          apiKey: config.apiKey.slice(0, 12) + "...",
+          hooksConfigured: hooksPresent
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  console.log("Olakai Monitor Status");
+  console.log("=====================");
+  console.log(`Agent:       ${config.agentName}`);
+  console.log(`Agent ID:    ${config.agentId}`);
+  console.log(`API Key:     ${config.apiKey.slice(0, 12)}...`);
+  console.log(`Endpoint:    ${config.monitoringEndpoint}`);
+  console.log(`Source:      ${config.source}`);
+  console.log(`Configured:  ${config.createdAt}`);
+  console.log(`Hooks:       ${hooksPresent ? "Active" : "Missing (run 'olakai monitor init' to restore)"}`);
+  try {
+    const token = getValidToken();
+    if (token) {
+      const params = new URLSearchParams({
+        agentId: config.agentId,
+        limit: "5"
+      });
+      const response = await fetch(
+        `${getBaseUrl()}/api/activity/prompts?${params}`,
+        {
+          headers: { Authorization: `Bearer ${token}` }
+        }
+      );
+      if (response.ok) {
+        const data = await response.json();
+        if (data.prompts && data.prompts.length > 0) {
+          console.log("");
+          console.log("Recent Activity:");
+          for (const p of data.prompts) {
+            console.log(`  ${p.createdAt}  ${p.id.slice(0, 12)}...`);
+          }
+        } else {
+          console.log("");
+          console.log("No activity recorded yet.");
+        }
+      }
+    }
+  } catch {
+  }
+}
+async function disableCommand(options) {
+  const projectRoot = findProjectRoot();
+  const settingsPath = getSettingsPath(projectRoot);
+  const settings = readJsonFile(settingsPath);
+  if (settings?.hooks) {
+    const cleanedHooks = {};
+    for (const [event, entries] of Object.entries(settings.hooks)) {
+      const filtered = entries.filter(
+        (e) => !e.hooks.some((h) => h.command.includes(OLAKAI_HOOK_MARKER))
+      );
+      if (filtered.length > 0) {
+        cleanedHooks[event] = filtered;
+      }
+    }
+    if (Object.keys(cleanedHooks).length > 0) {
+      settings.hooks = cleanedHooks;
+    } else {
+      delete settings.hooks;
+    }
+    writeJsonFile(settingsPath, settings);
+    console.log(`\u2713 Olakai hooks removed from ${CLAUDE_DIR}/${SETTINGS_FILE}`);
+  } else {
+    console.log("No hooks found in settings.json.");
+  }
+  if (!options.keepConfig) {
+    const configPath = getMonitorConfigPath(projectRoot);
+    if (fs2.existsSync(configPath)) {
+      fs2.unlinkSync(configPath);
+      console.log(`\u2713 Monitor config removed (${CLAUDE_DIR}/${MONITOR_CONFIG_FILE})`);
+    }
+  } else {
+    console.log(
+      `Monitor config retained at ${CLAUDE_DIR}/${MONITOR_CONFIG_FILE}`
+    );
+  }
+  console.log("");
+  console.log("Monitoring disabled. Run 'olakai monitor init' to re-enable.");
+}
+function registerMonitorCommand(program2) {
+  const monitor = program2.command("monitor").description("Monitor Claude Code sessions with Olakai");
+  monitor.command("init").description(
+    "Set up Olakai monitoring for this Claude Code workspace"
+  ).action(initCommand);
+  monitor.command("hook <event>").description("Hook handler called by Claude Code (internal use)").action(hookCommand);
+  monitor.command("status").description("Show monitoring status for this workspace").option("--json", "Output as JSON").action(statusCommand);
+  monitor.command("disable").description("Remove Olakai monitoring from this workspace").option(
+    "--keep-config",
+    "Keep the monitor config file (only remove hooks)"
+  ).action(disableCommand);
+}
+
 // src/index.ts
 var require2 = createRequire(import.meta.url);
 var packageJson = require2("../package.json");
@@ -2210,5 +2620,6 @@ registerWorkflowsCommand(program);
 registerKpisCommand(program);
 registerCustomDataCommand(program);
 registerActivityCommand(program);
+registerMonitorCommand(program);
 program.parse();
 //# sourceMappingURL=index.js.map