sentinelayer-cli 0.1.2 → 0.4.4

package/src/telemetry/sync.js

@@ -1,5 +1,23 @@
+import { execFileSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "node:path";
 import { readStoredSession } from "../auth/session-store.js";
 
+// Read CLI version from package.json at module load
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const pkgPath = resolve(__dirname, "../../package.json");
+let CLI_VERSION = "0.0.0";
+try {
+  CLI_VERSION = JSON.parse(readFileSync(pkgPath, "utf-8")).version;
+} catch { /* fallback */ }
+
+// Simple circuit breaker: skip sync after 3 consecutive failures
+let consecutiveFailures = 0;
+const MAX_CONSECUTIVE_FAILURES = 3;
+
 /**
  * Telemetry Sync — uploads CLI run results to sentinelayer-api.
  *
@@ -29,14 +47,19 @@ const SYNC_TIMEOUT_MS = 10000;
  * @param {string} [runData.persona] - e.g., "Jules Tanaka"
  * @param {string} [runData.mode] - e.g., "primary", "deep", "diff"
  * @param {object} [runData.summary] - { total, P0, P1, P2, P3, blocking }
- * @param {object} [runData.usage] - { tokens, costUsd, durationMs, toolCalls }
+ * @param {object} [runData.usage] - { tokens, inputTokens, outputTokens, costUsd, durationMs, toolCalls }
  * @param {string} [runData.stopReason] - e.g., "completed", "budget_exhausted"
  * @param {string} [runData.framework] - e.g., "next.js"
  * @param {object} [runData.reconciliation] - baseline reconciliation summary
  * @param {object} [runData.runtime] - runtime audit summary (lighthouse scores, headers)
- * @returns {Promise<{ synced: boolean, reason?: string }>}
+ * @returns {Promise<{ synced: boolean, reason?: string, runId?: string }>}
  */
 export async function syncRunToDashboard(runData) {
+  // Circuit breaker: skip if too many consecutive failures
+  if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+    return { synced: false, reason: "circuit_breaker_open" };
+  }
+
   let session;
   try {
     session = await readStoredSession();
@@ -49,88 +72,102 @@ export async function syncRunToDashboard(runData) {
   }
 
   const apiUrl = session.apiUrl || "https://api.sentinelayer.com";
+  const runId = randomUUID();
 
   try {
-    // Create a run record
-    const response = await fetch(apiUrl + "/api/v1/runs", {
+    const payload = {
+      schema_version: "1.0",
+      tier: 2,
+      run: {
+        run_id: runId,
+        timestamp_utc: new Date().toISOString(),
+        duration_ms: runData.usage?.durationMs || 0,
+        state: runData.stopReason || "passed",
+      },
+      repo: {
+        owner: detectRepoOwner(),
+        name: detectRepoName(),
+        branch: detectGitRef(),
+      },
+      scan: {
+        mode: mapCommandToMode(runData.command),
+        tokens_in: runData.usage?.inputTokens || runData.usage?.tokens || 0,
+        tokens_out: runData.usage?.outputTokens || 0,
+        cost_estimate_usd: runData.usage?.costUsd || 0,
+        model_used: runData.persona || "deterministic",
+      },
+      findings: {
+        counts: {
+          P0: runData.summary?.P0 || 0,
+          P1: runData.summary?.P1 || 0,
+          P2: runData.summary?.P2 || 0,
+          P3: runData.summary?.P3 || 0,
+        },
+      },
+      gate: {
+        result: runData.summary?.blocking ? "blocked" : "passed",
+        severity_threshold: "P1",
+      },
+      meta: {
+        source: "cli",
+        command: runData.command,
+        persona: runData.persona || null,
+        framework: runData.framework || null,
+        cli_version: CLI_VERSION,
+      },
+    };
+
+    const response = await fetchWithTimeout(apiUrl + "/api/v1/telemetry", {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        "Authorization": "Bearer " + session.token,
+        Authorization: "Bearer " + session.token,
       },
-      body: JSON.stringify({
-        mode: mapCommandToMode(runData.command),
-        runtime_profile: "cli_local",
-        repo: detectRepoName(),
-        ref: detectGitRef(),
-        orchestrator_model: runData.persona || "cli",
-        subagent_model: "deterministic",
-        budget: {
-          max_cost_usd: runData.usage?.maxCostUsd || 5.0,
-          max_iterations: runData.usage?.maxTurns || 25,
-        },
-        max_iterations: 1,
-      }),
-      signal: AbortSignal.timeout(SYNC_TIMEOUT_MS),
-    });
+      body: JSON.stringify(payload),
+    }, SYNC_TIMEOUT_MS);
 
     if (!response.ok) {
+      consecutiveFailures++;
       return { synced: false, reason: "api_" + response.status };
     }
 
-    const created = await response.json();
-    const runId = created.run_id;
-
-    // Post a completion event with telemetry
-    if (runId) {
-      await fetch(apiUrl + "/api/v1/runs/" + runId + "/complete", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "Authorization": "Bearer " + session.token,
-        },
-        body: JSON.stringify({
-          exit_reason: runData.stopReason || "completed",
-          stop_class: runData.summary?.blocking ? "BLOCKING_FINDINGS" : "CLEAN",
-          summary: {
-            command: runData.command,
-            persona: runData.persona || null,
-            mode: runData.mode || null,
-            framework: runData.framework || null,
-            findings: runData.summary || { total: 0, P0: 0, P1: 0, P2: 0, P3: 0 },
-            usage: {
-              token_usage: runData.usage?.tokens || runData.usage?.outputTokens || 0,
-              cost_usd: runData.usage?.costUsd || 0,
-              duration_ms: runData.usage?.durationMs || 0,
-              tool_calls: runData.usage?.toolCalls || 0,
-            },
-            reconciliation: runData.reconciliation || null,
-            runtime: runData.runtime || null,
-          },
-        }),
-        signal: AbortSignal.timeout(SYNC_TIMEOUT_MS),
-      }).catch(() => {}); // completion event is best-effort
-    }
-
+    consecutiveFailures = 0; // reset on success
     return { synced: true, runId };
   } catch (err) {
+    consecutiveFailures++;
     return { synced: false, reason: err.message };
   }
 }
 
 function mapCommandToMode(command) {
-  if (!command) return "audit_readonly";
+  if (!command) return "quick_scan";
   const lower = String(command).toLowerCase();
-  if (lower.includes("review")) return "audit_readonly";
-  if (lower.includes("omargate")) return "audit_readonly";
-  if (lower.includes("audit")) return "audit_readonly";
+  if (lower.includes("omargate")) return "deep_scan";
+  if (lower.includes("review")) return "quick_scan";
+  if (lower.includes("audit") && lower.includes("frontend")) return "audit_frontend";
+  if (lower.includes("audit")) return "audit_full";
   if (lower.includes("fix")) return "edit_gated";
-  return "audit_readonly";
+  return "quick_scan";
+}
+
+function detectRepoOwner() {
+  try {
+    const remote = execFileSync("git", ["remote", "get-url", "origin"], {
+      encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+    // Match owner from patterns like:
+    //   https://github.com/owner/repo.git
+    //   git@github.com:owner/repo.git
+    const httpsMatch = remote.match(/(?:github\.com|gitlab\.com)[/:]([^/]+)\//);
+    if (httpsMatch) return httpsMatch[1];
+    return "unknown";
+  } catch {
+    return "unknown";
+  }
 }
 
 function detectRepoName() {
   try {
-    const { execFileSync } = require("node:child_process");
     const remote = execFileSync("git", ["remote", "get-url", "origin"], {
       encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"],
     }).trim();
@@ -143,7 +180,6 @@ function detectRepoName() {
 
 function detectGitRef() {
   try {
-    const { execFileSync } = require("node:child_process");
     return execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
       encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"],
     }).trim() || "main";
@@ -151,3 +187,13 @@ function detectGitRef() {
     return "main";
   }
 }
+
+async function fetchWithTimeout(url, options, timeoutMs) {
+  const controller = new AbortController();
+  const timeoutHandle = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(url, { ...options, signal: controller.signal });
+  } finally {
+    clearTimeout(timeoutHandle);
+  }
+}

package/src/ui/markdown.js

@@ -1,220 +1,220 @@
-import pc from "picocolors";
-import { highlight } from "cli-highlight";
-
-const TABLE_SEPARATOR_PATTERN = /^\s*\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)+\|?\s*$/;
-
-function stripAnsi(text) {
-  return String(text || "").replace(/\x1B\[[0-9;]*m/g, "");
-}
-
-function visibleLength(text) {
-  return stripAnsi(text).length;
-}
-
-function padCell(text, width) {
-  const value = String(text || "");
-  const missing = Math.max(0, width - visibleLength(value));
-  return `${value}${" ".repeat(missing)}`;
-}
-
-function parseTableRow(line) {
-  const normalized = String(line || "").trim();
-  if (!normalized.includes("|")) {
-    return null;
-  }
-
-  const trimmed = normalized.startsWith("|") ? normalized.slice(1) : normalized;
-  const tailTrimmed = trimmed.endsWith("|") ? trimmed.slice(0, -1) : trimmed;
-  const cells = tailTrimmed.split("|").map((cell) => cell.trim());
-  if (cells.length < 2) {
-    return null;
-  }
-  return cells;
-}
-
-function isTableSeparator(line) {
-  return TABLE_SEPARATOR_PATTERN.test(String(line || "").trim());
-}
-
-function styleInlineMarkdown(line, plain = false) {
-  const input = String(line || "");
-  if (plain || !input) {
-    return input;
-  }
-
-  let output = input;
-  output = output.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, label, href) => {
-    return `${pc.underline(label)} ${pc.gray(`(${href})`)}`;
-  });
-  output = output.replace(/`([^`]+)`/g, (_, value) => pc.bgBlack(pc.white(` ${value} `)));
-  output = output.replace(/\*\*([^*]+)\*\*/g, (_, value) => pc.bold(value));
-  output = output.replace(/\*([^*]+)\*/g, (_, value) => pc.italic(value));
-  return output;
-}
-
-function renderTableBlock(lines, startIndex, plain = false) {
-  const header = parseTableRow(lines[startIndex]);
-  if (!header) {
-    return null;
-  }
-
-  if (startIndex + 1 >= lines.length || !isTableSeparator(lines[startIndex + 1])) {
-    return null;
-  }
-
-  const rows = [];
-  let cursor = startIndex + 2;
-  while (cursor < lines.length) {
-    const row = parseTableRow(lines[cursor]);
-    if (!row) {
-      break;
-    }
-    rows.push(row);
-    cursor += 1;
-  }
-
-  if (rows.length === 0) {
-    return null;
-  }
-
-  const tableRows = [header, ...rows];
-  const colCount = Math.max(...tableRows.map((row) => row.length));
-  const widths = Array.from({ length: colCount }, (_, col) => {
-    return Math.max(...tableRows.map((row) => visibleLength(row[col] || "")));
-  });
-
-  const drawBorder = (left, fill, join, right) =>
-    `${left}${widths.map((width) => fill.repeat(width + 2)).join(join)}${right}`;
-
-  const drawRow = (row, headerRow = false) => {
-    const cells = widths.map((width, col) => {
-      const raw = styleInlineMarkdown(row[col] || "", plain);
-      const value = headerRow && !plain ? pc.bold(raw) : raw;
-      return ` ${padCell(value, width)} `;
-    });
-    return `│${cells.join("│")}│`;
-  };
-
-  const renderedLines = [
-    drawBorder("┌", "─", "┬", "┐"),
-    drawRow(header, true),
-    drawBorder("├", "─", "┼", "┤"),
-    ...rows.map((row) => drawRow(row)),
-    drawBorder("└", "─", "┴", "┘"),
-  ];
-
-  return {
-    renderedLines,
-    nextIndex: cursor - 1,
-  };
-}
-
-function renderCodeBlock(lines, language, plain = false) {
-  const code = lines.join("\n");
-  if (plain || !code.trim()) {
-    return code;
-  }
-  try {
-    return highlight(code, {
-      language: language || undefined,
-      ignoreIllegals: true,
-    });
-  } catch {
-    return code;
-  }
-}
-
-function styleLine(line, plain = false) {
-  const input = String(line || "");
-  const trimmed = input.trimStart();
-
-  if (!trimmed) {
-    return "";
-  }
-
-  const headingMatch = trimmed.match(/^(#{1,6})\s+(.+)$/);
-  if (headingMatch) {
-    const [, marks, text] = headingMatch;
-    const heading = `${marks} ${styleInlineMarkdown(text, plain)}`;
-    if (plain) {
-      return heading;
-    }
-    if (marks.length <= 2) {
-      return pc.bold(pc.cyan(heading));
-    }
-    return pc.bold(heading);
-  }
-
-  if (trimmed.startsWith(">")) {
-    const quote = trimmed.replace(/^>\s?/, "");
-    const formatted = `> ${styleInlineMarkdown(quote, plain)}`;
-    return plain ? formatted : pc.gray(formatted);
-  }
-
-  if (/^\d+\.\s+/.test(trimmed)) {
-    const numbered = trimmed.replace(/^(\d+\.)\s+/, (_, idx) => `${idx} ${""}`);
-    return plain ? styleInlineMarkdown(numbered, true) : styleInlineMarkdown(numbered, false);
-  }
-
-  if (/^[-*+]\s+/.test(trimmed)) {
-    const bullet = trimmed.replace(/^[-*+]\s+/, "• ");
-    return plain ? styleInlineMarkdown(bullet, true) : styleInlineMarkdown(bullet, false);
-  }
-
-  if (/^(-{3,}|\*{3,}|_{3,})$/.test(trimmed)) {
-    const hr = "─".repeat(48);
-    return plain ? hr : pc.gray(hr);
-  }
-
-  return styleInlineMarkdown(input, plain);
-}
-
-export function renderTerminalMarkdown(markdown, options = {}) {
-  const plain = Boolean(options.plain);
-  const lines = String(markdown || "").split(/\r?\n/);
-  const rendered = [];
-  let inCodeBlock = false;
-  let codeLanguage = "";
-  let codeLines = [];
-
-  for (let index = 0; index < lines.length; index += 1) {
-    const line = lines[index];
-    const fenceMatch = String(line).match(/^```([\w-]+)?\s*$/);
-
-    if (fenceMatch) {
-      if (!inCodeBlock) {
-        inCodeBlock = true;
-        codeLanguage = String(fenceMatch[1] || "").trim();
-        rendered.push(plain ? line : pc.gray(line));
-      } else {
-        const highlighted = renderCodeBlock(codeLines, codeLanguage, plain);
-        rendered.push(highlighted);
-        rendered.push(plain ? line : pc.gray(line));
-        inCodeBlock = false;
-        codeLanguage = "";
-        codeLines = [];
-      }
-      continue;
-    }
-
-    if (inCodeBlock) {
-      codeLines.push(line);
-      continue;
-    }
-
-    const tableBlock = renderTableBlock(lines, index, plain);
-    if (tableBlock) {
-      rendered.push(...tableBlock.renderedLines);
-      index = tableBlock.nextIndex;
-      continue;
-    }
-
-    rendered.push(styleLine(line, plain));
-  }
-
-  if (inCodeBlock) {
-    rendered.push(renderCodeBlock(codeLines, codeLanguage, plain));
-  }
-
-  return rendered.join("\n");
-}
+import pc from "picocolors";
+import { highlight } from "cli-highlight";
+
+const TABLE_SEPARATOR_PATTERN = /^\s*\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)+\|?\s*$/;
+
+function stripAnsi(text) {
+  return String(text || "").replace(/\x1B\[[0-9;]*m/g, "");
+}
+
+function visibleLength(text) {
+  return stripAnsi(text).length;
+}
+
+function padCell(text, width) {
+  const value = String(text || "");
+  const missing = Math.max(0, width - visibleLength(value));
+  return `${value}${" ".repeat(missing)}`;
+}
+
+function parseTableRow(line) {
+  const normalized = String(line || "").trim();
+  if (!normalized.includes("|")) {
+    return null;
+  }
+
+  const trimmed = normalized.startsWith("|") ? normalized.slice(1) : normalized;
+  const tailTrimmed = trimmed.endsWith("|") ? trimmed.slice(0, -1) : trimmed;
+  const cells = tailTrimmed.split("|").map((cell) => cell.trim());
+  if (cells.length < 2) {
+    return null;
+  }
+  return cells;
+}
+
+function isTableSeparator(line) {
+  return TABLE_SEPARATOR_PATTERN.test(String(line || "").trim());
+}
+
+function styleInlineMarkdown(line, plain = false) {
+  const input = String(line || "");
+  if (plain || !input) {
+    return input;
+  }
+
+  let output = input;
+  output = output.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, label, href) => {
+    return `${pc.underline(label)} ${pc.gray(`(${href})`)}`;
+  });
+  output = output.replace(/`([^`]+)`/g, (_, value) => pc.bgBlack(pc.white(` ${value} `)));
+  output = output.replace(/\*\*([^*]+)\*\*/g, (_, value) => pc.bold(value));
+  output = output.replace(/\*([^*]+)\*/g, (_, value) => pc.italic(value));
+  return output;
+}
+
+function renderTableBlock(lines, startIndex, plain = false) {
+  const header = parseTableRow(lines[startIndex]);
+  if (!header) {
+    return null;
+  }
+
+  if (startIndex + 1 >= lines.length || !isTableSeparator(lines[startIndex + 1])) {
+    return null;
+  }
+
+  const rows = [];
+  let cursor = startIndex + 2;
+  while (cursor < lines.length) {
+    const row = parseTableRow(lines[cursor]);
+    if (!row) {
+      break;
+    }
+    rows.push(row);
+    cursor += 1;
+  }
+
+  if (rows.length === 0) {
+    return null;
+  }
+
+  const tableRows = [header, ...rows];
+  const colCount = Math.max(...tableRows.map((row) => row.length));
+  const widths = Array.from({ length: colCount }, (_, col) => {
+    return Math.max(...tableRows.map((row) => visibleLength(row[col] || "")));
+  });
+
+  const drawBorder = (left, fill, join, right) =>
+    `${left}${widths.map((width) => fill.repeat(width + 2)).join(join)}${right}`;
+
+  const drawRow = (row, headerRow = false) => {
+    const cells = widths.map((width, col) => {
+      const raw = styleInlineMarkdown(row[col] || "", plain);
+      const value = headerRow && !plain ? pc.bold(raw) : raw;
+      return ` ${padCell(value, width)} `;
+    });
+    return `│${cells.join("│")}│`;
+  };
+
+  const renderedLines = [
+    drawBorder("┌", "─", "┬", "┐"),
+    drawRow(header, true),
+    drawBorder("├", "─", "┼", "┤"),
+    ...rows.map((row) => drawRow(row)),
+    drawBorder("└", "─", "┴", "┘"),
+  ];
+
+  return {
+    renderedLines,
+    nextIndex: cursor - 1,
+  };
+}
+
+function renderCodeBlock(lines, language, plain = false) {
+  const code = lines.join("\n");
+  if (plain || !code.trim()) {
+    return code;
+  }
+  try {
+    return highlight(code, {
+      language: language || undefined,
+      ignoreIllegals: true,
+    });
+  } catch {
+    return code;
+  }
+}
+
+function styleLine(line, plain = false) {
+  const input = String(line || "");
+  const trimmed = input.trimStart();
+
+  if (!trimmed) {
+    return "";
+  }
+
+  const headingMatch = trimmed.match(/^(#{1,6})\s+(.+)$/);
+  if (headingMatch) {
+    const [, marks, text] = headingMatch;
+    const heading = `${marks} ${styleInlineMarkdown(text, plain)}`;
+    if (plain) {
+      return heading;
+    }
+    if (marks.length <= 2) {
+      return pc.bold(pc.cyan(heading));
+    }
+    return pc.bold(heading);
+  }
+
+  if (trimmed.startsWith(">")) {
+    const quote = trimmed.replace(/^>\s?/, "");
+    const formatted = `> ${styleInlineMarkdown(quote, plain)}`;
+    return plain ? formatted : pc.gray(formatted);
+  }
+
+  if (/^\d+\.\s+/.test(trimmed)) {
+    const numbered = trimmed.replace(/^(\d+\.)\s+/, (_, idx) => `${idx} ${""}`);
+    return plain ? styleInlineMarkdown(numbered, true) : styleInlineMarkdown(numbered, false);
+  }
+
+  if (/^[-*+]\s+/.test(trimmed)) {
+    const bullet = trimmed.replace(/^[-*+]\s+/, "• ");
+    return plain ? styleInlineMarkdown(bullet, true) : styleInlineMarkdown(bullet, false);
+  }
+
+  if (/^(-{3,}|\*{3,}|_{3,})$/.test(trimmed)) {
+    const hr = "─".repeat(48);
+    return plain ? hr : pc.gray(hr);
+  }
+
+  return styleInlineMarkdown(input, plain);
+}
+
+export function renderTerminalMarkdown(markdown, options = {}) {
+  const plain = Boolean(options.plain);
+  const lines = String(markdown || "").split(/\r?\n/);
+  const rendered = [];
+  let inCodeBlock = false;
+  let codeLanguage = "";
+  let codeLines = [];
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    const fenceMatch = String(line).match(/^```([\w-]+)?\s*$/);
+
+    if (fenceMatch) {
+      if (!inCodeBlock) {
+        inCodeBlock = true;
+        codeLanguage = String(fenceMatch[1] || "").trim();
+        rendered.push(plain ? line : pc.gray(line));
+      } else {
+        const highlighted = renderCodeBlock(codeLines, codeLanguage, plain);
+        rendered.push(highlighted);
+        rendered.push(plain ? line : pc.gray(line));
+        inCodeBlock = false;
+        codeLanguage = "";
+        codeLines = [];
+      }
+      continue;
+    }
+
+    if (inCodeBlock) {
+      codeLines.push(line);
+      continue;
+    }
+
+    const tableBlock = renderTableBlock(lines, index, plain);
+    if (tableBlock) {
+      rendered.push(...tableBlock.renderedLines);
+      index = tableBlock.nextIndex;
+      continue;
+    }
+
+    rendered.push(styleLine(line, plain));
+  }
+
+  if (inCodeBlock) {
+    rendered.push(renderCodeBlock(codeLines, codeLanguage, plain));
+  }
+
+  return rendered.join("\n");
+}