cc-flight 0.4.1

package/runtime-node/adapters/shared.ts

@@ -0,0 +1,113 @@
+import { readFile, stat } from "node:fs/promises";
+import { AgentLogSource, AgentProvider, ParsedAgentEvent, TimelineEvent, TokenUsage } from "../../core/types";
+import { redactValue } from "../../core/redactor";
+import { sha256 } from "../../core/hash";
+
+export async function fileSource(provider: AgentProvider, filePath: string): Promise<AgentLogSource> {
+  const stats = await stat(filePath);
+  return {
+    provider,
+    id: `${provider}:${filePath}`,
+    path: filePath,
+    sizeBytes: stats.size,
+    mtimeMs: stats.mtimeMs
+  };
+}
+
+export async function readJsonFile(sourcePath: string): Promise<unknown> {
+  return JSON.parse(await readFile(sourcePath, "utf8"));
+}
+
+export function parsedEvent(input: {
+  provider: AgentProvider;
+  sourcePath: string;
+  lineNo: number;
+  timestamp: string;
+  type: string;
+  payload: unknown;
+  raw?: string;
+}): ParsedAgentEvent {
+  const raw = input.raw ?? JSON.stringify({ timestamp: input.timestamp, type: input.type, payload: input.payload });
+  return {
+    provider: input.provider,
+    sourcePath: input.sourcePath,
+    lineNo: input.lineNo,
+    timestamp: input.timestamp,
+    type: input.type,
+    payload: input.payload,
+    redactedPayload: redactValue(input.payload),
+    sha256: sha256(raw)
+  };
+}
+
+export function makeTokenUsage(value: unknown): TokenUsage | null {
+  const rawInput = firstNumber(value, ["input_tokens", "prompt_tokens", "input", "prompt"]);
+  const output = firstNumber(value, ["output_tokens", "completion_tokens", "output", "completion"]);
+  const reasoning = firstNumber(value, ["reasoning_tokens", "reasoning", "reasoning_output_tokens"]);
+  // OpenAI/Codex style: cached_tokens / cached_input_tokens are ALREADY included in prompt_tokens/input_tokens.
+  // Anthropic style: cache_read_input_tokens and cache_creation_input_tokens are reported SEPARATELY from input_tokens.
+  const cachedRead = firstNumber(value, ["cached_input_tokens", "cached_tokens", "cache_read_input_tokens", "cached_input", "cache_read", "read"]);
+  const anthropicCacheRead = firstNumber(value, ["cache_read_input_tokens"]);
+  const anthropicCacheCreation = firstNumber(value, ["cache_creation_input_tokens"]);
+  const explicitTotal = firstNumber(value, ["total_tokens", "total"]);
+  const isAnthropicStyle = anthropicCacheRead !== null || anthropicCacheCreation !== null;
+  const input = isAnthropicStyle
+    ? (rawInput ?? 0) + (anthropicCacheRead ?? 0) + (anthropicCacheCreation ?? 0)
+    : rawInput;
+  const cachedInput = isAnthropicStyle ? (anthropicCacheRead ?? 0) : cachedRead;
+  const total = explicitTotal ?? sumKnown(input, output);
+  if (rawInput === null && output === null && reasoning === null && cachedRead === null && total === null && !isAnthropicStyle) return null;
+  return {
+    input: input ?? 0,
+    output: output ?? 0,
+    reasoning: reasoning ?? 0,
+    cachedInput: cachedInput ?? 0,
+    total: total ?? 0
+  };
+}
+
+export function attachTokenUsage(event: TimelineEvent, usage: TokenUsage | null): TimelineEvent {
+  return usage ? { ...event, tokenUsage: usage } : event;
+}
+
+export function asRecord(value: unknown): Record<string, unknown> {
+  return value && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, unknown>) : {};
+}
+
+export function stringValue(value: unknown): string | null {
+  return typeof value === "string" ? value : null;
+}
+
+export function numberTimestamp(value: unknown): string | null {
+  if (typeof value !== "number" || !Number.isFinite(value)) return null;
+  return new Date(value).toISOString();
+}
+
+function firstNumber(value: unknown, keys: string[]): number | null {
+  const matches = collectNumbers(value, new Set(keys.map(normalizeKey)));
+  return matches[0] ?? null;
+}
+
+function collectNumbers(value: unknown, keys: Set<string>): number[] {
+  if (!value || typeof value !== "object") return [];
+  if (Array.isArray(value)) return value.flatMap((item) => collectNumbers(item, keys));
+  const matches: number[] = [];
+  for (const [key, child] of Object.entries(value)) {
+    if (keys.has(normalizeKey(key)) && typeof child === "number" && Number.isFinite(child) && child >= 0) {
+      matches.push(Math.trunc(child));
+    }
+    if (child && typeof child === "object") {
+      matches.push(...collectNumbers(child, keys));
+    }
+  }
+  return matches;
+}
+
+function normalizeKey(value: string) {
+  return value.replace(/[^a-z0-9]/gi, "").toLowerCase();
+}
+
+function sumKnown(...values: Array<number | null>) {
+  const known = values.filter((value): value is number => value !== null);
+  return known.length > 0 ? known.reduce((sum, value) => sum + value, 0) : null;
+}

