@caspian2026/agent-sdk 0.0.2

package/dist/chunk-rx278zpa.js

@@ -0,0 +1,75 @@
+// @bun
+import {
+  addHiddenPaneId,
+  cleanupSessionTeams,
+  cleanupTeamDirectories,
+  getTeamDir,
+  getTeamFilePath,
+  init_teamHelpers,
+  inputSchema,
+  readTeamFile,
+  readTeamFileAsync,
+  registerTeamForSessionCleanup,
+  removeHiddenPaneId,
+  removeMemberByAgentId,
+  removeMemberFromTeam,
+  removeTeammateFromTeamFile,
+  sanitizeAgentName,
+  sanitizeName,
+  setMemberActive,
+  setMemberMode,
+  setMultipleMemberModes,
+  syncTeammateMode,
+  unregisterTeamForSessionCleanup,
+  writeTeamFileAsync
+} from "./chunk-nebezy1d.js";
+import"./chunk-6nsd9606.js";
+import"./chunk-64c1avct.js";
+import"./chunk-8g747a8x.js";
+import"./chunk-d7886r6a.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-tdbz9gbm.js";
+import"./chunk-0awwmrwr.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-70eey1nh.js";
+import"./chunk-1nk93fqz.js";
+import"./chunk-s8kj6ajy.js";
+import"./chunk-eenq3avg.js";
+import"./chunk-7mqab3z7.js";
+import"./chunk-5z28bqne.js";
+import"./chunk-qajrkk97.js";
+import"./chunk-phd1qfpc.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-jaaxk89e.js";
+import"./chunk-k8vp0atq.js";
+import"./chunk-vf612n57.js";
+import"./chunk-07069jq1.js";
+import"./chunk-d4mdda98.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-qp2qdcda.js";
+init_teamHelpers();
+
+export {
+  writeTeamFileAsync,
+  unregisterTeamForSessionCleanup,
+  syncTeammateMode,
+  setMultipleMemberModes,
+  setMemberMode,
+  setMemberActive,
+  sanitizeName,
+  sanitizeAgentName,
+  removeTeammateFromTeamFile,
+  removeMemberFromTeam,
+  removeMemberByAgentId,
+  removeHiddenPaneId,
+  registerTeamForSessionCleanup,
+  readTeamFileAsync,
+  readTeamFile,
+  inputSchema,
+  getTeamFilePath,
+  getTeamDir,
+  cleanupTeamDirectories,
+  cleanupSessionTeams,
+  addHiddenPaneId
+};

package/dist/chunk-s3hsqf80.js

