@raindrop-ai/claude-code 0.0.4 → 0.0.5

package/README.md

@@ -20,6 +20,10 @@ This saves your write key and configures Claude Code hooks. Every session will n
 
 - Every prompt turn as a separate event, grouped by session
 - Tool calls with inputs, outputs, and real durations
+- Token usage per turn and per session (input, output, cache read, cache creation)
+- Model name, service tier, and stop reason
+- CLAUDE.md and rules file contents
+- `--append-system-prompt` / `--append-system-prompt-file` content (best-effort)
 - Subagent spawns and completions
 - Permission denials and context compaction
 - Nested trace view (tools under root, subagent tools under subagent)

package/dist/cli.js

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 
 // src/event-mapper.ts
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, readdirSync, unlinkSync, writeFileSync } from "fs";
+import { execSync } from "child_process";
 import { randomUUID as randomUUID2 } from "crypto";
 import { tmpdir } from "os";
 import { join } from "path";
@@ -653,7 +654,7 @@ globalThis.RAINDROP_ASYNC_LOCAL_STORAGE = AsyncLocalStorage;
 
 // src/package-info.ts
 var PACKAGE_NAME = "@raindrop-ai/claude-code";
-var PACKAGE_VERSION = "0.0.4";
+var PACKAGE_VERSION = "0.0.5";
 
 // src/shipper.ts
 var EventShipper2 = class extends EventShipper {
@@ -690,6 +691,138 @@ var TraceShipper2 = class extends TraceShipper {
   }
 };
 
