@zyycn/claudex 1.0.3-fork.63859d8

package/dist/chunk-png9e5ck.js

@@ -0,0 +1,287 @@
+// @bun
+import {
+  getClaudeAIOAuthTokens,
+  getOrganizationUUID,
+  init_auth,
+  init_client,
+  init_sleep,
+  sleep
+} from "./chunk-kh4zk8k3.js";
+import {
+  init_v4,
+  v4_default
+} from "./chunk-g0j0t6qk.js";
+import {
+  init_lazySchema,
+  lazySchema
+} from "./chunk-55wgxwa9.js";
+import {
+  getOauthConfig,
+  init_oauth
+} from "./chunk-vqvd3qz0.js";
+import {
+  init_detectRepository,
+  parseGitHubRepository
+} from "./chunk-dstxhxsx.js";
+import {
+  init_log,
+  logError
+} from "./chunk-yysj6sxt.js";
+import {
+  errorMessage,
+  init_debug,
+  init_errors,
+  init_slowOperations,
+  jsonStringify,
+  logForDebugging,
+  toError
+} from "./chunk-sbbj6ta3.js";
+import {
+  axios_default,
+  init_axios
+} from "./chunk-xszk7n10.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/teleport/api.ts
+import { randomUUID } from "crypto";
+function isTransientNetworkError(error) {
+  if (!axios_default.isAxiosError(error)) {
+    return false;
+  }
+  if (!error.response) {
+    return true;
+  }
+  if (error.response.status >= 500) {
+    return true;
+  }
+  return false;
+}
+async function axiosGetWithRetry(url, config) {
+  let lastError;
+  for (let attempt = 0;attempt <= MAX_TELEPORT_RETRIES; attempt++) {
+    try {
+      return await axios_default.get(url, config);
+    } catch (error) {
+      lastError = error;
+      if (!isTransientNetworkError(error)) {
+        throw error;
+      }
+      if (attempt >= MAX_TELEPORT_RETRIES) {
+        logForDebugging(`Teleport request failed after ${attempt + 1} attempts: ${errorMessage(error)}`);
+        throw error;
+      }
+      const delay = TELEPORT_RETRY_DELAYS[attempt] ?? 2000;
+      logForDebugging(`Teleport request failed (attempt ${attempt + 1}/${MAX_TELEPORT_RETRIES + 1}), retrying in ${delay}ms: ${errorMessage(error)}`);
+      await sleep(delay);
+    }
+  }
+  throw lastError;
+}
+async function prepareApiRequest() {
+  const accessToken = getClaudeAIOAuthTokens()?.accessToken;
+  if (accessToken === undefined) {
+    throw new Error("Claude Code web sessions require authentication with a Claude.ai account. API key authentication is not sufficient. Please run /login to authenticate, or check your authentication status with /status.");
+  }
+  const orgUUID = await getOrganizationUUID();
+  if (!orgUUID) {
+    throw new Error("Unable to get organization UUID");
+  }
+  return { accessToken, orgUUID };
+}
+async function fetchCodeSessionsFromSessionsAPI() {
+  const { accessToken, orgUUID } = await prepareApiRequest();
+  const url = `${getOauthConfig().BASE_API_URL}/v1/sessions`;
+  try {
+    const headers = {
+      ...getOAuthHeaders(accessToken),
+      "anthropic-beta": "ccr-byoc-2025-07-29",
+      "x-organization-uuid": orgUUID
+    };
+    const response = await axiosGetWithRetry(url, {
+      headers
+    });
+    if (response.status !== 200) {
+      throw new Error(`Failed to fetch code sessions: ${response.statusText}`);
+    }
+    const sessions = response.data.data.map((session) => {
+      const gitSource = session.session_context.sources.find((source) => source.type === "git_repository");
+      let repo = null;
+      if (gitSource?.url) {
+        const repoPath = parseGitHubRepository(gitSource.url);
+        if (repoPath) {
+          const [owner, name] = repoPath.split("/");
+          if (owner && name) {
+            repo = {
+              name,
+              owner: {
+                login: owner
+              },
+              default_branch: gitSource.revision || undefined
+            };
+          }
+        }
+      }
+      return {
+        id: session.id,
+        title: session.title || "Untitled",
+        description: "",
+        status: session.session_status,
+        repo,
+        turns: [],
+        created_at: session.created_at,
+        updated_at: session.updated_at
+      };
+    });
+    return sessions;
+  } catch (error) {
+    const err = toError(error);
+    logError(err);
+    throw error;
+  }
+}
+function getOAuthHeaders(accessToken) {
+  return {
+    Authorization: `Bearer ${accessToken}`,
+    "Content-Type": "application/json",
+    "anthropic-version": "2023-06-01"
+  };
+}
+async function fetchSession(sessionId) {
+  const { accessToken, orgUUID } = await prepareApiRequest();
+  const url = `${getOauthConfig().BASE_API_URL}/v1/sessions/${sessionId}`;
+  const headers = {
+    ...getOAuthHeaders(accessToken),
+    "anthropic-beta": "ccr-byoc-2025-07-29",
+    "x-organization-uuid": orgUUID
+  };
+  const response = await axios_default.get(url, {
+    headers,
+    timeout: 15000,
+    validateStatus: (status) => status < 500
+  });
+  if (response.status !== 200) {
+    const errorData = response.data;
+    const apiMessage = errorData?.error?.message;
+    if (response.status === 404) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    if (response.status === 401) {
+      throw new Error("Session expired. Please run /login to sign in again.");
+    }
+    throw new Error(apiMessage || `Failed to fetch session: ${response.status} ${response.statusText}`);
+  }
+  return response.data;
+}
+function getBranchFromSession(session) {
+  const gitOutcome = session.session_context.outcomes?.find((outcome) => outcome.type === "git_repository");
+  return gitOutcome?.git_info?.branches[0];
+}
+async function sendEventToRemoteSession(sessionId, messageContent, opts) {
+  try {
+    const { accessToken, orgUUID } = await prepareApiRequest();
+    const url = `${getOauthConfig().BASE_API_URL}/v1/sessions/${sessionId}/events`;
+    const headers = {
+      ...getOAuthHeaders(accessToken),
+      "anthropic-beta": "ccr-byoc-2025-07-29",
+      "x-organization-uuid": orgUUID
+    };
+    const userEvent = {
+      uuid: opts?.uuid ?? randomUUID(),
+      session_id: sessionId,
+      type: "user",
+      parent_tool_use_id: null,
+      message: {
+        role: "user",
+        content: messageContent
+      }
+    };
+    const requestBody = {
+      events: [userEvent]
+    };
+    logForDebugging(`[sendEventToRemoteSession] Sending event to session ${sessionId}`);
+    const response = await axios_default.post(url, requestBody, {
+      headers,
+      validateStatus: (status) => status < 500,
+      timeout: 30000
+    });
+    if (response.status === 200 || response.status === 201) {
+      logForDebugging(`[sendEventToRemoteSession] Successfully sent event to session ${sessionId}`);
+      return true;
+    }
+    logForDebugging(`[sendEventToRemoteSession] Failed with status ${response.status}: ${jsonStringify(response.data)}`);
+    return false;
+  } catch (error) {
+    logForDebugging(`[sendEventToRemoteSession] Error: ${errorMessage(error)}`);
+    return false;
+  }
+}
+async function updateSessionTitle(sessionId, title) {
+  try {
+    const { accessToken, orgUUID } = await prepareApiRequest();
+    const url = `${getOauthConfig().BASE_API_URL}/v1/sessions/${sessionId}`;
+    const headers = {
+      ...getOAuthHeaders(accessToken),
+      "anthropic-beta": "ccr-byoc-2025-07-29",
+      "x-organization-uuid": orgUUID
+    };
+    logForDebugging(`[updateSessionTitle] Updating title for session ${sessionId}: "${title}"`);
+    const response = await axios_default.patch(url, { title }, {
+      headers,
+      validateStatus: (status) => status < 500
+    });
+    if (response.status === 200) {
+      logForDebugging(`[updateSessionTitle] Successfully updated title for session ${sessionId}`);
+      return true;
+    }
+    logForDebugging(`[updateSessionTitle] Failed with status ${response.status}: ${jsonStringify(response.data)}`);
+    return false;
+  } catch (error) {
+    logForDebugging(`[updateSessionTitle] Error: ${errorMessage(error)}`);
+    return false;
+  }
+}
+var TELEPORT_RETRY_DELAYS, MAX_TELEPORT_RETRIES, CCR_BYOC_BETA = "ccr-byoc-2025-07-29", CodeSessionSchema;
+var init_api = __esm(() => {
+  init_axios();
+  init_oauth();
+  init_client();
+  init_v4();
+  init_auth();
+  init_debug();
+  init_detectRepository();
+  init_errors();
+  init_lazySchema();
+  init_log();
+  init_sleep();
+  init_slowOperations();
+  TELEPORT_RETRY_DELAYS = [2000, 4000, 8000, 16000];
+  MAX_TELEPORT_RETRIES = TELEPORT_RETRY_DELAYS.length;
+  CodeSessionSchema = lazySchema(() => v4_default.object({
+    id: v4_default.string(),
+    title: v4_default.string(),
+    description: v4_default.string(),
+    status: v4_default.enum([
+      "idle",
+      "working",
+      "waiting",
+      "completed",
+      "archived",
+      "cancelled",
+      "rejected"
+    ]),
+    repo: v4_default.object({
+      name: v4_default.string(),
+      owner: v4_default.object({
+        login: v4_default.string()
+      }),
+      default_branch: v4_default.string().optional()
+    }).nullable(),
+    turns: v4_default.array(v4_default.string()),
+    created_at: v4_default.string(),
+    updated_at: v4_default.string()
+  }));
+});
+
+export { CCR_BYOC_BETA, isTransientNetworkError, axiosGetWithRetry, CodeSessionSchema, prepareApiRequest, fetchCodeSessionsFromSessionsAPI, getOAuthHeaders, fetchSession, getBranchFromSession, sendEventToRemoteSession, updateSessionTitle, init_api };