package/runtime-node/chrome-devtools.ts

@@ -0,0 +1,22 @@
+import { createHash } from "node:crypto";
+import path from "node:path";
+
+export const CHROME_DEVTOOLS_CONFIG_PATH = "/.well-known/appspecific/com.chrome.devtools.json";
+
+export function buildChromeDevToolsConfig(root = process.cwd()) {
+  const workspaceRoot = path.resolve(root);
+  return {
+    workspace: {
+      root: workspaceRoot,
+      uuid: uuidFromRoot(workspaceRoot)
+    }
+  };
+}
+
+function uuidFromRoot(root: string) {
+  const chars = createHash("sha256").update(root).digest("hex").slice(0, 32).split("");
+  chars[12] = "4";
+  chars[16] = ((Number.parseInt(chars[16], 16) & 0x3) | 0x8).toString(16);
+  const hex = chars.join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}

package/runtime-node/cli-ingest.ts

@@ -0,0 +1,7 @@
+import { SuperViewDatabase } from "../storage/database";
+import { IngestService } from "./ingest";
+
+const db = new SuperViewDatabase();
+const service = new IngestService(db);
+const result = service.start(process.argv[2] ? { codexHome: process.argv[2] } : {});
+console.log(JSON.stringify({ jobId: result.job.id, alreadyRunning: result.alreadyRunning }, null, 2));

package/runtime-node/cli-start.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+
+const require = createRequire(import.meta.url);
+const tsxDir = path.dirname(require.resolve("tsx/package.json"));
+const tsxPath = path.join(tsxDir, "dist", "cli.mjs");
+const cliPath = fileURLToPath(new URL("./cli-start.ts", import.meta.url));
+
+const child = spawn(process.execPath, [tsxPath, cliPath, ...process.argv.slice(2)], {
+  stdio: "inherit"
+});
+child.on("exit", (code) => process.exit(code ?? 0));

package/runtime-node/cli-start.ts

@@ -0,0 +1,21 @@
+import path from "node:path";
+import { startProdServer } from "./prod-server.js";
+
+const portArg = process.argv.find((arg) => arg.startsWith("--port="));
+const dataDirArg = process.argv.find((arg) => arg.startsWith("--data-dir="));
+const projectDirArg = process.argv.find((arg) => arg.startsWith("--project-dir="));
+
+if (portArg) process.env.SUPERVIEW_PORT = portArg.split("=")[1];
+if (dataDirArg) process.env.SUPERVIEW_DATA_DIR = dataDirArg.split("=")[1];
+
+const rawProjectDir = projectDirArg
+  ? projectDirArg.split("=")[1]
+  : process.argv[2] && !process.argv[2].startsWith("--")
+    ? process.argv[2]
+    : undefined;
+
+const projectDir = rawProjectDir
+  ? path.resolve(process.cwd(), rawProjectDir)
+  : undefined;
+
+startProdServer({ projectDir });

package/runtime-node/dev-server.ts

@@ -0,0 +1,13 @@
+import { createServer } from "./server.js";
+
+const port = Number(process.env.SUPERVIEW_API_PORT ?? 5174);
+const app = createServer();
+
+app.get("/", (_req, res) => {
+  const clientUrl = process.env.SUPERVIEW_UI_URL ?? `http://127.0.0.1:${process.env.SUPERVIEW_UI_PORT ?? 5173}/`;
+  res.redirect(302, clientUrl);
+});
+
+app.listen(port, "127.0.0.1", () => {
+  console.log(`SuperView API listening on http://127.0.0.1:${port}`);
+});

package/runtime-node/git-provider.ts

