@jayjiang/open-cc 0.2.1

package/dist/chunk-1pg8s12r.js

@@ -0,0 +1,338 @@
+// @bun
+import {
+  BROWSER_TOOLS,
+  init_src
+} from "./chunk-gyj242zr.js";
+import {
+  getChromeSystemPrompt,
+  init_prompt
+} from "./chunk-e6rrwzv0.js";
+import {
+  CLAUDE_IN_CHROME_MCP_SERVER_NAME,
+  getAllBrowserDataPaths,
+  getAllNativeMessagingHostsDirs,
+  getAllWindowsRegistryKeys,
+  init_common,
+  openInChrome
+} from "./chunk-6wkdqk81.js";
+import {
+  getFeatureValue_CACHED_MAY_BE_STALE,
+  getGlobalConfig,
+  init_config1 as init_config,
+  init_growthbook,
+  saveGlobalConfig
+} from "./chunk-30chpfyc.js";
+import {
+  getPlatform,
+  init_platform
+} from "./chunk-mzdtkccs.js";
+import {
+  init_bundledMode,
+  isInBundledMode
+} from "./chunk-5k2gdxnr.js";
+import {
+  execFileNoThrowWithCwd,
+  init_execFileNoThrow
+} from "./chunk-b5b7h81y.js";
+import {
+  init_debug,
+  init_errors,
+  init_slowOperations,
+  isFsInaccessible,
+  jsonStringify,
+  logForDebugging
+} from "./chunk-rwagvxh5.js";
+import {
+  getConfigHomeDir,
+  init_envUtils,
+  isEnvDefinedFalsy,
+  isEnvTruthy
+} from "./chunk-0fkqze0v.js";
+import {
+  getIsInteractive,
+  getIsNonInteractiveSession,
+  getSessionBypassPermissionsMode,
+  init_state
+} from "./chunk-2zcaw1jd.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, "Open CC", "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: "Open CC 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(getConfigHomeDir(), "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 Open CC - do not edit manually
+${command}
+` : `#!/bin/sh
+# Chrome native host wrapper script
+# Generated by Open CC - 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.open-cc.browser_extension", NATIVE_HOST_MANIFEST_NAME, shouldAutoEnable;
+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-1qjb22fx.js

@@ -0,0 +1,109 @@
+// @bun
+import {
+  Doctor,
+  init_Doctor
+} from "./chunk-178ykx7k.js";
+import"./chunk-cr6t6rth.js";
+import"./chunk-789khc7a.js";
+import"./chunk-4qedx22a.js";
+import"./chunk-jpgr7zfs.js";
+import"./chunk-sfht9xvd.js";
+import"./chunk-pthzapbx.js";
+import"./chunk-2y54j9ew.js";
+import"./chunk-1yzc16qa.js";
+import"./chunk-s10vyjz4.js";
+import"./chunk-1k4j1xcf.js";
+import"./chunk-3c4qja3e.js";
+import"./chunk-rc5bbzx4.js";
+import"./chunk-e6rrwzv0.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-743znc5c.js";
+import"./chunk-5p2ssw3d.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-bhdt6k7w.js";
+import"./chunk-6wkdqk81.js";
+import"./chunk-5dbk24zg.js";
+import"./chunk-bda3gxxz.js";
+import"./chunk-zxhezavg.js";
+import"./chunk-x8eg216f.js";
+import"./chunk-9gbamk79.js";
+import"./chunk-t175chdd.js";
+import"./chunk-7rjyn5d3.js";
+import"./chunk-6q2x8zeg.js";
+import"./chunk-0yb4dz9c.js";
+import"./chunk-7m2nd8da.js";
+import"./chunk-ps49ymvj.js";
+import {
+  require_jsx_dev_runtime
+} from "./chunk-g338npwr.js";
+import"./chunk-zk2wsm7d.js";
+import"./chunk-eh474zhj.js";
+import"./chunk-ga5faygf.js";
+import"./chunk-e7c8ypwc.js";
+import"./chunk-g6qddbvf.js";
+import"./chunk-b1s11z4y.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-yxmz5k16.js";
+import"./chunk-v9smspw2.js";
+import"./chunk-qz2x630m.js";
+import"./chunk-30chpfyc.js";
+import"./chunk-84k64e4a.js";
+import"./chunk-y3py9g5d.js";
+import"./chunk-7pemewz2.js";
+import"./chunk-s4w01jsb.js";
+import"./chunk-c8vn3ynx.js";
+import"./chunk-g0j0t6qk.js";
+import"./chunk-6kpbgc5w.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-mzdtkccs.js";
+import"./chunk-55wgxwa9.js";
+import"./chunk-5k2gdxnr.js";
+import"./chunk-2qhs9n36.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-mr9df5v8.js";
+import"./chunk-cdz5yb0r.js";
+import"./chunk-f2mhrmww.js";
+import"./chunk-10fdxge0.js";
+import"./chunk-r1v8d6da.js";
+import"./chunk-d3v2fbay.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-f2zhqnb6.js";
+import"./chunk-cvp5vayb.js";
+import"./chunk-b5b7h81y.js";
+import"./chunk-nm2cncrq.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-0rkbrabt.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-rwagvxh5.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-0fkqze0v.js";
+import"./chunk-2zcaw1jd.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/doctor/doctor.tsx
+var jsx_dev_runtime, call = (onDone, _context, _args) => {
+  return Promise.resolve(/* @__PURE__ */ jsx_dev_runtime.jsxDEV(Doctor, {
+    onDone
+  }, undefined, false, undefined, this));
+};
+var init_doctor = __esm(() => {
+  init_Doctor();
+  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+});
+init_doctor();
+
+export {
+  call
+};

