kojee-mcp 0.4.0 → 0.5.2

package/dist/doctor-TSHOMT5X.js

@@ -0,0 +1,237 @@
+import {
+  loadPairedConfig
+} from "./chunk-YH27B6SW.js";
+import {
+  deriveDiscoveryKey,
+  findClaudeAncestorPid
+} from "./chunk-BJMASMKX.js";
+import {
+  buildMonitorSpawn,
+  buildReplyRecipe
+} from "./chunk-C6GZ2L2W.js";
+import {
+  monitorHeartbeatPath,
+  statusLogPath
+} from "./chunk-2TUAFAIW.js";
+import {
+  discoveryPathForKey,
+  readSessionDiscoveryByKey
+} from "./chunk-DO42NPNR.js";
+import "./chunk-BLEGIR35.js";
+
+// src/doctor.ts
+import fs from "fs";
+function defaultIsPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    if (err.code === "EPERM") return true;
+    return false;
+  }
+}
+function defaultStat(path) {
+  try {
+    const s = fs.statSync(path);
+    return { mtimeMs: s.mtimeMs, size: s.size };
+  } catch {
+    return null;
+  }
+}
+var STATUS_TAIL_BYTES = 64 * 1024;
+function defaultReadLastStatusLine(path) {
+  let fd = null;
+  try {
+    const { size } = fs.statSync(path);
+    const start = Math.max(0, size - STATUS_TAIL_BYTES);
+    const len = size - start;
+    if (len === 0) return null;
+    fd = fs.openSync(path, "r");
+    const buf = Buffer.alloc(len);
+    fs.readSync(fd, buf, 0, len, start);
+    const text = buf.toString("utf8");
+    const statusLines = text.split("\n").filter((l) => l.includes("kojee-status"));
+    return statusLines.length > 0 ? statusLines[statusLines.length - 1] : null;
+  } catch {
+    return null;
+  } finally {
+    if (fd !== null) {
+      try {
+        fs.closeSync(fd);
+      } catch {
+      }
+    }
+  }
+}
+async function collectDoctorReport(deps = {}) {
+  const fetchFn = deps.fetchFn ?? fetch;
+  const isPidAlive = deps.isPidAlive ?? defaultIsPidAlive;
+  const statFile = deps.statFile ?? defaultStat;
+  const readLastStatusLine = deps.readLastStatusLine ?? defaultReadLastStatusLine;
+  const readDiscovery = deps.readDiscovery ?? readSessionDiscoveryByKey;
+  const projectDir = deps.projectDir ?? process.env["CLAUDE_PROJECT_DIR"];
+  const ccPid = deps.ccPid !== void 0 ? deps.ccPid : await findClaudeAncestorPid();
+  const discoveryKey = deriveDiscoveryKey(projectDir, ccPid);
+  const discoveryPath = discoveryPathForKey(discoveryKey);
+  const checks = [];
+  const discovery = readDiscovery(discoveryKey);
+  const tokenMode = discovery?.authMode === "token";
+  const paired = deps.pairedConfigPresent !== void 0 ? deps.pairedConfigPresent : loadPairedConfig() !== null;
+  checks.push(
+    tokenMode ? {
+      name: "paired config",
+      ok: true,
+      detail: "n/a (token mode) \u2014 proxy launched with --token; no ~/.kojee/config.json by design"
+    } : {
+      name: "paired config",
+      ok: paired,
+      detail: paired ? "present" : "MISSING \u2014 run `kojee-mcp pair <code> --url <broker>`"
+    }
+  );
+  let logPath = null;
+  if (!discovery) {
+    checks.push({
+      name: "session discovery",
+      ok: false,
+      detail: `no discovery file at ${discoveryPath} (key=${discoveryKey}) \u2014 proxy not running for this session?`
+    });
+  } else {
+    logPath = discovery.eventLogPath ?? null;
+    const proxyPid = discovery.proxyPid ?? discovery.pid;
+    const alive = typeof proxyPid === "number" && isPidAlive(proxyPid);
+    checks.push({
+      name: "proxy process",
+      ok: alive,
+      detail: alive ? `alive (pid=${proxyPid})` : `DEAD (pid=${proxyPid ?? "?"}) \u2014 restart Claude Code`
+    });
+    const base = `http://127.0.0.1:${discovery.port}`;
+    const health = await probeJson(fetchFn, `${base}/health`);
+    checks.push({
+      name: "hook-server /health",
+      ok: health !== null,
+      detail: health !== null ? "ok" : "unreachable"
+    });
+    const statusProbe = await probeJsonWithStatus(fetchFn, `${base}/status`);
+    if (statusProbe.json === null && statusProbe.routeAbsent) {
+      checks.push({
+        name: "hook-server /status",
+        ok: "unknown",
+        detail: "proxy predates /status (old version) \u2014 stream state unknown; restart the session to upgrade"
+      });
+    } else if (statusProbe.json === null) {
+      checks.push({ name: "hook-server /status", ok: false, detail: "unreachable" });
+    } else {
+      const status = statusProbe.json;
+      const s = status;
+      const connected = s.connected === true;
+      const stale = s.stale === true;
+      const hbAge = s.lastHeartbeatAgeMs;
+      const hbStr = hbAge === null || hbAge === void 0 ? "no heartbeat yet" : `last heartbeat ${Math.round(hbAge / 1e3)}s ago`;
+      checks.push({
+        name: "SSE stream",
+        ok: connected && !stale ? true : connected ? "warn" : false,
+        detail: `${s.stream ?? "?"}; ${hbStr}; subscribed=${s.subscribedTandemCount ?? 0}; reconnects=${s.reconnectCount ?? 0}${stale ? " \u2014 STALE" : ""}`
+      });
+    }
+  }
+  if (logPath) {
+    const logStat = statFile(logPath);
+    if (!logStat) {
+      checks.push({ name: "messages log", ok: false, detail: `missing at ${logPath}` });
+    } else {
+      const ageMs = Date.now() - logStat.mtimeMs;
+      checks.push({
+        name: "messages log",
+        ok: true,
+        detail: `${logPath} (${logStat.size} bytes, mtime ${Math.round(ageMs / 1e3)}s ago)` + (logStat.size === 0 ? " \u2014 no Tandem messages yet (normal)" : "")
+      });
+    }
+    const statusPath = statusLogPath(logPath);
+    const statusStat = statFile(statusPath);
+    const lastStatus = readLastStatusLine(statusPath);
+    if (!statusStat) {
+      checks.push({ name: "status stream", ok: "warn", detail: `no status sibling at ${statusPath}` });
+    } else {
+      const sAge = Date.now() - statusStat.mtimeMs;
+      checks.push({
+        name: "status stream",
+        ok: true,
+        detail: `${statusPath} (${statusStat.size} bytes, mtime ${Math.round(sAge / 1e3)}s ago)` + (lastStatus ? `
+      last status: ${lastStatus.trim()}` : " \u2014 no status lines yet")
+      });
+    }
+    const sentinel = monitorHeartbeatPath(logPath);
+    const sentinelStat = statFile(sentinel);
+    const sentinelFresh = sentinelStat !== null && Date.now() - sentinelStat.mtimeMs < 5e3;
+    checks.push({
+      name: "Monitor (tail) heartbeat",
+      ok: sentinelFresh ? true : "warn",
+      detail: sentinelFresh ? "live (a Monitor is reading the log)" : "no fresh sentinel \u2014 spawn the Monitor (recipe below)"
+    });
+  }
+  checks.push({
+    name: "wire contract",
+    ok: "unknown",
+    detail: "fixture-vs-wire drift is NOT unit-testable \u2014 periodically reconcile the SSE wire `kind` enum (spec [tell,ask,ack,status] vs live [message,status,system]) against a live backend; see tests/fixtures/tandem-event.ts NOTE 7."
+  });
+  const recipe = logPath ? { monitorSpawn: buildMonitorSpawn(logPath), reply: buildReplyRecipe() } : null;
+  const verdict = checks.some((c) => c.ok === false) ? "broken" : checks.some((c) => c.ok === "warn") ? "degraded" : "healthy";
+  return { discoveryKey, discoveryPath, logPath, checks, recipe, verdict };
+}
+async function probeJson(fetchFn, url) {
+  try {
+    const res = await fetchFn(url);
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+async function probeJsonWithStatus(fetchFn, url) {
+  try {
+    const res = await fetchFn(url);
+    if (res.ok) return { json: await res.json(), routeAbsent: false };
+    const routeAbsent = res.status === 404 || res.status === 405;
+    return { json: null, routeAbsent };
+  } catch {
+    return { json: null, routeAbsent: false };
+  }
+}
+function formatDoctorReport(report) {
+  const mark = (ok) => ok === true ? "\u2713" : ok === "warn" ? "\u26A0" : ok === "unknown" ? "?" : "\u2717";
+  const lines = [];
+  lines.push(`kojee-mcp doctor \u2014 verdict: ${report.verdict.toUpperCase()}`);
+  lines.push("");
+  lines.push(`  discovery key: ${report.discoveryKey}`);
+  for (const c of report.checks) {
+    lines.push(`  ${mark(c.ok)} ${c.name}: ${c.detail}`);
+  }
+  lines.push("");
+  if (report.recipe) {
+    lines.push("Wake recipe (spawn once at session start):");
+    lines.push(`  ${report.recipe.monitorSpawn}`);
+    lines.push(`Then ${report.recipe.reply}.`);
+  } else {
+    lines.push("No event-log path resolved \u2014 the proxy isn't running for this session.");
+    lines.push("Start Claude Code (which spawns the kojee proxy), then re-run doctor.");
+  }
+  return lines.join("\n");
+}
+async function runDoctor() {
+  const { readRecordedRuntime } = await import("./runtime-record-WO4IECM6.js");
+  if (readRecordedRuntime() === "codex") {
+    const { collectCodexDoctorReport, formatCodexDoctorReport } = await import("./doctor-codex-BMI5JOO6.js");
+    const report2 = collectCodexDoctorReport();
+    console.error(formatCodexDoctorReport(report2));
+    return report2.verdict === "broken" ? 1 : 0;
+  }
+  const report = await collectDoctorReport();
+  console.error(formatDoctorReport(report));
+  return report.verdict === "broken" ? 1 : 0;
+}
+export {
+  collectDoctorReport,
+  defaultReadLastStatusLine,
+  formatDoctorReport,
+  runDoctor
+};

package/dist/doctor-codex-BMI5JOO6.js

@@ -0,0 +1,130 @@
+import {
+  defaultCodexConfigPath,
+  defaultCodexHooksPath
+} from "./chunk-ZW4SW7LJ.js";
+import "./chunk-SQL56SEB.js";
+import {
+  CODEX_LISTEN_CAP_MS
+} from "./chunk-C6GZ2L2W.js";
+import "./chunk-BLEGIR35.js";
+import {
+  resolveWebhookConfig
+} from "./chunk-F7L25L2J.js";
+
+// src/doctor-codex.ts
+import fs from "fs";
+function parseCodexEnvFromToml(toml) {
+  const env = {};
+  let inEnv = false;
+  for (const line of toml.split("\n")) {
+    const header = line.trim();
+    const isTableHeader = /^\[\[?[^\]]+\]\]?$/.test(header);
+    if (isTableHeader) {
+      inEnv = header === "[mcp_servers.kojee.env]";
+      continue;
+    }
+    if (!inEnv) continue;
+    const eq = line.indexOf("=");
+    if (eq <= 0) continue;
+    const key = line.slice(0, eq).trim();
+    if (!/^[A-Za-z0-9_.-]+$/.test(key)) continue;
+    let value = line.slice(eq + 1).trim();
+    const quote = value[0];
+    if ((quote === '"' || quote === "'") && value.endsWith(quote)) {
+      value = value.slice(1, -1);
+      if (quote === '"') value = value.replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+    }
+    env[key] = value;
+  }
+  return env;
+}
+var WIZARD_RERUN = "re-run `kojee-mcp init --runtime codex`";
+function defaultReadFile(path) {
+  return () => {
+    try {
+      return fs.readFileSync(path, "utf8");
+    } catch {
+      return null;
+    }
+  };
+}
+function collectCodexDoctorReport(deps = {}) {
+  const readConfigToml = deps.readConfigToml ?? defaultReadFile(defaultCodexConfigPath());
+  const readHooksJson = deps.readHooksJson ?? defaultReadFile(defaultCodexHooksPath());
+  const checks = [];
+  const toml = readConfigToml() ?? "";
+  const env = deps.env ?? parseCodexEnvFromToml(toml);
+  const hasKojeeTable = toml.includes("[mcp_servers.kojee]");
+  const hasRuntimeEnv = /KOJEE_RUNTIME\s*=\s*"codex"/.test(toml);
+  const configOk = hasKojeeTable && hasRuntimeEnv;
+  checks.push({
+    name: "~/.codex/config.toml [mcp_servers.kojee]",
+    ok: configOk,
+    detail: configOk ? 'present with env.KOJEE_RUNTIME="codex" (Tier-1 contract)' : `MISSING [mcp_servers.kojee] or env.KOJEE_RUNTIME="codex" \u2014 ${WIZARD_RERUN}`
+  });
+  const hooksRaw = readHooksJson() ?? "{}";
+  let hookPresent = false;
+  try {
+    const hooks = JSON.parse(hooksRaw);
+    hookPresent = !!hooks.hooks?.Stop?.some(
+      (e) => e.hooks?.some((h) => (h.command ?? "").includes("hook --type=codex-stop"))
+    );
+  } catch {
+  }
+  if (!hookPresent && /hook --type=codex-stop/.test(toml)) hookPresent = true;
+  checks.push({
+    name: "Codex Stop hook (codex-stop)",
+    ok: hookPresent,
+    detail: hookPresent ? "present (fast PEEK + model-chosen bounded listen)" : `MISSING in ~/.codex/hooks.json / [[hooks.Stop]] \u2014 ${WIZARD_RERUN}`
+  });
+  const resolution = resolveWebhookConfig(env);
+  if (resolution.enabled && resolution.config) {
+    checks.push({
+      name: "webhook sink",
+      ok: true,
+      detail: `enabled \u2014 ${resolution.config.redactedSummary}`
+    });
+  } else if (resolution.error) {
+    checks.push({
+      name: "webhook sink",
+      ok: false,
+      detail: `${resolution.error} \u2014 ${WIZARD_RERUN} (it generates a secret)`
+    });
+  } else {
+    checks.push({
+      name: "webhook sink",
+      ok: false,
+      detail: `not configured (no KOJEE_WEBHOOK_URL) \u2014 ${WIZARD_RERUN}`
+    });
+  }
+  if (deps.pingReceiver) {
+    const reachable = deps.pingReceiver();
+    checks.push({
+      name: "webhook receiver (optional ping)",
+      ok: reachable ? true : "warn",
+      detail: reachable ? "reachable" : "unreachable \u2014 stand up your receiver at KOJEE_WEBHOOK_URL (owner-built; see doctor note)"
+    });
+  }
+  const verdict = checks.some((c) => c.ok === false) ? "broken" : checks.some((c) => c.ok === "warn") ? "degraded" : "healthy";
+  return { checks, verdict };
+}
+function formatCodexDoctorReport(report) {
+  const mark = (ok) => ok === true ? "\u2713" : ok === "warn" ? "\u26A0" : ok === "unknown" ? "?" : "\u2717";
+  const lines = [];
+  lines.push(`kojee-mcp doctor (codex) \u2014 verdict: ${report.verdict.toUpperCase()}`);
+  lines.push("");
+  lines.push("  Wake mode: webhook-sink + stop-hook peek (Codex has no channel injection).");
+  lines.push(`  Bounded-listen cap: ${CODEX_LISTEN_CAP_MS}ms (model picks listen vs drain vs ignore).`);
+  lines.push("");
+  for (const c of report.checks) {
+    lines.push(`  ${mark(c.ok)} ${c.name}: ${c.detail}`);
+  }
+  lines.push("");
+  lines.push("NOTE: live Codex verification (hook fires, MCP connects, bounded listen) is an owner step.");
+  return lines.join("\n");
+}
+export {
+  collectCodexDoctorReport,
+  formatCodexDoctorReport,
+  parseCodexEnvFromToml
+};

package/dist/event-log-RSTM4PLL.js

@@ -0,0 +1,18 @@
+import {
+  STATUS_LINE_PREFIX,
+  monitorHeartbeatPath,
+  nudgeSentinelPath,
+  startEventLog,
+  statusLogPath,
+  sweepStaleEventLogs
+} from "./chunk-2TUAFAIW.js";
+import "./chunk-DO42NPNR.js";
+import "./chunk-BLEGIR35.js";
+export {
+  STATUS_LINE_PREFIX,
+  monitorHeartbeatPath,
+  nudgeSentinelPath,
+  startEventLog,
+  statusLogPath,
+  sweepStaleEventLogs
+};

package/dist/{hook-server-43QS7L7P.js → hook-server-QF5JVUHV.js}

@@ -24,6 +24,9 @@ async function handleRequest(req, res, opts) {
   if (req.method === "GET" && url.pathname === "/health") {
     return json(res, 200, { ok: true });
   }
+  if (req.method === "GET" && url.pathname === "/status") {
+    return respondWithStatus(res, opts);
+  }
   if (req.method === "GET" && url.pathname === "/poll") {
     const type = url.searchParams.get("type") ?? "";
     const timeoutMs = Number.parseInt(url.searchParams.get("timeout_ms") ?? "0", 10);
@@ -42,6 +45,31 @@ function respondWithEvents(res, opts) {
   const events = entries.map((entry) => opts.adapter.formatTandemEvent(entry.event));
   json(res, 200, { events, count: events.length });
 }
+function respondWithStatus(res, opts) {
+  const now = Date.now();
+  if (!opts.getStreamState) {
+    return json(res, 200, { stream: "unknown", now });
+  }
+  const s = opts.getStreamState();
+  const lastEventAgeMs = s.lastEventAt === null ? null : now - s.lastEventAt;
+  const lastHeartbeatAgeMs = s.lastHeartbeatAt === null ? null : now - s.lastHeartbeatAt;
+  const stale = s.connected && s.staleAfterMs !== null && lastEventAgeMs !== null && lastEventAgeMs >= s.staleAfterMs;
+  json(res, 200, {
+    stream: s.connected ? "connected" : "disconnected",
+    connected: s.connected,
+    connectedSince: s.connectedSince,
+    lastEventAt: s.lastEventAt,
+    lastEventAgeMs,
+    lastHeartbeatAt: s.lastHeartbeatAt,
+    lastHeartbeatAgeMs,
+    reconnectCount: s.reconnectCount,
+    subscribedTandemCount: Object.keys(s.cursors).length,
+    cursors: s.cursors,
+    staleAfterMs: s.staleAfterMs,
+    stale,
+    now
+  });
+}
 async function longPollAndRespond(res, opts, timeoutMs) {
   const immediate = opts.queue.takeForHook();
   if (immediate.length > 0) {

package/dist/index.d.ts

@@ -2,6 +2,15 @@ interface ProxyConfig {
     token: string;
     url: string;
     keystorePath: string;
+    /**
+     * How credentials were resolved at launch: "token" when `--token` was passed
+     * on the CLI, "paired" when read from ~/.kojee/config.json. The proxy records
+     * this in its session-discovery file so `kojee-mcp doctor` can render the
+     * pairing check honestly on a token-mode box (no config.json by design).
+     * Defaults to "paired" when unset (back-compat with callers predating the
+     * field).
+     */
+    authMode?: "token" | "paired";
 }
 
 declare function startProxy(config: ProxyConfig): Promise<void>;

package/dist/index.js

@@ -1,7 +1,10 @@
 import {
   startProxy
-} from "./chunk-ZGVUM4AG.js";
-import "./chunk-36DMIXH7.js";
+} from "./chunk-YEC7IHIG.js";
+import "./chunk-BJMASMKX.js";
+import "./chunk-C6GZ2L2W.js";
+import "./chunk-WBMX4CHB.js";
+import "./chunk-BLEGIR35.js";
 export {
   startProxy
 };

package/dist/{install-WV25CRU2.js → install-WBIUVBZW.js}

@@ -1,8 +1,13 @@
+import {
+  secureFile
+} from "./chunk-BLEGIR35.js";
+
 // src/hooks/install.ts
 import fs from "fs";
+import os from "os";
 import path from "path";
 function discoverInstallTargets() {
-  const home = process.env["HOME"] ?? "~";
+  const home = os.homedir();
   const targets = [];
   const cliPath = path.join(home, ".claude.json");
   const cliHooksPath = path.join(home, ".claude", "settings.json");
@@ -28,10 +33,10 @@ var MCP_SERVER_CMD = "npx";
 var MCP_SERVER_ARGS = ["kojee-mcp"];
 var MCP_SERVER_ENV = { KOJEE_RUNTIME: "claude-code" };
 function defaultConfigPath() {
-  return path.join(process.env["HOME"] ?? "~", ".claude.json");
+  return path.join(os.homedir(), ".claude.json");
 }
 function defaultHooksPath() {
-  return path.join(process.env["HOME"] ?? "~", ".claude", "settings.json");
+  return path.join(os.homedir(), ".claude", "settings.json");
 }
 function deriveHooksPath(configPath) {
   return path.join(path.dirname(configPath), ".claude", "settings.json");
@@ -47,10 +52,7 @@ function writeConfig(p, cfg) {
   const dir = path.dirname(p);
   fs.mkdirSync(dir, { recursive: true });
   fs.writeFileSync(p, JSON.stringify(cfg, null, 2), { mode: 384 });
-  try {
-    fs.chmodSync(p, 384);
-  } catch {
-  }
+  secureFile(p);
 }
 function hasKojeeEntry(arr, command) {
   if (!arr) return false;

package/dist/{paired-config-OAR3O3XY.js → paired-config-JTFLHMZ2.js}

@@ -2,7 +2,8 @@ import {
   loadPairedConfig,
   pairedConfigPath,
   savePairedConfig
-} from "./chunk-E7TE4QZD.js";
+} from "./chunk-YH27B6SW.js";
+import "./chunk-BLEGIR35.js";
 export {
   loadPairedConfig,
   pairedConfigPath,

package/dist/resubscribe-SLZNA76S.js

@@ -0,0 +1,59 @@
+// src/tandem/resubscribe.ts
+var DEFAULT_PER_CALL_TIMEOUT_MS = 1e4;
+var DEFAULT_CONCURRENCY = 4;
+var DEFAULT_DEBOUNCE_MS = 3e4;
+async function resubscribeMemberships(opts) {
+  const { gateway, eventLog } = opts;
+  const perCallTimeoutMs = opts.perCallTimeoutMs ?? DEFAULT_PER_CALL_TIMEOUT_MS;
+  const concurrency = Math.max(1, opts.concurrency ?? DEFAULT_CONCURRENCY);
+  const now = opts.now ?? Date.now;
+  const debounceMs = opts.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+  if (opts.debounceState && now() - opts.debounceState.lastRunAt < debounceMs) {
+    return 0;
+  }
+  let tandemIds;
+  try {
+    tandemIds = opts.listTandems ? await opts.listTandems() : opts.tandemIds ?? [];
+  } catch (err) {
+    console.error("[resubscribe] re-list failed:", err.message);
+    tandemIds = [];
+  }
+  let touched = 0;
+  async function touchOne(tandemId) {
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), perCallTimeoutMs);
+    try {
+      const result = await gateway.sendRpc(
+        "tools/call",
+        { name: "tandem_messages", arguments: { tandem_id: tandemId, limit: 1 } },
+        ac.signal
+      );
+      const maybeErr = result;
+      if (!maybeErr.isError) touched += 1;
+    } catch (err) {
+      console.error(
+        `[resubscribe] touch failed for ${tandemId}:`,
+        err.message
+      );
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  let next = 0;
+  async function worker() {
+    while (next < tandemIds.length) {
+      const i = next++;
+      await touchOne(tandemIds[i]);
+    }
+  }
+  await Promise.all(
+    Array.from({ length: Math.min(concurrency, tandemIds.length) }, () => worker())
+  );
+  if (opts.debounceState) opts.debounceState.lastRunAt = now();
+  await eventLog?.appendStatus(`status=subscribed n=${tandemIds.length} touched=${touched}`).catch(() => {
+  });
+  return touched;
+}
+export {
+  resubscribeMemberships
+};

package/dist/runtime-record-WO4IECM6.js

@@ -0,0 +1,14 @@
+import {
+  clearRuntimeRecord,
+  readRecordedRuntime,
+  recordRuntime,
+  runtimeRecordPath
+} from "./chunk-EW72ZNQL.js";
+import "./chunk-SQL56SEB.js";
+import "./chunk-BLEGIR35.js";
+export {
+  clearRuntimeRecord,
+  readRecordedRuntime,
+  recordRuntime,
+  runtimeRecordPath
+};

package/dist/runtimes-CO43XUUK.js

@@ -0,0 +1,12 @@
+import {
+  RUNTIME_MENU,
+  WEBHOOK_RUNTIMES,
+  WIZARD_RUNTIMES,
+  isWizardRuntime
+} from "./chunk-LVL25VLO.js";
+export {
+  RUNTIME_MENU,
+  WEBHOOK_RUNTIMES,
+  WIZARD_RUNTIMES,
+  isWizardRuntime
+};

package/dist/{session-discovery-WSHLR4OV.js → session-discovery-FNMJGFPM.js}

@@ -10,7 +10,8 @@ import {
   sweepStaleDiscovery,
   writeDiscoveryByKey,
   writeSessionDiscovery
-} from "./chunk-VZVGTHGF.js";
+} from "./chunk-DO42NPNR.js";
+import "./chunk-BLEGIR35.js";
 export {
   cleanupDiscoveryByKey,
   cleanupSessionDiscovery,