@rainhole/rain-code 1.1.0

package/dist/chunk-2a42s11t.js

@@ -0,0 +1,412 @@
+// @bun
+import {
+  require_dist_cjs as require_dist_cjs2
+} from "./chunk-jzmz18nn.js";
+import {
+  require_dist_cjs as require_dist_cjs3
+} from "./chunk-j2k4p94p.js";
+import {
+  require_dist_cjs
+} from "./chunk-hk9xz7gk.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/@smithy+credential-provider-imds@4.2.12/node_modules/@smithy/credential-provider-imds/dist-es/remoteProvider/httpRequest.js
+import { Buffer } from "buffer";
+import { request } from "http";
+function httpRequest(options) {
+  return new Promise((resolve, reject) => {
+    const req = request({
+      method: "GET",
+      ...options,
+      hostname: options.hostname?.replace(/^\[(.+)\]$/, "$1")
+    });
+    req.on("error", (err) => {
+      reject(Object.assign(new import_property_provider.ProviderError("Unable to connect to instance metadata service"), err));
+      req.destroy();
+    });
+    req.on("timeout", () => {
+      reject(new import_property_provider.ProviderError("TimeoutError from instance metadata service"));
+      req.destroy();
+    });
+    req.on("response", (res) => {
+      const { statusCode = 400 } = res;
+      if (statusCode < 200 || 300 <= statusCode) {
+        reject(Object.assign(new import_property_provider.ProviderError("Error response received from instance metadata service"), { statusCode }));
+        req.destroy();
+      }
+      const chunks = [];
+      res.on("data", (chunk) => {
+        chunks.push(chunk);
+      });
+      res.on("end", () => {
+        resolve(Buffer.concat(chunks));
+        req.destroy();
+      });
+    });
+    req.end();
+  });
+}
+var import_property_provider;
+var init_httpRequest = __esm(() => {
+  import_property_provider = __toESM(require_dist_cjs(), 1);
+});
+
+// node_modules/.bun/@smithy+credential-provider-imds@4.2.12/node_modules/@smithy/credential-provider-imds/dist-es/remoteProvider/ImdsCredentials.js
+var isImdsCredentials = (arg) => Boolean(arg) && typeof arg === "object" && typeof arg.AccessKeyId === "string" && typeof arg.SecretAccessKey === "string" && typeof arg.Token === "string" && typeof arg.Expiration === "string", fromImdsCredentials = (creds) => ({
+  accessKeyId: creds.AccessKeyId,
+  secretAccessKey: creds.SecretAccessKey,
+  sessionToken: creds.Token,
+  expiration: new Date(creds.Expiration),
+  ...creds.AccountId && { accountId: creds.AccountId }
+});
+var init_ImdsCredentials = () => {};
+
+// node_modules/.bun/@smithy+credential-provider-imds@4.2.12/node_modules/@smithy/credential-provider-imds/dist-es/remoteProvider/RemoteProviderInit.js
+var DEFAULT_TIMEOUT = 1000, DEFAULT_MAX_RETRIES = 0, providerConfigFromInit = ({ maxRetries = DEFAULT_MAX_RETRIES, timeout = DEFAULT_TIMEOUT }) => ({ maxRetries, timeout });
+var init_RemoteProviderInit = () => {};
+
+// node_modules/.bun/@smithy+credential-provider-imds@4.2.12/node_modules/@smithy/credential-provider-imds/dist-es/remoteProvider/retry.js
+var retry = (toRetry, maxRetries) => {
+  let promise = toRetry();
+  for (let i = 0;i < maxRetries; i++) {
+    promise = promise.catch(toRetry);
+  }
+  return promise;
+};
+var init_retry = () => {};
+
+// node_modules/.bun/@smithy+credential-provider-imds@4.2.12/node_modules/@smithy/credential-provider-imds/dist-es/fromContainerMetadata.js
+import { parse } from "url";
+var import_property_provider2, ENV_CMDS_FULL_URI = "AWS_CONTAINER_CREDENTIALS_FULL_URI", ENV_CMDS_RELATIVE_URI = "AWS_CONTAINER_CREDENTIALS_RELATIVE_URI", ENV_CMDS_AUTH_TOKEN = "AWS_CONTAINER_AUTHORIZATION_TOKEN", fromContainerMetadata = (init = {}) => {
+  const { timeout, maxRetries } = providerConfigFromInit(init);
+  return () => retry(async () => {
+    const requestOptions = await getCmdsUri({ logger: init.logger });
+    const credsResponse = JSON.parse(await requestFromEcsImds(timeout, requestOptions));
+    if (!isImdsCredentials(credsResponse)) {
+      throw new import_property_provider2.CredentialsProviderError("Invalid response received from instance metadata service.", {
+        logger: init.logger
+      });
+    }
+    return fromImdsCredentials(credsResponse);
+  }, maxRetries);
+}, requestFromEcsImds = async (timeout, options) => {
+  if (process.env[ENV_CMDS_AUTH_TOKEN]) {
+    options.headers = {
+      ...options.headers,
+      Authorization: process.env[ENV_CMDS_AUTH_TOKEN]
+    };
+  }
+  const buffer = await httpRequest({
+    ...options,
+    timeout
+  });
+  return buffer.toString();
+}, CMDS_IP = "169.254.170.2", GREENGRASS_HOSTS, GREENGRASS_PROTOCOLS, getCmdsUri = async ({ logger }) => {
+  if (process.env[ENV_CMDS_RELATIVE_URI]) {
+    return {
+      hostname: CMDS_IP,
+      path: process.env[ENV_CMDS_RELATIVE_URI]
+    };
+  }
+  if (process.env[ENV_CMDS_FULL_URI]) {
+    const parsed = parse(process.env[ENV_CMDS_FULL_URI]);
+    if (!parsed.hostname || !(parsed.hostname in GREENGRASS_HOSTS)) {
+      throw new import_property_provider2.CredentialsProviderError(`${parsed.hostname} is not a valid container metadata service hostname`, {
+        tryNextLink: false,
+        logger
+      });
+    }
+    if (!parsed.protocol || !(parsed.protocol in GREENGRASS_PROTOCOLS)) {
+      throw new import_property_provider2.CredentialsProviderError(`${parsed.protocol} is not a valid container metadata service protocol`, {
+        tryNextLink: false,
+        logger
+      });
+    }
+    return {
+      ...parsed,
+      port: parsed.port ? parseInt(parsed.port, 10) : undefined
+    };
+  }
+  throw new import_property_provider2.CredentialsProviderError("The container metadata credential provider cannot be used unless" + ` the ${ENV_CMDS_RELATIVE_URI} or ${ENV_CMDS_FULL_URI} environment` + " variable is set", {
+    tryNextLink: false,
+    logger
+  });
+};
+var init_fromContainerMetadata = __esm(() => {
+  init_httpRequest();
+  init_ImdsCredentials();
+  init_RemoteProviderInit();
+  init_retry();
+  import_property_provider2 = __toESM(require_dist_cjs(), 1);
+  GREENGRASS_HOSTS = {
+    localhost: true,
+    "127.0.0.1": true
+  };
+  GREENGRASS_PROTOCOLS = {
+    "http:": true,
+    "https:": true
+  };
+});
+
+// node_modules/.bun/@smithy+credential-provider-imds@4.2.12/node_modules/@smithy/credential-provider-imds/dist-es/error/InstanceMetadataV1FallbackError.js
+var import_property_provider3, InstanceMetadataV1FallbackError;
+var init_InstanceMetadataV1FallbackError = __esm(() => {
+  import_property_provider3 = __toESM(require_dist_cjs(), 1);
+  InstanceMetadataV1FallbackError = class InstanceMetadataV1FallbackError extends import_property_provider3.CredentialsProviderError {
+    tryNextLink;
+    name = "InstanceMetadataV1FallbackError";
+    constructor(message, tryNextLink = true) {
+      super(message, tryNextLink);
+      this.tryNextLink = tryNextLink;
+      Object.setPrototypeOf(this, InstanceMetadataV1FallbackError.prototype);
+    }
+  };
+});
+
+// node_modules/.bun/@smithy+credential-provider-imds@4.2.12/node_modules/@smithy/credential-provider-imds/dist-es/config/Endpoint.js
+var Endpoint;
+var init_Endpoint = __esm(() => {
+  (function(Endpoint2) {
+    Endpoint2["IPv4"] = "http://169.254.169.254";
+    Endpoint2["IPv6"] = "http://[fd00:ec2::254]";
+  })(Endpoint || (Endpoint = {}));
+});
+
+// node_modules/.bun/@smithy+credential-provider-imds@4.2.12/node_modules/@smithy/credential-provider-imds/dist-es/config/EndpointConfigOptions.js
+var ENV_ENDPOINT_NAME = "AWS_EC2_METADATA_SERVICE_ENDPOINT", CONFIG_ENDPOINT_NAME = "ec2_metadata_service_endpoint", ENDPOINT_CONFIG_OPTIONS;
+var init_EndpointConfigOptions = __esm(() => {
+  ENDPOINT_CONFIG_OPTIONS = {
+    environmentVariableSelector: (env) => env[ENV_ENDPOINT_NAME],
+    configFileSelector: (profile) => profile[CONFIG_ENDPOINT_NAME],
+    default: undefined
+  };
+});
+
+// node_modules/.bun/@smithy+credential-provider-imds@4.2.12/node_modules/@smithy/credential-provider-imds/dist-es/config/EndpointMode.js
+var EndpointMode;
+var init_EndpointMode = __esm(() => {
+  (function(EndpointMode2) {
+    EndpointMode2["IPv4"] = "IPv4";
+    EndpointMode2["IPv6"] = "IPv6";
+  })(EndpointMode || (EndpointMode = {}));
+});
+
+// node_modules/.bun/@smithy+credential-provider-imds@4.2.12/node_modules/@smithy/credential-provider-imds/dist-es/config/EndpointModeConfigOptions.js
+var ENV_ENDPOINT_MODE_NAME = "AWS_EC2_METADATA_SERVICE_ENDPOINT_MODE", CONFIG_ENDPOINT_MODE_NAME = "ec2_metadata_service_endpoint_mode", ENDPOINT_MODE_CONFIG_OPTIONS;
+var init_EndpointModeConfigOptions = __esm(() => {
+  init_EndpointMode();
+  ENDPOINT_MODE_CONFIG_OPTIONS = {
+    environmentVariableSelector: (env) => env[ENV_ENDPOINT_MODE_NAME],
+    configFileSelector: (profile) => profile[CONFIG_ENDPOINT_MODE_NAME],
+    default: EndpointMode.IPv4
+  };
+});
+
+// node_modules/.bun/@smithy+credential-provider-imds@4.2.12/node_modules/@smithy/credential-provider-imds/dist-es/utils/getInstanceMetadataEndpoint.js
+var import_node_config_provider, import_url_parser, getInstanceMetadataEndpoint = async () => import_url_parser.parseUrl(await getFromEndpointConfig() || await getFromEndpointModeConfig()), getFromEndpointConfig = async () => import_node_config_provider.loadConfig(ENDPOINT_CONFIG_OPTIONS)(), getFromEndpointModeConfig = async () => {
+  const endpointMode = await import_node_config_provider.loadConfig(ENDPOINT_MODE_CONFIG_OPTIONS)();
+  switch (endpointMode) {
+    case EndpointMode.IPv4:
+      return Endpoint.IPv4;
+    case EndpointMode.IPv6:
+      return Endpoint.IPv6;
+    default:
+      throw new Error(`Unsupported endpoint mode: ${endpointMode}.` + ` Select from ${Object.values(EndpointMode)}`);
+  }
+};
+var init_getInstanceMetadataEndpoint = __esm(() => {
+  init_Endpoint();
+  init_EndpointConfigOptions();
+  init_EndpointMode();
+  init_EndpointModeConfigOptions();
+  import_node_config_provider = __toESM(require_dist_cjs2(), 1);
+  import_url_parser = __toESM(require_dist_cjs3(), 1);
+});
+
+// node_modules/.bun/@smithy+credential-provider-imds@4.2.12/node_modules/@smithy/credential-provider-imds/dist-es/utils/getExtendedInstanceMetadataCredentials.js
+var STATIC_STABILITY_REFRESH_INTERVAL_SECONDS, STATIC_STABILITY_REFRESH_INTERVAL_JITTER_WINDOW_SECONDS, STATIC_STABILITY_DOC_URL = "https://docs.aws.amazon.com/sdkref/latest/guide/feature-static-credentials.html", getExtendedInstanceMetadataCredentials = (credentials, logger) => {
+  const refreshInterval = STATIC_STABILITY_REFRESH_INTERVAL_SECONDS + Math.floor(Math.random() * STATIC_STABILITY_REFRESH_INTERVAL_JITTER_WINDOW_SECONDS);
+  const newExpiration = new Date(Date.now() + refreshInterval * 1000);
+  logger.warn("Attempting credential expiration extension due to a credential service availability issue. A refresh of these " + `credentials will be attempted after ${new Date(newExpiration)}.
+For more information, please visit: ` + STATIC_STABILITY_DOC_URL);
+  const originalExpiration = credentials.originalExpiration ?? credentials.expiration;
+  return {
+    ...credentials,
+    ...originalExpiration ? { originalExpiration } : {},
+    expiration: newExpiration
+  };
+};
+var init_getExtendedInstanceMetadataCredentials = __esm(() => {
+  STATIC_STABILITY_REFRESH_INTERVAL_SECONDS = 5 * 60;
+  STATIC_STABILITY_REFRESH_INTERVAL_JITTER_WINDOW_SECONDS = 5 * 60;
+});
+
+// node_modules/.bun/@smithy+credential-provider-imds@4.2.12/node_modules/@smithy/credential-provider-imds/dist-es/utils/staticStabilityProvider.js
+var staticStabilityProvider = (provider, options = {}) => {
+  const logger = options?.logger || console;
+  let pastCredentials;
+  return async () => {
+    let credentials;
+    try {
+      credentials = await provider();
+      if (credentials.expiration && credentials.expiration.getTime() < Date.now()) {
+        credentials = getExtendedInstanceMetadataCredentials(credentials, logger);
+      }
+    } catch (e) {
+      if (pastCredentials) {
+        logger.warn("Credential renew failed: ", e);
+        credentials = getExtendedInstanceMetadataCredentials(pastCredentials, logger);
+      } else {
+        throw e;
+      }
+    }
+    pastCredentials = credentials;
+    return credentials;
+  };
+};
+var init_staticStabilityProvider = __esm(() => {
+  init_getExtendedInstanceMetadataCredentials();
+});
+
+// node_modules/.bun/@smithy+credential-provider-imds@4.2.12/node_modules/@smithy/credential-provider-imds/dist-es/fromInstanceMetadata.js
+var import_node_config_provider2, import_property_provider4, IMDS_PATH = "/latest/meta-data/iam/security-credentials/", IMDS_TOKEN_PATH = "/latest/api/token", AWS_EC2_METADATA_V1_DISABLED = "AWS_EC2_METADATA_V1_DISABLED", PROFILE_AWS_EC2_METADATA_V1_DISABLED = "ec2_metadata_v1_disabled", X_AWS_EC2_METADATA_TOKEN = "x-aws-ec2-metadata-token", fromInstanceMetadata = (init = {}) => staticStabilityProvider(getInstanceMetadataProvider(init), { logger: init.logger }), getInstanceMetadataProvider = (init = {}) => {
+  let disableFetchToken = false;
+  const { logger, profile } = init;
+  const { timeout, maxRetries } = providerConfigFromInit(init);
+  const getCredentials = async (maxRetries2, options) => {
+    const isImdsV1Fallback = disableFetchToken || options.headers?.[X_AWS_EC2_METADATA_TOKEN] == null;
+    if (isImdsV1Fallback) {
+      let fallbackBlockedFromProfile = false;
+      let fallbackBlockedFromProcessEnv = false;
+      const configValue = await import_node_config_provider2.loadConfig({
+        environmentVariableSelector: (env) => {
+          const envValue = env[AWS_EC2_METADATA_V1_DISABLED];
+          fallbackBlockedFromProcessEnv = !!envValue && envValue !== "false";
+          if (envValue === undefined) {
+            throw new import_property_provider4.CredentialsProviderError(`${AWS_EC2_METADATA_V1_DISABLED} not set in env, checking config file next.`, { logger: init.logger });
+          }
+          return fallbackBlockedFromProcessEnv;
+        },
+        configFileSelector: (profile2) => {
+          const profileValue = profile2[PROFILE_AWS_EC2_METADATA_V1_DISABLED];
+          fallbackBlockedFromProfile = !!profileValue && profileValue !== "false";
+          return fallbackBlockedFromProfile;
+        },
+        default: false
+      }, {
+        profile
+      })();
+      if (init.ec2MetadataV1Disabled || configValue) {
+        const causes = [];
+        if (init.ec2MetadataV1Disabled)
+          causes.push("credential provider initialization (runtime option ec2MetadataV1Disabled)");
+        if (fallbackBlockedFromProfile)
+          causes.push(`config file profile (${PROFILE_AWS_EC2_METADATA_V1_DISABLED})`);
+        if (fallbackBlockedFromProcessEnv)
+          causes.push(`process environment variable (${AWS_EC2_METADATA_V1_DISABLED})`);
+        throw new InstanceMetadataV1FallbackError(`AWS EC2 Metadata v1 fallback has been blocked by AWS SDK configuration in the following: [${causes.join(", ")}].`);
+      }
+    }
+    const imdsProfile = (await retry(async () => {
+      let profile2;
+      try {
+        profile2 = await getProfile(options);
+      } catch (err) {
+        if (err.statusCode === 401) {
+          disableFetchToken = false;
+        }
+        throw err;
+      }
+      return profile2;
+    }, maxRetries2)).trim();
+    return retry(async () => {
+      let creds;
+      try {
+        creds = await getCredentialsFromProfile(imdsProfile, options, init);
+      } catch (err) {
+        if (err.statusCode === 401) {
+          disableFetchToken = false;
+        }
+        throw err;
+      }
+      return creds;
+    }, maxRetries2);
+  };
+  return async () => {
+    const endpoint = await getInstanceMetadataEndpoint();
+    if (disableFetchToken) {
+      logger?.debug("AWS SDK Instance Metadata", "using v1 fallback (no token fetch)");
+      return getCredentials(maxRetries, { ...endpoint, timeout });
+    } else {
+      let token;
+      try {
+        token = (await getMetadataToken({ ...endpoint, timeout })).toString();
+      } catch (error) {
+        if (error?.statusCode === 400) {
+          throw Object.assign(error, {
+            message: "EC2 Metadata token request returned error"
+          });
+        } else if (error.message === "TimeoutError" || [403, 404, 405].includes(error.statusCode)) {
+          disableFetchToken = true;
+        }
+        logger?.debug("AWS SDK Instance Metadata", "using v1 fallback (initial)");
+        return getCredentials(maxRetries, { ...endpoint, timeout });
+      }
+      return getCredentials(maxRetries, {
+        ...endpoint,
+        headers: {
+          [X_AWS_EC2_METADATA_TOKEN]: token
+        },
+        timeout
+      });
+    }
+  };
+}, getMetadataToken = async (options) => httpRequest({
+  ...options,
+  path: IMDS_TOKEN_PATH,
+  method: "PUT",
+  headers: {
+    "x-aws-ec2-metadata-token-ttl-seconds": "21600"
+  }
+}), getProfile = async (options) => (await httpRequest({ ...options, path: IMDS_PATH })).toString(), getCredentialsFromProfile = async (profile, options, init) => {
+  const credentialsResponse = JSON.parse((await httpRequest({
+    ...options,
+    path: IMDS_PATH + profile
+  })).toString());
+  if (!isImdsCredentials(credentialsResponse)) {
+    throw new import_property_provider4.CredentialsProviderError("Invalid response received from instance metadata service.", {
+      logger: init.logger
+    });
+  }
+  return fromImdsCredentials(credentialsResponse);
+};
+var init_fromInstanceMetadata = __esm(() => {
+  init_InstanceMetadataV1FallbackError();
+  init_httpRequest();
+  init_ImdsCredentials();
+  init_RemoteProviderInit();
+  init_retry();
+  init_getInstanceMetadataEndpoint();
+  init_staticStabilityProvider();
+  import_node_config_provider2 = __toESM(require_dist_cjs2(), 1);
+  import_property_provider4 = __toESM(require_dist_cjs(), 1);
+});
+
+// node_modules/.bun/@smithy+credential-provider-imds@4.2.12/node_modules/@smithy/credential-provider-imds/dist-es/types.js
+var init_types = () => {};
+
+// node_modules/.bun/@smithy+credential-provider-imds@4.2.12/node_modules/@smithy/credential-provider-imds/dist-es/index.js
+var init_dist_es = __esm(() => {
+  init_httpRequest();
+  init_getInstanceMetadataEndpoint();
+  init_Endpoint();
+  init_fromContainerMetadata();
+  init_fromInstanceMetadata();
+  init_RemoteProviderInit();
+  init_types();
+});
+
+export { httpRequest, DEFAULT_TIMEOUT, DEFAULT_MAX_RETRIES, providerConfigFromInit, ENV_CMDS_FULL_URI, ENV_CMDS_RELATIVE_URI, ENV_CMDS_AUTH_TOKEN, fromContainerMetadata, Endpoint, getInstanceMetadataEndpoint, fromInstanceMetadata, init_dist_es };

package/dist/chunk-2ekjxh7d.js

@@ -0,0 +1,289 @@
+// @bun
+import {
+  getClaudeAIOAuthTokens,
+  getOrganizationUUID,
+  init_auth,
+  init_client
+} from "./chunk-7b6bg1r4.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 {
+  getOauthConfig,
+  init_oauth
+} from "./chunk-q82r31er.js";
+import {
+  init_detectRepository,
+  parseGitHubRepository
+} from "./chunk-h1mr3371.js";
+import {
+  init_log,
+  logError
+} from "./chunk-y3r7v9pq.js";
+import {
+  errorMessage,
+  init_debug,
+  init_errors,
+  init_slowOperations,
+  jsonStringify,
+  logForDebugging,
+  toError
+} from "./chunk-404qm8xt.js";
+import {
+  axios_default,
+  init_axios
+} from "./chunk-nh3cd07f.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 };