@jdi-code/claude-code 1.0.3

package/dist/chunk-eb90vwvr.js

@@ -0,0 +1,152 @@
+// @bun
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-f2mhrmww.js";
+import {
+  init_diagLogs,
+  logForDiagnosticsNoPII
+} from "./chunk-hrzerbfw.js";
+import {
+  errorMessage,
+  init_debug,
+  init_errors,
+  init_slowOperations,
+  jsonParse,
+  logForDebugging
+} from "./chunk-nxsh6de2.js";
+
+// src/bridge/jwtUtils.ts
+init_analytics();
+init_debug();
+init_diagLogs();
+init_errors();
+init_slowOperations();
+function formatDuration(ms) {
+  if (ms < 60000)
+    return `${Math.round(ms / 1000)}s`;
+  const m = Math.floor(ms / 60000);
+  const s = Math.round(ms % 60000 / 1000);
+  return s > 0 ? `${m}m ${s}s` : `${m}m`;
+}
+function decodeJwtPayload(token) {
+  const jwt = token.startsWith("sk-ant-si-") ? token.slice("sk-ant-si-".length) : token;
+  const parts = jwt.split(".");
+  if (parts.length !== 3 || !parts[1])
+    return null;
+  try {
+    return jsonParse(Buffer.from(parts[1], "base64url").toString("utf8"));
+  } catch {
+    return null;
+  }
+}
+function decodeJwtExpiry(token) {
+  const payload = decodeJwtPayload(token);
+  if (payload !== null && typeof payload === "object" && "exp" in payload && typeof payload.exp === "number") {
+    return payload.exp;
+  }
+  return null;
+}
+var TOKEN_REFRESH_BUFFER_MS = 5 * 60 * 1000;
+var FALLBACK_REFRESH_INTERVAL_MS = 30 * 60 * 1000;
+var MAX_REFRESH_FAILURES = 3;
+var REFRESH_RETRY_DELAY_MS = 60000;
+function createTokenRefreshScheduler({
+  getAccessToken,
+  onRefresh,
+  label,
+  refreshBufferMs = TOKEN_REFRESH_BUFFER_MS
+}) {
+  const timers = new Map;
+  const failureCounts = new Map;
+  const generations = new Map;
+  function nextGeneration(sessionId) {
+    const gen = (generations.get(sessionId) ?? 0) + 1;
+    generations.set(sessionId, gen);
+    return gen;
+  }
+  function schedule(sessionId, token) {
+    const expiry = decodeJwtExpiry(token);
+    if (!expiry) {
+      logForDebugging(`[${label}:token] Could not decode JWT expiry for sessionId=${sessionId}, token prefix=${token.slice(0, 15)}\u2026, keeping existing timer`);
+      return;
+    }
+    const existing = timers.get(sessionId);
+    if (existing) {
+      clearTimeout(existing);
+    }
+    const gen = nextGeneration(sessionId);
+    const expiryDate = new Date(expiry * 1000).toISOString();
+    const delayMs = expiry * 1000 - Date.now() - refreshBufferMs;
+    if (delayMs <= 0) {
+      logForDebugging(`[${label}:token] Token for sessionId=${sessionId} expires=${expiryDate} (past or within buffer), refreshing immediately`);
+      doRefresh(sessionId, gen);
+      return;
+    }
+    logForDebugging(`[${label}:token] Scheduled token refresh for sessionId=${sessionId} in ${formatDuration(delayMs)} (expires=${expiryDate}, buffer=${refreshBufferMs / 1000}s)`);
+    const timer = setTimeout(doRefresh, delayMs, sessionId, gen);
+    timers.set(sessionId, timer);
+  }
+  function scheduleFromExpiresIn(sessionId, expiresInSeconds) {
+    const existing = timers.get(sessionId);
+    if (existing)
+      clearTimeout(existing);
+    const gen = nextGeneration(sessionId);
+    const delayMs = Math.max(expiresInSeconds * 1000 - refreshBufferMs, 30000);
+    logForDebugging(`[${label}:token] Scheduled token refresh for sessionId=${sessionId} in ${formatDuration(delayMs)} (expires_in=${expiresInSeconds}s, buffer=${refreshBufferMs / 1000}s)`);
+    const timer = setTimeout(doRefresh, delayMs, sessionId, gen);
+    timers.set(sessionId, timer);
+  }
+  async function doRefresh(sessionId, gen) {
+    let oauthToken;
+    try {
+      oauthToken = await getAccessToken();
+    } catch (err) {
+      logForDebugging(`[${label}:token] getAccessToken threw for sessionId=${sessionId}: ${errorMessage(err)}`, { level: "error" });
+    }
+    if (generations.get(sessionId) !== gen) {
+      logForDebugging(`[${label}:token] doRefresh for sessionId=${sessionId} stale (gen ${gen} vs ${generations.get(sessionId)}), skipping`);
+      return;
+    }
+    if (!oauthToken) {
+      const failures = (failureCounts.get(sessionId) ?? 0) + 1;
+      failureCounts.set(sessionId, failures);
+      logForDebugging(`[${label}:token] No OAuth token available for refresh, sessionId=${sessionId} (failure ${failures}/${MAX_REFRESH_FAILURES})`, { level: "error" });
+      logForDiagnosticsNoPII("error", "bridge_token_refresh_no_oauth");
+      if (failures < MAX_REFRESH_FAILURES) {
+        const retryTimer = setTimeout(doRefresh, REFRESH_RETRY_DELAY_MS, sessionId, gen);
+        timers.set(sessionId, retryTimer);
+      }
+      return;
+    }
+    failureCounts.delete(sessionId);
+    logForDebugging(`[${label}:token] Refreshing token for sessionId=${sessionId}: new token prefix=${oauthToken.slice(0, 15)}\u2026`);
+    logEvent("tengu_bridge_token_refreshed", {});
+    onRefresh(sessionId, oauthToken);
+    const timer = setTimeout(doRefresh, FALLBACK_REFRESH_INTERVAL_MS, sessionId, gen);
+    timers.set(sessionId, timer);
+    logForDebugging(`[${label}:token] Scheduled follow-up refresh for sessionId=${sessionId} in ${formatDuration(FALLBACK_REFRESH_INTERVAL_MS)}`);
+  }
+  function cancel(sessionId) {
+    nextGeneration(sessionId);
+    const timer = timers.get(sessionId);
+    if (timer) {
+      clearTimeout(timer);
+      timers.delete(sessionId);
+    }
+    failureCounts.delete(sessionId);
+  }
+  function cancelAll() {
+    for (const sessionId of generations.keys()) {
+      nextGeneration(sessionId);
+    }
+    for (const timer of timers.values()) {
+      clearTimeout(timer);
+    }
+    timers.clear();
+    failureCounts.clear();
+  }
+  return { schedule, scheduleFromExpiresIn, cancel, cancelAll };
+}
+
+export { decodeJwtExpiry, createTokenRefreshScheduler };