@@ -0,0 +1,473 @@
+// @bun
+import {
+  init_which,
+  which,
+  whichSync
+} from "./chunk-eenq3avg.js";
+import {
+  getFsImplementation,
+  init_fsOperations
+} from "./chunk-phd1qfpc.js";
+import {
+  getClaudeConfigHomeDir,
+  init_envUtils,
+  isEnvTruthy
+} from "./chunk-jaaxk89e.js";
+import {
+  init_memoize,
+  memoize_default
+} from "./chunk-vf612n57.js";
+import {
+  __esm,
+  __require
+} from "./chunk-qp2qdcda.js";
+
+// src/constants/oauth.ts
+function getOauthConfigType() {
+  if (process.env.USER_TYPE === "ant") {
+    if (isEnvTruthy(process.env.USE_LOCAL_OAUTH)) {
+      return "local";
+    }
+    if (isEnvTruthy(process.env.USE_STAGING_OAUTH)) {
+      return "staging";
+    }
+  }
+  return "prod";
+}
+function fileSuffixForOauthConfig() {
+  if (process.env.CLAUDE_CODE_CUSTOM_OAUTH_URL) {
+    return "-custom-oauth";
+  }
+  switch (getOauthConfigType()) {
+    case "local":
+      return "-local-oauth";
+    case "staging":
+      return "-staging-oauth";
+    case "prod":
+      return "";
+  }
+}
+function getLocalOauthConfig() {
+  const api = process.env.CLAUDE_LOCAL_OAUTH_API_BASE?.replace(/\/$/, "") ?? "http://localhost:8000";
+  const apps = process.env.CLAUDE_LOCAL_OAUTH_APPS_BASE?.replace(/\/$/, "") ?? "http://localhost:4000";
+  const consoleBase = process.env.CLAUDE_LOCAL_OAUTH_CONSOLE_BASE?.replace(/\/$/, "") ?? "http://localhost:3000";
+  return {
+    BASE_API_URL: api,
+    CONSOLE_AUTHORIZE_URL: `${consoleBase}/oauth/authorize`,
+    CLAUDE_AI_AUTHORIZE_URL: `${apps}/oauth/authorize`,
+    CLAUDE_AI_ORIGIN: apps,
+    TOKEN_URL: `${api}/v1/oauth/token`,
+    API_KEY_URL: `${api}/api/oauth/claude_cli/create_api_key`,
+    ROLES_URL: `${api}/api/oauth/claude_cli/roles`,
+    CONSOLE_SUCCESS_URL: `${consoleBase}/buy_credits?returnUrl=/oauth/code/success%3Fapp%3Dclaude-code`,
+    CLAUDEAI_SUCCESS_URL: `${consoleBase}/oauth/code/success?app=claude-code`,
+    MANUAL_REDIRECT_URL: `${consoleBase}/oauth/code/callback`,
+    CLIENT_ID: "22422756-60c9-4084-8eb7-27705fd5cf9a",
+    OAUTH_FILE_SUFFIX: "-local-oauth",
+    MCP_PROXY_URL: "http://localhost:8205",
+    MCP_PROXY_PATH: "/v1/toolbox/shttp/mcp/{server_id}"
+  };
+}
+function getOauthConfig() {
+  let config = (() => {
+    switch (getOauthConfigType()) {
+      case "local":
+        return getLocalOauthConfig();
+      case "staging":
+        return STAGING_OAUTH_CONFIG ?? PROD_OAUTH_CONFIG;
+      case "prod":
+        return PROD_OAUTH_CONFIG;
+    }
+  })();
+  const oauthBaseUrl = process.env.CLAUDE_CODE_CUSTOM_OAUTH_URL;
+  if (oauthBaseUrl) {
+    const base = oauthBaseUrl.replace(/\/$/, "");
+    if (!ALLOWED_OAUTH_BASE_URLS.includes(base)) {
+      throw new Error("CLAUDE_CODE_CUSTOM_OAUTH_URL is not an approved endpoint.");
+    }
+    config = {
+      ...config,
+      BASE_API_URL: base,
+      CONSOLE_AUTHORIZE_URL: `${base}/oauth/authorize`,
+      CLAUDE_AI_AUTHORIZE_URL: `${base}/oauth/authorize`,
+      CLAUDE_AI_ORIGIN: base,
+      TOKEN_URL: `${base}/v1/oauth/token`,
+      API_KEY_URL: `${base}/api/oauth/claude_cli/create_api_key`,
+      ROLES_URL: `${base}/api/oauth/claude_cli/roles`,
+      CONSOLE_SUCCESS_URL: `${base}/oauth/code/success?app=claude-code`,
+      CLAUDEAI_SUCCESS_URL: `${base}/oauth/code/success?app=claude-code`,
+      MANUAL_REDIRECT_URL: `${base}/oauth/code/callback`,
+      OAUTH_FILE_SUFFIX: "-custom-oauth"
+    };
+  }
+  const clientIdOverride = process.env.CLAUDE_CODE_OAUTH_CLIENT_ID;
+  if (clientIdOverride) {
+    config = {
+      ...config,
+      CLIENT_ID: clientIdOverride
+    };
+  }
+  return config;
+}
+var CLAUDE_AI_INFERENCE_SCOPE = "user:inference", CLAUDE_AI_PROFILE_SCOPE = "user:profile", CONSOLE_SCOPE = "org:create_api_key", OAUTH_BETA_HEADER = "oauth-2025-04-20", CONSOLE_OAUTH_SCOPES, CLAUDE_AI_OAUTH_SCOPES, ALL_OAUTH_SCOPES, PROD_OAUTH_CONFIG, MCP_CLIENT_METADATA_URL = "https://claude.ai/oauth/claude-code-client-metadata", STAGING_OAUTH_CONFIG, ALLOWED_OAUTH_BASE_URLS;
+var init_oauth = __esm(() => {
+  init_envUtils();
+  CONSOLE_OAUTH_SCOPES = [
+    CONSOLE_SCOPE,
+    CLAUDE_AI_PROFILE_SCOPE
+  ];
+  CLAUDE_AI_OAUTH_SCOPES = [
+    CLAUDE_AI_PROFILE_SCOPE,
+    CLAUDE_AI_INFERENCE_SCOPE,
+    "user:sessions:claude_code",
+    "user:mcp_servers",
+    "user:file_upload"
+  ];
+  ALL_OAUTH_SCOPES = Array.from(new Set([...CONSOLE_OAUTH_SCOPES, ...CLAUDE_AI_OAUTH_SCOPES]));
+  PROD_OAUTH_CONFIG = {
+    BASE_API_URL: "https://api.anthropic.com",
+    CONSOLE_AUTHORIZE_URL: "https://platform.claude.com/oauth/authorize",
+    CLAUDE_AI_AUTHORIZE_URL: "https://claude.com/cai/oauth/authorize",
+    CLAUDE_AI_ORIGIN: "https://claude.ai",
+    TOKEN_URL: "https://platform.claude.com/v1/oauth/token",
+    API_KEY_URL: "https://api.anthropic.com/api/oauth/claude_cli/create_api_key",
+    ROLES_URL: "https://api.anthropic.com/api/oauth/claude_cli/roles",
+    CONSOLE_SUCCESS_URL: "https://platform.claude.com/buy_credits?returnUrl=/oauth/code/success%3Fapp%3Dclaude-code",
+    CLAUDEAI_SUCCESS_URL: "https://platform.claude.com/oauth/code/success?app=claude-code",
+    MANUAL_REDIRECT_URL: "https://platform.claude.com/oauth/code/callback",
+    CLIENT_ID: "9d1c250a-e61b-44d9-88ed-5944d1962f5e",
+    OAUTH_FILE_SUFFIX: "",
+    MCP_PROXY_URL: "https://mcp-proxy.anthropic.com",
+    MCP_PROXY_PATH: "/v1/mcp/{server_id}"
+  };
+  STAGING_OAUTH_CONFIG = process.env.USER_TYPE === "ant" ? {
+    BASE_API_URL: "https://api-staging.anthropic.com",
+    CONSOLE_AUTHORIZE_URL: "https://platform.staging.ant.dev/oauth/authorize",
+    CLAUDE_AI_AUTHORIZE_URL: "https://claude-ai.staging.ant.dev/oauth/authorize",
+    CLAUDE_AI_ORIGIN: "https://claude-ai.staging.ant.dev",
+    TOKEN_URL: "https://platform.staging.ant.dev/v1/oauth/token",
+    API_KEY_URL: "https://api-staging.anthropic.com/api/oauth/claude_cli/create_api_key",
+    ROLES_URL: "https://api-staging.anthropic.com/api/oauth/claude_cli/roles",
+    CONSOLE_SUCCESS_URL: "https://platform.staging.ant.dev/buy_credits?returnUrl=/oauth/code/success%3Fapp%3Dclaude-code",
+    CLAUDEAI_SUCCESS_URL: "https://platform.staging.ant.dev/oauth/code/success?app=claude-code",
+    MANUAL_REDIRECT_URL: "https://platform.staging.ant.dev/oauth/code/callback",
+    CLIENT_ID: "22422756-60c9-4084-8eb7-27705fd5cf9a",
+    OAUTH_FILE_SUFFIX: "-staging-oauth",
+    MCP_PROXY_URL: "https://mcp-proxy-staging.anthropic.com",
+    MCP_PROXY_PATH: "/v1/mcp/{server_id}"
+  } : undefined;
+  ALLOWED_OAUTH_BASE_URLS = [
+    "https://beacon.claude-ai.staging.ant.dev",
+    "https://claude.fedstart.com",
+    "https://claude-staging.fedstart.com"
+  ];
+});
+
+// src/utils/bundledMode.ts
+function isRunningWithBun() {
+  return process.versions.bun !== undefined;
+}
+function isInBundledMode() {
+  return typeof Bun !== "undefined" && Array.isArray(Bun.embeddedFiles) && Bun.embeddedFiles.length > 0;
+}
+var init_bundledMode = () => {};
+
+// src/utils/findExecutable.ts
+function findExecutable(exe, args) {
+  const resolved = whichSync(exe);
+  return { cmd: resolved ?? exe, args };
+}
+var init_findExecutable = __esm(() => {
+  init_which();
+});
+
+// src/utils/env.ts
+import { homedir } from "os";
+import { join } from "path";
+async function isCommandAvailable(command) {
+  try {
+    return !!await which(command);
+  } catch {
+    return false;
+  }
+}
+function isConductor() {
+  return process.env.__CFBundleIdentifier === "com.conductor.app";
+}
+function detectTerminal() {
+  if (process.env.CURSOR_TRACE_ID)
+    return "cursor";
+  if (process.env.VSCODE_GIT_ASKPASS_MAIN?.includes("cursor")) {
+    return "cursor";
+  }
+  if (process.env.VSCODE_GIT_ASKPASS_MAIN?.includes("windsurf")) {
+    return "windsurf";
+  }
+  if (process.env.VSCODE_GIT_ASKPASS_MAIN?.includes("antigravity")) {
+    return "antigravity";
+  }
+  const bundleId = process.env.__CFBundleIdentifier?.toLowerCase();
+  if (bundleId?.includes("vscodium"))
+    return "codium";
+  if (bundleId?.includes("windsurf"))
+    return "windsurf";
+  if (bundleId?.includes("com.google.android.studio"))
+    return "androidstudio";
+  if (bundleId) {
+    for (const ide of JETBRAINS_IDES) {
+      if (bundleId.includes(ide))
+        return ide;
+    }
+  }
+  if (process.env.VisualStudioVersion) {
+    return "visualstudio";
+  }
+  if (process.env.TERMINAL_EMULATOR === "JetBrains-JediTerm") {
+    if (process.platform === "darwin")
+      return "pycharm";
+    return "pycharm";
+  }
+  if (process.env.TERM === "xterm-ghostty") {
+    return "ghostty";
+  }
+  if (process.env.TERM?.includes("kitty")) {
+    return "kitty";
+  }
+  if (process.env.TERM_PROGRAM) {
+    return process.env.TERM_PROGRAM;
+  }
+  if (process.env.TMUX)
+    return "tmux";
+  if (process.env.STY)
+    return "screen";
+  if (process.env.KONSOLE_VERSION)
+    return "konsole";
+  if (process.env.GNOME_TERMINAL_SERVICE)
+    return "gnome-terminal";
+  if (process.env.XTERM_VERSION)
+    return "xterm";
+  if (process.env.VTE_VERSION)
+    return "vte-based";
+  if (process.env.TERMINATOR_UUID)
+    return "terminator";
+  if (process.env.KITTY_WINDOW_ID) {
+    return "kitty";
+  }
+  if (process.env.ALACRITTY_LOG)
+    return "alacritty";
+  if (process.env.TILIX_ID)
+    return "tilix";
+  if (process.env.WT_SESSION)
+    return "windows-terminal";
+  if (process.env.SESSIONNAME && process.env.TERM === "cygwin")
+    return "cygwin";
+  if (process.env.MSYSTEM)
+    return process.env.MSYSTEM.toLowerCase();
+  if (process.env.ConEmuANSI || process.env.ConEmuPID || process.env.ConEmuTask) {
+    return "conemu";
+  }
+  if (process.env.WSL_DISTRO_NAME)
+    return `wsl-${process.env.WSL_DISTRO_NAME}`;
+  if (isSSHSession()) {
+    return "ssh-session";
+  }
+  if (process.env.TERM) {
+    const term = process.env.TERM;
+    if (term.includes("alacritty"))
+      return "alacritty";
+    if (term.includes("rxvt"))
+      return "rxvt";
+    if (term.includes("termite"))
+      return "termite";
+    return process.env.TERM;
+  }
+  if (!process.stdout.isTTY)
+    return "non-interactive";
+  return null;
+}
+function isSSHSession() {
+  return !!(process.env.SSH_CONNECTION || process.env.SSH_CLIENT || process.env.SSH_TTY);
+}
+function getHostPlatformForAnalytics() {
+  const override = process.env.CLAUDE_CODE_HOST_PLATFORM;
+  if (override === "win32" || override === "darwin" || override === "linux") {
+    return override;
+  }
+  return env.platform;
+}
+var getGlobalClaudeFile, hasInternetAccess, detectPackageManagers, detectRuntimes, isWslEnvironment, isNpmFromWindowsPath, JETBRAINS_IDES, detectDeploymentEnvironment, env;
+var init_env = __esm(() => {
+  init_memoize();
+  init_oauth();
+  init_bundledMode();
+  init_envUtils();
+  init_findExecutable();
+  init_fsOperations();
+  init_which();
+  getGlobalClaudeFile = memoize_default(() => {
+    if (getFsImplementation().existsSync(join(getClaudeConfigHomeDir(), ".config.json"))) {
+      return join(getClaudeConfigHomeDir(), ".config.json");
+    }
+    const filename = `.claude${fileSuffixForOauthConfig()}.json`;
+    return join(process.env.CLAUDE_CONFIG_DIR || homedir(), filename);
+  });
+  hasInternetAccess = memoize_default(async () => {
+    try {
+      const { default: axiosClient } = await import("./chunk-t29a6zb5.js");
+      await axiosClient.head("http://1.1.1.1", {
+        signal: AbortSignal.timeout(1000)
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  });
+  detectPackageManagers = memoize_default(async () => {
+    const packageManagers = [];
+    if (await isCommandAvailable("npm"))
+      packageManagers.push("npm");
+    if (await isCommandAvailable("yarn"))
+      packageManagers.push("yarn");
+    if (await isCommandAvailable("pnpm"))
+      packageManagers.push("pnpm");
+    return packageManagers;
+  });
+  detectRuntimes = memoize_default(async () => {
+    const runtimes = [];
+    if (await isCommandAvailable("bun"))
+      runtimes.push("bun");
+    if (await isCommandAvailable("deno"))
+      runtimes.push("deno");
+    if (await isCommandAvailable("node"))
+      runtimes.push("node");
+    return runtimes;
+  });
+  isWslEnvironment = memoize_default(() => {
+    try {
+      return getFsImplementation().existsSync("/proc/sys/fs/binfmt_misc/WSLInterop");
+    } catch (_error) {
+      return false;
+    }
+  });
+  isNpmFromWindowsPath = memoize_default(() => {
+    try {
+      if (!isWslEnvironment()) {
+        return false;
+      }
+      const { cmd } = findExecutable("npm", []);
+      return cmd.startsWith("/mnt/c/");
+    } catch (_error) {
+      return false;
+    }
+  });
+  JETBRAINS_IDES = [
+    "pycharm",
+    "intellij",
+    "webstorm",
+    "phpstorm",
+    "rubymine",
+    "clion",
+    "goland",
+    "rider",
+    "datagrip",
+    "appcode",
+    "dataspell",
+    "aqua",
+    "gateway",
+    "fleet",
+    "jetbrains",
+    "androidstudio"
+  ];
+  detectDeploymentEnvironment = memoize_default(() => {
+    if (isEnvTruthy(process.env.CODESPACES))
+      return "codespaces";
+    if (process.env.GITPOD_WORKSPACE_ID)
+      return "gitpod";
+    if (process.env.REPL_ID || process.env.REPL_SLUG)
+      return "replit";
+    if (process.env.PROJECT_DOMAIN)
+      return "glitch";
+    if (isEnvTruthy(process.env.VERCEL))
+      return "vercel";
+    if (process.env.RAILWAY_ENVIRONMENT_NAME || process.env.RAILWAY_SERVICE_NAME) {
+      return "railway";
+    }
+    if (isEnvTruthy(process.env.RENDER))
+      return "render";
+    if (isEnvTruthy(process.env.NETLIFY))
+      return "netlify";
+    if (process.env.DYNO)
+      return "heroku";
+    if (process.env.FLY_APP_NAME || process.env.FLY_MACHINE_ID)
+      return "fly.io";
+    if (isEnvTruthy(process.env.CF_PAGES))
+      return "cloudflare-pages";
+    if (process.env.DENO_DEPLOYMENT_ID)
+      return "deno-deploy";
+    if (process.env.AWS_LAMBDA_FUNCTION_NAME)
+      return "aws-lambda";
+    if (process.env.AWS_EXECUTION_ENV === "AWS_ECS_FARGATE")
+      return "aws-fargate";
+    if (process.env.AWS_EXECUTION_ENV === "AWS_ECS_EC2")
+      return "aws-ecs";
+    try {
+      const uuid = getFsImplementation().readFileSync("/sys/hypervisor/uuid", { encoding: "utf8" }).trim().toLowerCase();
+      if (uuid.startsWith("ec2"))
+        return "aws-ec2";
+    } catch {}
+    if (process.env.K_SERVICE)
+      return "gcp-cloud-run";
+    if (process.env.GOOGLE_CLOUD_PROJECT)
+      return "gcp";
+    if (process.env.WEBSITE_SITE_NAME || process.env.WEBSITE_SKU)
+      return "azure-app-service";
+    if (process.env.AZURE_FUNCTIONS_ENVIRONMENT)
+      return "azure-functions";
+    if (process.env.APP_URL?.includes("ondigitalocean.app")) {
+      return "digitalocean-app-platform";
+    }
+    if (process.env.SPACE_CREATOR_USER_ID)
+      return "huggingface-spaces";
+    if (isEnvTruthy(process.env.GITHUB_ACTIONS))
+      return "github-actions";
+    if (isEnvTruthy(process.env.GITLAB_CI))
+      return "gitlab-ci";
+    if (process.env.CIRCLECI)
+      return "circleci";
+    if (process.env.BUILDKITE)
+      return "buildkite";
+    if (isEnvTruthy(process.env.CI))
+      return "ci";
+    if (process.env.KUBERNETES_SERVICE_HOST)
+      return "kubernetes";
+    try {
+      if (getFsImplementation().existsSync("/.dockerenv"))
+        return "docker";
+    } catch {}
+    if (env.platform === "darwin")
+      return "unknown-darwin";
+    if (env.platform === "linux")
+      return "unknown-linux";
+    if (env.platform === "win32")
+      return "unknown-win32";
+    return "unknown";
+  });
+  env = {
+    hasInternetAccess,
+    isCI: isEnvTruthy(process.env.CI),
+    platform: ["win32", "darwin"].includes(process.platform) ? process.platform : "linux",
+    arch: process.arch,
+    nodeVersion: process.version,
+    terminal: detectTerminal(),
+    isSSH: isSSHSession,
+    getPackageManagers: detectPackageManagers,
+    getRuntimes: detectRuntimes,
+    isRunningWithBun: memoize_default(isRunningWithBun),
+    isWslEnvironment,
+    isNpmFromWindowsPath,
+    isConductor,
+    detectDeploymentEnvironment
+  };
+});
+
+export { CLAUDE_AI_INFERENCE_SCOPE, OAUTH_BETA_HEADER, CLAUDE_AI_OAUTH_SCOPES, ALL_OAUTH_SCOPES, MCP_CLIENT_METADATA_URL, getOauthConfig, init_oauth, isRunningWithBun, isInBundledMode, init_bundledMode, findExecutable, init_findExecutable, getGlobalClaudeFile, JETBRAINS_IDES, env, getHostPlatformForAnalytics, init_env };