@@ -0,0 +1,102 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import type { GitCommitRecord } from "../core/types";
+
+const execFileAsync = promisify(execFile);
+const GIT_TIMEOUT_MS = 3000;
+
+export async function getRepoRoot(cwd: string): Promise<string | null> {
+  try {
+    const { stdout } = await execFileAsync("git", ["-C", cwd, "rev-parse", "--show-toplevel"], { timeout: GIT_TIMEOUT_MS });
+    return stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+export async function getCommits(repoRoot: string, from?: string | null, to?: string | null): Promise<GitCommitRecord[]> {
+  const args = [
+    "-C",
+    repoRoot,
+    "log",
+    "--date=iso-strict",
+    "--pretty=format:%x1e%H%x1f%h%x1f%an%x1f%ae%x1f%ad%x1f%s",
+    "--numstat"
+  ];
+
+  if (from) {
+    args.push(`--since=${formatGitDateArg(from)}`);
+  }
+  if (to) {
+    args.push(`--until=${formatGitDateArg(to)}`);
+  }
+
+  try {
+    const { stdout } = await execFileAsync("git", args, {
+      timeout: GIT_TIMEOUT_MS,
+      maxBuffer: 10 * 1024 * 1024
+    });
+    return parseGitLogNumstat(stdout, repoRoot);
+  } catch {
+    return [];
+  }
+}
+
+function parseGitLogNumstat(stdout: string, repoRoot: string): GitCommitRecord[] {
+  return stdout
+    .split("\x1e")
+    .map((entry) => entry.trim())
+    .filter(Boolean)
+    .map((entry) => parseGitCommitEntry(entry, repoRoot))
+    .filter((commit): commit is GitCommitRecord => commit !== null);
+}
+
+function parseGitCommitEntry(entry: string, repoRoot: string): GitCommitRecord | null {
+  const lines = entry.split(/\r?\n/).filter(Boolean);
+  const header = lines.shift();
+  if (!header) return null;
+
+  const [hash, shortHash, authorName, authorEmail, timestamp, subject] = header.split("\x1f");
+  if (!hash || !shortHash || !timestamp) return null;
+
+  let filesChanged = 0;
+  let insertions = 0;
+  let deletions = 0;
+
+  for (const line of lines) {
+    const [inserted, deleted] = line.split(/\t/);
+    if (inserted === undefined || deleted === undefined) continue;
+
+    filesChanged += 1;
+    insertions += parseNumstatCount(inserted);
+    deletions += parseNumstatCount(deleted);
+  }
+
+  return {
+    id: hash,
+    projectId: repoRoot,
+    repoRoot,
+    hash,
+    shortHash,
+    authorName: authorName || null,
+    authorEmail: authorEmail || null,
+    timestamp,
+    subject: subject ?? "",
+    filesChanged,
+    insertions,
+    deletions
+  };
+}
+
+function parseNumstatCount(value: string): number {
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+function formatGitDateArg(value: string): string {
+  const parsed = new Date(value);
+  if (Number.isNaN(parsed.getTime())) {
+    return value;
+  }
+  return `@${Math.floor(parsed.getTime() / 1000)}`;
+}

package/runtime-node/history.ts

@@ -0,0 +1,9 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { parseCodexHistoryJsonlContent, type CodexHistoryParseResult } from "../core/history";
+
+export async function parseCodexHistoryJsonlFile(sourcePath = join(homedir(), ".codex", "history.jsonl")): Promise<CodexHistoryParseResult> {
+  const content = await readFile(sourcePath, "utf8");
+  return parseCodexHistoryJsonlContent(content, sourcePath);
+}

package/runtime-node/ingest-worker.ts

@@ -0,0 +1,32 @@
+import { SuperViewDatabase } from "../storage/database";
+import { parseIngestOptions, runIngestJob } from "./ingest";
+
+const [jobId, encodedOptions] = process.argv.slice(2);
+
+if (!jobId) {
+  throw new Error("Missing ingest job id");
+}
+
+const db = new SuperViewDatabase();
+
+try {
+  if (process.env.SUPERVIEW_TEST_INGEST_WORKER_FAIL === "1") {
+    markFailed(db, jobId, "Forced ingest worker failure");
+    process.exitCode = 1;
+  } else {
+    await runIngestJob(db, jobId, parseIngestOptions(encodedOptions), { workerPid: process.pid });
+  }
+} finally {
+  db.close();
+}
+
+function markFailed(database: SuperViewDatabase, id: string, message: string) {
+  const job = database.getJob(id);
+  if (!job) return;
+  job.status = "failed";
+  job.phase = "failed";
+  job.finishedAt = new Date().toISOString();
+  job.currentFile = null;
+  job.errors.push(message);
+  database.upsertJob(job);
+}