package/dist/chunk-ps49ymvj.js

@@ -0,0 +1,43 @@
+// @bun
+import {
+  require_semver
+} from "./chunk-0vkfrmqm.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/semver.ts
+function getNpmSemver() {
+  if (!_npmSemver) {
+    _npmSemver = require_semver();
+  }
+  return _npmSemver;
+}
+function gt(a, b) {
+  if (typeof Bun !== "undefined") {
+    return Bun.semver.order(a, b) === 1;
+  }
+  return getNpmSemver().gt(a, b, { loose: true });
+}
+function gte(a, b) {
+  if (typeof Bun !== "undefined") {
+    return Bun.semver.order(a, b) >= 0;
+  }
+  return getNpmSemver().gte(a, b, { loose: true });
+}
+function lt(a, b) {
+  if (typeof Bun !== "undefined") {
+    return Bun.semver.order(a, b) === -1;
+  }
+  return getNpmSemver().lt(a, b, { loose: true });
+}
+function satisfies(version, range) {
+  if (typeof Bun !== "undefined") {
+    return Bun.semver.satisfies(version, range);
+  }
+  return getNpmSemver().satisfies(version, range, { loose: true });
+}
+var _npmSemver;
+var init_semver = () => {};
+
+export { gt, gte, lt, satisfies, init_semver };

