@jdi-code/claude-code 1.0.3

package/dist/chunk-g8dr8vvj.js

@@ -0,0 +1,111 @@
+// @bun
+import {
+  detectAndGetBackend,
+  ensureBackendsRegistered,
+  getBackendByType,
+  getCachedBackend,
+  getCachedDetectionResult,
+  getInProcessBackend,
+  getResolvedTeammateMode,
+  getTeammateExecutor,
+  init_registry,
+  isInProcessEnabled,
+  markInProcessFallback,
+  registerITermBackend,
+  registerTmuxBackend,
+  resetBackendDetection
+} from "./chunk-5frcqxsv.js";
+import"./chunk-t0rgmccj.js";
+import"./chunk-gb2q3nvc.js";
+import"./chunk-neh2frnn.js";
+import"./chunk-q6b51yc5.js";
+import"./chunk-gfkppe34.js";
+import"./chunk-kqd0e3xj.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-3be7ka25.js";
+import"./chunk-xe6z85xc.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-bhdt6k7w.js";
+import"./chunk-45kxdsp8.js";
+import"./chunk-5dbk24zg.js";
+import"./chunk-pxrffn0w.js";
+import"./chunk-0nt9md2b.js";
+import"./chunk-rn4kqfvd.js";
+import"./chunk-9gbamk79.js";
+import"./chunk-n8sjmqba.js";
+import"./chunk-9e2kqv5g.js";
+import"./chunk-g653q217.js";
+import"./chunk-z72st5c8.js";
+import"./chunk-7m2nd8da.js";
+import"./chunk-ps49ymvj.js";
+import"./chunk-g338npwr.js";
+import"./chunk-zk2wsm7d.js";
+import"./chunk-35x3tjnr.js";
+import"./chunk-m06q12hg.js";
+import"./chunk-40b8p5em.js";
+import"./chunk-s0xfxkys.js";
+import"./chunk-spqaamnc.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-7sb5axvf.js";
+import"./chunk-v9smspw2.js";
+import"./chunk-qz2x630m.js";
+import"./chunk-53nbpp47.js";
+import"./chunk-e3g8q4cn.js";
+import"./chunk-ctw5jwcd.js";
+import"./chunk-fw49pe3p.js";
+import"./chunk-0e1xsncc.js";
+import"./chunk-vratq94g.js";
+import"./chunk-g0j0t6qk.js";
+import"./chunk-6kpbgc5w.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-tjaqa99q.js";
+import"./chunk-55wgxwa9.js";
+import"./chunk-w2z5pqd3.js";
+import"./chunk-7ymfj7m3.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-1rvz0433.js";
+import"./chunk-cdz5yb0r.js";
+import"./chunk-f2mhrmww.js";
+import"./chunk-7z8j9qfn.js";
+import"./chunk-hrzerbfw.js";
+import"./chunk-d18z9pna.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-hjhc4cpt.js";
+import"./chunk-vyc0rjyx.js";
+import"./chunk-hx2tr4ep.js";
+import"./chunk-p7g7pf3f.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-8bedvdm1.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-nxsh6de2.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-3r24h7t6.js";
+import"./chunk-qqfa0dqg.js";
+import"./chunk-hqmz36b3.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import"./chunk-xszk7n10.js";
+import"./chunk-sdj9b9wh.js";
+import"./chunk-qp2qdcda.js";
+init_registry();
+
+export {
+  resetBackendDetection,
+  registerTmuxBackend,
+  registerITermBackend,
+  markInProcessFallback,
+  isInProcessEnabled,
+  getTeammateExecutor,
+  getResolvedTeammateMode,
+  getInProcessBackend,
+  getCachedDetectionResult,
+  getCachedBackend,
+  getBackendByType,
+  ensureBackendsRegistered,
+  detectAndGetBackend
+};

package/dist/chunk-gax0fcbx.js

