runtape 0.1.0

package/dist/index.js

@@ -0,0 +1,756 @@
+import {
+  RuntapeEvent
+} from "./chunk-Q4RSBPGN.js";
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/login.ts
+import { createInterface } from "readline/promises";
+import { stdin as input, stdout as output } from "process";
+
+// src/lib/config.ts
+import { chmod, mkdir, readFile, writeFile, unlink } from "fs/promises";
+import { dirname } from "path";
+import { z } from "zod";
+
+// src/lib/paths.ts
+import { homedir } from "os";
+import { join } from "path";
+var RUNTAPE_HOME = process.env.RUNTAPE_HOME ?? join(homedir(), ".runtape");
+var paths = {
+  home: RUNTAPE_HOME,
+  config: join(RUNTAPE_HOME, "config.json"),
+  bufferDir: join(RUNTAPE_HOME, "buffer"),
+  seqDir: join(RUNTAPE_HOME, "seq"),
+  flusherPid: join(RUNTAPE_HOME, "flusher.pid"),
+  flusherLog: join(RUNTAPE_HOME, "flusher.log"),
+  bufferFile: (sessionId) => join(RUNTAPE_HOME, "buffer", `${sessionId}.ndjson`),
+  seqFile: (sessionId) => join(RUNTAPE_HOME, "seq", sessionId),
+  claudeSettings: (scope) => scope === "user" ? join(homedir(), ".claude", "settings.json") : join(process.cwd(), ".claude", "settings.json"),
+  claudeSettingsBackup: (scope) => scope === "user" ? join(homedir(), ".claude", "settings.json.runtape-backup") : join(process.cwd(), ".claude", "settings.json.runtape-backup")
+};
+
+// src/lib/config.ts
+var Config = z.object({
+  api_key: z.string().regex(/^rtk_[a-f0-9]{64}$/, "api_key must be rtk_ followed by 64 hex chars"),
+  server_url: z.string().url()
+});
+var DEFAULT_SERVER_URL = process.env.RUNTAPE_API_URL ?? "https://runtape.dev";
+async function readConfig() {
+  let raw;
+  try {
+    raw = await readFile(paths.config, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+  const parsed = Config.safeParse(JSON.parse(raw));
+  if (!parsed.success) {
+    throw new Error(`Invalid config at ${paths.config}: ${parsed.error.message}`);
+  }
+  return parsed.data;
+}
+async function writeConfig(c) {
+  await mkdir(dirname(paths.config), { recursive: true });
+  await writeFile(paths.config, JSON.stringify(c, null, 2) + "\n", { mode: 384 });
+  await chmod(paths.config, 384);
+}
+async function clearConfig() {
+  try {
+    await unlink(paths.config);
+  } catch (err) {
+    if (err.code === "ENOENT") return;
+    throw err;
+  }
+}
+function defaultServerUrl() {
+  return DEFAULT_SERVER_URL;
+}
+
+// src/lib/api.ts
+function isRetryableStatus(status) {
+  return status === 408 || status === 425 || status === 429 || status >= 500;
+}
+async function postEvents(serverUrl, apiKey, events) {
+  let response;
+  try {
+    response = await fetch(`${serverUrl.replace(/\/$/, "")}/api/v1/events`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({ events })
+    });
+  } catch (err) {
+    return {
+      ok: false,
+      status: 0,
+      error: err instanceof Error ? err.message : String(err),
+      retryable: true
+    };
+  }
+  if (response.ok) {
+    const body = await response.json();
+    return { ok: true, accepted: body.accepted, errors: body.errors };
+  }
+  let detail = "";
+  try {
+    detail = await response.text();
+  } catch {
+  }
+  return {
+    ok: false,
+    status: response.status,
+    error: detail || response.statusText,
+    retryable: isRetryableStatus(response.status)
+  };
+}
+async function pingProject(serverUrl, apiKey) {
+  let response;
+  try {
+    response = await fetch(`${serverUrl.replace(/\/$/, "")}/api/v1/events`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({ events: [] })
+    });
+  } catch (err) {
+    return { ok: false, status: 0, detail: err instanceof Error ? err.message : String(err) };
+  }
+  if (response.status === 400) return { ok: true, status: 400 };
+  if (response.status === 401) return { ok: false, status: 401, detail: "invalid api key" };
+  return { ok: false, status: response.status, detail: response.statusText };
+}
+
+// src/commands/login.ts
+async function loginCommand(opts) {
+  const serverUrl = opts.serverUrl ?? defaultServerUrl();
+  let apiKey = opts.key;
+  if (!apiKey) {
+    const rl = createInterface({ input, output });
+    apiKey = (await rl.question("Paste your Runtape API key (rtk_\u2026): ")).trim();
+    rl.close();
+  }
+  const validation = Config.shape.api_key.safeParse(apiKey);
+  if (!validation.success) {
+    process.stderr.write(`Invalid API key format. Expected rtk_<64 hex chars>.
+`);
+    return 2;
+  }
+  process.stdout.write(`Validating against ${serverUrl}\u2026
+`);
+  const ping = await pingProject(serverUrl, apiKey);
+  if (!ping.ok) {
+    process.stderr.write(`Login failed: ${ping.status === 401 ? "unknown API key" : ping.detail ?? "server unreachable"}
+`);
+    return 1;
+  }
+  await writeConfig({ api_key: apiKey, server_url: serverUrl });
+  process.stdout.write(`Saved. You can now run: runtape install
+`);
+  return 0;
+}
+
+// src/commands/logout.ts
+async function logoutCommand() {
+  await clearConfig();
+  process.stdout.write("Logged out. Config removed.\n");
+  return 0;
+}
+
+// src/commands/install.ts
+import { createInterface as createInterface2 } from "readline/promises";
+import { stdin as input2, stdout as output2 } from "process";
+
+// src/lib/hooks-installer.ts
+import { copyFile, mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2 } from "path";
+
+// src/lib/hook-mapping.ts
+var SUPPORTED_HOOKS = [
+  "SessionStart",
+  "UserPromptSubmit",
+  "PreToolUse",
+  "PostToolUse",
+  "Stop",
+  "SubagentStop"
+];
+function mapHookPayload(hookName, payload, augment) {
+  const base = {
+    session_id: payload.session_id,
+    transcript_path: payload.transcript_path,
+    cwd: payload.cwd,
+    hook_event_name: payload.hook_event_name ?? hookName,
+    permission_mode: payload.permission_mode,
+    wall_ts: augment.wall_ts,
+    sequence: augment.sequence
+  };
+  let candidate;
+  switch (hookName) {
+    case "SessionStart":
+      candidate = { ...base, type: "session_start", source: payload.source ?? "startup" };
+      break;
+    case "UserPromptSubmit":
+      candidate = { ...base, type: "user_prompt", prompt: payload.prompt };
+      break;
+    case "PreToolUse":
+      candidate = {
+        ...base,
+        type: "tool_attempt",
+        tool_name: payload.tool_name,
+        tool_input: payload.tool_input,
+        tool_use_id: payload.tool_use_id
+      };
+      break;
+    case "PostToolUse":
+      candidate = {
+        ...base,
+        type: "tool_call",
+        tool_name: payload.tool_name,
+        tool_input: payload.tool_input,
+        tool_response: payload.tool_response,
+        tool_use_id: payload.tool_use_id,
+        duration_ms: payload.duration_ms
+      };
+      break;
+    case "Stop":
+      candidate = {
+        ...base,
+        type: "session_end",
+        last_assistant_message: payload.last_assistant_message,
+        stop_hook_active: payload.stop_hook_active
+      };
+      break;
+    case "SubagentStop":
+      candidate = {
+        ...base,
+        type: "subagent_end",
+        agent_id: payload.agent_id,
+        agent_type: payload.agent_type,
+        agent_transcript_path: payload.agent_transcript_path,
+        last_assistant_message: payload.last_assistant_message,
+        stop_hook_active: payload.stop_hook_active
+      };
+      break;
+    default:
+      return { kind: "drop", reason: `unsupported hook: ${hookName}` };
+  }
+  const parsed = RuntapeEvent.safeParse(candidate);
+  if (!parsed.success) {
+    return { kind: "drop", reason: `validation failed: ${parsed.error.issues.map((i) => i.path.join(".") + ": " + i.message).join("; ")}` };
+  }
+  return { kind: "event", event: parsed.data };
+}
+
+// src/lib/hooks-installer.ts
+var RUNTAPE_MARKER = "runtape:managed";
+function runtapeEntry(hookName, cliBinPath) {
+  return {
+    type: "command",
+    command: `${cliBinPath} push --event ${hookName}`,
+    [RUNTAPE_MARKER]: true
+  };
+}
+async function readSettings(file) {
+  try {
+    const raw = await readFile2(file, "utf8");
+    return JSON.parse(raw);
+  } catch (err) {
+    if (err.code === "ENOENT") return {};
+    throw err;
+  }
+}
+async function writeSettings(file, data) {
+  await mkdir2(dirname2(file), { recursive: true });
+  await writeFile2(file, JSON.stringify(data, null, 2) + "\n");
+}
+async function installHooks(scope, cliBinPath) {
+  const settingsPath = paths.claudeSettings(scope);
+  const backupPath = paths.claudeSettingsBackup(scope);
+  try {
+    await copyFile(settingsPath, backupPath);
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  const settings = await readSettings(settingsPath);
+  settings.hooks = settings.hooks ?? {};
+  const added = [];
+  for (const hookName of SUPPORTED_HOOKS) {
+    const matchers = settings.hooks[hookName] = settings.hooks[hookName] ?? [];
+    let star = matchers.find((m) => m.matcher === "*");
+    if (!star) {
+      star = { matcher: "*", hooks: [] };
+      matchers.push(star);
+    }
+    star.hooks = star.hooks ?? [];
+    const already = star.hooks.some((h) => h[RUNTAPE_MARKER] === true);
+    if (!already) {
+      star.hooks.push(runtapeEntry(hookName, cliBinPath));
+      added.push(hookName);
+    }
+  }
+  await writeSettings(settingsPath, settings);
+  return { settingsPath, backupPath, addedHooks: added };
+}
+async function uninstallHooks(scope) {
+  const settingsPath = paths.claudeSettings(scope);
+  const settings = await readSettings(settingsPath);
+  const removed = [];
+  if (settings.hooks) {
+    for (const hookName of Object.keys(settings.hooks)) {
+      const matchers = settings.hooks[hookName];
+      for (const matcher of matchers) {
+        if (!Array.isArray(matcher.hooks)) continue;
+        const before = matcher.hooks.length;
+        matcher.hooks = matcher.hooks.filter((h) => h[RUNTAPE_MARKER] !== true);
+        if (matcher.hooks.length < before) removed.push(hookName);
+      }
+      settings.hooks[hookName] = matchers.filter((m) => Array.isArray(m.hooks) && m.hooks.length > 0);
+      if (settings.hooks[hookName].length === 0) delete settings.hooks[hookName];
+    }
+    if (Object.keys(settings.hooks).length === 0) delete settings.hooks;
+  }
+  await writeSettings(settingsPath, settings);
+  return { settingsPath, removedHooks: Array.from(new Set(removed)) };
+}
+
+// src/lib/cli-bin.ts
+import { fileURLToPath } from "url";
+import { dirname as dirname3, resolve, sep } from "path";
+function resolveCliBinPath() {
+  if (process.env.RUNTAPE_CLI_BIN) return process.env.RUNTAPE_CLI_BIN;
+  const argv1 = process.argv[1];
+  if (argv1) {
+    if (argv1.includes(`${sep}node_modules${sep}`)) return "runtape";
+    try {
+      return resolve(argv1);
+    } catch {
+    }
+  }
+  return "runtape";
+}
+
+// src/commands/install.ts
+async function installCommand(opts) {
+  const cfg = await readConfig();
+  if (!cfg) {
+    process.stderr.write("Not logged in. Run `runtape login` first.\n");
+    return 1;
+  }
+  const scope = opts.project ? "project" : "user";
+  const cliBinPath = resolveCliBinPath();
+  if (!opts.yes) {
+    const rl = createInterface2({ input: input2, output: output2 });
+    const answer = (await rl.question(`Install Runtape hooks into ${scope} settings (yes/no)? `)).trim().toLowerCase();
+    rl.close();
+    if (answer !== "y" && answer !== "yes") {
+      process.stdout.write("Aborted.\n");
+      return 0;
+    }
+  }
+  const result = await installHooks(scope, cliBinPath);
+  process.stdout.write(`Updated ${result.settingsPath}
+`);
+  process.stdout.write(`Backup: ${result.backupPath}
+`);
+  if (result.addedHooks.length === 0) {
+    process.stdout.write("Hooks already installed \u2014 nothing changed.\n");
+  } else {
+    process.stdout.write(`Added: ${result.addedHooks.join(", ")}
+`);
+  }
+  return 0;
+}
+
+// src/commands/uninstall.ts
+async function uninstallCommand(opts) {
+  const scope = opts.project ? "project" : "user";
+  const result = await uninstallHooks(scope);
+  if (result.removedHooks.length === 0) {
+    process.stdout.write(`No Runtape hooks found in ${result.settingsPath}.
+`);
+  } else {
+    process.stdout.write(`Removed Runtape entries from: ${result.removedHooks.join(", ")}
+`);
+  }
+  return 0;
+}
+
+// src/commands/push.ts
+import { spawn } from "child_process";
+
+// src/lib/sequence.ts
+import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname4 } from "path";
+async function nextSequence(sessionId) {
+  const file = paths.seqFile(sessionId);
+  await mkdir3(dirname4(file), { recursive: true });
+  let current = 0;
+  try {
+    const raw = await readFile3(file, "utf8");
+    const parsed = Number.parseInt(raw.trim(), 10);
+    if (Number.isFinite(parsed) && parsed >= 0) current = parsed;
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  const next = current + 1;
+  await writeFile3(file, String(next));
+  return next - 1;
+}
+
+// src/lib/buffer.ts
+import { appendFile, mkdir as mkdir4, readFile as readFile4, readdir, writeFile as writeFile4, unlink as unlink2, stat } from "fs/promises";
+async function appendEvent(sessionId, event) {
+  await mkdir4(paths.bufferDir, { recursive: true });
+  const line = JSON.stringify(event) + "\n";
+  await appendFile(paths.bufferFile(sessionId), line, { encoding: "utf8" });
+}
+async function listBufferedSessions() {
+  let entries;
+  try {
+    entries = await readdir(paths.bufferDir);
+  } catch (err) {
+    if (err.code === "ENOENT") return [];
+    throw err;
+  }
+  return entries.filter((e) => e.endsWith(".ndjson")).map((e) => e.slice(0, -".ndjson".length));
+}
+async function readBufferedSession(sessionId) {
+  let raw;
+  try {
+    raw = await readFile4(paths.bufferFile(sessionId), "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+  const lines = raw.split("\n").filter((l) => l.length > 0);
+  const events = [];
+  for (const line of lines) {
+    try {
+      events.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return { sessionId, events, raw: lines };
+}
+async function rewriteBufferedSession(sessionId, unflushedLines) {
+  const file = paths.bufferFile(sessionId);
+  if (unflushedLines.length === 0) {
+    try {
+      await unlink2(file);
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
+    return;
+  }
+  const tmp = file + ".tmp";
+  await writeFile4(tmp, unflushedLines.map((l) => l + "\n").join(""));
+  const { rename } = await import("fs/promises");
+  await rename(tmp, file);
+}
+async function bufferSize(sessionId) {
+  try {
+    const s = await stat(paths.bufferFile(sessionId));
+    return s.size;
+  } catch (err) {
+    if (err.code === "ENOENT") return 0;
+    throw err;
+  }
+}
+async function bufferMtimeMs(sessionId) {
+  try {
+    const s = await stat(paths.bufferFile(sessionId));
+    return s.mtimeMs;
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+}
+
+// src/commands/push.ts
+async function readStdin() {
+  if (process.stdin.isTTY) return "";
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+function spawnFlusher(cliBinPath) {
+  const child = spawn(cliBinPath, ["--internal-flusher"], {
+    detached: true,
+    stdio: "ignore",
+    env: process.env
+  });
+  child.unref();
+}
+async function pushCommand(opts) {
+  try {
+    const cfg = await readConfig();
+    if (!cfg) {
+      process.stderr.write("runtape: not logged in \u2014 skipping event\n");
+      return 0;
+    }
+    const raw = await readStdin();
+    if (!raw.trim()) {
+      return 0;
+    }
+    let payload;
+    try {
+      payload = JSON.parse(raw);
+    } catch (err) {
+      process.stderr.write(`runtape: invalid JSON on stdin: ${err instanceof Error ? err.message : String(err)}
+`);
+      return 0;
+    }
+    const sessionId = typeof payload.session_id === "string" ? payload.session_id : null;
+    if (!sessionId) {
+      process.stderr.write("runtape: missing session_id on hook payload\n");
+      return 0;
+    }
+    const sequence = await nextSequence(sessionId);
+    const result = mapHookPayload(opts.event, payload, {
+      wall_ts: (/* @__PURE__ */ new Date()).toISOString(),
+      sequence
+    });
+    if (result.kind === "drop") {
+      process.stderr.write(`runtape: dropped ${opts.event}: ${result.reason}
+`);
+      return 0;
+    }
+    await appendEvent(sessionId, result.event);
+    spawnFlusher(resolveCliBinPath());
+    return 0;
+  } catch (err) {
+    process.stderr.write(`runtape: push error: ${err instanceof Error ? err.message : String(err)}
+`);
+    return 0;
+  }
+}
+
+// src/commands/status.ts
+import { readFile as readFile5 } from "fs/promises";
+async function readFlusherPid() {
+  try {
+    const raw = await readFile5(paths.flusherPid, "utf8");
+    const n = Number.parseInt(raw.trim(), 10);
+    return Number.isFinite(n) ? n : null;
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+}
+async function statusCommand() {
+  const cfg = await readConfig();
+  if (!cfg) {
+    process.stdout.write("Not logged in. Run `runtape login`.\n");
+    return 0;
+  }
+  process.stdout.write(`Server: ${cfg.server_url}
+`);
+  process.stdout.write(`API key: ${cfg.api_key.slice(0, 8)}\u2026${cfg.api_key.slice(-4)}
+`);
+  const ping = await pingProject(cfg.server_url, cfg.api_key);
+  process.stdout.write(`Reachable: ${ping.ok ? "yes" : `no (${ping.detail ?? ping.status})`}
+`);
+  const sessions = await listBufferedSessions();
+  if (sessions.length === 0) {
+    process.stdout.write("Buffer: empty.\n");
+  } else {
+    process.stdout.write(`Buffer: ${sessions.length} session(s) pending.
+`);
+    for (const s of sessions) {
+      const size = await bufferSize(s);
+      const mtime = await bufferMtimeMs(s);
+      const ageSec = mtime ? Math.round((Date.now() - mtime) / 1e3) : null;
+      process.stdout.write(`  ${s}: ${size} bytes${ageSec !== null ? `, updated ${ageSec}s ago` : ""}
+`);
+    }
+  }
+  const flusherPid = await readFlusherPid();
+  if (flusherPid !== null) {
+    process.stdout.write(`Flusher: PID ${flusherPid}
+`);
+  } else {
+    process.stdout.write("Flusher: not running.\n");
+  }
+  return 0;
+}
+
+// src/commands/runs.ts
+import { spawn as spawn2 } from "child_process";
+import { platform } from "process";
+function openCommand() {
+  if (platform === "darwin") return { cmd: "open", args: [] };
+  if (platform === "win32") return { cmd: "cmd", args: ["/c", "start", ""] };
+  return { cmd: "xdg-open", args: [] };
+}
+async function runsCommand() {
+  const cfg = await readConfig();
+  if (!cfg) {
+    process.stderr.write("Not logged in. Run `runtape login` first.\n");
+    return 1;
+  }
+  const url = `${cfg.server_url.replace(/\/$/, "")}/dashboard/runs`;
+  const { cmd, args } = openCommand();
+  const child = spawn2(cmd, [...args, url], { stdio: "ignore", detached: true });
+  child.on("error", (err) => {
+    process.stderr.write(`Could not launch browser (${err.message}). Open this manually:
+${url}
+`);
+  });
+  child.unref();
+  process.stdout.write(`Opening ${url}
+`);
+  return 0;
+}
+
+// src/lib/flusher.ts
+import { appendFile as appendFile2, mkdir as mkdir5, readFile as readFile6, unlink as unlink3, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname5 } from "path";
+var POLL_INTERVAL_MS = 1500;
+var IDLE_EXIT_MS = 3e4;
+var BATCH_MAX = 100;
+var BACKOFF_STEPS_MS = [1e3, 2e3, 4e3, 8e3, 16e3, 32e3, 6e4];
+async function log(line) {
+  try {
+    await mkdir5(dirname5(paths.flusherLog), { recursive: true });
+    await appendFile2(paths.flusherLog, `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
+`);
+  } catch {
+  }
+}
+async function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    if (err.code === "ESRCH") return false;
+    if (err.code === "EPERM") return true;
+    return false;
+  }
+}
+async function acquirePidLock() {
+  await mkdir5(dirname5(paths.flusherPid), { recursive: true });
+  try {
+    const existing = await readFile6(paths.flusherPid, "utf8");
+    const pid = Number.parseInt(existing.trim(), 10);
+    if (Number.isFinite(pid) && await isProcessAlive(pid)) {
+      return false;
+    }
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  await writeFile5(paths.flusherPid, String(process.pid));
+  return true;
+}
+async function releasePidLock() {
+  try {
+    await unlink3(paths.flusherPid);
+  } catch {
+  }
+}
+function delay(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function drainSession(sessionId, serverUrl, apiKey) {
+  const snapshot = await readBufferedSession(sessionId);
+  if (!snapshot || snapshot.events.length === 0) {
+    await rewriteBufferedSession(sessionId, []);
+    return false;
+  }
+  let cursor = 0;
+  let anyFlushed = false;
+  while (cursor < snapshot.events.length) {
+    const slice = snapshot.events.slice(cursor, cursor + BATCH_MAX);
+    const result = await postEvents(serverUrl, apiKey, slice);
+    if (result.ok) {
+      cursor += slice.length;
+      anyFlushed = true;
+      continue;
+    }
+    if (!result.retryable) {
+      await log(`drop_poison session=${sessionId} status=${result.status} error=${result.error.slice(0, 200)}`);
+      cursor += slice.length;
+      anyFlushed = true;
+      continue;
+    }
+    await log(`retryable session=${sessionId} status=${result.status} cursor=${cursor} error=${result.error.slice(0, 200)}`);
+    break;
+  }
+  const remaining = snapshot.raw.slice(cursor);
+  await rewriteBufferedSession(sessionId, remaining);
+  return anyFlushed;
+}
+async function runFlusher() {
+  const acquired = await acquirePidLock();
+  if (!acquired) {
+    await log("exit_already_running");
+    return;
+  }
+  await log(`start pid=${process.pid}`);
+  let lastActivityMs = Date.now();
+  let backoffIdx = 0;
+  try {
+    while (true) {
+      const cfg = await readConfig();
+      if (!cfg) {
+        await log("exit_no_config");
+        return;
+      }
+      const sessions = await listBufferedSessions();
+      let flushedThisCycle = false;
+      for (const sessionId of sessions) {
+        const flushed = await drainSession(sessionId, cfg.server_url, cfg.api_key);
+        flushedThisCycle = flushedThisCycle || flushed;
+      }
+      if (flushedThisCycle) {
+        lastActivityMs = Date.now();
+        backoffIdx = 0;
+      }
+      const remaining = await listBufferedSessions();
+      const idleMs = Date.now() - lastActivityMs;
+      if (remaining.length === 0 && idleMs >= IDLE_EXIT_MS) {
+        await log(`exit_idle idle_ms=${idleMs}`);
+        return;
+      }
+      const wait = remaining.length > 0 && !flushedThisCycle ? BACKOFF_STEPS_MS[Math.min(backoffIdx++, BACKOFF_STEPS_MS.length - 1)] : POLL_INTERVAL_MS;
+      await delay(wait);
+    }
+  } catch (err) {
+    await log(`crash error=${err instanceof Error ? err.message : String(err)}`);
+    throw err;
+  } finally {
+    await releasePidLock();
+  }
+}
+
+// src/index.ts
+if (process.argv.includes("--internal-flusher")) {
+  void runFlusher().then(
+    () => process.exit(0),
+    (err) => {
+      console.error(err);
+      process.exit(1);
+    }
+  );
+} else {
+  const program = new Command();
+  program.name("runtape").description("Flight recorder for AI coding agents.").version("0.1.2");
+  program.command("login").description("Paste your API key from runtape.dev/dashboard and save it locally.").option("-k, --key <key>", "API key (skip the prompt)").option("-s, --server-url <url>", "Override server URL").action(async (opts) => process.exit(await loginCommand(opts)));
+  program.command("logout").description("Remove saved credentials.").action(async () => process.exit(await logoutCommand()));
+  program.command("install").description("Add Runtape hooks to ~/.claude/settings.json (or project-local with --project).").option("--project", "Install into ./.claude/settings.json instead of user-level").option("-y, --yes", "Skip the confirmation prompt").action(async (opts) => process.exit(await installCommand(opts)));
+  program.command("uninstall").description("Remove Runtape hooks from Claude settings.").option("--project", "Operate on ./.claude/settings.json instead of user-level").action(async (opts) => process.exit(await uninstallCommand(opts)));
+  program.command("push").description("Internal: invoked by Claude Code hooks. Reads stdin and buffers an event.").requiredOption("--event <name>", "Claude hook event name (SessionStart, PostToolUse, \u2026)").action(async (opts) => process.exit(await pushCommand(opts)));
+  program.command("status").description("Show current login, buffer state, and server reachability.").action(async () => process.exit(await statusCommand()));
+  program.command("runs").description("Open your Runtape dashboard in the default browser.").action(async () => process.exit(await runsCommand()));
+  program.parseAsync(process.argv).catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });
+}
+//# sourceMappingURL=index.js.map