@zyycn/claudex 1.0.3-fork.0cb3e59

package/dist/chunk-4f6xmap7.js

@@ -0,0 +1,153 @@
+// @bun
+import {
+  calculateApiKeyHelperTTL,
+  checkAndRefreshOAuthTokenIfNeeded,
+  checkGcpCredentialsValid,
+  clearApiKeyHelperCache,
+  clearAwsCredentialsCache,
+  clearGcpCredentialsCache,
+  clearOAuthTokenCache,
+  getAccountInformation,
+  getAnthropicApiKey,
+  getAnthropicApiKeyWithSource,
+  getApiKeyFromApiKeyHelper,
+  getApiKeyFromApiKeyHelperCached,
+  getApiKeyFromConfigOrMacOSKeychain,
+  getApiKeyHelperElapsedMs,
+  getAuthTokenSource,
+  getClaudeAIOAuthTokens,
+  getClaudeAIOAuthTokensAsync,
+  getConfiguredApiKeyHelper,
+  getOauthAccountInfo,
+  getOtelHeadersFromHelper,
+  getRateLimitTier,
+  getSubscriptionName,
+  getSubscriptionType,
+  handleOAuth401Error,
+  hasAnthropicApiKeyAuth,
+  hasOpusAccess,
+  hasProfileScope,
+  init_auth,
+  is1PApiCustomer,
+  isAnthropicAuthEnabled,
+  isAwsAuthRefreshFromProjectSettings,
+  isAwsCredentialExportFromProjectSettings,
+  isClaudeAISubscriber,
+  isConsumerSubscriber,
+  isCustomApiKeyApproved,
+  isEnterpriseSubscriber,
+  isGcpAuthRefreshFromProjectSettings,
+  isMaxSubscriber,
+  isOtelHeadersHelperFromProjectOrLocalSettings,
+  isOverageProvisioningAllowed,
+  isProSubscriber,
+  isTeamPremiumSubscriber,
+  isTeamSubscriber,
+  isUsing3PServices,
+  prefetchApiKeyFromApiKeyHelperIfSafe,
+  prefetchAwsCredentialsAndBedRockInfoIfSafe,
+  prefetchGcpCredentialsIfSafe,
+  refreshAndGetAwsCredentials,
+  refreshAwsAuth,
+  refreshGcpAuth,
+  refreshGcpCredentialsIfNeeded,
+  removeApiKey,
+  saveApiKey,
+  saveOAuthTokensIfNeeded,
+  validateForceLoginOrg
+} from "./chunk-hgba8zda.js";
+import"./chunk-eebcvtbb.js";
+import"./chunk-xq4cfvpn.js";
+import"./chunk-4qz9vbs1.js";
+import"./chunk-gmaybtrd.js";
+import"./chunk-b75fzr8e.js";
+import"./chunk-g0j0t6qk.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-nj17bhkh.js";
+import"./chunk-55wgxwa9.js";
+import"./chunk-wn2268qd.js";
+import"./chunk-vqvd3qz0.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-wgcssf6v.js";
+import"./chunk-cdz5yb0r.js";
+import"./chunk-h0rbjg6x.js";
+import"./chunk-b8x1gk3y.js";
+import"./chunk-9k2drwej.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-fbpftpf0.js";
+import"./chunk-3vs3nm7w.js";
+import"./chunk-gzzfhtdv.js";
+import"./chunk-yysj6sxt.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-8bedvdm1.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-sbbj6ta3.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-raqgs410.js";
+import"./chunk-qqfa0dqg.js";
+import"./chunk-hqmz36b3.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import"./chunk-xszk7n10.js";
+import"./chunk-sdj9b9wh.js";
+import"./chunk-qp2qdcda.js";
+init_auth();
+
+export {
+  validateForceLoginOrg,
+  saveOAuthTokensIfNeeded,
+  saveApiKey,
+  removeApiKey,
+  refreshGcpCredentialsIfNeeded,
+  refreshGcpAuth,
+  refreshAwsAuth,
+  refreshAndGetAwsCredentials,
+  prefetchGcpCredentialsIfSafe,
+  prefetchAwsCredentialsAndBedRockInfoIfSafe,
+  prefetchApiKeyFromApiKeyHelperIfSafe,
+  isUsing3PServices,
+  isTeamSubscriber,
+  isTeamPremiumSubscriber,
+  isProSubscriber,
+  isOverageProvisioningAllowed,
+  isOtelHeadersHelperFromProjectOrLocalSettings,
+  isMaxSubscriber,
+  isGcpAuthRefreshFromProjectSettings,
+  isEnterpriseSubscriber,
+  isCustomApiKeyApproved,
+  isConsumerSubscriber,
+  isClaudeAISubscriber,
+  isAwsCredentialExportFromProjectSettings,
+  isAwsAuthRefreshFromProjectSettings,
+  isAnthropicAuthEnabled,
+  is1PApiCustomer,
+  hasProfileScope,
+  hasOpusAccess,
+  hasAnthropicApiKeyAuth,
+  handleOAuth401Error,
+  getSubscriptionType,
+  getSubscriptionName,
+  getRateLimitTier,
+  getOtelHeadersFromHelper,
+  getOauthAccountInfo,
+  getConfiguredApiKeyHelper,
+  getClaudeAIOAuthTokensAsync,
+  getClaudeAIOAuthTokens,
+  getAuthTokenSource,
+  getApiKeyHelperElapsedMs,
+  getApiKeyFromConfigOrMacOSKeychain,
+  getApiKeyFromApiKeyHelperCached,
+  getApiKeyFromApiKeyHelper,
+  getAnthropicApiKeyWithSource,
+  getAnthropicApiKey,
+  getAccountInformation,
+  clearOAuthTokenCache,
+  clearGcpCredentialsCache,
+  clearAwsCredentialsCache,
+  clearApiKeyHelperCache,
+  checkGcpCredentialsValid,
+  checkAndRefreshOAuthTokenIfNeeded,
+  calculateApiKeyHelperTTL
+};