@@ -0,0 +1,182 @@
+// @bun
+import {
+  init_path
+} from "./chunk-ctw5jwcd.js";
+import {
+  sanitizePath
+} from "./chunk-vratq94g.js";
+import {
+  createBufferedWriter,
+  getFsImplementation,
+  init_bufferedWriter,
+  init_cleanupRegistry,
+  init_debug,
+  init_fsOperations,
+  init_slowOperations,
+  jsonStringify,
+  logForDebugging,
+  registerCleanup
+} from "./chunk-nxsh6de2.js";
+import {
+  getClaudeConfigHomeDir,
+  init_envUtils,
+  isEnvTruthy
+} from "./chunk-3r24h7t6.js";
+import {
+  getOriginalCwd,
+  getSessionId,
+  init_state
+} from "./chunk-qqfa0dqg.js";
+
+// src/utils/asciicast.ts
+init_state();
+init_bufferedWriter();
+init_cleanupRegistry();
+init_debug();
+init_envUtils();
+init_fsOperations();
+init_path();
+init_slowOperations();
+import { appendFile, rename } from "fs/promises";
+import { basename, dirname, join } from "path";
+var recordingState = {
+  filePath: null,
+  timestamp: 0
+};
+function getRecordFilePath() {
+  if (recordingState.filePath !== null) {
+    return recordingState.filePath;
+  }
+  if (process.env.USER_TYPE !== "ant") {
+    return null;
+  }
+  if (!isEnvTruthy(process.env.CLAUDE_CODE_TERMINAL_RECORDING)) {
+    return null;
+  }
+  const projectsDir = join(getClaudeConfigHomeDir(), "projects");
+  const projectDir = join(projectsDir, sanitizePath(getOriginalCwd()));
+  recordingState.timestamp = Date.now();
+  recordingState.filePath = join(projectDir, `${getSessionId()}-${recordingState.timestamp}.cast`);
+  return recordingState.filePath;
+}
+function _resetRecordingStateForTesting() {
+  recordingState.filePath = null;
+  recordingState.timestamp = 0;
+}
+function getSessionRecordingPaths() {
+  const sessionId = getSessionId();
+  const projectsDir = join(getClaudeConfigHomeDir(), "projects");
+  const projectDir = join(projectsDir, sanitizePath(getOriginalCwd()));
+  try {
+    const entries = getFsImplementation().readdirSync(projectDir);
+    const names = typeof entries[0] === "string" ? entries : entries.map((e) => e.name);
+    const files = names.filter((f) => f.startsWith(sessionId) && f.endsWith(".cast")).sort();
+    return files.map((f) => join(projectDir, f));
+  } catch {
+    return [];
+  }
+}
+async function renameRecordingForSession() {
+  const oldPath = recordingState.filePath;
+  if (!oldPath || recordingState.timestamp === 0) {
+    return;
+  }
+  const projectsDir = join(getClaudeConfigHomeDir(), "projects");
+  const projectDir = join(projectsDir, sanitizePath(getOriginalCwd()));
+  const newPath = join(projectDir, `${getSessionId()}-${recordingState.timestamp}.cast`);
+  if (oldPath === newPath) {
+    return;
+  }
+  await recorder?.flush();
+  const oldName = basename(oldPath);
+  const newName = basename(newPath);
+  try {
+    await rename(oldPath, newPath);
+    recordingState.filePath = newPath;
+    logForDebugging(`[asciicast] Renamed recording: ${oldName} \u2192 ${newName}`);
+  } catch {
+    logForDebugging(`[asciicast] Failed to rename recording from ${oldName} to ${newName}`);
+  }
+}
+var recorder = null;
+function getTerminalSize() {
+  const cols = process.stdout.columns || 80;
+  const rows = process.stdout.rows || 24;
+  return { cols, rows };
+}
+async function flushAsciicastRecorder() {
+  await recorder?.flush();
+}
+function installAsciicastRecorder() {
+  const filePath = getRecordFilePath();
+  if (!filePath) {
+    return;
+  }
+  const { cols, rows } = getTerminalSize();
+  const startTime = performance.now();
+  const header = jsonStringify({
+    version: 2,
+    width: cols,
+    height: rows,
+    timestamp: Math.floor(Date.now() / 1000),
+    env: {
+      SHELL: process.env.SHELL || "",
+      TERM: process.env.TERM || ""
+    }
+  });
+  try {
+    getFsImplementation().mkdirSync(dirname(filePath));
+  } catch {}
+  getFsImplementation().appendFileSync(filePath, header + `
+`, { mode: 384 });
+  let pendingWrite = Promise.resolve();
+  const writer = createBufferedWriter({
+    writeFn(content) {
+      const currentPath = recordingState.filePath;
+      if (!currentPath) {
+        return;
+      }
+      pendingWrite = pendingWrite.then(() => appendFile(currentPath, content)).catch(() => {});
+    },
+    flushIntervalMs: 500,
+    maxBufferSize: 50,
+    maxBufferBytes: 10 * 1024 * 1024
+  });
+  const originalWrite = process.stdout.write.bind(process.stdout);
+  process.stdout.write = function(chunk, encodingOrCb, cb) {
+    const elapsed = (performance.now() - startTime) / 1000;
+    const text = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf-8");
+    writer.write(jsonStringify([elapsed, "o", text]) + `
+`);
+    if (typeof encodingOrCb === "function") {
+      return originalWrite(chunk, encodingOrCb);
+    }
+    return originalWrite(chunk, encodingOrCb, cb);
+  };
+  function onResize() {
+    const elapsed = (performance.now() - startTime) / 1000;
+    const { cols: newCols, rows: newRows } = getTerminalSize();
+    writer.write(jsonStringify([elapsed, "r", `${newCols}x${newRows}`]) + `
+`);
+  }
+  process.stdout.on("resize", onResize);
+  recorder = {
+    async flush() {
+      writer.flush();
+      await pendingWrite;
+    },
+    async dispose() {
+      writer.dispose();
+      await pendingWrite;
+      process.stdout.removeListener("resize", onResize);
+      process.stdout.write = originalWrite;
+    }
+  };
+  registerCleanup(async () => {
+    await recorder?.dispose();
+    recorder = null;
+  });
+  logForDebugging(`[asciicast] Recording to ${filePath}`);
+}
+
+export { getRecordFilePath, _resetRecordingStateForTesting, getSessionRecordingPaths, renameRecordingForSession, flushAsciicastRecorder, installAsciicastRecorder };

