runtape 0.2.0 → 0.4.0

package/README.md

@@ -6,7 +6,7 @@
 
 ## Status
 
-v0.1 — MVP. The CLI captures Claude Code sessions via hooks and streams them to a Runtape backend.
+v0.3 — Adds subagent (Task tool) capture. The full internal session of every spawned agent — its user prompt, assistant turns with model + token usage, and tool calls — is now recorded as nested children of the parent `Agent` step.
 
 ## Install
 
@@ -44,11 +44,12 @@ If you prefer the granular commands instead of the wizard, `runtape login` and `
 
 ```
 ~/.runtape/
-  config.json                 # api_key (chmod 600), server_url
-  buffer/<session_id>.ndjson  # pending events
-  seq/<session_id>            # monotonic sequence counter
-  flusher.pid                 # daemon PID
-  flusher.log                 # daemon log (append-only)
+  config.json                  # api_key (chmod 600), server_url
+  buffer/<session_id>.ndjson   # pending events
+  seq/<session_id>             # monotonic sequence counter
+  transcript/<session_id>      # uuids of assistant turns already emitted (v0.2+)
+  flusher.pid                  # daemon PID
+  flusher.log                  # daemon log (append-only)
 ```
 
 Override the home dir with `RUNTAPE_HOME` (useful for tests). Override the server with `RUNTAPE_API_URL` or `runtape login --server-url <url>`.
@@ -63,6 +64,36 @@ import { RuntapeEvent, IngestionRequest } from "runtape/types";
 
 The schemas live in `src/types.ts`. The package's `exports` map points TypeScript at the source file (no build step required for type consumers) and Node at the compiled `dist/types.js`.
 
+## Changelog
+
+### 0.3.0 — 2026-05-15
+
+- **Subagent capture.** On `SubagentStop`, the CLI now reads the subagent's `agent_transcript_path` and synthesizes the full internal event stream — user prompt, assistant turns (with model + usage), tool attempts and calls. Every synthesized event carries `agent_tool_use_id` so the server resolves it as a child of the parent `Agent` step. The dashboard renders these inline as nested rows under the Agent.
+- **`agent_tool_use_id` envelope field.** Optional on every event type. Server-side, when set, it overrides the open-Agent temporal heuristic and resolves the parent step directly.
+
+### 0.2.1 — 2026-05-15
+
+- **Skip `<synthetic>` turns.** Claude Code emits placeholder assistant messages with `model: "<synthetic>"` (compaction markers, internal state) that always have zero usage. The transcript scanner now drops them so the dashboard doesn't show empty no-cost turns.
+
+### 0.2.0 — 2026-05-15
+
+- **Model + token usage per turn.** The CLI now reads the Claude Code transcript JSONL on `PostToolUse` / `Stop` / `SubagentStop` and emits a new `assistant_turn` event for every assistant message, carrying `model`, `input_tokens`, `output_tokens`, `cache_read_tokens`, and `cache_creation_tokens`. The dashboard surfaces a per-turn model + cost pill and a run-level total.
+- **Tool error surfacing.** `tool_call` events now carry `is_error` + `error_message` (derived from the tool response shape — Bash exits, Edit/Write rejections, `is_error` content blocks, interrupts). Errored tools are visible in the run timeline without expanding the step.
+- **State.** Adds `~/.runtape/transcript/<session_id>` to track which assistant message uuids have already been emitted (idempotent scans across hook fires).
+
+To upgrade:
+
+```bash
+npm install -g runtape@latest
+runtape install   # safe to re-run; refreshes the hook entries
+```
+
+No changes to the existing hook commands or config file format.
+
+### 0.1.x
+
+Initial MVP. Hook-based capture of Claude Code sessions (`SessionStart`, `UserPromptSubmit`, `PreToolUse`, `PostToolUse`, `Stop`, `SubagentStop`), buffered to disk and flushed by a detached daemon.
+
 ## Open source
 
 MIT licensed. Audit exactly what's captured. The Runtape backend (dashboard, ingestion API) is closed-source SaaS at [runtape.dev](https://runtape.dev).
@@ -70,7 +101,7 @@ MIT licensed. Audit exactly what's captured. The Runtape backend (dashboard, ing
 ## Repos
 
 - This repo (`runtape`) — the open-source CLI
-- `runtape-mcp` — MCP server for Runtape (coming v0.2)
+- `runtape-mcp` — MCP server for Runtape (planned)
 
 ## License
 

package/dist/{chunk-PMFKNOJA.js → chunk-LGAXYSLN.js}

@@ -9,7 +9,8 @@ var ClaudeHookBase = z.object({
 });
 var CliAugment = z.object({
   wall_ts: z.string().datetime(),
-  sequence: z.number().int().nonnegative()
+  sequence: z.number().int().nonnegative(),
+  agent_tool_use_id: z.string().min(1).optional()
 });
 var SessionStartEvent = ClaudeHookBase.extend(CliAugment.shape).extend({
   type: z.literal("session_start"),
@@ -61,6 +62,10 @@ var SessionEndEvent = ClaudeHookBase.extend(CliAugment.shape).extend({
   last_assistant_message: z.string().optional(),
   stop_hook_active: z.boolean().optional()
 });
+var SessionCloseEvent = ClaudeHookBase.extend(CliAugment.shape).extend({
+  type: z.literal("session_close"),
+  reason: z.string().optional()
+});
 var RuntapeEvent = z.discriminatedUnion("type", [
   SessionStartEvent,
   UserPromptEvent,
@@ -68,7 +73,8 @@ var RuntapeEvent = z.discriminatedUnion("type", [
   ToolCallEvent,
   AssistantTurnEvent,
   SubagentEndEvent,
-  SessionEndEvent
+  SessionEndEvent,
+  SessionCloseEvent
 ]);
 var IngestionRequest = z.object({
   events: z.array(RuntapeEvent).min(1).max(100)
@@ -91,8 +97,9 @@ export {
   AssistantTurnEvent,
   SubagentEndEvent,
   SessionEndEvent,
+  SessionCloseEvent,
   RuntapeEvent,
   IngestionRequest,
   IngestionResponse
 };
-//# sourceMappingURL=chunk-PMFKNOJA.js.map
+//# sourceMappingURL=chunk-LGAXYSLN.js.map

package/dist/chunk-LGAXYSLN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types.ts"],"sourcesContent":["import { z } from 'zod';\n\n// Every Claude Code hook event carries these envelope fields.\nconst ClaudeHookBase = z.object({\n  session_id: z.string().min(1),\n  transcript_path: z.string().min(1),\n  cwd: z.string().min(1),\n  hook_event_name: z.string().min(1),\n  permission_mode: z.string().optional(),\n});\n\n// CLI-augmented envelope adds monotonic ordering + wall-clock timestamp.\n// agent_tool_use_id is set when the CLI is synthesizing events from a\n// subagent transcript — it carries the parent Agent step's tool_use_id so\n// the server can resolve parent_step_id deterministically instead of\n// relying on the temporal open-stack heuristic. Optional so the field is\n// absent for normal top-level events.\nconst CliAugment = z.object({\n  wall_ts: z.string().datetime(),\n  sequence: z.number().int().nonnegative(),\n  agent_tool_use_id: z.string().min(1).optional(),\n});\n\nexport const SessionStartEvent = ClaudeHookBase.extend(CliAugment.shape).extend({\n  type: z.literal('session_start'),\n  source: z.string(),\n});\n\nexport const UserPromptEvent = ClaudeHookBase.extend(CliAugment.shape).extend({\n  type: z.literal('user_prompt'),\n  prompt: z.string(),\n});\n\nexport const ToolAttemptEvent = ClaudeHookBase.extend(CliAugment.shape).extend({\n  type: z.literal('tool_attempt'),\n  tool_name: z.string().min(1),\n  tool_input: z.unknown(),\n  tool_use_id: z.string().min(1),\n});\n\nexport const ToolCallEvent = ClaudeHookBase.extend(CliAugment.shape).extend({\n  type: z.literal('tool_call'),\n  tool_name: z.string().min(1),\n  tool_input: z.unknown(),\n  tool_response: z.unknown(),\n  tool_use_id: z.string().min(1),\n  duration_ms: z.number().nonnegative(),\n  // Set by the CLI when the tool_response signals an error (Bash non-zero\n  // exit, Edit/Write rejection, tool_response.is_error, etc.). Optional so\n  // older CLI versions stay forward-compatible.\n  is_error: z.boolean().optional(),\n  error_message: z.string().optional(),\n});\n\n// Emitted by the CLI on Stop / PostToolUse after scanning the Claude Code\n// transcript JSONL. One event per assistant message we haven't seen yet,\n// keyed by message_uuid so re-deliveries dedupe at the server. Carries the\n// model identifier and token usage for that turn — the only place either\n// datum is available in Claude Code's emit chain.\nexport const AssistantTurnEvent = ClaudeHookBase.extend(CliAugment.shape).extend({\n  type: z.literal('assistant_turn'),\n  message_uuid: z.string().min(1),\n  model: z.string().min(1),\n  input_tokens: z.number().int().nonnegative(),\n  output_tokens: z.number().int().nonnegative(),\n  cache_read_tokens: z.number().int().nonnegative().default(0),\n  cache_creation_tokens: z.number().int().nonnegative().default(0),\n  text: z.string().optional(),\n});\n\nexport const SubagentEndEvent = ClaudeHookBase.extend(CliAugment.shape).extend({\n  type: z.literal('subagent_end'),\n  agent_id: z.string().min(1),\n  agent_type: z.string().min(1),\n  agent_transcript_path: z.string().min(1),\n  last_assistant_message: z.string(),\n  stop_hook_active: z.boolean().optional(),\n});\n\n// Stop hook (fires every turn). Despite the literal name 'session_end', this\n// is \"turn end\" semantically. Kept for backward compatibility with CLI <= 0.3.x.\n// New CLIs still emit this; the server interprets it as \"run is idle\".\nexport const SessionEndEvent = ClaudeHookBase.extend(CliAugment.shape).extend({\n  type: z.literal('session_end'),\n  last_assistant_message: z.string().optional(),\n  stop_hook_active: z.boolean().optional(),\n});\n\n// SessionEnd hook (fires once when Claude Code actually closes the session).\n// Server uses this to promote the run from 'idle' to 'ended'.\nexport const SessionCloseEvent = ClaudeHookBase.extend(CliAugment.shape).extend({\n  type: z.literal('session_close'),\n  reason: z.string().optional(),\n});\n\nexport const RuntapeEvent = z.discriminatedUnion('type', [\n  SessionStartEvent,\n  UserPromptEvent,\n  ToolAttemptEvent,\n  ToolCallEvent,\n  AssistantTurnEvent,\n  SubagentEndEvent,\n  SessionEndEvent,\n  SessionCloseEvent,\n]);\n\nexport type RuntapeEvent = z.infer<typeof RuntapeEvent>;\n\n// POST /v1/events body — a batch of up to 100 events.\nexport const IngestionRequest = z.object({\n  events: z.array(RuntapeEvent).min(1).max(100),\n});\n\nexport type IngestionRequest = z.infer<typeof IngestionRequest>;\n\n// Response shape (server returns 200 on accepted, 400 on Zod failure, 401 on bad auth).\nexport const IngestionResponse = z.object({\n  accepted: z.number().int().nonnegative(),\n  errors: z\n    .array(\n      z.object({\n        index: z.number().int().nonnegative(),\n        reason: z.string(),\n      }),\n    )\n    .default([]),\n});\n\nexport type IngestionResponse = z.infer<typeof IngestionResponse>;\n"],"mappings":"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","names":[]}

package/dist/index.js

@@ -1,11 +1,11 @@
 import {
   RuntapeEvent
-} from "./chunk-PMFKNOJA.js";
+} from "./chunk-LGAXYSLN.js";
 
 // src/index.ts
 import { readFileSync } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname7, join as join2 } from "path";
+import { dirname as dirname8, join as join2 } from "path";
 import { Command } from "commander";
 
 // src/commands/login.ts
@@ -185,7 +185,8 @@ var SUPPORTED_HOOKS = [
   "PreToolUse",
   "PostToolUse",
   "Stop",
-  "SubagentStop"
+  "SubagentStop",
+  "SessionEnd"
 ];
 function inspectToolResponse(tool_response) {
   if (!tool_response || typeof tool_response !== "object") return { is_error: false };
@@ -261,6 +262,13 @@ function mapHookPayload(hookName, payload, augment) {
         stop_hook_active: payload.stop_hook_active
       };
       break;
+    case "SessionEnd":
+      candidate = {
+        ...base,
+        type: "session_close",
+        reason: payload.reason
+      };
+      break;
     case "SubagentStop":
       candidate = {
         ...base,
@@ -549,7 +557,7 @@ async function readNewAssistantTurns(sessionId, transcriptPath) {
     if (uuid === "" || seen.has(uuid)) continue;
     const msg = parsed.message ?? {};
     const model = typeof msg.model === "string" ? msg.model : "";
-    if (model === "") continue;
+    if (model === "" || model === "<synthetic>") continue;
     const usage = msg.usage ?? {};
     turns.push({
       message_uuid: uuid,
@@ -583,6 +591,157 @@ async function persistCursor(sessionId, seen, newlyEmitted) {
   await writeFile5(file, trimmed.join("\n") + "\n");
 }
 
+// src/lib/subagent-transcript.ts
+import { mkdir as mkdir6, readFile as readFile6, writeFile as writeFile6 } from "fs/promises";
+import { dirname as dirname6 } from "path";
+function asInt2(x) {
+  if (typeof x === "number" && Number.isFinite(x) && x >= 0) return Math.trunc(x);
+  return 0;
+}
+function textFromBlocks(content) {
+  if (!Array.isArray(content)) return typeof content === "string" ? content : void 0;
+  const parts = [];
+  for (const block of content) {
+    if (block && typeof block === "object" && "type" in block) {
+      const b = block;
+      if (b.type === "text" && typeof b.text === "string") parts.push(b.text);
+    }
+  }
+  const joined = parts.join("\n").trim();
+  return joined === "" ? void 0 : joined;
+}
+function summarizeToolResult(content) {
+  if (!Array.isArray(content)) {
+    if (typeof content === "string") return { is_error: false };
+    return { is_error: false };
+  }
+  let isError = false;
+  const texts = [];
+  for (const block of content) {
+    if (block && typeof block === "object") {
+      const b = block;
+      if (b.is_error === true) isError = true;
+      if (typeof b.text === "string") texts.push(b.text);
+    }
+  }
+  if (isError && texts.length > 0) return { is_error: true, error_message: texts.join("\n").slice(0, 500) };
+  if (isError) return { is_error: true };
+  return { is_error: false };
+}
+async function readNewSubagentEvents(parentSessionId, agentToolUseId, transcriptPath) {
+  const seen = await readCursor2(parentSessionId, agentToolUseId);
+  let raw;
+  try {
+    raw = await readFile6(transcriptPath, "utf8");
+  } catch {
+    return { emits: [], seen };
+  }
+  const emits = [];
+  const toolNameByUseId = /* @__PURE__ */ new Map();
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    const uuid = typeof parsed.uuid === "string" ? parsed.uuid : "";
+    if (uuid === "" || seen.has(uuid)) continue;
+    const msg = parsed.message ?? {};
+    if (parsed.type === "user") {
+      const content = msg.content;
+      const hasToolResults = Array.isArray(content) && content.some(
+        (b) => b && typeof b === "object" && b.type === "tool_result"
+      );
+      if (hasToolResults) {
+        for (const block of content) {
+          if (!block || typeof block !== "object") continue;
+          const b = block;
+          if (b.type !== "tool_result") continue;
+          const tuid = typeof b.tool_use_id === "string" ? b.tool_use_id : "";
+          if (tuid === "") continue;
+          const { is_error, error_message } = summarizeToolResult(b.content);
+          emits.push({
+            kind: "tool_call",
+            uuid: `${uuid}:${tuid}`,
+            tool_use_id: tuid,
+            tool_name: toolNameByUseId.get(tuid) ?? "unknown",
+            tool_response: b.content,
+            is_error,
+            error_message
+          });
+        }
+      } else {
+        const text = textFromBlocks(content);
+        if (text !== void 0) {
+          emits.push({ kind: "user_prompt", uuid, prompt: text });
+        }
+      }
+      continue;
+    }
+    if (parsed.type === "assistant") {
+      const model = typeof msg.model === "string" ? msg.model : "";
+      if (model === "" || model === "<synthetic>") continue;
+      const usage = msg.usage ?? {};
+      emits.push({
+        kind: "assistant_turn",
+        uuid,
+        message_uuid: uuid,
+        model,
+        input_tokens: asInt2(usage.input_tokens),
+        output_tokens: asInt2(usage.output_tokens),
+        cache_read_tokens: asInt2(usage.cache_read_input_tokens),
+        cache_creation_tokens: asInt2(usage.cache_creation_input_tokens),
+        text: textFromBlocks(msg.content)
+      });
+      if (Array.isArray(msg.content)) {
+        for (const block of msg.content) {
+          if (!block || typeof block !== "object") continue;
+          const b = block;
+          if (b.type !== "tool_use") continue;
+          const tuid = typeof b.id === "string" ? b.id : "";
+          const tname = typeof b.name === "string" ? b.name : "";
+          if (tuid === "" || tname === "") continue;
+          toolNameByUseId.set(tuid, tname);
+          emits.push({
+            kind: "tool_attempt",
+            uuid: `${uuid}:${tuid}`,
+            tool_use_id: tuid,
+            tool_name: tname,
+            tool_input: b.input
+          });
+        }
+      }
+      continue;
+    }
+  }
+  return { emits, seen };
+}
+var CURSOR_KEEP2 = 500;
+async function readCursor2(parentSessionId, agentToolUseId) {
+  try {
+    const raw = await readFile6(cursorFile(parentSessionId, agentToolUseId), "utf8");
+    return new Set(
+      raw.split("\n").map((s) => s.trim()).filter((s) => s !== "")
+    );
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function cursorFile(parentSessionId, agentToolUseId) {
+  return `${paths.transcriptDir}/subagent-${parentSessionId}-${agentToolUseId}`;
+}
+async function persistSubagentCursor(parentSessionId, agentToolUseId, seen, newlyEmitted) {
+  for (const u of newlyEmitted) seen.add(u);
+  const file = cursorFile(parentSessionId, agentToolUseId);
+  await mkdir6(dirname6(file), { recursive: true });
+  const arr = [...seen];
+  const trimmed = arr.length > CURSOR_KEEP2 ? arr.slice(arr.length - CURSOR_KEEP2) : arr;
+  await writeFile6(file, trimmed.join("\n") + "\n");
+}
+
 // src/commands/push.ts
 async function readStdin() {
   if (process.stdin.isTTY) return "";
@@ -668,6 +827,76 @@ async function pushCommand(opts) {
           }
         } catch (err) {
           process.stderr.write(`runtape: transcript scan failed: ${err instanceof Error ? err.message : String(err)}