package/dist/chunk-pwwa7s62.js

@@ -0,0 +1,11 @@
+// @bun
+import {
+  init_worktreeModeEnabled,
+  isWorktreeModeEnabled
+} from "./chunk-cgfdkzhb.js";
+import"./chunk-qp2qdcda.js";
+init_worktreeModeEnabled();
+
+export {
+  isWorktreeModeEnabled
+};

package/dist/chunk-py5y9jh1.js

@@ -0,0 +1,38 @@
+// @bun
+import {
+  clearRepositoryCaches,
+  detectCurrentRepository,
+  detectCurrentRepositoryWithHost,
+  getCachedRepository,
+  init_detectRepository,
+  parseGitHubRepository,
+  parseGitRemote
+} from "./chunk-dstxhxsx.js";
+import"./chunk-b8x1gk3y.js";
+import"./chunk-9k2drwej.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-fbpftpf0.js";
+import"./chunk-3vs3nm7w.js";
+import"./chunk-gzzfhtdv.js";
+import"./chunk-yysj6sxt.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-8bedvdm1.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-sbbj6ta3.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-raqgs410.js";
+import"./chunk-qqfa0dqg.js";
+import"./chunk-hqmz36b3.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import"./chunk-qp2qdcda.js";
+init_detectRepository();
+
+export {
+  parseGitRemote,
+  parseGitHubRepository,
+  getCachedRepository,
+  detectCurrentRepositoryWithHost,
+  detectCurrentRepository,
+  clearRepositoryCaches
+};

package/dist/chunk-q25bjaev.js

@@ -0,0 +1,15 @@
+// @bun
+import {
+  fromProcess,
+  init_dist_es
+} from "./chunk-27xc1csx.js";
+import"./chunk-n0qaeaa5.js";
+import"./chunk-b4wg70y1.js";
+import"./chunk-hk9xz7gk.js";
+import"./chunk-xsq9ae7x.js";
+import"./chunk-qp2qdcda.js";
+init_dist_es();
+
+export {
+  fromProcess
+};

