runtape 0.5.0 → 0.6.0

package/dist/index.js

@@ -40,9 +40,17 @@ var paths = {
 };
 
 // src/lib/config.ts
+var WatchMode = z.enum(["allow_all", "deny_list", "allow_list"]);
+var WatchConfig = z.object({
+  mode: WatchMode.default("allow_all"),
+  paths: z.array(z.string()).default([])
+});
 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()
+  server_url: z.string().url(),
+  // Optional so any existing 0.5.x config keeps parsing — push.ts treats
+  // missing/undefined as allow_all.
+  watch: WatchConfig.optional()
 });
 var DEFAULT_SERVER_URL = process.env.RUNTAPE_API_URL ?? "https://runtape.dev";
 async function readConfig() {
@@ -742,7 +750,34 @@ async function persistSubagentCursor(parentSessionId, agentToolUseId, seen, newl
   await writeFile6(file, trimmed.join("\n") + "\n");
 }
 
+// src/lib/watch.ts
+import { homedir as homedir2 } from "os";
+import { resolve as resolve2 } from "path";
+function isCaptureAllowed(watch, cwd) {
+  if (!watch || watch.mode === "allow_all") return true;
+  if (watch.paths.length === 0) {
+    return watch.mode === "deny_list";
+  }
+  const cwdNorm = normalizePath(cwd);
+  const matched = watch.paths.some((p) => isPrefixMatch(cwdNorm, normalizePath(p)));
+  return watch.mode === "allow_list" ? matched : !matched;
+}
+function isPrefixMatch(cwd, prefix) {
+  return cwd === prefix || cwd.startsWith(prefix + "/");
+}
+function normalizePath(input4) {
+  let expanded = input4;
+  if (expanded === "~") expanded = homedir2();
+  else if (expanded.startsWith("~/")) expanded = `${homedir2()}/${expanded.slice(2)}`;
+  const abs = resolve2(expanded);
+  return abs.replace(/\/+$/, "") || "/";
+}
+
 // src/commands/push.ts
+function isDisabledByEnv() {
+  const v = (process.env.RUNTAPE_DISABLE ?? "").trim().toLowerCase();
+  return v === "1" || v === "true" || v === "yes";
+}
 async function readStdin() {
   if (process.stdin.isTTY) return "";
   const chunks = [];
@@ -761,6 +796,7 @@ function spawnFlusher(cliBinPath) {
 }
 async function pushCommand(opts) {
   try {
+    if (isDisabledByEnv()) return 0;
     const cfg = await readConfig();
     if (!cfg) {
       process.stderr.write("runtape: not logged in \u2014 skipping event\n");
@@ -783,6 +819,10 @@ async function pushCommand(opts) {
       process.stderr.write("runtape: missing session_id on hook payload\n");
       return 0;
     }
+    const cwd = typeof payload.cwd === "string" ? payload.cwd : "";
+    if (cwd && !isCaptureAllowed(cfg.watch, cwd)) {
+      return 0;
+    }
     const sequence = await nextSequence(sessionId);
     const result = mapHookPayload(opts.event, payload, {
       wall_ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -838,13 +878,13 @@ async function pushCommand(opts) {
         try {
           const { emits, seen } = await readNewSubagentEvents(sessionId, agentToolUseId, subTranscript);
           const newlyEmitted = [];
-          const cwd = typeof payload.cwd === "string" ? payload.cwd : "";
+          const cwd2 = typeof payload.cwd === "string" ? payload.cwd : "";
           for (const e of emits) {
             const seq = await nextSequence(sessionId);
             const baseEnvelope = {
               session_id: sessionId,
               transcript_path: subTranscript,
-              cwd,
+              cwd: cwd2,
               hook_event_name: opts.event,
               permission_mode: typeof payload.permission_mode === "string" ? payload.permission_mode : void 0,
               wall_ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -1101,6 +1141,109 @@ Step 3/3 \u2014 Claude Code hooks
   return 0;
 }
 
+// src/commands/watch.ts
+function modeLabel(mode) {
+  if (mode === "allow_all") return "allow_all (capturing every session)";
+  if (mode === "allow_list") return "allow_list (capturing ONLY listed paths)";
+  return "deny_list (capturing every session EXCEPT listed paths)";
+}
+async function readOrExit() {
+  const cfg = await readConfig();
+  if (!cfg) {
+    process.stderr.write("Not logged in. Run `runtape login` first.\n");
+    process.exit(1);
+  }
+  return cfg;
+}
+function ensureWatch(cfg) {
+  return cfg.watch ? { mode: cfg.watch.mode, paths: [...cfg.watch.paths] } : { mode: "allow_all", paths: [] };
+}
+async function watchListCommand() {
+  const cfg = await readOrExit();
+  const w = ensureWatch(cfg);
+  process.stdout.write(`Mode: ${modeLabel(w.mode)}
+`);
+  if (w.paths.length === 0) {
+    process.stdout.write("Paths: (none)\n");
+  } else {
+    process.stdout.write("Paths:\n");
+    for (const p of w.paths) process.stdout.write(`  ${p}
+`);
+  }
+  process.stdout.write("\nEnv override: set RUNTAPE_DISABLE=1 to skip capture for a single session.\n");
+  return 0;
+}
+async function watchIgnoreCommand(path) {
+  const cfg = await readOrExit();
+  const w = ensureWatch(cfg);
+  if (w.mode === "allow_list") {
+    process.stderr.write(
+      "Current mode is allow_list (only listed paths are captured). `ignore` only makes sense in allow_all/deny_list mode.\nRun `runtape watch reset` to start over, or use `runtape watch only <path>` to add to the allow list.\n"
+    );
+    return 1;
+  }
+  const normalized = normalizePath(path);
+  if (w.paths.includes(normalized)) {
+    process.stdout.write(`Already ignored: ${normalized}
+`);
+    return 0;
+  }
+  w.paths.push(normalized);
+  const next = w.mode === "allow_all" ? "deny_list" : w.mode;
+  await writeConfig({ ...cfg, watch: { mode: next, paths: w.paths } });
+  if (next !== w.mode) process.stdout.write(`Mode switched to deny_list.
+`);
+  process.stdout.write(`Ignoring ${normalized}
+`);
+  return 0;
+}
+async function watchOnlyCommand(path) {
+  const cfg = await readOrExit();
+  const w = ensureWatch(cfg);
+  if (w.mode === "deny_list") {
+    process.stderr.write(
+      "Current mode is deny_list (all except listed paths). `only` would conflict.\nRun `runtape watch reset` to start over, then `runtape watch only <path>` to switch to allow_list.\n"
+    );
+    return 1;
+  }
+  const normalized = normalizePath(path);
+  if (w.paths.includes(normalized)) {
+    process.stdout.write(`Already in allow list: ${normalized}
+`);
+    return 0;
+  }
+  w.paths.push(normalized);
+  const next = w.mode === "allow_all" ? "allow_list" : w.mode;
+  await writeConfig({ ...cfg, watch: { mode: next, paths: w.paths } });
+  if (next !== w.mode) process.stdout.write(`Mode switched to allow_list.
+`);
+  process.stdout.write(`Capturing only: ${normalized}
+`);
+  return 0;
+}
+async function watchUnignoreCommand(path) {
+  const cfg = await readOrExit();
+  const w = ensureWatch(cfg);
+  const normalized = normalizePath(path);
+  const filtered = w.paths.filter((p) => p !== normalized);
+  if (filtered.length === w.paths.length) {
+    process.stdout.write(`Not in the list: ${normalized}
+`);
+    return 0;
+  }
+  await writeConfig({ ...cfg, watch: { mode: w.mode, paths: filtered } });
+  process.stdout.write(`Removed: ${normalized}
+`);
+  return 0;
+}
+async function watchResetCommand() {
+  const cfg = await readOrExit();
+  const { watch: _unused, ...rest } = cfg;
+  await writeConfig(rest);
+  process.stdout.write("Reset to allow_all. All sessions will be captured.\n");
+  return 0;
+}
+
 // src/lib/flusher.ts
 import { appendFile as appendFile2, mkdir as mkdir7, readFile as readFile8, unlink as unlink3, writeFile as writeFile7 } from "fs/promises";
 import { dirname as dirname7 } from "path";
@@ -1147,7 +1290,7 @@ async function releasePidLock() {
   }
 }
 function delay(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 async function drainSession(sessionId, serverUrl, apiKey) {
   const snapshot = await readBufferedSession(sessionId);
@@ -1243,6 +1386,12 @@ if (process.argv.includes("--internal-flusher")) {
   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()));
+  const watch = program.command("watch").description("Control which directories the hooks capture (allow / deny lists).");
+  watch.command("list").description("Show the current watch mode and paths.").action(async () => process.exit(await watchListCommand()));
+  watch.command("ignore <path>").description("Stop capturing sessions whose cwd is under <path>. Switches mode to deny_list.").action(async (path) => process.exit(await watchIgnoreCommand(path)));
+  watch.command("only <path>").description("Capture ONLY sessions whose cwd is under <path>. Switches mode to allow_list.").action(async (path) => process.exit(await watchOnlyCommand(path)));
+  watch.command("unignore <path>").description("Remove <path> from the current watch list.").action(async (path) => process.exit(await watchUnignoreCommand(path)));
+  watch.command("reset").description("Capture every session (clear all watch settings).").action(async () => process.exit(await watchResetCommand()));
   program.parseAsync(process.argv).catch((err) => {
     console.error(err);
     process.exit(1);