@foxclicom/foxcli 2.1.89

package/dist/chunk-7wj3b774.js

@@ -0,0 +1,287 @@
+// @bun
+import {
+  getClaudeAIOAuthTokens,
+  getOrganizationUUID,
+  init_auth,
+  init_client,
+  init_sleep,
+  sleep
+} from "./chunk-skctedsv.js";
+import {
+  init_v4,
+  v4_default
+} from "./chunk-g0j0t6qk.js";
+import {
+  init_lazySchema,
+  lazySchema
+} from "./chunk-55wgxwa9.js";
+import {
+  getOauthConfig,
+  init_oauth
+} from "./chunk-7ymfj7m3.js";
+import {
+  init_detectRepository,
+  parseGitHubRepository
+} from "./chunk-7z8j9qfn.js";
+import {
+  init_log,
+  logError
+} from "./chunk-p7g7pf3f.js";
+import {
+  errorMessage,
+  init_debug,
+  init_errors,
+  init_slowOperations,
+  jsonStringify,
+  logForDebugging,
+  toError
+} from "./chunk-nxsh6de2.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-7wm5s02e.js

@@ -0,0 +1,216 @@
+// @bun
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/signals.js
+var signals;
+var init_signals = __esm(() => {
+  signals = [];
+  signals.push("SIGHUP", "SIGINT", "SIGTERM");
+  if (process.platform !== "win32") {
+    signals.push("SIGALRM", "SIGABRT", "SIGVTALRM", "SIGXCPU", "SIGXFSZ", "SIGUSR2", "SIGTRAP", "SIGSYS", "SIGQUIT", "SIGIOT");
+  }
+  if (process.platform === "linux") {
+    signals.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT");
+  }
+});
+
+// node_modules/.bun/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/index.js
+class Emitter {
+  emitted = {
+    afterExit: false,
+    exit: false
+  };
+  listeners = {
+    afterExit: [],
+    exit: []
+  };
+  count = 0;
+  id = Math.random();
+  constructor() {
+    if (global[kExitEmitter]) {
+      return global[kExitEmitter];
+    }
+    ObjectDefineProperty(global, kExitEmitter, {
+      value: this,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+  }
+  on(ev, fn) {
+    this.listeners[ev].push(fn);
+  }
+  removeListener(ev, fn) {
+    const list = this.listeners[ev];
+    const i = list.indexOf(fn);
+    if (i === -1) {
+      return;
+    }
+    if (i === 0 && list.length === 1) {
+      list.length = 0;
+    } else {
+      list.splice(i, 1);
+    }
+  }
+  emit(ev, code, signal) {
+    if (this.emitted[ev]) {
+      return false;
+    }
+    this.emitted[ev] = true;
+    let ret = false;
+    for (const fn of this.listeners[ev]) {
+      ret = fn(code, signal) === true || ret;
+    }
+    if (ev === "exit") {
+      ret = this.emit("afterExit", code, signal) || ret;
+    }
+    return ret;
+  }
+}
+
+class SignalExitBase {
+}
+var processOk = (process2) => !!process2 && typeof process2 === "object" && typeof process2.removeListener === "function" && typeof process2.emit === "function" && typeof process2.reallyExit === "function" && typeof process2.listeners === "function" && typeof process2.kill === "function" && typeof process2.pid === "number" && typeof process2.on === "function", kExitEmitter, global, ObjectDefineProperty, signalExitWrap = (handler) => {
+  return {
+    onExit(cb, opts) {
+      return handler.onExit(cb, opts);
+    },
+    load() {
+      return handler.load();
+    },
+    unload() {
+      return handler.unload();
+    }
+  };
+}, SignalExitFallback, SignalExit, process2, onExit, load, unload;
+var init_mjs = __esm(() => {
+  init_signals();
+  kExitEmitter = Symbol.for("signal-exit emitter");
+  global = globalThis;
+  ObjectDefineProperty = Object.defineProperty.bind(Object);
+  SignalExitFallback = class SignalExitFallback extends SignalExitBase {
+    onExit() {
+      return () => {};
+    }
+    load() {}
+    unload() {}
+  };
+  SignalExit = class SignalExit extends SignalExitBase {
+    #hupSig = process2.platform === "win32" ? "SIGINT" : "SIGHUP";
+    #emitter = new Emitter;
+    #process;
+    #originalProcessEmit;
+    #originalProcessReallyExit;
+    #sigListeners = {};
+    #loaded = false;
+    constructor(process2) {
+      super();
+      this.#process = process2;
+      this.#sigListeners = {};
+      for (const sig of signals) {
+        this.#sigListeners[sig] = () => {
+          const listeners = this.#process.listeners(sig);
+          let { count } = this.#emitter;
+          const p = process2;
+          if (typeof p.__signal_exit_emitter__ === "object" && typeof p.__signal_exit_emitter__.count === "number") {
+            count += p.__signal_exit_emitter__.count;
+          }
+          if (listeners.length === count) {
+            this.unload();
+            const ret = this.#emitter.emit("exit", null, sig);
+            const s = sig === "SIGHUP" ? this.#hupSig : sig;
+            if (!ret)
+              process2.kill(process2.pid, s);
+          }
+        };
+      }
+      this.#originalProcessReallyExit = process2.reallyExit;
+      this.#originalProcessEmit = process2.emit;
+    }
+    onExit(cb, opts) {
+      if (!processOk(this.#process)) {
+        return () => {};
+      }
+      if (this.#loaded === false) {
+        this.load();
+      }
+      const ev = opts?.alwaysLast ? "afterExit" : "exit";
+      this.#emitter.on(ev, cb);
+      return () => {
+        this.#emitter.removeListener(ev, cb);
+        if (this.#emitter.listeners["exit"].length === 0 && this.#emitter.listeners["afterExit"].length === 0) {
+          this.unload();
+        }
+      };
+    }
+    load() {
+      if (this.#loaded) {
+        return;
+      }
+      this.#loaded = true;
+      this.#emitter.count += 1;
+      for (const sig of signals) {
+        try {
+          const fn = this.#sigListeners[sig];
+          if (fn)
+            this.#process.on(sig, fn);
+        } catch (_) {}
+      }
+      this.#process.emit = (ev, ...a) => {
+        return this.#processEmit(ev, ...a);
+      };
+      this.#process.reallyExit = (code) => {
+        return this.#processReallyExit(code);
+      };
+    }
+    unload() {
+      if (!this.#loaded) {
+        return;
+      }
+      this.#loaded = false;
+      signals.forEach((sig) => {
+        const listener = this.#sigListeners[sig];
+        if (!listener) {
+          throw new Error("Listener not defined for signal: " + sig);
+        }
+        try {
+          this.#process.removeListener(sig, listener);
+        } catch (_) {}
+      });
+      this.#process.emit = this.#originalProcessEmit;
+      this.#process.reallyExit = this.#originalProcessReallyExit;
+      this.#emitter.count -= 1;
+    }
+    #processReallyExit(code) {
+      if (!processOk(this.#process)) {
+        return 0;
+      }
+      this.#process.exitCode = code || 0;
+      this.#emitter.emit("exit", this.#process.exitCode, null);
+      return this.#originalProcessReallyExit.call(this.#process, this.#process.exitCode);
+    }
+    #processEmit(ev, ...args) {
+      const og = this.#originalProcessEmit;
+      if (ev === "exit" && processOk(this.#process)) {
+        if (typeof args[0] === "number") {
+          this.#process.exitCode = args[0];
+        }
+        const ret = og.call(this.#process, ev, ...args);
+        this.#emitter.emit("exit", this.#process.exitCode, null);
+        return ret;
+      } else {
+        return og.call(this.#process, ev, ...args);
+      }
+    }
+  };
+  process2 = globalThis.process;
+  ({
+    onExit,
+    load,
+    unload
+  } = signalExitWrap(processOk(process2) ? new SignalExit(process2) : new SignalExitFallback));
+});
+
+export { onExit, init_mjs };