@caspian2026/agent-sdk 0.0.2

package/dist/chunk-kbm69rtz.js

@@ -0,0 +1,276 @@
+// @bun
+import {
+  init_useKeybinding
+} from "./chunk-68ffk5qa.js";
+import {
+  getOAuthHeaders,
+  init_api,
+  prepareApiRequest
+} from "./chunk-b0qptb1k.js";
+import {
+  getGlobalConfig,
+  getOauthAccountInfo,
+  getSubscriptionType,
+  init_auth,
+  init_config,
+  isClaudeAISubscriber,
+  saveGlobalConfig
+} from "./chunk-tp2jxmcx.js";
+import {
+  getOauthConfig,
+  init_oauth
+} from "./chunk-s3hsqf80.js";
+import {
+  init_src,
+  useDoublePress,
+  useKeybindings,
+  use_app_default
+} from "./chunk-c7jwbe76.js";
+import {
+  require_react
+} from "./chunk-7sgtxrsc.js";
+import {
+  init_log,
+  init_privacyLevel,
+  isEssentialTrafficOnly,
+  logError
+} from "./chunk-1nk93fqz.js";
+import {
+  init_debug,
+  logForDebugging
+} from "./chunk-phd1qfpc.js";
+import {
+  axios_default,
+  init_axios
+} from "./chunk-55raexh7.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/hooks/useDoublePress.ts
+var init_useDoublePress = __esm(() => {
+  init_src();
+  init_src();
+});
+
+// src/hooks/useExitOnCtrlCD.ts
+function useExitOnCtrlCD(useKeybindingsHook, onInterrupt, onExit, isActive = true) {
+  const { exit } = use_app_default();
+  const [exitState, setExitState] = import_react.useState({
+    pending: false,
+    keyName: null
+  });
+  const exitFn = import_react.useMemo(() => onExit ?? exit, [onExit, exit]);
+  const handleCtrlCDoublePress = useDoublePress((pending) => setExitState({ pending, keyName: "Ctrl-C" }), exitFn);
+  const handleCtrlDDoublePress = useDoublePress((pending) => setExitState({ pending, keyName: "Ctrl-D" }), exitFn);
+  const handleInterrupt = import_react.useCallback(() => {
+    if (onInterrupt?.())
+      return;
+    handleCtrlCDoublePress();
+  }, [handleCtrlCDoublePress, onInterrupt]);
+  const handleExit = import_react.useCallback(() => {
+    handleCtrlDDoublePress();
+  }, [handleCtrlDDoublePress]);
+  const handlers = import_react.useMemo(() => ({
+    "app:interrupt": handleInterrupt,
+    "app:exit": handleExit
+  }), [handleInterrupt, handleExit]);
+  useKeybindingsHook(handlers, { context: "Global", isActive });
+  return exitState;
+}
+var import_react;
+var init_useExitOnCtrlCD = __esm(() => {
+  init_src();
+  init_useDoublePress();
+  import_react = __toESM(require_react(), 1);
+});
+
+// src/hooks/useExitOnCtrlCDWithKeybindings.ts
+function useExitOnCtrlCDWithKeybindings(onExit, onInterrupt, isActive) {
+  return useExitOnCtrlCD(useKeybindings, onInterrupt, onExit, isActive);
+}
+var init_useExitOnCtrlCDWithKeybindings = __esm(() => {
+  init_useKeybinding();
+  init_useExitOnCtrlCD();
+});
+
+// src/services/api/referral.ts
+async function fetchReferralEligibility(campaign = "claude_code_guest_pass") {
+  const { accessToken, orgUUID } = await prepareApiRequest();
+  const headers = {
+    ...getOAuthHeaders(accessToken),
+    "x-organization-uuid": orgUUID
+  };
+  const url = `${getOauthConfig().BASE_API_URL}/api/oauth/organizations/${orgUUID}/referral/eligibility`;
+  const response = await axios_default.get(url, {
+    headers,
+    params: { campaign },
+    timeout: 5000
+  });
+  return response.data;
+}
+async function fetchReferralRedemptions(campaign = "claude_code_guest_pass") {
+  const { accessToken, orgUUID } = await prepareApiRequest();
+  const headers = {
+    ...getOAuthHeaders(accessToken),
+    "x-organization-uuid": orgUUID
+  };
+  const url = `${getOauthConfig().BASE_API_URL}/api/oauth/organizations/${orgUUID}/referral/redemptions`;
+  const response = await axios_default.get(url, {
+    headers,
+    params: { campaign },
+    timeout: 1e4
+  });
+  return response.data;
+}
+function shouldCheckForPasses() {
+  return !!(getOauthAccountInfo()?.organizationUuid && isClaudeAISubscriber() && getSubscriptionType() === "max");
+}
+function checkCachedPassesEligibility() {
+  if (!shouldCheckForPasses()) {
+    return {
+      eligible: false,
+      needsRefresh: false,
+      hasCache: false
+    };
+  }
+  const orgId = getOauthAccountInfo()?.organizationUuid;
+  if (!orgId) {
+    return {
+      eligible: false,
+      needsRefresh: false,
+      hasCache: false
+    };
+  }
+  const config = getGlobalConfig();
+  const cachedEntry = config.passesEligibilityCache?.[orgId];
+  if (!cachedEntry) {
+    return {
+      eligible: false,
+      needsRefresh: true,
+      hasCache: false
+    };
+  }
+  const { eligible, timestamp } = cachedEntry;
+  const now = Date.now();
+  const needsRefresh = now - timestamp > CACHE_EXPIRATION_MS;
+  return {
+    eligible,
+    needsRefresh,
+    hasCache: true
+  };
+}
+function formatCreditAmount(reward) {
+  const symbol = CURRENCY_SYMBOLS[reward.currency] ?? `${reward.currency} `;
+  const amount = reward.amount_minor_units / 100;
+  const formatted = amount % 1 === 0 ? amount.toString() : amount.toFixed(2);
+  return `${symbol}${formatted}`;
+}
+function getCachedReferrerReward() {
+  const orgId = getOauthAccountInfo()?.organizationUuid;
+  if (!orgId)
+    return null;
+  const config = getGlobalConfig();
+  const cachedEntry = config.passesEligibilityCache?.[orgId];
+  return cachedEntry?.referrer_reward ?? null;
+}
+function getCachedRemainingPasses() {
+  const orgId = getOauthAccountInfo()?.organizationUuid;
+  if (!orgId)
+    return null;
+  const config = getGlobalConfig();
+  const cachedEntry = config.passesEligibilityCache?.[orgId];
+  return cachedEntry?.remaining_passes ?? null;
+}
+async function fetchAndStorePassesEligibility() {
+  if (fetchInProgress) {
+    logForDebugging("Passes: Reusing in-flight eligibility fetch");
+    return fetchInProgress;
+  }
+  const orgId = getOauthAccountInfo()?.organizationUuid;
+  if (!orgId) {
+    return null;
+  }
+  fetchInProgress = (async () => {
+    try {
+      const response = await fetchReferralEligibility();
+      const cacheEntry = {
+        ...response,
+        timestamp: Date.now()
+      };
+      saveGlobalConfig((current) => ({
+        ...current,
+        passesEligibilityCache: {
+          ...current.passesEligibilityCache,
+          [orgId]: cacheEntry
+        }
+      }));
+      logForDebugging(`Passes eligibility cached for org ${orgId}: ${response.eligible}`);
+      return response;
+    } catch (error) {
+      logForDebugging("Failed to fetch and cache passes eligibility");
+      logError(error);
+      return null;
+    } finally {
+      fetchInProgress = null;
+    }
+  })();
+  return fetchInProgress;
+}
+async function getCachedOrFetchPassesEligibility() {
+  if (!shouldCheckForPasses()) {
+    return null;
+  }
+  const orgId = getOauthAccountInfo()?.organizationUuid;
+  if (!orgId) {
+    return null;
+  }
+  const config = getGlobalConfig();
+  const cachedEntry = config.passesEligibilityCache?.[orgId];
+  const now = Date.now();
+  if (!cachedEntry) {
+    logForDebugging("Passes: No cache, fetching eligibility in background (command unavailable this session)");
+    fetchAndStorePassesEligibility();
+    return null;
+  }
+  if (now - cachedEntry.timestamp > CACHE_EXPIRATION_MS) {
+    logForDebugging("Passes: Cache stale, returning cached data and refreshing in background");
+    fetchAndStorePassesEligibility();
+    const { timestamp: timestamp2, ...response2 } = cachedEntry;
+    return response2;
+  }
+  logForDebugging("Passes: Using fresh cached eligibility data");
+  const { timestamp, ...response } = cachedEntry;
+  return response;
+}
+async function prefetchPassesEligibility() {
+  if (isEssentialTrafficOnly()) {
+    return;
+  }
+  getCachedOrFetchPassesEligibility();
+}
+var CACHE_EXPIRATION_MS, fetchInProgress = null, CURRENCY_SYMBOLS;
+var init_referral = __esm(() => {
+  init_axios();
+  init_oauth();
+  init_auth();
+  init_config();
+  init_debug();
+  init_log();
+  init_privacyLevel();
+  init_api();
+  CACHE_EXPIRATION_MS = 24 * 60 * 60 * 1000;
+  CURRENCY_SYMBOLS = {
+    USD: "$",
+    EUR: "\u20AC",
+    GBP: "\xA3",
+    BRL: "R$",
+    CAD: "CA$",
+    AUD: "A$",
+    NZD: "NZ$",
+    SGD: "S$"
+  };
+});
+
+export { init_useDoublePress, useExitOnCtrlCDWithKeybindings, init_useExitOnCtrlCDWithKeybindings, fetchReferralRedemptions, checkCachedPassesEligibility, formatCreditAmount, getCachedReferrerReward, getCachedRemainingPasses, getCachedOrFetchPassesEligibility, prefetchPassesEligibility, init_referral };