package/dist/chunk-q3y7hz85.js

@@ -0,0 +1,263 @@
+// @bun
+import {
+  MAX_TRANSCRIPT_READ_BYTES,
+  adoptResumedSessionFile,
+  buildConversationChain,
+  cacheSessionTitle,
+  checkResumeConsistency,
+  cleanMessagesForLogging,
+  clearAgentTranscriptSubdir,
+  clearSessionMessagesCache,
+  clearSessionMetadata,
+  deleteRemoteAgentMetadata,
+  doesMessageExistInSession,
+  enrichLogs,
+  extractAgentIdsFromMessages,
+  extractTeammateTranscriptsFromTasks,
+  fetchLogs,
+  findUnresolvedToolUse,
+  flushSessionStorage,
+  getAgentTranscript,
+  getAgentTranscriptPath,
+  getCurrentSessionAgentColor,
+  getCurrentSessionTag,
+  getCurrentSessionTitle,
+  getFirstMeaningfulUserMessageTextContent,
+  getLastSessionLog,
+  getLogByIndex,
+  getNodeEnv,
+  getProjectDir,
+  getProjectsDir,
+  getSessionFilesLite,
+  getSessionFilesWithMtime,
+  getSessionIdFromLog,
+  getTranscriptPath,
+  getTranscriptPathForSession,
+  getUserType,
+  hydrateFromCCRv2InternalEvents,
+  hydrateRemoteSession,
+  init_sessionStorage,
+  isChainParticipant,
+  isCustomTitleEnabled,
+  isEphemeralToolProgress,
+  isLiteLog,
+  isLoggableMessage,
+  isTranscriptMessage,
+  linkSessionToPR,
+  listRemoteAgentMetadata,
+  loadAllLogsFromSessionFile,
+  loadAllProjectsMessageLogs,
+  loadAllProjectsMessageLogsProgressive,
+  loadAllSubagentTranscriptsFromDisk,
+  loadFullLog,
+  loadMessageLogs,
+  loadSameRepoMessageLogs,
+  loadSameRepoMessageLogsProgressive,
+  loadSubagentTranscripts,
+  loadTranscriptFile,
+  loadTranscriptFromFile,
+  reAppendSessionMetadata,
+  readAgentMetadata,
+  readRemoteAgentMetadata,
+  recordAttributionSnapshot,
+  recordContentReplacement,
+  recordContextCollapseCommit,
+  recordContextCollapseSnapshot,
+  recordFileHistorySnapshot,
+  recordQueueOperation,
+  recordSidechainTranscript,
+  recordTranscript,
+  removeExtraFields,
+  removeTranscriptMessage,
+  resetProjectFlushStateForTesting,
+  resetProjectForTesting,
+  resetSessionFilePointer,
+  restoreSessionMetadata,
+  saveAgentColor,
+  saveAgentName,
+  saveAgentSetting,
+  saveAiGeneratedTitle,
+  saveCustomTitle,
+  saveMode,
+  saveTag,
+  saveTaskSummary,
+  saveWorktreeState,
+  searchSessionsByCustomTitle,
+  sessionIdExists,
+  setAgentTranscriptSubdir,
+  setInternalEventReader,
+  setInternalEventWriter,
+  setRemoteIngressUrlForTesting,
+  setSessionFileForTesting,
+  writeAgentMetadata,
+  writeRemoteAgentMetadata
+} from "./chunk-2ssrm349.js";
+import"./chunk-0hgm34fp.js";
+import"./chunk-t0rgmccj.js";
+import"./chunk-bftwqs59.js";
+import"./chunk-zkpjxvnd.js";
+import"./chunk-cyp8x61z.js";
+import"./chunk-cgeewb6e.js";
+import"./chunk-41x5pfyr.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-vhjx5fag.js";
+import"./chunk-smfnjta6.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-j5hc27hv.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-pa86j0bt.js";
+import"./chunk-cgqxb74c.js";
+import"./chunk-9gbamk79.js";
+import"./chunk-pn0gryjm.js";
+import"./chunk-gv0tqhg0.js";
+import"./chunk-n9n0mrjy.js";
+import"./chunk-e65m636c.js";
+import"./chunk-7m2nd8da.js";
+import"./chunk-ps49ymvj.js";
+import"./chunk-g338npwr.js";
+import"./chunk-pfz2eecq.js";
+import"./chunk-zk2wsm7d.js";
+import"./chunk-png9e5ck.js";
+import"./chunk-7e6ahfxz.js";
+import"./chunk-4bt4tycr.js";
+import"./chunk-kh4zk8k3.js";
+import"./chunk-eebcvtbb.js";
+import"./chunk-xq4cfvpn.js";
+import"./chunk-4qz9vbs1.js";
+import"./chunk-9nta4x35.js";
+import"./chunk-b75fzr8e.js";
+import"./chunk-g0j0t6qk.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-nj17bhkh.js";
+import"./chunk-55wgxwa9.js";
+import"./chunk-vqk1n5qr.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-wn2268qd.js";
+import"./chunk-vqvd3qz0.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-qz2x630m.js";
+import"./chunk-d9kz373t.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-v9smspw2.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-w8yw30sd.js";
+import"./chunk-wgcssf6v.js";
+import"./chunk-cdz5yb0r.js";
+import"./chunk-h0rbjg6x.js";
+import"./chunk-dstxhxsx.js";
+import"./chunk-b8x1gk3y.js";
+import"./chunk-9k2drwej.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-fbpftpf0.js";
+import"./chunk-3vs3nm7w.js";
+import"./chunk-gzzfhtdv.js";
+import"./chunk-yysj6sxt.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-8bedvdm1.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-sbbj6ta3.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-raqgs410.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_sessionStorage();
+
+export {
+  writeRemoteAgentMetadata,
+  writeAgentMetadata,
+  setSessionFileForTesting,
+  setRemoteIngressUrlForTesting,
+  setInternalEventWriter,
+  setInternalEventReader,
+  setAgentTranscriptSubdir,
+  sessionIdExists,
+  searchSessionsByCustomTitle,
+  saveWorktreeState,
+  saveTaskSummary,
+  saveTag,
+  saveMode,
+  saveCustomTitle,
+  saveAiGeneratedTitle,
+  saveAgentSetting,
+  saveAgentName,
+  saveAgentColor,
+  restoreSessionMetadata,
+  resetSessionFilePointer,
+  resetProjectForTesting,
+  resetProjectFlushStateForTesting,
+  removeTranscriptMessage,
+  removeExtraFields,
+  recordTranscript,
+  recordSidechainTranscript,
+  recordQueueOperation,
+  recordFileHistorySnapshot,
+  recordContextCollapseSnapshot,
+  recordContextCollapseCommit,
+  recordContentReplacement,
+  recordAttributionSnapshot,
+  readRemoteAgentMetadata,
+  readAgentMetadata,
+  reAppendSessionMetadata,
+  loadTranscriptFromFile,
+  loadTranscriptFile,
+  loadSubagentTranscripts,
+  loadSameRepoMessageLogsProgressive,
+  loadSameRepoMessageLogs,
+  loadMessageLogs,
+  loadFullLog,
+  loadAllSubagentTranscriptsFromDisk,
+  loadAllProjectsMessageLogsProgressive,
+  loadAllProjectsMessageLogs,
+  loadAllLogsFromSessionFile,
+  listRemoteAgentMetadata,
+  linkSessionToPR,
+  isTranscriptMessage,
+  isLoggableMessage,
+  isLiteLog,
+  isEphemeralToolProgress,
+  isCustomTitleEnabled,
+  isChainParticipant,
+  hydrateRemoteSession,
+  hydrateFromCCRv2InternalEvents,
+  getUserType,
+  getTranscriptPathForSession,
+  getTranscriptPath,
+  getSessionIdFromLog,
+  getSessionFilesWithMtime,
+  getSessionFilesLite,
+  getProjectsDir,
+  getProjectDir,
+  getNodeEnv,
+  getLogByIndex,
+  getLastSessionLog,
+  getFirstMeaningfulUserMessageTextContent,
+  getCurrentSessionTitle,
+  getCurrentSessionTag,
+  getCurrentSessionAgentColor,
+  getAgentTranscriptPath,
+  getAgentTranscript,
+  flushSessionStorage,
+  findUnresolvedToolUse,
+  fetchLogs,
+  extractTeammateTranscriptsFromTasks,
+  extractAgentIdsFromMessages,
+  enrichLogs,
+  doesMessageExistInSession,
+  deleteRemoteAgentMetadata,
+  clearSessionMetadata,
+  clearSessionMessagesCache,
+  clearAgentTranscriptSubdir,
+  cleanMessagesForLogging,
+  checkResumeConsistency,
+  cacheSessionTitle,
+  buildConversationChain,
+  adoptResumedSessionFile,
+  MAX_TRANSCRIPT_READ_BYTES
+};