+`);
+        }
+      }
+    }
+    if (opts.event === "SubagentStop") {
+      const subTranscript = typeof payload.agent_transcript_path === "string" ? payload.agent_transcript_path : "";
+      const agentToolUseId = typeof payload.agent_id === "string" ? payload.agent_id : "";
+      if (subTranscript !== "" && agentToolUseId !== "") {
+        try {
+          const { emits, seen } = await readNewSubagentEvents(sessionId, agentToolUseId, subTranscript);
+          const newlyEmitted = [];
+          const cwd = 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,
+              hook_event_name: opts.event,
+              permission_mode: typeof payload.permission_mode === "string" ? payload.permission_mode : void 0,
+              wall_ts: (/* @__PURE__ */ new Date()).toISOString(),
+              sequence: seq,
+              agent_tool_use_id: agentToolUseId
+            };
+            let ev = null;
+            if (e.kind === "user_prompt") {
+              ev = { ...baseEnvelope, type: "user_prompt", prompt: e.prompt };
+            } else if (e.kind === "assistant_turn") {
+              ev = {
+                ...baseEnvelope,
+                type: "assistant_turn",
+                message_uuid: e.message_uuid,
+                model: e.model,
+                input_tokens: e.input_tokens,
+                output_tokens: e.output_tokens,
+                cache_read_tokens: e.cache_read_tokens,
+                cache_creation_tokens: e.cache_creation_tokens,
+                text: e.text
+              };
+            } else if (e.kind === "tool_attempt") {
+              ev = {
+                ...baseEnvelope,
+                type: "tool_attempt",
+                tool_name: e.tool_name,
+                tool_input: e.tool_input,
+                tool_use_id: e.tool_use_id
+              };
+            } else if (e.kind === "tool_call") {
+              ev = {
+                ...baseEnvelope,
+                type: "tool_call",
+                tool_name: e.tool_name,
+                tool_input: null,
+                tool_response: e.tool_response,
+                tool_use_id: e.tool_use_id,
+                duration_ms: 0,
+                is_error: e.is_error,
+                error_message: e.error_message
+              };
+            }
+            if (ev) {
+              await appendEvent(sessionId, ev);
+              newlyEmitted.push(e.uuid);
+            }
+          }
+          if (newlyEmitted.length > 0) {
+            await persistSubagentCursor(sessionId, agentToolUseId, seen, newlyEmitted);
+          }
+        } catch (err) {
+          process.stderr.write(`runtape: subagent transcript scan failed: ${err instanceof Error ? err.message : String(err)}
 `);
         }
       }
@@ -682,10 +911,10 @@ async function pushCommand(opts) {
 }
 
 // src/commands/status.ts
-import { readFile as readFile6 } from "fs/promises";
+import { readFile as readFile7 } from "fs/promises";
 async function readFlusherPid() {
   try {
-    const raw = await readFile6(paths.flusherPid, "utf8");
+    const raw = await readFile7(paths.flusherPid, "utf8");
     const n = Number.parseInt(raw.trim(), 10);
     return Number.isFinite(n) ? n : null;
   } catch (err) {
@@ -873,15 +1102,15 @@ Step 3/3 \u2014 Claude Code hooks
 }
 
 // src/lib/flusher.ts
-import { appendFile as appendFile2, mkdir as mkdir6, readFile as readFile7, unlink as unlink3, writeFile as writeFile6 } from "fs/promises";
-import { dirname as dirname6 } from "path";
+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";
 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 mkdir6(dirname6(paths.flusherLog), { recursive: true });
+    await mkdir7(dirname7(paths.flusherLog), { recursive: true });
     await appendFile2(paths.flusherLog, `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
 `);
   } catch {
@@ -898,9 +1127,9 @@ async function isProcessAlive(pid) {
   }
 }
 async function acquirePidLock() {
-  await mkdir6(dirname6(paths.flusherPid), { recursive: true });
+  await mkdir7(dirname7(paths.flusherPid), { recursive: true });
   try {
-    const existing = await readFile7(paths.flusherPid, "utf8");
+    const existing = await readFile8(paths.flusherPid, "utf8");
     const pid = Number.parseInt(existing.trim(), 10);
     if (Number.isFinite(pid) && await isProcessAlive(pid)) {
       return false;
@@ -908,7 +1137,7 @@ async function acquirePidLock() {
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
   }
-  await writeFile6(paths.flusherPid, String(process.pid));
+  await writeFile7(paths.flusherPid, String(process.pid));
   return true;
 }
 async function releasePidLock() {
@@ -993,7 +1222,7 @@ async function runFlusher() {
 }
 
 // src/index.ts
-var pkgPath = join2(dirname7(fileURLToPath2(import.meta.url)), "..", "package.json");
+var pkgPath = join2(dirname8(fileURLToPath2(import.meta.url)), "..", "package.json");
 var PKG_VERSION = JSON.parse(readFileSync(pkgPath, "utf8")).version;
 if (process.argv.includes("--internal-flusher")) {
   void runFlusher().then(