@caspian2026/agent-sdk 0.0.2

package/dist/chunk-b0qptb1k.js

@@ -0,0 +1,640 @@
+// @bun
+import {
+  getAnthropicApiKey,
+  getClaudeAIOAuthTokens,
+  getGlobalConfig,
+  hasProfileScope,
+  init_auth,
+  init_config,
+  saveApiKey,
+  saveGlobalConfig
+} from "./chunk-tp2jxmcx.js";
+import {
+  init_lazySchema,
+  lazySchema
+} from "./chunk-64c1avct.js";
+import {
+  init_sleep,
+  sleep
+} from "./chunk-8g5pe1gr.js";
+import {
+  init_v4,
+  v4_default
+} from "./chunk-8g747a8x.js";
+import {
+  ALL_OAUTH_SCOPES,
+  CLAUDE_AI_INFERENCE_SCOPE,
+  CLAUDE_AI_OAUTH_SCOPES,
+  OAUTH_BETA_HEADER,
+  getOauthConfig,
+  init_oauth
+} from "./chunk-s3hsqf80.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-x8d2ehd7.js";
+import {
+  init_detectRepository,
+  parseGitHubRepository
+} from "./chunk-15m49c67.js";
+import {
+  init_log,
+  logError
+} from "./chunk-1nk93fqz.js";
+import {
+  errorMessage,
+  init_debug,
+  init_errors,
+  init_slowOperations,
+  jsonStringify,
+  logForDebugging,
+  toError
+} from "./chunk-phd1qfpc.js";
+import {
+  axios_default,
+  init_axios
+} from "./chunk-55raexh7.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/services/oauth/getOauthProfile.ts
+async function getOauthProfileFromApiKey() {
+  const config = getGlobalConfig();
+  const accountUuid = config.oauthAccount?.accountUuid;
+  const apiKey = getAnthropicApiKey();
+  if (!accountUuid || !apiKey) {
+    return;
+  }
+  const endpoint = `${getOauthConfig().BASE_API_URL}/api/claude_cli_profile`;
+  try {
+    const response = await axios_default.get(endpoint, {
+      headers: {
+        "x-api-key": apiKey,
+        "anthropic-beta": OAUTH_BETA_HEADER
+      },
+      params: {
+        account_uuid: accountUuid
+      },
+      timeout: 1e4
+    });
+    return response.data;
+  } catch (error) {
+    logError(error);
+  }
+}
+async function getOauthProfileFromOauthToken(accessToken) {
+  const endpoint = `${getOauthConfig().BASE_API_URL}/api/oauth/profile`;
+  try {
+    const response = await axios_default.get(endpoint, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json"
+      },
+      timeout: 1e4
+    });
+    return response.data;
+  } catch (error) {
+    logError(error);
+  }
+}
+var init_getOauthProfile = __esm(() => {
+  init_axios();
+  init_oauth();
+  init_auth();
+  init_config();
+  init_log();
+});
+
+// src/services/oauth/client.ts
+function shouldUseClaudeAIAuth(scopes) {
+  return Boolean(scopes?.includes(CLAUDE_AI_INFERENCE_SCOPE));
+}
+function parseScopes(scopeString) {
+  return scopeString?.split(" ").filter(Boolean) ?? [];
+}
+function buildAuthUrl({
+  codeChallenge,
+  state,
+  port,
+  isManual,
+  loginWithClaudeAi,
+  inferenceOnly,
+  orgUUID,
+  loginHint,
+  loginMethod
+}) {
+  const authUrlBase = loginWithClaudeAi ? getOauthConfig().CLAUDE_AI_AUTHORIZE_URL : getOauthConfig().CONSOLE_AUTHORIZE_URL;
+  const authUrl = new URL(authUrlBase);
+  authUrl.searchParams.append("code", "true");
+  authUrl.searchParams.append("client_id", getOauthConfig().CLIENT_ID);
+  authUrl.searchParams.append("response_type", "code");
+  authUrl.searchParams.append("redirect_uri", isManual ? getOauthConfig().MANUAL_REDIRECT_URL : `http://localhost:${port}/callback`);
+  const scopesToUse = inferenceOnly ? [CLAUDE_AI_INFERENCE_SCOPE] : ALL_OAUTH_SCOPES;
+  authUrl.searchParams.append("scope", scopesToUse.join(" "));
+  authUrl.searchParams.append("code_challenge", codeChallenge);
+  authUrl.searchParams.append("code_challenge_method", "S256");
+  authUrl.searchParams.append("state", state);
+  if (orgUUID) {
+    authUrl.searchParams.append("orgUUID", orgUUID);
+  }
+  if (loginHint) {
+    authUrl.searchParams.append("login_hint", loginHint);
+  }
+  if (loginMethod) {
+    authUrl.searchParams.append("login_method", loginMethod);
+  }
+  return authUrl.toString();
+}
+async function exchangeCodeForTokens(authorizationCode, state, codeVerifier, port, useManualRedirect = false, expiresIn) {
+  const requestBody = {
+    grant_type: "authorization_code",
+    code: authorizationCode,
+    redirect_uri: useManualRedirect ? getOauthConfig().MANUAL_REDIRECT_URL : `http://localhost:${port}/callback`,
+    client_id: getOauthConfig().CLIENT_ID,
+    code_verifier: codeVerifier,
+    state
+  };
+  if (expiresIn !== undefined) {
+    requestBody.expires_in = expiresIn;
+  }
+  const response = await axios_default.post(getOauthConfig().TOKEN_URL, requestBody, {
+    headers: { "Content-Type": "application/json" },
+    timeout: 15000
+  });
+  if (response.status !== 200) {
+    throw new Error(response.status === 401 ? "Authentication failed: Invalid authorization code" : `Token exchange failed (${response.status}): ${response.statusText}`);
+  }
+  logEvent("tengu_oauth_token_exchange_success", {});
+  return response.data;
+}
+async function refreshOAuthToken(refreshToken, { scopes: requestedScopes } = {}) {
+  const requestBody = {
+    grant_type: "refresh_token",
+    refresh_token: refreshToken,
+    client_id: getOauthConfig().CLIENT_ID,
+    scope: ((requestedScopes?.length) ? requestedScopes : CLAUDE_AI_OAUTH_SCOPES).join(" ")
+  };
+  try {
+    const response = await axios_default.post(getOauthConfig().TOKEN_URL, requestBody, {
+      headers: { "Content-Type": "application/json" },
+      timeout: 15000
+    });
+    if (response.status !== 200) {
+      throw new Error(`Token refresh failed: ${response.statusText}`);
+    }
+    const data = response.data;
+    const {
+      access_token: accessToken,
+      refresh_token: newRefreshToken = refreshToken,
+      expires_in: expiresIn
+    } = data;
+    const expiresAt = Date.now() + expiresIn * 1000;
+    const scopes = parseScopes(data.scope);
+    logEvent("tengu_oauth_token_refresh_success", {});
+    const config = getGlobalConfig();
+    const existing = getClaudeAIOAuthTokens();
+    const haveProfileAlready = config.oauthAccount?.billingType !== undefined && config.oauthAccount?.accountCreatedAt !== undefined && config.oauthAccount?.subscriptionCreatedAt !== undefined && existing?.subscriptionType != null && existing?.rateLimitTier != null;
+    const profileInfo = haveProfileAlready ? null : await fetchProfileInfo(accessToken);
+    if (profileInfo && config.oauthAccount) {
+      const updates = {};
+      if (profileInfo.displayName !== undefined) {
+        updates.displayName = profileInfo.displayName;
+      }
+      if (typeof profileInfo.hasExtraUsageEnabled === "boolean") {
+        updates.hasExtraUsageEnabled = profileInfo.hasExtraUsageEnabled;
+      }
+      if (profileInfo.billingType !== null) {
+        updates.billingType = profileInfo.billingType;
+      }
+      if (profileInfo.accountCreatedAt !== undefined) {
+        updates.accountCreatedAt = profileInfo.accountCreatedAt;
+      }
+      if (profileInfo.subscriptionCreatedAt !== undefined) {
+        updates.subscriptionCreatedAt = profileInfo.subscriptionCreatedAt;
+      }
+      if (Object.keys(updates).length > 0) {
+        saveGlobalConfig((current) => ({
+          ...current,
+          oauthAccount: current.oauthAccount ? { ...current.oauthAccount, ...updates } : current.oauthAccount
+        }));
+      }
+    }
+    return {
+      accessToken,
+      refreshToken: newRefreshToken,
+      expiresAt,
+      scopes,
+      subscriptionType: profileInfo?.subscriptionType ?? existing?.subscriptionType ?? null,
+      rateLimitTier: profileInfo?.rateLimitTier ?? existing?.rateLimitTier ?? null,
+      profile: profileInfo?.rawProfile,
+      tokenAccount: data.account ? {
+        uuid: data.account.uuid,
+        emailAddress: data.account.email_address,
+        organizationUuid: data.organization?.uuid
+      } : undefined
+    };
+  } catch (error) {
+    const responseBody = axios_default.isAxiosError(error) && error.response?.data ? JSON.stringify(error.response.data) : undefined;
+    logEvent("tengu_oauth_token_refresh_failure", {
+      error: error.message,
+      ...responseBody && {
+        responseBody
+      }
+    });
+    throw error;
+  }
+}
+async function fetchAndStoreUserRoles(accessToken) {
+  const response = await axios_default.get(getOauthConfig().ROLES_URL, {
+    headers: { Authorization: `Bearer ${accessToken}` }
+  });
+  if (response.status !== 200) {
+    throw new Error(`Failed to fetch user roles: ${response.statusText}`);
+  }
+  const data = response.data;
+  const config = getGlobalConfig();
+  if (!config.oauthAccount) {
+    throw new Error("OAuth account information not found in config");
+  }
+  saveGlobalConfig((current) => ({
+    ...current,
+    oauthAccount: current.oauthAccount ? {
+      ...current.oauthAccount,
+      organizationRole: data.organization_role,
+      workspaceRole: data.workspace_role,
+      organizationName: data.organization_name
+    } : current.oauthAccount
+  }));
+  logEvent("tengu_oauth_roles_stored", {
+    org_role: data.organization_role
+  });
+}
+async function createAndStoreApiKey(accessToken) {
+  try {
+    const response = await axios_default.post(getOauthConfig().API_KEY_URL, null, {
+      headers: { Authorization: `Bearer ${accessToken}` }
+    });
+    const apiKey = response.data?.raw_key;
+    if (apiKey) {
+      await saveApiKey(apiKey);
+      logEvent("tengu_oauth_api_key", {
+        status: "success",
+        statusCode: response.status
+      });
+      return apiKey;
+    }
+    return null;
+  } catch (error) {
+    logEvent("tengu_oauth_api_key", {
+      status: "failure",
+      error: error instanceof Error ? error.message : String(error)
+    });
+    throw error;
+  }
+}
+function isOAuthTokenExpired(expiresAt) {
+  if (expiresAt === null) {
+    return false;
+  }
+  const bufferTime = 5 * 60 * 1000;
+  const now = Date.now();
+  const expiresWithBuffer = now + bufferTime;
+  return expiresWithBuffer >= expiresAt;
+}
+async function fetchProfileInfo(accessToken) {
+  const profile = await getOauthProfileFromOauthToken(accessToken);
+  const orgType = profile?.organization?.organization_type;
+  let subscriptionType = null;
+  switch (orgType) {
+    case "claude_max":
+      subscriptionType = "max";
+      break;
+    case "claude_pro":
+      subscriptionType = "pro";
+      break;
+    case "claude_enterprise":
+      subscriptionType = "enterprise";
+      break;
+    case "claude_team":
+      subscriptionType = "team";
+      break;
+    default:
+      subscriptionType = null;
+      break;
+  }
+  const result = {
+    subscriptionType,
+    rateLimitTier: profile?.organization?.rate_limit_tier ?? null,
+    hasExtraUsageEnabled: profile?.organization?.has_extra_usage_enabled ?? null,
+    billingType: profile?.organization?.billing_type ?? null
+  };
+  if (profile?.account?.display_name) {
+    result.displayName = profile.account.display_name;
+  }
+  if (profile?.account?.created_at) {
+    result.accountCreatedAt = profile.account.created_at;
+  }
+  if (profile?.organization?.subscription_created_at) {
+    result.subscriptionCreatedAt = profile.organization.subscription_created_at;
+  }
+  logEvent("tengu_oauth_profile_fetch_success", {});
+  return { ...result, rawProfile: profile };
+}
+async function getOrganizationUUID() {
+  const globalConfig = getGlobalConfig();
+  const orgUUID = globalConfig.oauthAccount?.organizationUuid;
+  if (orgUUID) {
+    return orgUUID;
+  }
+  const accessToken = getClaudeAIOAuthTokens()?.accessToken;
+  if (accessToken === undefined || !hasProfileScope()) {
+    return null;
+  }
+  const profile = await getOauthProfileFromOauthToken(accessToken);
+  const profileOrgUUID = profile?.organization?.uuid;
+  if (!profileOrgUUID) {
+    return null;
+  }
+  return profileOrgUUID;
+}
+function storeOAuthAccountInfo({
+  accountUuid,
+  emailAddress,
+  organizationUuid,
+  displayName,
+  hasExtraUsageEnabled,
+  billingType,
+  accountCreatedAt,
+  subscriptionCreatedAt
+}) {
+  const accountInfo = {
+    accountUuid,
+    emailAddress,
+    organizationUuid,
+    hasExtraUsageEnabled,
+    billingType,
+    accountCreatedAt,
+    subscriptionCreatedAt
+  };
+  if (displayName) {
+    accountInfo.displayName = displayName;
+  }
+  saveGlobalConfig((current) => {
+    if (current.oauthAccount?.accountUuid === accountInfo.accountUuid && current.oauthAccount?.emailAddress === accountInfo.emailAddress && current.oauthAccount?.organizationUuid === accountInfo.organizationUuid && current.oauthAccount?.displayName === accountInfo.displayName && current.oauthAccount?.hasExtraUsageEnabled === accountInfo.hasExtraUsageEnabled && current.oauthAccount?.billingType === accountInfo.billingType && current.oauthAccount?.accountCreatedAt === accountInfo.accountCreatedAt && current.oauthAccount?.subscriptionCreatedAt === accountInfo.subscriptionCreatedAt) {
+      return current;
+    }
+    return { ...current, oauthAccount: accountInfo };
+  });
+}
+var init_client = __esm(() => {
+  init_axios();
+  init_analytics();
+  init_oauth();
+  init_auth();
+  init_config();
+  init_debug();
+  init_getOauthProfile();
+});
+
+// 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, 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 { getOauthProfileFromApiKey, getOauthProfileFromOauthToken, init_getOauthProfile, shouldUseClaudeAIAuth, parseScopes, buildAuthUrl, exchangeCodeForTokens, refreshOAuthToken, fetchAndStoreUserRoles, createAndStoreApiKey, isOAuthTokenExpired, fetchProfileInfo, getOrganizationUUID, storeOAuthAccountInfo, init_client, isTransientNetworkError, prepareApiRequest, fetchCodeSessionsFromSessionsAPI, getOAuthHeaders, fetchSession, getBranchFromSession, sendEventToRemoteSession, updateSessionTitle, init_api };

package/dist/chunk-b1kcd3ss.js

@@ -0,0 +1,27 @@
+// @bun
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/telemetry/instrumentation.ts
+function bootstrapTelemetry() {}
+function parseExporterTypes(_value) {
+  return [];
+}
+function isTelemetryEnabled() {
+  return false;
+}
+async function initializeTelemetry() {
+  return null;
+}
+async function flushTelemetry() {}
+var init_instrumentation = () => {};
+init_instrumentation();
+
+export {
+  parseExporterTypes,
+  isTelemetryEnabled,
+  initializeTelemetry,
+  flushTelemetry,
+  bootstrapTelemetry
+};