package/dist/chunk-edg1yhec.js

@@ -0,0 +1,32 @@
+// @bun
+import {
+  getClaudeAIOAuthTokens,
+  init_auth
+} from "./chunk-53nbpp47.js";
+import {
+  getOauthConfig,
+  init_oauth
+} from "./chunk-7ymfj7m3.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/bridge/bridgeConfig.ts
+function getBridgeTokenOverride() {
+  return process.env.USER_TYPE === "ant" && process.env.CLAUDE_BRIDGE_OAUTH_TOKEN || undefined;
+}
+function getBridgeBaseUrlOverride() {
+  return process.env.USER_TYPE === "ant" && process.env.CLAUDE_BRIDGE_BASE_URL || undefined;
+}
+function getBridgeAccessToken() {
+  return getBridgeTokenOverride() ?? getClaudeAIOAuthTokens()?.accessToken;
+}
+function getBridgeBaseUrl() {
+  return getBridgeBaseUrlOverride() ?? getOauthConfig().BASE_API_URL;
+}
+var init_bridgeConfig = __esm(() => {
+  init_oauth();
+  init_auth();
+});
+
+export { getBridgeTokenOverride, getBridgeBaseUrlOverride, getBridgeAccessToken, getBridgeBaseUrl, init_bridgeConfig };

package/dist/chunk-eh8h36nt.js

@@ -0,0 +1,80 @@
+// @bun
+import {
+  getGlobalConfig,
+  init_config1 as init_config,
+  saveGlobalConfig
+} from "./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-1rvz0433.js";
+import"./chunk-cdz5yb0r.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-f2mhrmww.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 {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/commands/vim/vim.ts
+var call = async () => {
+  const config = getGlobalConfig();
+  let currentMode = config.editorMode || "normal";
+  if (currentMode === "emacs") {
+    currentMode = "normal";
+  }
+  const newMode = currentMode === "normal" ? "vim" : "normal";
+  saveGlobalConfig((current) => ({
+    ...current,
+    editorMode: newMode
+  }));
+  logEvent("tengu_editor_mode_changed", {
+    mode: newMode,
+    source: "command"
+  });
+  return {
+    type: "text",
+    value: `Editor mode set to ${newMode}. ${newMode === "vim" ? "Use Escape key to toggle between INSERT and NORMAL modes." : "Using standard (readline) keyboard bindings."}`
+  };
+};
+var init_vim = __esm(() => {
+  init_analytics();
+  init_config();
+});
+init_vim();
+
+export {
+  call
+};