+// src/transcript.ts
+import { existsSync, readFileSync } from "fs";
+function parseTranscript(transcriptPath) {
+  var _a, _b, _c, _d, _e;
+  try {
+    if (!existsSync(transcriptPath)) return void 0;
+    const content = readFileSync(transcriptPath, "utf-8");
+    const lines = content.split("\n").filter((l) => l.trim());
+    const summary = {
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalCacheReadTokens: 0,
+      totalCacheCreationTokens: 0,
+      turnCount: 0,
+      toolsUsed: [],
+      hasThinking: false
+    };
+    const toolNames = /* @__PURE__ */ new Set();
+    let lastUsage;
+    for (const line of lines) {
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch (e) {
+        continue;
+      }
+      if (entry.type === "system" && entry.subtype === "turn_duration") {
+        const durationMs = entry["durationMs"];
+        if (typeof durationMs === "number") {
+          summary.totalDurationMs = ((_a = summary.totalDurationMs) != null ? _a : 0) + durationMs;
+        }
+        const version = entry["version"];
+        if (typeof version === "string") {
+          summary.codeVersion = version;
+        }
+        const branch = entry["gitBranch"];
+        if (typeof branch === "string") {
+          summary.gitBranch = branch;
+        }
+        continue;
+      }
+      if (entry.type !== "assistant") continue;
+      const msg = entry.message;
+      if (!msg) continue;
+      summary.turnCount++;
+      if (msg.model) {
+        summary.model = msg.model;
+      }
+      if (msg.stop_reason) {
+        summary.stopReason = msg.stop_reason;
+      }
+      const entryVersion = entry["version"];
+      if (typeof entryVersion === "string") {
+        summary.codeVersion = entryVersion;
+      }
+      const entryBranch = entry["gitBranch"];
+      if (typeof entryBranch === "string") {
+        summary.gitBranch = entryBranch;
+      }
+      if (msg.usage) {
+        const u = msg.usage;
+        summary.totalInputTokens += (_b = u.input_tokens) != null ? _b : 0;
+        summary.totalOutputTokens += (_c = u.output_tokens) != null ? _c : 0;
+        summary.totalCacheReadTokens += (_d = u.cache_read_input_tokens) != null ? _d : 0;
+        summary.totalCacheCreationTokens += (_e = u.cache_creation_input_tokens) != null ? _e : 0;
+        if (u.service_tier) {
+          summary.serviceTier = u.service_tier;
+        }
+        lastUsage = u;
+      }
+      if (Array.isArray(msg.content)) {
+        for (const block of msg.content) {
+          if (block.type === "tool_use" && block.name) {
+            toolNames.add(block.name);
+          }
+          if (block.type === "thinking") {
+            summary.hasThinking = true;
+          }
+        }
+      }
+    }
+    if (lastUsage) {
+      summary.lastTurnInputTokens = lastUsage.input_tokens;
+      summary.lastTurnOutputTokens = lastUsage.output_tokens;
+      summary.lastTurnCacheReadTokens = lastUsage.cache_read_input_tokens;
+    }
+    summary.toolsUsed = [...toolNames].sort();
+    return summary;
+  } catch (e) {
+    return void 0;
+  }
+}
+function transcriptToProperties(summary) {
+  var _a, _b;
+  const props = {};
+  props["ai.usage.prompt_tokens"] = (_a = summary.lastTurnInputTokens) != null ? _a : summary.totalInputTokens;
+  props["ai.usage.completion_tokens"] = (_b = summary.lastTurnOutputTokens) != null ? _b : summary.totalOutputTokens;
+  if (summary.lastTurnCacheReadTokens !== void 0) {
+    props["ai.usage.cache_read_tokens"] = summary.lastTurnCacheReadTokens;
+  }
+  props["ai.usage.session_total.prompt_tokens"] = summary.totalInputTokens;
+  props["ai.usage.session_total.completion_tokens"] = summary.totalOutputTokens;
+  props["ai.usage.session_total.cache_read_tokens"] = summary.totalCacheReadTokens;
+  props["ai.usage.session_total.cache_creation_tokens"] = summary.totalCacheCreationTokens;
+  if (summary.model) {
+    props["ai.model"] = summary.model;
+  }
+  if (summary.serviceTier) {
+    props["ai.service_tier"] = summary.serviceTier;
+  }
+  if (summary.stopReason) {
+    props["ai.stop_reason"] = summary.stopReason;
+  }
+  if (summary.toolsUsed.length > 0) {
+    props["ai.tools_used"] = summary.toolsUsed.join(", ");
+  }
+  props["ai.turn_count"] = summary.turnCount;
+  if (summary.totalDurationMs !== void 0) {
+    props["ai.duration_ms"] = summary.totalDurationMs;
+  }
+  if (summary.codeVersion) {
+    props["claude_code.version"] = summary.codeVersion;
+  }
+  if (summary.gitBranch) {
+    props["git.branch"] = summary.gitBranch;
+  }
+  if (summary.hasThinking) {
+    props["ai.has_thinking"] = true;
+  }
+  return props;
+}
+
 // src/event-mapper.ts
 var MAX_ATTR_LENGTH = 32768;
 function truncate(value) {
@@ -734,8 +867,8 @@ function writeState(key, value) {
 function readState(key) {
   try {
     const filePath = statePath(key);
-    if (!existsSync(filePath)) return void 0;
-    return readFileSync(filePath, "utf-8");
+    if (!existsSync2(filePath)) return void 0;
+    return readFileSync2(filePath, "utf-8");
   } catch (e) {
     return void 0;
   }
@@ -800,12 +933,15 @@ async function mapHookToRaindrop(payload, config, eventShipper, traceShipper) {
     cwd: payload.cwd,
     permission_mode: payload.permission_mode,
     plugin_version: PACKAGE_VERSION,
+    sdk: PACKAGE_NAME,
+    sdk_version: PACKAGE_VERSION,
     ...payload.agent_id ? { agent_id: payload.agent_id } : {},
     ...payload.agent_type ? { agent_type: payload.agent_type } : {}
   };
   switch (payload.hook_event_name) {
     case "SessionStart":
       writeState(`model_${payload.session_id}`, (_a = payload.model) != null ? _a : "");
+      tryCaptureAppendSystemPrompt(payload.session_id);
       break;
     case "UserPromptSubmit":
       await handleUserPromptSubmit(payload, convoId, config, baseProperties, eventShipper, traceShipper);
@@ -820,10 +956,13 @@ async function mapHookToRaindrop(payload, config, eventShipper, traceShipper) {
       handlePostToolUseFailure(payload, getCurrentEventId(payload.session_id), traceShipper);
       break;
     case "Stop":
-      await handleStop(payload, getCurrentEventId(payload.session_id), config, baseProperties, eventShipper);
+      await handleStopOrFailure(payload, getCurrentEventId(payload.session_id), config, baseProperties, eventShipper, traceShipper);
       break;
     case "StopFailure":
-      await handleStopFailure(payload, getCurrentEventId(payload.session_id), config, baseProperties, eventShipper);
+      await handleStopOrFailure(payload, getCurrentEventId(payload.session_id), config, baseProperties, eventShipper, traceShipper, {
+        error: payload.error,
+        error_details: payload.error_details
+      });
       break;
     case "SubagentStart":
       handleSubagentStart(payload, getCurrentEventId(payload.session_id), traceShipper);
@@ -834,6 +973,9 @@ async function mapHookToRaindrop(payload, config, eventShipper, traceShipper) {
     case "PermissionDenied":
       handlePermissionDenied(payload, getCurrentEventId(payload.session_id), traceShipper);
       break;
+    case "InstructionsLoaded":
+      handleInstructionsLoaded(payload);
+      break;
     case "PostCompact":
       await handlePostCompact(payload, getCurrentEventId(payload.session_id), config, baseProperties, eventShipper);
       break;
@@ -842,6 +984,8 @@ async function mapHookToRaindrop(payload, config, eventShipper, traceShipper) {
       deleteState(turnEventKey(payload.session_id));
       deleteState(rootSpanKey(payload.session_id));
       deleteState(`model_${payload.session_id}`);
+      deleteState(appendSystemPromptKey(payload.session_id));
+      cleanupInstructions(payload.session_id);
       break;
     default:
       if (config.debug) {
@@ -999,25 +1143,243 @@ async function handlePostCompact(payload, eventId, config, properties, eventShip
     }
   });
 }
-async function handleStop(payload, eventId, config, properties, eventShipper) {
-  await eventShipper.patch(eventId, {
-    isPending: false,
-    userId: config.userId,
-    eventName: config.eventName,
-    output: payload.last_assistant_message,
-    properties
-  });
+function handleInstructionsLoaded(payload) {
+  var _a;
+  if (!payload.file_path || !payload.session_id) return;
+  try {
+    if (existsSync2(payload.file_path)) {
+      const content = readFileSync2(payload.file_path, "utf-8");
+      const MAX_INSTRUCTIONS_LENGTH = 8192;
+      const truncated = content.length > MAX_INSTRUCTIONS_LENGTH ? content.slice(0, MAX_INSTRUCTIONS_LENGTH) + "\n...[truncated]" : content;
+      const fileKey = safeKey(payload.file_path);
+      const header = `# ${(_a = payload.memory_type) != null ? _a : "instructions"}: ${payload.file_path}
+`;
+      writeState(
+        `instr_${payload.session_id}_${fileKey}`,
+        header + truncated
+      );
+    }
+  } catch (e) {
+  }
+}
+function gatherInstructions(sessionId) {
+  try {
+    if (!existsSync2(STATE_DIR)) return void 0;
+    const prefix = safeKey(`instr_${sessionId}_`);
+    const files = readdirSync(STATE_DIR).filter((f) => f.startsWith(prefix));
+    if (files.length === 0) return void 0;
+    const parts = [];
+    for (const file of files.sort()) {
+      try {
+        parts.push(readFileSync2(join(STATE_DIR, file), "utf-8"));
+      } catch (e) {
+        continue;
+      }
+    }
+    return parts.length > 0 ? parts.join("\n\n---\n\n") : void 0;
+  } catch (e) {
+    return void 0;
+  }
+}
+function cleanupInstructions(sessionId) {
+  try {
+    if (!existsSync2(STATE_DIR)) return;
+    const prefix = safeKey(`instr_${sessionId}_`);
+    for (const file of readdirSync(STATE_DIR).filter((f) => f.startsWith(prefix))) {
+      try {
+        unlinkSync(join(STATE_DIR, file));
+      } catch (e) {
+      }
+    }
+  } catch (e) {
+  }
+}
+var APPEND_FLAG = "--append-system-prompt";
+var APPEND_FILE_FLAG = "--append-system-prompt-file";
+var MAX_ANCESTOR_DEPTH = 15;
+var PS_TIMEOUT_MS = 3e3;
+function appendSystemPromptKey(sessionId) {
+  return `append_sysprompt_${sessionId}`;
+}
+function tryCaptureAppendSystemPrompt(sessionId) {
+  try {
+    const content = readAncestorAppendSystemPrompt();
+    if (content) {
+      writeState(appendSystemPromptKey(sessionId), content);
+    }
+  } catch (e) {
+  }
 }
-async function handleStopFailure(payload, eventId, config, properties, eventShipper) {
+function readAncestorAppendSystemPrompt() {
+  let pid;
+  try {
+    pid = process.ppid;
+  } catch (e) {
+    return void 0;
+  }
+  if (!pid || pid <= 1) return void 0;
+  for (let depth = 0; depth < MAX_ANCESTOR_DEPTH && pid != null && pid > 1; depth++) {
+    try {
+      const args2 = getProcessArgs(pid);
+      if (args2 && args2.length > 0) {
+        const content = extractAppendSystemPrompt(args2);
+        if (content) return content;
+      }
+    } catch (e) {
+    }
+    try {
+      pid = getParentPid(pid);
+    } catch (e) {
+      break;
+    }
+  }
+  return void 0;
+}
+function getProcessArgs(pid) {
+  if (process.platform === "linux") {
+    try {
+      const raw = readFileSync2(`/proc/${pid}/cmdline`, "utf-8");
+      const args2 = raw.split("\0").filter(Boolean);
+      return args2.length > 0 ? args2 : void 0;
+    } catch (e) {
+    }
+  }
+  try {
+    const output = execSync(`ps -ww -o args= -p ${pid}`, {
+      encoding: "utf-8",
+      timeout: PS_TIMEOUT_MS,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const trimmed = output.trim();
+    if (!trimmed) return void 0;
+    return trimmed.split(/\s+/);
+  } catch (e) {
+    return void 0;
+  }
+}
+function getParentPid(pid) {
+  try {
+    const output = execSync(`ps -o ppid= -p ${pid}`, {
+      encoding: "utf-8",
+      timeout: PS_TIMEOUT_MS,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const ppid = parseInt(output.trim(), 10);
+    return Number.isFinite(ppid) && ppid > 0 ? ppid : void 0;
+  } catch (e) {
+    return void 0;
+  }
+}
+function extractAppendSystemPrompt(args2) {
+  const parts = [];
+  for (let i = 0; i < args2.length; i++) {
+    const arg = args2[i];
+    try {
+      if (arg === APPEND_FILE_FLAG && i + 1 < args2.length) {
+        const filePath = args2[i + 1];
+        i++;
+        try {
+          if (existsSync2(filePath)) {
+            parts.push(readFileSync2(filePath, "utf-8"));
+          }
+        } catch (e) {
+        }
+        continue;
+      }
+      if (arg.startsWith(APPEND_FILE_FLAG + "=")) {
+        const filePath = arg.slice(APPEND_FILE_FLAG.length + 1);
+        try {
+          if (filePath && existsSync2(filePath)) {
+            parts.push(readFileSync2(filePath, "utf-8"));
+          }
+        } catch (e) {
+        }
+        continue;
+      }
+      if (arg === APPEND_FLAG && i + 1 < args2.length) {
+        const valueParts = [];
+        for (let j = i + 1; j < args2.length; j++) {
+          if (args2[j].startsWith("--")) break;
+          valueParts.push(args2[j]);
+          i = j;
+        }
+        if (valueParts.length > 0) {
+          parts.push(valueParts.join(" "));
+        }
+        continue;
+      }
+      if (arg.startsWith(APPEND_FLAG + "=") && !arg.startsWith(APPEND_FILE_FLAG)) {
+        const value = arg.slice(APPEND_FLAG.length + 1);
+        if (value) {
+          parts.push(value);
+        }
+        continue;
+      }
+    } catch (e) {
+      continue;
+    }
+  }
+  return parts.length > 0 ? parts.join("\n") : void 0;
+}
+function readAppendSystemPrompt(sessionId) {
+  try {
+    return readState(appendSystemPromptKey(sessionId)) || void 0;
+  } catch (e) {
+    return void 0;
+  }
+}
+function enrichFromTranscript(payload, eventId, traceShipper) {
+  var _a, _b;
+  if (!payload.transcript_path) {
+    return { summary: void 0, props: {} };
+  }
+  try {
+    const summary = parseTranscript(payload.transcript_path);
+    if (!summary) return { summary: void 0, props: {} };
+    const props = transcriptToProperties(summary);
+    const spanInputTokens = (_a = summary.lastTurnInputTokens) != null ? _a : summary.totalInputTokens;
+    const spanOutputTokens = (_b = summary.lastTurnOutputTokens) != null ? _b : summary.totalOutputTokens;
+    if (summary.model && (spanInputTokens > 0 || spanOutputTokens > 0)) {
+      const parent = getParentContext(payload);
+      const now = nowUnixNanoString();
+      traceShipper.createSpan({
+        name: summary.model,
+        eventId,
+        parent,
+        startTimeUnixNano: now,
+        endTimeUnixNano: now,
+        attributes: [
+          attrString("ai.operationId", "generateText"),
+          attrString("gen_ai.response.model", summary.model),
+          attrString("gen_ai.system", "anthropic"),
+          attrInt("gen_ai.usage.prompt_tokens", spanInputTokens),
+          attrInt("gen_ai.usage.completion_tokens", spanOutputTokens),
+          ...summary.lastTurnCacheReadTokens != null && summary.lastTurnCacheReadTokens > 0 ? [attrInt("gen_ai.usage.cache_read_tokens", summary.lastTurnCacheReadTokens)] : []
+        ]
+      });
+    }
+    return { summary, props };
+  } catch (e) {
+    return { summary: void 0, props: {} };
+  }
+}
+async function handleStopOrFailure(payload, eventId, config, properties, eventShipper, traceShipper, extraProperties) {
+  const { summary, props: transcriptProps } = enrichFromTranscript(payload, eventId, traceShipper);
+  const instructions = gatherInstructions(payload.session_id);
+  const appendSysPrompt = readAppendSystemPrompt(payload.session_id);
   await eventShipper.patch(eventId, {
     isPending: false,
     userId: config.userId,
+    convoId: payload.session_id,
     eventName: config.eventName,
     output: payload.last_assistant_message,
+    ...(summary == null ? void 0 : summary.model) ? { model: summary.model } : {},
     properties: {
       ...properties,
-      error: payload.error,
-      error_details: payload.error_details
+      ...transcriptProps,
+      ...instructions ? { system_instructions: truncate(instructions) } : {},
+      ...appendSysPrompt ? { append_system_prompt: truncate(appendSysPrompt) } : {},
+      ...extraProperties
     }
   });
 }
@@ -1034,7 +1396,7 @@ async function handleSessionEnd(payload, eventId, config, properties, eventShipp
 }
 
 // src/config.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
 import { homedir, userInfo } from "os";
 import { dirname, join as join2 } from "path";
 var CONFIG_PATH = join2(homedir(), ".config", "raindrop", "config.json");
@@ -1042,8 +1404,8 @@ function loadConfig() {
   var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
   let file = {};
   try {
-    if (existsSync2(CONFIG_PATH)) {
-      file = JSON.parse(readFileSync2(CONFIG_PATH, "utf-8"));
+    if (existsSync3(CONFIG_PATH)) {
+      file = JSON.parse(readFileSync3(CONFIG_PATH, "utf-8"));
     }
   } catch (e) {
   }
@@ -1083,8 +1445,8 @@ function updateConfig(patch) {
   mkdirSync2(dir, { recursive: true });
   let existing = {};
   try {
-    if (existsSync2(CONFIG_PATH)) {
-      existing = JSON.parse(readFileSync2(CONFIG_PATH, "utf-8"));
+    if (existsSync3(CONFIG_PATH)) {
+      existing = JSON.parse(readFileSync3(CONFIG_PATH, "utf-8"));
     }
   } catch (e) {
   }
@@ -1092,7 +1454,7 @@ function updateConfig(patch) {
 }
 
 // src/local-debugger.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
 import { join as join3 } from "path";
 var DEFAULT_PORT = 5899;
@@ -1103,8 +1465,8 @@ var CACHE_FILE = join3(CACHE_DIR, "debugger_cache");
 var CACHE_TTL_MS = 5e3;
 function readCache() {
   try {
-    if (!existsSync3(CACHE_FILE)) return void 0;
-    const data = JSON.parse(readFileSync3(CACHE_FILE, "utf-8"));
+    if (!existsSync4(CACHE_FILE)) return void 0;
+    const data = JSON.parse(readFileSync4(CACHE_FILE, "utf-8"));
     if (Date.now() - data.ts > CACHE_TTL_MS) return void 0;
     return data;
   } catch (e) {
@@ -1173,7 +1535,7 @@ function mirrorEventToLocalDebugger(baseUrl, payload, debug) {
 }
 
 // src/hook-handler.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
 import { join as join4 } from "path";
 import { tmpdir as tmpdir3 } from "os";
 var STDIN_TIMEOUT_MS = 5e3;
@@ -1182,8 +1544,8 @@ function getOtlpTraceId(sessionId) {
   try {
     const key = `rootspan_${sessionId}`.replace(/[^a-zA-Z0-9_\-]/g, "_");
     const filePath = join4(STATE_DIR2, key);
-    if (!existsSync4(filePath)) return void 0;
-    const ctx = JSON.parse(readFileSync4(filePath, "utf-8"));
+    if (!existsSync5(filePath)) return void 0;
+    const ctx = JSON.parse(readFileSync5(filePath, "utf-8"));
     if (!ctx.traceIdB64) return void 0;
     return Buffer.from(ctx.traceIdB64, "base64").toString("hex");
   } catch (e) {
@@ -1302,11 +1664,11 @@ async function handleHook() {
 }
 
 // src/setup.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
 import { homedir as homedir2, userInfo as userInfo2 } from "os";
 import { dirname as dirname2, join as join5, resolve } from "path";
 import { createInterface } from "readline";
-import { execSync } from "child_process";
+import { execSync as execSync2 } from "child_process";
 function getClaudeSettingsPath(scope, cwd) {
   if (scope === "project") {
     return resolve(cwd, ".claude", "settings.json");
@@ -1325,8 +1687,9 @@ var CORE_HOOK_EVENTS = [
   "SessionEnd"
 ];
 var VERSIONED_HOOK_EVENTS = [
-  { minVersion: "2.1.78", events: ["StopFailure"] },
   { minVersion: "2.1.76", events: ["PostCompact"] },
+  { minVersion: "2.1.78", events: ["StopFailure"] },
+  { minVersion: "2.1.78", events: ["InstructionsLoaded"] },
   { minVersion: "2.1.89", events: ["PermissionDenied"] }
 ];
 function parseVersion(version) {
@@ -1345,7 +1708,7 @@ function isVersionAtLeast(current, required) {
 }
 function detectClaudeCodeVersion() {
   try {
-    const output = execSync("claude --version", {
+    const output = execSync2("claude --version", {
       encoding: "utf-8",
       timeout: 5e3,
       stdio: ["ignore", "pipe", "ignore"]
@@ -1424,8 +1787,8 @@ async function runSetup(args2) {
     mkdirSync4(configDir, { recursive: true });
     let existingConfig = {};
     try {
-      if (existsSync5(configPath)) {
-        existingConfig = JSON.parse(readFileSync5(configPath, "utf-8"));
+      if (existsSync6(configPath)) {
+        existingConfig = JSON.parse(readFileSync6(configPath, "utf-8"));
       }
     } catch (e) {
     }
@@ -1449,9 +1812,9 @@ async function runSetup(args2) {
   const settingsDir = dirname2(settingsPath);
   mkdirSync4(settingsDir, { recursive: true });
   let settings = {};
-  if (existsSync5(settingsPath)) {
+  if (existsSync6(settingsPath)) {
     try {
-      settings = JSON.parse(readFileSync5(settingsPath, "utf-8"));
+      settings = JSON.parse(readFileSync6(settingsPath, "utf-8"));
     } catch (e) {
       console.warn(`  Warning: could not parse ${settingsPath}, creating fresh`);
       settings = {};
@@ -1481,7 +1844,7 @@ async function runSetup(args2) {
   console.log(`  Updated Claude Code hooks in ${settingsPath} (${scopeLabel})`);
   const whichCmd = process.platform === "win32" ? "where" : "which";
   try {
-    execSync(`${whichCmd} raindrop-claude-code`, { stdio: "ignore" });
+    execSync2(`${whichCmd} raindrop-claude-code`, { stdio: "ignore" });
   } catch (e) {
     console.log(`
   Warning: 'raindrop-claude-code' is not in your PATH.