package/dist/chunk-kjh11txh.js

@@ -0,0 +1,419 @@
+// @bun
+import {
+  PermissionDialog
+} from "./chunk-mswx2nma.js";
+import {
+  BASH_TOOL_NAME,
+  SAFE_ENV_VARS,
+  Select,
+  getMcpConfigsByScope,
+  getPermissionRulesForSource,
+  gracefulShutdownSync,
+  init_CustomSelect,
+  init_config as init_config2,
+  init_gracefulShutdown,
+  init_managedEnvConstants,
+  init_permissionsLoader,
+  init_toolName
+} from "./chunk-vzgkedm9.js";
+import"./chunk-46hdszda.js";
+import"./chunk-hwfknpxv.js";
+import"./chunk-4nspekjp.js";
+import"./chunk-jzthz1bx.js";
+import"./chunk-1gx78081.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-68w91pzt.js";
+import"./chunk-s4cb0bcb.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-bxcfz5gy.js";
+import"./chunk-nebezy1d.js";
+import"./chunk-wayfjcwt.js";
+import {
+  init_useExitOnCtrlCDWithKeybindings,
+  useExitOnCtrlCDWithKeybindings
+} from "./chunk-kbm69rtz.js";
+import"./chunk-j5bth84e.js";
+import"./chunk-nxgsnh2y.js";
+import {
+  init_useKeybinding
+} from "./chunk-68ffk5qa.js";
+import"./chunk-ps49ymvj.js";
+import"./chunk-bmbq6nt1.js";
+import"./chunk-15sfg4bs.js";
+import"./chunk-p7vkh4wx.js";
+import"./chunk-b0qptb1k.js";
+import"./chunk-m87bhhqv.js";
+import"./chunk-j3zhb8vv.js";
+import"./chunk-b2fd462a.js";
+import"./chunk-c11swzas.js";
+import"./chunk-chsyvavm.js";
+import"./chunk-5rv9c8yd.js";
+import {
+  checkHasTrustDialogAccepted,
+  getSettingsForSource,
+  init_config,
+  init_settings1 as init_settings,
+  saveCurrentProjectConfig
+} from "./chunk-tp2jxmcx.js";
+import"./chunk-z19sd3bt.js";
+import"./chunk-1ax1znzj.js";
+import"./chunk-wha6v7za.js";
+import"./chunk-6nsd9606.js";
+import"./chunk-xp61y5ba.js";
+import"./chunk-64c1avct.js";
+import"./chunk-8g5pe1gr.js";
+import"./chunk-4cp6193g.js";
+import"./chunk-8g747a8x.js";
+import"./chunk-d7886r6a.js";
+import"./chunk-yvtzznds.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-qz2x630m.js";
+import"./chunk-2f21meep.js";
+import"./chunk-nrtksr2p.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-s3hsqf80.js";
+import"./chunk-yyf72f78.js";
+import"./chunk-cdz5yb0r.js";
+import {
+  Link,
+  ThemedBox_default,
+  ThemedText,
+  init_src,
+  useKeybinding
+} from "./chunk-c7jwbe76.js";
+import"./chunk-0vkfrmqm.js";
+import {
+  require_jsx_dev_runtime,
+  require_react
+} from "./chunk-7sgtxrsc.js";
+import"./chunk-0xjaqda8.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-x8d2ehd7.js";
+import"./chunk-15m49c67.js";
+import"./chunk-tdbz9gbm.js";
+import"./chunk-0awwmrwr.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-70eey1nh.js";
+import"./chunk-1nk93fqz.js";
+import {
+  getCwd,
+  init_cwd
+} from "./chunk-s8kj6ajy.js";
+import"./chunk-eenq3avg.js";
+import"./chunk-7mqab3z7.js";
+import"./chunk-5z28bqne.js";
+import"./chunk-qajrkk97.js";
+import {
+  getFsImplementation,
+  init_fsOperations
+} from "./chunk-phd1qfpc.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-jaaxk89e.js";
+import {
+  init_state,
+  setSessionTrustAccepted
+} from "./chunk-k8vp0atq.js";
+import"./chunk-vf612n57.js";
+import"./chunk-07069jq1.js";
+import"./chunk-d4mdda98.js";
+import"./chunk-55raexh7.js";
+import"./chunk-v9smspw2.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-b0kf00ff.js";
+import"./chunk-netzwgv1.js";
+import {
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/components/TrustDialog/TrustDialog.tsx
+init_analytics();
+init_state();
+init_useExitOnCtrlCDWithKeybindings();
+init_src();
+init_useKeybinding();
+init_config2();
+init_toolName();
+init_config();
+init_cwd();
+init_fsOperations();
+init_gracefulShutdown();
+init_CustomSelect();
+var import_react = __toESM(require_react(), 1);
+import { homedir } from "os";
+
+// src/components/TrustDialog/utils.ts
+init_settings();
+init_toolName();
+init_managedEnvConstants();
+init_permissionsLoader();
+function hasHooks(settings) {
+  if (settings === null || settings.disableAllHooks) {
+    return false;
+  }
+  if (settings.statusLine) {
+    return true;
+  }
+  if (settings.fileSuggestion) {
+    return true;
+  }
+  if (!settings.hooks) {
+    return false;
+  }
+  for (const hookConfig of Object.values(settings.hooks)) {
+    if (hookConfig.length > 0) {
+      return true;
+    }
+  }
+  return false;
+}
+function getHooksSources() {
+  const sources = [];
+  const projectSettings = getSettingsForSource("projectSettings");
+  if (hasHooks(projectSettings)) {
+    sources.push(".claude/settings.json");
+  }
+  const localSettings = getSettingsForSource("localSettings");
+  if (hasHooks(localSettings)) {
+    sources.push(".claude/settings.local.json");
+  }
+  return sources;
+}
+function hasBashPermission(rules) {
+  return rules.some((rule) => rule.ruleBehavior === "allow" && (rule.ruleValue.toolName === BASH_TOOL_NAME || rule.ruleValue.toolName.startsWith(BASH_TOOL_NAME + "(")));
+}
+function getBashPermissionSources() {
+  const sources = [];
+  const projectRules = getPermissionRulesForSource("projectSettings");
+  if (hasBashPermission(projectRules)) {
+    sources.push(".claude/settings.json");
+  }
+  const localRules = getPermissionRulesForSource("localSettings");
+  if (hasBashPermission(localRules)) {
+    sources.push(".claude/settings.local.json");
+  }
+  return sources;
+}
+function hasOtelHeadersHelper(settings) {
+  return !!settings?.otelHeadersHelper;
+}
+function getOtelHeadersHelperSources() {
+  const sources = [];
+  const projectSettings = getSettingsForSource("projectSettings");
+  if (hasOtelHeadersHelper(projectSettings)) {
+    sources.push(".claude/settings.json");
+  }
+  const localSettings = getSettingsForSource("localSettings");
+  if (hasOtelHeadersHelper(localSettings)) {
+    sources.push(".claude/settings.local.json");
+  }
+  return sources;
+}
+function hasApiKeyHelper(settings) {
+  return !!settings?.apiKeyHelper;
+}
+function getApiKeyHelperSources() {
+  const sources = [];
+  const projectSettings = getSettingsForSource("projectSettings");
+  if (hasApiKeyHelper(projectSettings)) {
+    sources.push(".claude/settings.json");
+  }
+  const localSettings = getSettingsForSource("localSettings");
+  if (hasApiKeyHelper(localSettings)) {
+    sources.push(".claude/settings.local.json");
+  }
+  return sources;
+}
+function hasAwsCommands(settings) {
+  return !!(settings?.awsAuthRefresh || settings?.awsCredentialExport);
+}
+function getAwsCommandsSources() {
+  const sources = [];
+  const projectSettings = getSettingsForSource("projectSettings");
+  if (hasAwsCommands(projectSettings)) {
+    sources.push(".claude/settings.json");
+  }
+  const localSettings = getSettingsForSource("localSettings");
+  if (hasAwsCommands(localSettings)) {
+    sources.push(".claude/settings.local.json");
+  }
+  return sources;
+}
+function hasGcpCommands(settings) {
+  return !!settings?.gcpAuthRefresh;
+}
+function getGcpCommandsSources() {
+  const sources = [];
+  const projectSettings = getSettingsForSource("projectSettings");
+  if (hasGcpCommands(projectSettings)) {
+    sources.push(".claude/settings.json");
+  }
+  const localSettings = getSettingsForSource("localSettings");
+  if (hasGcpCommands(localSettings)) {
+    sources.push(".claude/settings.local.json");
+  }
+  return sources;
+}
+function hasDangerousEnvVars(settings) {
+  if (!settings?.env) {
+    return false;
+  }
+  return Object.keys(settings.env).some((key) => !SAFE_ENV_VARS.has(key.toUpperCase()));
+}
+function getDangerousEnvVarsSources() {
+  const sources = [];
+  const projectSettings = getSettingsForSource("projectSettings");
+  if (hasDangerousEnvVars(projectSettings)) {
+    sources.push(".claude/settings.json");
+  }
+  const localSettings = getSettingsForSource("localSettings");
+  if (hasDangerousEnvVars(localSettings)) {
+    sources.push(".claude/settings.local.json");
+  }
+  return sources;
+}
+
+// src/components/TrustDialog/TrustDialog.tsx
+var jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+function TrustDialog({ onDone, commands }) {
+  const { servers: projectServers } = getMcpConfigsByScope("project");
+  const hasMcpServers = Object.keys(projectServers).length > 0;
+  const hooksSettingSources = getHooksSources();
+  const hasHooks2 = hooksSettingSources.length > 0;
+  const bashSettingSources = getBashPermissionSources();
+  const apiKeyHelperSources = getApiKeyHelperSources();
+  const hasApiKeyHelper2 = apiKeyHelperSources.length > 0;
+  const awsCommandsSources = getAwsCommandsSources();
+  const hasAwsCommands2 = awsCommandsSources.length > 0;
+  const gcpCommandsSources = getGcpCommandsSources();
+  const hasGcpCommands2 = gcpCommandsSources.length > 0;
+  const otelHeadersHelperSources = getOtelHeadersHelperSources();
+  const hasOtelHeadersHelper2 = otelHeadersHelperSources.length > 0;
+  const dangerousEnvVarsSources = getDangerousEnvVarsSources();
+  const hasDangerousEnvVars2 = dangerousEnvVarsSources.length > 0;
+  const hasSlashCommandBash = commands?.some((command) => command.type === "prompt" && command.loadedFrom === "commands_DEPRECATED" && (command.source === "projectSettings" || command.source === "localSettings") && command.allowedTools?.some((tool) => tool === BASH_TOOL_NAME || tool.startsWith(BASH_TOOL_NAME + "("))) ?? false;
+  const hasSkillsBash = commands?.some((command) => command.type === "prompt" && (command.loadedFrom === "skills" || command.loadedFrom === "plugin") && (command.source === "projectSettings" || command.source === "localSettings" || command.source === "plugin") && command.allowedTools?.some((tool) => tool === BASH_TOOL_NAME || tool.startsWith(BASH_TOOL_NAME + "("))) ?? false;
+  const hasAnyBashExecution = bashSettingSources.length > 0 || hasSlashCommandBash || hasSkillsBash;
+  const hasTrustDialogAccepted = checkHasTrustDialogAccepted();
+  import_react.default.useEffect(() => {
+    const isHomeDir = homedir() === getCwd();
+    logEvent("tengu_trust_dialog_shown", {
+      isHomeDir,
+      hasMcpServers,
+      hasHooks: hasHooks2,
+      hasBashExecution: hasAnyBashExecution,
+      hasApiKeyHelper: hasApiKeyHelper2,
+      hasAwsCommands: hasAwsCommands2,
+      hasGcpCommands: hasGcpCommands2,
+      hasOtelHeadersHelper: hasOtelHeadersHelper2,
+      hasDangerousEnvVars: hasDangerousEnvVars2
+    });
+  }, [
+    hasMcpServers,
+    hasHooks2,
+    hasAnyBashExecution,
+    hasApiKeyHelper2,
+    hasAwsCommands2,
+    hasGcpCommands2,
+    hasOtelHeadersHelper2,
+    hasDangerousEnvVars2
+  ]);
+  function onChange(value) {
+    if (value === "exit") {
+      gracefulShutdownSync(1);
+      return;
+    }
+    const isHomeDir = homedir() === getCwd();
+    logEvent("tengu_trust_dialog_accept", {
+      isHomeDir,
+      hasMcpServers,
+      hasHooks: hasHooks2,
+      hasBashExecution: hasAnyBashExecution,
+      hasApiKeyHelper: hasApiKeyHelper2,
+      hasAwsCommands: hasAwsCommands2,
+      hasGcpCommands: hasGcpCommands2,
+      hasOtelHeadersHelper: hasOtelHeadersHelper2,
+      hasDangerousEnvVars: hasDangerousEnvVars2
+    });
+    if (isHomeDir) {
+      setSessionTrustAccepted(true);
+    } else {
+      saveCurrentProjectConfig((current) => ({
+        ...current,
+        hasTrustDialogAccepted: true
+      }));
+    }
+    onDone();
+  }
+  const exitState = useExitOnCtrlCDWithKeybindings(() => gracefulShutdownSync(1));
+  useKeybinding("confirm:no", () => {
+    gracefulShutdownSync(0);
+  }, { context: "Confirmation" });
+  if (hasTrustDialogAccepted) {
+    setTimeout(onDone);
+    return null;
+  }
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(PermissionDialog, {
+    color: "warning",
+    titleColor: "warning",
+    title: "Accessing workspace:",
+    children: /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+      flexDirection: "column",
+      gap: 1,
+      paddingTop: 1,
+      children: [
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+          bold: true,
+          children: getFsImplementation().cwd()
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+          children: [
+            "Quick safety check: Is this a project you created or one you trust? (Like your own code, a well-known open source project, or work from your team). If not, take a moment to review what",
+            "'",
+            "s in this folder first."
+          ]
+        }, undefined, true, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+          children: [
+            "Claude Code",
+            "'",
+            "ll be able to read, edit, and execute files here."
+          ]
+        }, undefined, true, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+          dimColor: true,
+          children: /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Link, {
+            url: "https://code.claude.com/docs/en/security",
+            children: "Security guide"
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Select, {
+          options: [
+            { label: "Yes, I trust this folder", value: "enable_all" },
+            { label: "No, exit", value: "exit" }
+          ],
+          onChange: (value) => onChange(value),
+          onCancel: () => onChange("exit")
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+          dimColor: true,
+          children: exitState.pending ? /* @__PURE__ */ jsx_dev_runtime.jsxDEV(jsx_dev_runtime.Fragment, {
+            children: [
+              "Press ",
+              exitState.keyName,
+              " again to exit"
+            ]
+          }, undefined, true, undefined, this) : /* @__PURE__ */ jsx_dev_runtime.jsxDEV(jsx_dev_runtime.Fragment, {
+            children: "Enter to confirm \xB7 Esc to cancel"
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this)
+  }, undefined, false, undefined, this);
+}
+export {
+  TrustDialog
+};