package/dist/chunk-4g3v8y12.js

@@ -0,0 +1,23 @@
+// @bun
+import {
+  init_api_promise,
+  init_client,
+  init_error,
+  init_pagination,
+  init_uploads
+} from "./chunk-7739pg2c.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/@anthropic-ai+sdk@0.80.0+3c5d820c62823f0b/node_modules/@anthropic-ai/sdk/index.mjs
+var init_sdk = __esm(() => {
+  init_client();
+  init_uploads();
+  init_api_promise();
+  init_client();
+  init_pagination();
+  init_error();
+});
+
+export { init_sdk };

package/dist/chunk-4j2pg3ms.js

@@ -0,0 +1,338 @@
+// @bun
+import {
+  BROWSER_TOOLS,
+  init_src
+} from "./chunk-gyj242zr.js";
+import {
+  getChromeSystemPrompt,
+  init_prompt
+} from "./chunk-d9y2zh54.js";
+import {
+  CLAUDE_IN_CHROME_MCP_SERVER_NAME,
+  getAllBrowserDataPaths,
+  getAllNativeMessagingHostsDirs,
+  getAllWindowsRegistryKeys,
+  init_common,
+  openInChrome
+} from "./chunk-j5hc27hv.js";
+import {
+  getFeatureValue_CACHED_MAY_BE_STALE,
+  getGlobalConfig,
+  init_config1 as init_config,
+  init_growthbook,
+  saveGlobalConfig
+} from "./chunk-hgba8zda.js";
+import {
+  getPlatform,
+  init_platform
+} from "./chunk-nj17bhkh.js";
+import {
+  init_bundledMode,
+  isInBundledMode
+} from "./chunk-wn2268qd.js";
+import {
+  execFileNoThrowWithCwd,
+  init_execFileNoThrow
+} from "./chunk-gzzfhtdv.js";
+import {
+  init_debug,
+  init_errors,
+  init_slowOperations,
+  isFsInaccessible,
+  jsonStringify,
+  logForDebugging
+} from "./chunk-sbbj6ta3.js";
+import {
+  getClaudeConfigHomeDir,
+  init_envUtils,
+  isEnvDefinedFalsy,
+  isEnvTruthy
+} from "./chunk-raqgs410.js";
+import {
+  getIsInteractive,
+  getIsNonInteractiveSession,
+  getSessionBypassPermissionsMode,
+  init_state
+} from "./chunk-qqfa0dqg.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/claudeInChrome/setupPortable.ts
+import { readdir } from "fs/promises";
+import { join } from "path";
+function getExtensionIds() {
+  return process.env.USER_TYPE === "ant" ? [PROD_EXTENSION_ID, DEV_EXTENSION_ID, ANT_EXTENSION_ID] : [PROD_EXTENSION_ID];
+}
+async function detectExtensionInstallationPortable(browserPaths, log) {
+  if (browserPaths.length === 0) {
+    log?.(`[Claude in Chrome] No browser paths to check`);
+    return { isInstalled: false, browser: null };
+  }
+  const extensionIds = getExtensionIds();
+  for (const { browser, path: browserBasePath } of browserPaths) {
+    let browserProfileEntries = [];
+    try {
+      browserProfileEntries = await readdir(browserBasePath, {
+        withFileTypes: true
+      });
+    } catch (e) {
+      if (isFsInaccessible(e))
+        continue;
+      throw e;
+    }
+    const profileDirs = browserProfileEntries.filter((entry) => entry.isDirectory()).filter((entry) => entry.name === "Default" || entry.name.startsWith("Profile ")).map((entry) => entry.name);
+    if (profileDirs.length > 0) {
+      log?.(`[Claude in Chrome] Found ${browser} profiles: ${profileDirs.join(", ")}`);
+    }
+    for (const profile of profileDirs) {
+      for (const extensionId of extensionIds) {
+        const extensionPath = join(browserBasePath, profile, "Extensions", extensionId);
+        try {
+          await readdir(extensionPath);
+          log?.(`[Claude in Chrome] Extension ${extensionId} found in ${browser} ${profile}`);
+          return { isInstalled: true, browser };
+        } catch {}
+      }
+    }
+  }
+  log?.(`[Claude in Chrome] Extension not found in any browser`);
+  return { isInstalled: false, browser: null };
+}
+async function isChromeExtensionInstalledPortable(browserPaths, log) {
+  const result = await detectExtensionInstallationPortable(browserPaths, log);
+  return result.isInstalled;
+}
+var PROD_EXTENSION_ID = "fcoeoabgfenejglbffodgkkbkcdhcgfn", DEV_EXTENSION_ID = "dihbgbndebgnbjfmelmegjepbnkhlgni", ANT_EXTENSION_ID = "dngcpimnedloihjnnfngkgjoidhnaolf";
+var init_setupPortable = __esm(() => {
+  init_errors();
+});
+
+// src/utils/claudeInChrome/setup.ts
+import { chmod, mkdir, readFile, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { join as join2 } from "path";
+import { fileURLToPath } from "url";
+function shouldEnableClaudeInChrome(chromeFlag) {
+  if (getIsNonInteractiveSession() && chromeFlag !== true) {
+    return false;
+  }
+  if (chromeFlag === true) {
+    return true;
+  }
+  if (chromeFlag === false) {
+    return false;
+  }
+  if (isEnvTruthy(process.env.CLAUDE_CODE_ENABLE_CFC)) {
+    return true;
+  }
+  if (isEnvDefinedFalsy(process.env.CLAUDE_CODE_ENABLE_CFC)) {
+    return false;
+  }
+  const config = getGlobalConfig();
+  if (config.claudeInChromeDefaultEnabled !== undefined) {
+    return config.claudeInChromeDefaultEnabled;
+  }
+  return false;
+}
+function shouldAutoEnableClaudeInChrome() {
+  if (shouldAutoEnable !== undefined) {
+    return shouldAutoEnable;
+  }
+  shouldAutoEnable = getIsInteractive() && isChromeExtensionInstalled_CACHED_MAY_BE_STALE() && (process.env.USER_TYPE === "ant" || getFeatureValue_CACHED_MAY_BE_STALE("tengu_chrome_auto_enable", false));
+  return shouldAutoEnable;
+}
+function setupClaudeInChrome() {
+  const isNativeBuild = isInBundledMode();
+  const allowedTools = BROWSER_TOOLS.map((tool) => `mcp__claude-in-chrome__${tool.name}`);
+  const env = {};
+  if (getSessionBypassPermissionsMode()) {
+    env.CLAUDE_CHROME_PERMISSION_MODE = "skip_all_permission_checks";
+  }
+  const hasEnv = Object.keys(env).length > 0;
+  if (isNativeBuild) {
+    const execCommand = `"${process.execPath}" --chrome-native-host`;
+    createWrapperScript(execCommand).then((manifestBinaryPath) => installChromeNativeHostManifest(manifestBinaryPath)).catch((e) => logForDebugging(`[Claude in Chrome] Failed to install native host: ${e}`, { level: "error" }));
+    return {
+      mcpConfig: {
+        [CLAUDE_IN_CHROME_MCP_SERVER_NAME]: {
+          type: "stdio",
+          command: process.execPath,
+          args: ["--claude-in-chrome-mcp"],
+          scope: "dynamic",
+          ...hasEnv && { env }
+        }
+      },
+      allowedTools,
+      systemPrompt: getChromeSystemPrompt()
+    };
+  } else {
+    const __filename2 = fileURLToPath(import.meta.url);
+    const __dirname2 = join2(__filename2, "..");
+    const cliPath = join2(__dirname2, "cli.js");
+    createWrapperScript(`"${process.execPath}" "${cliPath}" --chrome-native-host`).then((manifestBinaryPath) => installChromeNativeHostManifest(manifestBinaryPath)).catch((e) => logForDebugging(`[Claude in Chrome] Failed to install native host: ${e}`, { level: "error" }));
+    const mcpConfig = {
+      [CLAUDE_IN_CHROME_MCP_SERVER_NAME]: {
+        type: "stdio",
+        command: process.execPath,
+        args: [`${cliPath}`, "--claude-in-chrome-mcp"],
+        scope: "dynamic",
+        ...hasEnv && { env }
+      }
+    };
+    return {
+      mcpConfig,
+      allowedTools,
+      systemPrompt: getChromeSystemPrompt()
+    };
+  }
+}
+function getNativeMessagingHostsDirs() {
+  const platform = getPlatform();
+  if (platform === "windows") {
+    const home = homedir();
+    const appData = process.env.APPDATA || join2(home, "AppData", "Local");
+    return [join2(appData, "Claude Code", "ChromeNativeHost")];
+  }
+  return getAllNativeMessagingHostsDirs().map(({ path }) => path);
+}
+async function installChromeNativeHostManifest(manifestBinaryPath) {
+  const manifestDirs = getNativeMessagingHostsDirs();
+  if (manifestDirs.length === 0) {
+    throw Error("Claude in Chrome Native Host not supported on this platform");
+  }
+  const manifest = {
+    name: NATIVE_HOST_IDENTIFIER,
+    description: "Claude Code Browser Extension Native Host",
+    path: manifestBinaryPath,
+    type: "stdio",
+    allowed_origins: [
+      `chrome-extension://fcoeoabgfenejglbffodgkkbkcdhcgfn/`,
+      ...process.env.USER_TYPE === "ant" ? [
+        "chrome-extension://dihbgbndebgnbjfmelmegjepbnkhlgni/",
+        "chrome-extension://dngcpimnedloihjnnfngkgjoidhnaolf/"
+      ] : []
+    ]
+  };
+  const manifestContent = jsonStringify(manifest, null, 2);
+  let anyManifestUpdated = false;
+  for (const manifestDir of manifestDirs) {
+    const manifestPath = join2(manifestDir, NATIVE_HOST_MANIFEST_NAME);
+    const existingContent = await readFile(manifestPath, "utf-8").catch(() => null);
+    if (existingContent === manifestContent) {
+      continue;
+    }
+    try {
+      await mkdir(manifestDir, { recursive: true });
+      await writeFile(manifestPath, manifestContent);
+      logForDebugging(`[Claude in Chrome] Installed native host manifest at: ${manifestPath}`);
+      anyManifestUpdated = true;
+    } catch (error) {
+      logForDebugging(`[Claude in Chrome] Failed to install manifest at ${manifestPath}: ${error}`);
+    }
+  }
+  if (getPlatform() === "windows") {
+    const manifestPath = join2(manifestDirs[0], NATIVE_HOST_MANIFEST_NAME);
+    registerWindowsNativeHosts(manifestPath);
+  }
+  if (anyManifestUpdated) {
+    isChromeExtensionInstalled().then((isInstalled) => {
+      if (isInstalled) {
+        logForDebugging(`[Claude in Chrome] First-time install detected, opening reconnect page in browser`);
+        openInChrome(CHROME_EXTENSION_RECONNECT_URL);
+      } else {
+        logForDebugging(`[Claude in Chrome] First-time install detected, but extension not installed, skipping reconnect`);
+      }
+    });
+  }
+}
+function registerWindowsNativeHosts(manifestPath) {
+  const registryKeys = getAllWindowsRegistryKeys();
+  for (const { browser, key } of registryKeys) {
+    const fullKey = `${key}\\${NATIVE_HOST_IDENTIFIER}`;
+    execFileNoThrowWithCwd("reg", [
+      "add",
+      fullKey,
+      "/ve",
+      "/t",
+      "REG_SZ",
+      "/d",
+      manifestPath,
+      "/f"
+    ]).then((result) => {
+      if (result.code === 0) {
+        logForDebugging(`[Claude in Chrome] Registered native host for ${browser} in Windows registry: ${fullKey}`);
+      } else {
+        logForDebugging(`[Claude in Chrome] Failed to register native host for ${browser} in Windows registry: ${result.stderr}`);
+      }
+    });
+  }
+}
+async function createWrapperScript(command) {
+  const platform = getPlatform();
+  const chromeDir = join2(getClaudeConfigHomeDir(), "chrome");
+  const wrapperPath = platform === "windows" ? join2(chromeDir, "chrome-native-host.bat") : join2(chromeDir, "chrome-native-host");
+  const scriptContent = platform === "windows" ? `@echo off
+REM Chrome native host wrapper script
+REM Generated by Claude Code - do not edit manually
+${command}
+` : `#!/bin/sh
+# Chrome native host wrapper script
+# Generated by Claude Code - do not edit manually
+exec ${command}
+`;
+  const existingContent = await readFile(wrapperPath, "utf-8").catch(() => null);
+  if (existingContent === scriptContent) {
+    return wrapperPath;
+  }
+  await mkdir(chromeDir, { recursive: true });
+  await writeFile(wrapperPath, scriptContent);
+  if (platform !== "windows") {
+    await chmod(wrapperPath, 493);
+  }
+  logForDebugging(`[Claude in Chrome] Created Chrome native host wrapper script: ${wrapperPath}`);
+  return wrapperPath;
+}
+function isChromeExtensionInstalled_CACHED_MAY_BE_STALE() {
+  isChromeExtensionInstalled().then((isInstalled) => {
+    if (!isInstalled) {
+      return;
+    }
+    const config = getGlobalConfig();
+    if (config.cachedChromeExtensionInstalled !== isInstalled) {
+      saveGlobalConfig((prev) => ({
+        ...prev,
+        cachedChromeExtensionInstalled: isInstalled
+      }));
+    }
+  });
+  const cached = getGlobalConfig().cachedChromeExtensionInstalled;
+  return cached ?? false;
+}
+async function isChromeExtensionInstalled() {
+  const browserPaths = getAllBrowserDataPaths();
+  if (browserPaths.length === 0) {
+    logForDebugging(`[Claude in Chrome] Unsupported platform for extension detection: ${getPlatform()}`);
+    return false;
+  }
+  return isChromeExtensionInstalledPortable(browserPaths, logForDebugging);
+}
+var CHROME_EXTENSION_RECONNECT_URL = "https://clau.de/chrome/reconnect", NATIVE_HOST_IDENTIFIER = "com.anthropic.claude_code_browser_extension", NATIVE_HOST_MANIFEST_NAME, shouldAutoEnable = undefined;
+var init_setup = __esm(() => {
+  init_src();
+  init_state();
+  init_growthbook();
+  init_bundledMode();
+  init_config();
+  init_debug();
+  init_envUtils();
+  init_execFileNoThrow();
+  init_platform();
+  init_slowOperations();
+  init_common();
+  init_prompt();
+  init_setupPortable();
+  NATIVE_HOST_MANIFEST_NAME = `${NATIVE_HOST_IDENTIFIER}.json`;
+});
+
+export { shouldEnableClaudeInChrome, shouldAutoEnableClaudeInChrome, setupClaudeInChrome, isChromeExtensionInstalled, init_setup };

package/dist/chunk-4jm600zv.js

@@ -0,0 +1,13 @@
+// @bun
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/swarm/constants.ts
+function getSwarmSocketName() {
+  return `claude-swarm-${process.pid}`;
+}
+var TEAM_LEAD_NAME = "team-lead", SWARM_SESSION_NAME = "claude-swarm", SWARM_VIEW_WINDOW_NAME = "swarm-view", TMUX_COMMAND = "tmux", HIDDEN_SESSION_NAME = "claude-hidden", TEAMMATE_COMMAND_ENV_VAR = "CLAUDE_CODE_TEAMMATE_COMMAND";
+var init_constants = () => {};
+
+export { TEAM_LEAD_NAME, SWARM_SESSION_NAME, SWARM_VIEW_WINDOW_NAME, TMUX_COMMAND, HIDDEN_SESSION_NAME, getSwarmSocketName, TEAMMATE_COMMAND_ENV_VAR, init_constants };

package/dist/chunk-4ka7s9ee.js

@@ -0,0 +1,115 @@
+// @bun
+import {
+  Feedback,
+  init_Feedback
+} from "./chunk-ar42apnb.js";
+import"./chunk-5eecpt8g.js";
+import"./chunk-czvztj44.js";
+import"./chunk-46xsszyy.js";
+import"./chunk-2zcggr61.js";
+import"./chunk-q0q2tsae.js";
+import"./chunk-t0rgmccj.js";
+import"./chunk-d9y2zh54.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-xffq0yyv.js";
+import"./chunk-02gx6hwz.js";
+import"./chunk-vhjx5fag.js";
+import"./chunk-w2yzntwd.js";
+import"./chunk-kdqsfmc5.js";
+import"./chunk-j5hc27hv.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-0fzmdbg5.js";
+import"./chunk-sn49y8be.js";
+import"./chunk-9gbamk79.js";
+import"./chunk-8rjvjb5t.js";
+import"./chunk-gv0tqhg0.js";
+import"./chunk-nw5zdpcj.js";
+import"./chunk-aa3rx320.js";
+import"./chunk-7m2nd8da.js";
+import"./chunk-ps49ymvj.js";
+import {
+  require_jsx_dev_runtime
+} from "./chunk-g338npwr.js";
+import"./chunk-n2pzg3mt.js";
+import"./chunk-zk2wsm7d.js";
+import"./chunk-tdgkxc3j.js";
+import"./chunk-7e6ahfxz.js";
+import"./chunk-zrw9ava1.js";
+import"./chunk-mx28h61f.js";
+import"./chunk-hgba8zda.js";
+import"./chunk-eebcvtbb.js";
+import"./chunk-xq4cfvpn.js";
+import"./chunk-4qz9vbs1.js";
+import"./chunk-gmaybtrd.js";
+import"./chunk-b75fzr8e.js";
+import"./chunk-g0j0t6qk.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-nj17bhkh.js";
+import"./chunk-55wgxwa9.js";
+import"./chunk-vqk1n5qr.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-wn2268qd.js";
+import"./chunk-vqvd3qz0.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-qz2x630m.js";
+import"./chunk-d9kz373t.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-v9smspw2.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-res15ktd.js";
+import"./chunk-wgcssf6v.js";
+import"./chunk-cdz5yb0r.js";
+import"./chunk-h0rbjg6x.js";
+import"./chunk-dstxhxsx.js";
+import"./chunk-b8x1gk3y.js";
+import"./chunk-9k2drwej.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-fbpftpf0.js";
+import"./chunk-3vs3nm7w.js";
+import"./chunk-gzzfhtdv.js";
+import"./chunk-yysj6sxt.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-8bedvdm1.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-sbbj6ta3.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-raqgs410.js";
+import"./chunk-qqfa0dqg.js";
+import"./chunk-hqmz36b3.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import"./chunk-xszk7n10.js";
+import"./chunk-sdj9b9wh.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/commands/feedback/feedback.tsx
+function renderFeedbackComponent(onDone, abortSignal, messages, initialDescription = "", backgroundTasks = {}) {
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Feedback, {
+    abortSignal,
+    messages,
+    initialDescription,
+    onDone,
+    backgroundTasks
+  }, undefined, false, undefined, this);
+}
+async function call(onDone, context, args) {
+  const initialDescription = args || "";
+  return renderFeedbackComponent(onDone, context.abortController.signal, context.messages, initialDescription);
+}
+var jsx_dev_runtime;
+var init_feedback = __esm(() => {
+  init_Feedback();
+  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+});
+init_feedback();
+
+export {
+  renderFeedbackComponent,
+  call
+};