package/dist/chunk-1yzc16qa.js

@@ -0,0 +1,39 @@
+// @bun
+import {
+  clearBetaHeaderLatches,
+  clearSystemPromptSectionState,
+  getSystemPromptSectionCache,
+  init_state,
+  setSystemPromptSectionCacheEntry
+} from "./chunk-2zcaw1jd.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/constants/systemPromptSections.ts
+function systemPromptSection(name, compute) {
+  return { name, compute, cacheBreak: false };
+}
+function DANGEROUS_uncachedSystemPromptSection(name, compute, _reason) {
+  return { name, compute, cacheBreak: true };
+}
+async function resolveSystemPromptSections(sections) {
+  const cache = getSystemPromptSectionCache();
+  return Promise.all(sections.map(async (s) => {
+    if (!s.cacheBreak && cache.has(s.name)) {
+      return cache.get(s.name) ?? null;
+    }
+    const value = await s.compute();
+    setSystemPromptSectionCacheEntry(s.name, value);
+    return value;
+  }));
+}
+function clearSystemPromptSections() {
+  clearSystemPromptSectionState();
+  clearBetaHeaderLatches();
+}
+var init_systemPromptSections = __esm(() => {
+  init_state();
+});
+
+export { systemPromptSection, DANGEROUS_uncachedSystemPromptSection, resolveSystemPromptSections, clearSystemPromptSections, init_systemPromptSections };

package/dist/chunk-20gm89wf.js