package/dist/chunk-gb2q3nvc.js

@@ -0,0 +1,224 @@
+// @bun
+import {
+  CCR_SESSION_INGRESS_TOKEN_PATH,
+  init_authFileDescriptor,
+  maybePersistTokenForSubprocesses,
+  readTokenFromWellKnownFile
+} from "./chunk-53nbpp47.js";
+import {
+  init_diagLogs,
+  logForDiagnosticsNoPII
+} from "./chunk-hrzerbfw.js";
+import {
+  errorMessage,
+  getFsImplementation,
+  init_cleanupRegistry,
+  init_debug,
+  init_errors,
+  init_fsOperations,
+  logForDebugging,
+  registerCleanup
+} from "./chunk-nxsh6de2.js";
+import {
+  init_envUtils,
+  isEnvTruthy
+} from "./chunk-3r24h7t6.js";
+import {
+  getSessionIngressToken,
+  init_state,
+  setSessionIngressToken
+} from "./chunk-qqfa0dqg.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/sessionIngressAuth.ts
+function getTokenFromFileDescriptor() {
+  const cachedToken = getSessionIngressToken();
+  if (cachedToken !== undefined) {
+    return cachedToken;
+  }
+  const fdEnv = process.env.CLAUDE_CODE_WEBSOCKET_AUTH_FILE_DESCRIPTOR;
+  if (!fdEnv) {
+    const path = process.env.CLAUDE_SESSION_INGRESS_TOKEN_FILE ?? CCR_SESSION_INGRESS_TOKEN_PATH;
+    const fromFile = readTokenFromWellKnownFile(path, "session ingress token");
+    setSessionIngressToken(fromFile);
+    return fromFile;
+  }
+  const fd = parseInt(fdEnv, 10);
+  if (Number.isNaN(fd)) {
+    logForDebugging(`CLAUDE_CODE_WEBSOCKET_AUTH_FILE_DESCRIPTOR must be a valid file descriptor number, got: ${fdEnv}`, { level: "error" });
+    setSessionIngressToken(null);
+    return null;
+  }
+  try {
+    const fsOps = getFsImplementation();
+    const fdPath = process.platform === "darwin" || process.platform === "freebsd" ? `/dev/fd/${fd}` : `/proc/self/fd/${fd}`;
+    const token = fsOps.readFileSync(fdPath, { encoding: "utf8" }).trim();
+    if (!token) {
+      logForDebugging("File descriptor contained empty token", {
+        level: "error"
+      });
+      setSessionIngressToken(null);
+      return null;
+    }
+    logForDebugging(`Successfully read token from file descriptor ${fd}`);
+    setSessionIngressToken(token);
+    maybePersistTokenForSubprocesses(CCR_SESSION_INGRESS_TOKEN_PATH, token, "session ingress token");
+    return token;
+  } catch (error) {
+    logForDebugging(`Failed to read token from file descriptor ${fd}: ${errorMessage(error)}`, { level: "error" });
+    const path = process.env.CLAUDE_SESSION_INGRESS_TOKEN_FILE ?? CCR_SESSION_INGRESS_TOKEN_PATH;
+    const fromFile = readTokenFromWellKnownFile(path, "session ingress token");
+    setSessionIngressToken(fromFile);
+    return fromFile;
+  }
+}
+function getSessionIngressAuthToken() {
+  const envToken = process.env.CLAUDE_CODE_SESSION_ACCESS_TOKEN;
+  if (envToken) {
+    return envToken;
+  }
+  return getTokenFromFileDescriptor();
+}
+function getSessionIngressAuthHeaders() {
+  const token = getSessionIngressAuthToken();
+  if (!token)
+    return {};
+  if (token.startsWith("sk-ant-sid")) {
+    const headers = {
+      Cookie: `sessionKey=${token}`
+    };
+    const orgUuid = process.env.CLAUDE_CODE_ORGANIZATION_UUID;
+    if (orgUuid) {
+      headers["X-Organization-Uuid"] = orgUuid;
+    }
+    return headers;
+  }
+  return { Authorization: `Bearer ${token}` };
+}
+function updateSessionIngressAuthToken(token) {
+  process.env.CLAUDE_CODE_SESSION_ACCESS_TOKEN = token;
+}
+var init_sessionIngressAuth = __esm(() => {
+  init_state();
+  init_authFileDescriptor();
+  init_debug();
+  init_errors();
+  init_fsOperations();
+});
+
+// src/services/api/emptyUsage.ts
+var EMPTY_USAGE;
+var init_emptyUsage = __esm(() => {
+  EMPTY_USAGE = {
+    input_tokens: 0,
+    cache_creation_input_tokens: 0,
+    cache_read_input_tokens: 0,
+    output_tokens: 0,
+    server_tool_use: { web_search_requests: 0, web_fetch_requests: 0 },
+    service_tier: "standard",
+    cache_creation: {
+      ephemeral_1h_input_tokens: 0,
+      ephemeral_5m_input_tokens: 0
+    },
+    inference_geo: "",
+    iterations: [],
+    speed: "standard"
+  };
+});
+
+// src/utils/sessionActivity.ts
+function startHeartbeatTimer() {
+  clearIdleTimer();
+  heartbeatTimer = setInterval(() => {
+    logForDiagnosticsNoPII("debug", "session_keepalive_heartbeat", {
+      refcount
+    });
+    if (isEnvTruthy(process.env.CLAUDE_CODE_REMOTE_SEND_KEEPALIVES)) {
+      activityCallback?.();
+    }
+  }, SESSION_ACTIVITY_INTERVAL_MS);
+}
+function startIdleTimer() {
+  clearIdleTimer();
+  if (activityCallback === null) {
+    return;
+  }
+  idleTimer = setTimeout(() => {
+    logForDiagnosticsNoPII("info", "session_idle_30s");
+    idleTimer = null;
+  }, SESSION_ACTIVITY_INTERVAL_MS);
+}
+function clearIdleTimer() {
+  if (idleTimer !== null) {
+    clearTimeout(idleTimer);
+    idleTimer = null;
+  }
+}
+function registerSessionActivityCallback(cb) {
+  activityCallback = cb;
+  if (refcount > 0 && heartbeatTimer === null) {
+    startHeartbeatTimer();
+  }
+}
+function unregisterSessionActivityCallback() {
+  activityCallback = null;
+  if (heartbeatTimer !== null) {
+    clearInterval(heartbeatTimer);
+    heartbeatTimer = null;
+  }
+  clearIdleTimer();
+}
+function sendSessionActivitySignal() {
+  if (isEnvTruthy(process.env.CLAUDE_CODE_REMOTE_SEND_KEEPALIVES)) {
+    activityCallback?.();
+  }
+}
+function isSessionActivityTrackingActive() {
+  return activityCallback !== null;
+}
+function startSessionActivity(reason) {
+  refcount++;
+  activeReasons.set(reason, (activeReasons.get(reason) ?? 0) + 1);
+  if (refcount === 1) {
+    oldestActivityStartedAt = Date.now();
+    if (activityCallback !== null && heartbeatTimer === null) {
+      startHeartbeatTimer();
+    }
+  }
+  if (!cleanupRegistered) {
+    cleanupRegistered = true;
+    registerCleanup(async () => {
+      logForDiagnosticsNoPII("info", "session_activity_at_shutdown", {
+        refcount,
+        active: Object.fromEntries(activeReasons),
+        oldest_activity_ms: refcount > 0 && oldestActivityStartedAt !== null ? Date.now() - oldestActivityStartedAt : null
+      });
+    });
+  }
+}
+function stopSessionActivity(reason) {
+  if (refcount > 0) {
+    refcount--;
+  }
+  const n = (activeReasons.get(reason) ?? 0) - 1;
+  if (n > 0)
+    activeReasons.set(reason, n);
+  else
+    activeReasons.delete(reason);
+  if (refcount === 0 && heartbeatTimer !== null) {
+    clearInterval(heartbeatTimer);
+    heartbeatTimer = null;
+    startIdleTimer();
+  }
+}
+var SESSION_ACTIVITY_INTERVAL_MS = 30000, activityCallback = null, refcount = 0, activeReasons, oldestActivityStartedAt = null, heartbeatTimer = null, idleTimer = null, cleanupRegistered = false;
+var init_sessionActivity = __esm(() => {
+  init_cleanupRegistry();
+  init_diagLogs();
+  init_envUtils();
+  activeReasons = new Map;
+});
+
+export { getSessionIngressAuthToken, getSessionIngressAuthHeaders, updateSessionIngressAuthToken, init_sessionIngressAuth, registerSessionActivityCallback, unregisterSessionActivityCallback, sendSessionActivitySignal, isSessionActivityTrackingActive, startSessionActivity, stopSessionActivity, init_sessionActivity, EMPTY_USAGE, init_emptyUsage };