@@ -0,0 +1,208 @@
+// @bun
+import {
+  SETTING_SOURCE_TO_SCOPE,
+  cacheAndRegisterPlugin,
+  getAddDirEnabledPlugins,
+  getInMemoryInstalledPlugins,
+  getPluginById,
+  init_addDirPluginSettings,
+  init_installedPluginsManager,
+  init_marketplaceManager,
+  init_pluginIdentifier,
+  init_pluginInstallationHelpers,
+  migrateFromEnabledPlugins,
+  registerPluginInstallation,
+  scopeToSettingSource
+} from "./chunk-2y54j9ew.js";
+import {
+  getInitialSettings,
+  getSettingsForSource,
+  init_schemas,
+  init_settings1 as init_settings,
+  isLocalPluginSource,
+  updateSettingsForSource
+} from "./chunk-30chpfyc.js";
+import {
+  init_log,
+  logError
+} from "./chunk-nm2cncrq.js";
+import {
+  getCwd,
+  init_cwd
+} from "./chunk-0rkbrabt.js";
+import {
+  init_debug,
+  logForDebugging
+} from "./chunk-rwagvxh5.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/plugins/pluginStartupCheck.ts
+import { join } from "path";
+async function checkEnabledPlugins() {
+  const settings = getInitialSettings();
+  const enabledPlugins = [];
+  const addDirPlugins = getAddDirEnabledPlugins();
+  for (const [pluginId, value] of Object.entries(addDirPlugins)) {
+    if (pluginId.includes("@") && value) {
+      enabledPlugins.push(pluginId);
+    }
+  }
+  if (settings.enabledPlugins) {
+    for (const [pluginId, value] of Object.entries(settings.enabledPlugins)) {
+      if (!pluginId.includes("@")) {
+        continue;
+      }
+      const idx = enabledPlugins.indexOf(pluginId);
+      if (value) {
+        if (idx === -1) {
+          enabledPlugins.push(pluginId);
+        }
+      } else {
+        if (idx !== -1) {
+          enabledPlugins.splice(idx, 1);
+        }
+      }
+    }
+  }
+  return enabledPlugins;
+}
+function getPluginEditableScopes() {
+  const result = new Map;
+  const addDirPlugins = getAddDirEnabledPlugins();
+  for (const [pluginId, value] of Object.entries(addDirPlugins)) {
+    if (!pluginId.includes("@")) {
+      continue;
+    }
+    if (value === true) {
+      result.set(pluginId, "flag");
+    } else if (value === false) {
+      result.delete(pluginId);
+    }
+  }
+  const scopeSources = [
+    { scope: "managed", source: "policySettings" },
+    { scope: "user", source: "userSettings" },
+    { scope: "project", source: "projectSettings" },
+    { scope: "local", source: "localSettings" },
+    { scope: "flag", source: "flagSettings" }
+  ];
+  for (const { scope, source } of scopeSources) {
+    const settings = getSettingsForSource(source);
+    if (!settings?.enabledPlugins) {
+      continue;
+    }
+    for (const [pluginId, value] of Object.entries(settings.enabledPlugins)) {
+      if (!pluginId.includes("@")) {
+        continue;
+      }
+      if (pluginId in addDirPlugins && addDirPlugins[pluginId] !== value) {
+        logForDebugging(`Plugin ${pluginId} from --add-dir (${addDirPlugins[pluginId]}) overridden by ${source} (${value})`);
+      }
+      if (value === true) {
+        result.set(pluginId, scope);
+      } else if (value === false) {
+        result.delete(pluginId);
+      }
+    }
+  }
+  logForDebugging(`Found ${result.size} enabled plugins with scopes: ${Array.from(result.entries()).map(([id, scope]) => `${id}(${scope})`).join(", ")}`);
+  return result;
+}
+function isPersistableScope(scope) {
+  return scope !== "flag";
+}
+function settingSourceToScope(source) {
+  return SETTING_SOURCE_TO_SCOPE[source];
+}
+async function getInstalledPlugins() {
+  migrateFromEnabledPlugins().catch((error) => {
+    logError(error);
+  });
+  const v2Data = getInMemoryInstalledPlugins();
+  const installed = Object.keys(v2Data.plugins);
+  logForDebugging(`Found ${installed.length} installed plugins`);
+  return installed;
+}
+async function findMissingPlugins(enabledPlugins) {
+  try {
+    const installedPlugins = await getInstalledPlugins();
+    const notInstalled = enabledPlugins.filter((id) => !installedPlugins.includes(id));
+    const lookups = await Promise.all(notInstalled.map(async (pluginId) => {
+      try {
+        const plugin = await getPluginById(pluginId);
+        return { pluginId, found: plugin !== null && plugin !== undefined };
+      } catch (error) {
+        logForDebugging(`Failed to check plugin ${pluginId} in marketplace: ${error}`);
+        return { pluginId, found: false };
+      }
+    }));
+    const missing = lookups.filter(({ found }) => found).map(({ pluginId }) => pluginId);
+    return missing;
+  } catch (error) {
+    logError(error);
+    return [];
+  }
+}
+async function installSelectedPlugins(pluginsToInstall, onProgress, scope = "user") {
+  const projectPath = scope !== "user" ? getCwd() : undefined;
+  const settingSource = scopeToSettingSource(scope);
+  const settings = getSettingsForSource(settingSource);
+  const updatedEnabledPlugins = { ...settings?.enabledPlugins };
+  const installed = [];
+  const failed = [];
+  for (let i = 0;i < pluginsToInstall.length; i++) {
+    const pluginId = pluginsToInstall[i];
+    if (!pluginId)
+      continue;
+    if (onProgress) {
+      onProgress(pluginId, i + 1, pluginsToInstall.length);
+    }
+    try {
+      const pluginInfo = await getPluginById(pluginId);
+      if (!pluginInfo) {
+        failed.push({
+          name: pluginId,
+          error: "Plugin not found in any marketplace"
+        });
+        continue;
+      }
+      const { entry, marketplaceInstallLocation } = pluginInfo;
+      if (!isLocalPluginSource(entry.source)) {
+        await cacheAndRegisterPlugin(pluginId, entry, scope, projectPath);
+      } else {
+        registerPluginInstallation({
+          pluginId,
+          installPath: join(marketplaceInstallLocation, entry.source),
+          version: entry.version
+        }, scope, projectPath);
+      }
+      updatedEnabledPlugins[pluginId] = true;
+      installed.push(pluginId);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      failed.push({ name: pluginId, error: errorMessage });
+      logError(error);
+    }
+  }
+  updateSettingsForSource(settingSource, {
+    ...settings,
+    enabledPlugins: updatedEnabledPlugins
+  });
+  return { installed, failed };
+}
+var init_pluginStartupCheck = __esm(() => {
+  init_cwd();
+  init_debug();
+  init_log();
+  init_settings();
+  init_addDirPluginSettings();
+  init_installedPluginsManager();
+  init_marketplaceManager();
+  init_pluginIdentifier();
+  init_pluginInstallationHelpers();
+  init_schemas();
+});
+
+export { checkEnabledPlugins, getPluginEditableScopes, isPersistableScope, settingSourceToScope, getInstalledPlugins, findMissingPlugins, installSelectedPlugins, init_pluginStartupCheck };