@shadowob/cloud 1.1.6-dev.311

package/dist/chunk-HUICDC56.js

@@ -0,0 +1,62 @@
+// src/utils/logger.ts
+import * as chalkModule from "chalk";
+function identity(text) {
+  return text;
+}
+var passthroughChalk = {
+  blue: identity,
+  green: identity,
+  yellow: identity,
+  red: identity,
+  cyan: identity,
+  dim: identity,
+  bold: identity
+};
+function isObjectLike(value) {
+  return typeof value === "object" && value !== null || typeof value === "function";
+}
+function isChalkFormatter(value) {
+  if (!isObjectLike(value)) return false;
+  return typeof value.blue === "function" && typeof value.green === "function" && typeof value.yellow === "function" && typeof value.red === "function" && typeof value.cyan === "function" && typeof value.dim === "function" && typeof value.bold === "function";
+}
+function resolveChalkFormatter(moduleLike) {
+  const queue = [moduleLike];
+  const seen = /* @__PURE__ */ new Set();
+  while (queue.length > 0) {
+    const candidate = queue.shift();
+    if (!candidate || seen.has(candidate)) continue;
+    seen.add(candidate);
+    if (isChalkFormatter(candidate)) {
+      return candidate;
+    }
+    if (isObjectLike(candidate) && "default" in candidate) {
+      queue.push(candidate.default);
+    }
+  }
+  return passthroughChalk;
+}
+var chalk = resolveChalkFormatter(chalkModule);
+var log = {
+  info: (msg) => console.log(chalk.blue("\u2139"), msg),
+  success: (msg) => console.log(chalk.green("\u2713"), msg),
+  warn: (msg) => console.log(chalk.yellow("\u26A0"), msg),
+  error: (msg) => console.error(chalk.red("\u2717"), msg),
+  step: (msg) => console.log(chalk.cyan("\u25B8"), msg),
+  dim: (msg) => console.log(chalk.dim(msg)),
+  table: (rows) => {
+    if (rows.length === 0) return;
+    const keys = Object.keys(rows[0]);
+    const widths = keys.map((k) => Math.max(k.length, ...rows.map((r) => (r[k] ?? "").length)));
+    const header = keys.map((k, i) => k.padEnd(widths[i])).join("  ");
+    const separator = widths.map((w) => "\u2500".repeat(w)).join("\u2500\u2500");
+    console.log(chalk.bold(header));
+    console.log(chalk.dim(separator));
+    for (const row of rows) {
+      console.log(keys.map((k, i) => (row[k] ?? "").padEnd(widths[i])).join("  "));
+    }
+  }
+};
+
+export {
+  log
+};

package/dist/chunk-JUPAE5IA.js

@@ -0,0 +1,527 @@
+// src/plugins/registry.ts
+function createPluginRegistry() {
+  const plugins = /* @__PURE__ */ new Map();
+  return {
+    get size() {
+      return plugins.size;
+    },
+    register(plugin) {
+      const { id } = plugin.manifest;
+      if (plugins.has(id)) {
+        throw new Error(`Plugin "${id}" is already registered`);
+      }
+      plugins.set(id, plugin);
+    },
+    get(id) {
+      return plugins.get(id);
+    },
+    getAll() {
+      return [...plugins.values()];
+    },
+    getByCategory(category) {
+      return [...plugins.values()].filter((p) => p.manifest.category === category);
+    },
+    getByCapability(cap) {
+      return [...plugins.values()].filter((p) => p.manifest.capabilities.includes(cap));
+    },
+    search(query) {
+      const q = query.toLowerCase();
+      return [...plugins.values()].filter((p) => {
+        const m = p.manifest;
+        return m.name.toLowerCase().includes(q) || m.description.toLowerCase().includes(q) || m.id.toLowerCase().includes(q) || m.tags.some((t) => t.toLowerCase().includes(q));
+      });
+    }
+  };
+}
+var _globalRegistry = null;
+function getPluginRegistry() {
+  if (!_globalRegistry) {
+    _globalRegistry = createPluginRegistry();
+  }
+  return _globalRegistry;
+}
+function resetPluginRegistry() {
+  _globalRegistry = null;
+}
+
+// src/plugins/loader.ts
+import * as __typia_transform__validateReport from "typia/lib/internal/_validateReport";
+import * as __typia_transform__createStandardSchema from "typia/lib/internal/_createStandardSchema";
+var validatePluginManifest = (() => {
+  const _iv1 = /* @__PURE__ */ new Set(["communication", "project-management", "ai-provider", "devops", "database", "productivity", "automation", "crm", "finance", "analytics", "media", "email", "calendar", "search", "code", "other"]);
+  const _iv3 = /* @__PURE__ */ new Set(["channel", "tool", "notification", "webhook", "data-source", "action", "auth-provider", "skill", "cli", "mcp", "config-builder", "config-resolver"]);
+  const _vv7 = /* @__PURE__ */ new Set(["communication", "project-management", "ai-provider", "devops", "database", "productivity", "automation", "crm", "finance", "analytics", "media", "email", "calendar", "search", "code", "other"]);
+  const _vv9 = /* @__PURE__ */ new Set(["channel", "tool", "notification", "webhook", "data-source", "action", "auth-provider", "skill", "cli", "mcp", "config-builder", "config-resolver"]);
+  const _io0 = (input) => "string" === typeof input.id && "string" === typeof input.name && "string" === typeof input.description && "string" === typeof input.version && true === _iv1.has(input.category) && "string" === typeof input.icon && (void 0 === input.website || "string" === typeof input.website) && (void 0 === input.docs || "string" === typeof input.docs) && ("object" === typeof input.auth && null !== input.auth && _io1(input.auth)) && (void 0 === input.config || "object" === typeof input.config && null !== input.config && false === Array.isArray(input.config) && _io4(input.config)) && (Array.isArray(input.capabilities) && input.capabilities.every((elem) => true === _iv3.has(elem))) && (Array.isArray(input.tags) && input.tags.every((elem) => "string" === typeof elem)) && (void 0 === input.popularity || "number" === typeof input.popularity);
+  const _io1 = (input) => ("oauth2" === input.type || "api-key" === input.type || "token" === input.type || "basic" === input.type || "none" === input.type) && (Array.isArray(input.fields) && input.fields.every((elem) => "object" === typeof elem && null !== elem && _io2(elem))) && (void 0 === input.oauth || "object" === typeof input.oauth && null !== input.oauth && _io3(input.oauth));
+  const _io2 = (input) => "string" === typeof input.key && "string" === typeof input.label && (void 0 === input.description || "string" === typeof input.description) && "boolean" === typeof input.required && "boolean" === typeof input.sensitive && (void 0 === input.placeholder || "string" === typeof input.placeholder) && (void 0 === input.validation || "string" === typeof input.validation) && (void 0 === input.helpUrl || "string" === typeof input.helpUrl);
+  const _io3 = (input) => "string" === typeof input.authorizationUrl && "string" === typeof input.tokenUrl && (Array.isArray(input.scopes) && input.scopes.every((elem) => "string" === typeof elem)) && (void 0 === input.pkce || "boolean" === typeof input.pkce);
+  const _io4 = (input) => Object.keys(input).every((key) => {
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return true;
+  });
+  const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.id || _report(_exceptionable, {
+    path: _path + ".id",
+    expected: "string",
+    value: input.id
+  }), "string" === typeof input.name || _report(_exceptionable, {
+    path: _path + ".name",
+    expected: "string",
+    value: input.name
+  }), "string" === typeof input.description || _report(_exceptionable, {
+    path: _path + ".description",
+    expected: "string",
+    value: input.description
+  }), "string" === typeof input.version || _report(_exceptionable, {
+    path: _path + ".version",
+    expected: "string",
+    value: input.version
+  }), true === _vv7.has(input.category) || _report(_exceptionable, {
+    path: _path + ".category",
+    expected: '("ai-provider" | "analytics" | "automation" | "calendar" | "code" | "communication" | "crm" | "database" | "devops" | "email" | "finance" | "media" | "other" | "productivity" | "project-management" | "search")',
+    value: input.category
+  }), "string" === typeof input.icon || _report(_exceptionable, {
+    path: _path + ".icon",
+    expected: "string",
+    value: input.icon
+  }), void 0 === input.website || "string" === typeof input.website || _report(_exceptionable, {
+    path: _path + ".website",
+    expected: "(string | undefined)",
+    value: input.website
+  }), void 0 === input.docs || "string" === typeof input.docs || _report(_exceptionable, {
+    path: _path + ".docs",
+    expected: "(string | undefined)",
+    value: input.docs
+  }), ("object" === typeof input.auth && null !== input.auth || _report(_exceptionable, {
+    path: _path + ".auth",
+    expected: "PluginAuth",
+    value: input.auth
+  })) && _vo1(input.auth, _path + ".auth", _exceptionable) || _report(_exceptionable, {
+    path: _path + ".auth",
+    expected: "PluginAuth",
+    value: input.auth
+  }), void 0 === input.config || ("object" === typeof input.config && null !== input.config && false === Array.isArray(input.config) || _report(_exceptionable, {
+    path: _path + ".config",
+    expected: "(Record<string, unknown> | undefined)",
+    value: input.config
+  })) && _vo4(input.config, _path + ".config", _exceptionable) || _report(_exceptionable, {
+    path: _path + ".config",
+    expected: "(Record<string, unknown> | undefined)",
+    value: input.config
+  }), (Array.isArray(input.capabilities) || _report(_exceptionable, {
+    path: _path + ".capabilities",
+    expected: "Array<PluginCapability>",
+    value: input.capabilities
+  })) && input.capabilities.map((elem, _index8) => true === _vv9.has(elem) || _report(_exceptionable, {
+    path: _path + ".capabilities[" + _index8 + "]",
+    expected: '("action" | "auth-provider" | "channel" | "cli" | "config-builder" | "config-resolver" | "data-source" | "mcp" | "notification" | "skill" | "tool" | "webhook")',
+    value: elem
+  })).every((flag) => flag) || _report(_exceptionable, {
+    path: _path + ".capabilities",
+    expected: "Array<PluginCapability>",
+    value: input.capabilities
+  }), (Array.isArray(input.tags) || _report(_exceptionable, {
+    path: _path + ".tags",
+    expected: "Array<string>",
+    value: input.tags
+  })) && input.tags.map((elem, _index10) => "string" === typeof elem || _report(_exceptionable, {
+    path: _path + ".tags[" + _index10 + "]",
+    expected: "string",
+    value: elem
+  })).every((flag) => flag) || _report(_exceptionable, {
+    path: _path + ".tags",
+    expected: "Array<string>",
+    value: input.tags
+  }), void 0 === input.popularity || "number" === typeof input.popularity || _report(_exceptionable, {
+    path: _path + ".popularity",
+    expected: "(number | undefined)",
+    value: input.popularity
+  })].every((flag) => flag);
+  const _vo1 = (input, _path, _exceptionable = true) => ["oauth2" === input.type || "api-key" === input.type || "token" === input.type || "basic" === input.type || "none" === input.type || _report(_exceptionable, {
+    path: _path + ".type",
+    expected: '("api-key" | "basic" | "none" | "oauth2" | "token")',
+    value: input.type
+  }), (Array.isArray(input.fields) || _report(_exceptionable, {
+    path: _path + ".fields",
+    expected: "Array<PluginAuthField>",
+    value: input.fields
+  })) && input.fields.map((elem, _index11) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+    path: _path + ".fields[" + _index11 + "]",
+    expected: "PluginAuthField",
+    value: elem
+  })) && _vo2(elem, _path + ".fields[" + _index11 + "]", _exceptionable) || _report(_exceptionable, {
+    path: _path + ".fields[" + _index11 + "]",
+    expected: "PluginAuthField",
+    value: elem
+  })).every((flag) => flag) || _report(_exceptionable, {
+    path: _path + ".fields",
+    expected: "Array<PluginAuthField>",
+    value: input.fields
+  }), void 0 === input.oauth || ("object" === typeof input.oauth && null !== input.oauth || _report(_exceptionable, {
+    path: _path + ".oauth",
+    expected: "(PluginOAuthConfig | undefined)",
+    value: input.oauth
+  })) && _vo3(input.oauth, _path + ".oauth", _exceptionable) || _report(_exceptionable, {
+    path: _path + ".oauth",
+    expected: "(PluginOAuthConfig | undefined)",
+    value: input.oauth
+  })].every((flag) => flag);
+  const _vo2 = (input, _path, _exceptionable = true) => ["string" === typeof input.key || _report(_exceptionable, {
+    path: _path + ".key",
+    expected: "string",
+    value: input.key
+  }), "string" === typeof input.label || _report(_exceptionable, {
+    path: _path + ".label",
+    expected: "string",
+    value: input.label
+  }), void 0 === input.description || "string" === typeof input.description || _report(_exceptionable, {
+    path: _path + ".description",
+    expected: "(string | undefined)",
+    value: input.description
+  }), "boolean" === typeof input.required || _report(_exceptionable, {
+    path: _path + ".required",
+    expected: "boolean",
+    value: input.required
+  }), "boolean" === typeof input.sensitive || _report(_exceptionable, {
+    path: _path + ".sensitive",
+    expected: "boolean",
+    value: input.sensitive
+  }), void 0 === input.placeholder || "string" === typeof input.placeholder || _report(_exceptionable, {
+    path: _path + ".placeholder",
+    expected: "(string | undefined)",
+    value: input.placeholder
+  }), void 0 === input.validation || "string" === typeof input.validation || _report(_exceptionable, {
+    path: _path + ".validation",
+    expected: "(string | undefined)",
+    value: input.validation
+  }), void 0 === input.helpUrl || "string" === typeof input.helpUrl || _report(_exceptionable, {
+    path: _path + ".helpUrl",
+    expected: "(string | undefined)",
+    value: input.helpUrl
+  })].every((flag) => flag);
+  const _vo3 = (input, _path, _exceptionable = true) => ["string" === typeof input.authorizationUrl || _report(_exceptionable, {
+    path: _path + ".authorizationUrl",
+    expected: "string",
+    value: input.authorizationUrl
+  }), "string" === typeof input.tokenUrl || _report(_exceptionable, {
+    path: _path + ".tokenUrl",
+    expected: "string",
+    value: input.tokenUrl
+  }), (Array.isArray(input.scopes) || _report(_exceptionable, {
+    path: _path + ".scopes",
+    expected: "Array<string>",
+    value: input.scopes
+  })) && input.scopes.map((elem, _index12) => "string" === typeof elem || _report(_exceptionable, {
+    path: _path + ".scopes[" + _index12 + "]",
+    expected: "string",
+    value: elem
+  })).every((flag) => flag) || _report(_exceptionable, {
+    path: _path + ".scopes",
+    expected: "Array<string>",
+    value: input.scopes
+  }), void 0 === input.pkce || "boolean" === typeof input.pkce || _report(_exceptionable, {
+    path: _path + ".pkce",
+    expected: "(boolean | undefined)",
+    value: input.pkce
+  })].every((flag) => flag);
+  const _vo4 = (input, _path, _exceptionable = true) => [false === _exceptionable || Object.keys(input).map((key) => {
+    const value = input[key];
+    if (void 0 === value)
+      return true;
+    return true;
+  }).every((flag) => flag)].every((flag) => flag);
+  const __is = (input) => "object" === typeof input && null !== input && _io0(input);
+  let errors;
+  let _report;
+  return __typia_transform__createStandardSchema._createStandardSchema((input) => {
+    if (false === __is(input)) {
+      errors = [];
+      _report = __typia_transform__validateReport._validateReport(errors);
+      ((input2, _path, _exceptionable = true) => ("object" === typeof input2 && null !== input2 || _report(true, {
+        path: _path + "",
+        expected: "PluginManifest",
+        value: input2
+      })) && _vo0(input2, _path + "", true) || _report(true, {
+        path: _path + "",
+        expected: "PluginManifest",
+        value: input2
+      }))(input, "$input", true);
+      const success = 0 === errors.length;
+      return success ? {
+        success,
+        data: input
+      } : {
+        success,
+        errors,
+        data: input
+      };
+    }
+    return {
+      success: true,
+      data: input
+    };
+  });
+})();
+function validateManifest(manifest) {
+  return validatePluginManifest(manifest).success;
+}
+function registerPlugin(registry, plugin) {
+  if (!validateManifest(plugin.manifest)) {
+    console.warn(`Invalid plugin manifest for "${plugin.manifest?.id ?? "unknown"}", skipping`);
+    return;
+  }
+  registry.register(plugin);
+}
+async function loadAllPlugins(registry) {
+  const pluginModules = await Promise.all([
+    import("./shadowob-JELOWHWX.js"),
+    import("./model-provider-KFB76XV5.js"),
+    import("./github-XRO5Z3GC.js"),
+    import("./google-workspace-LL3EWVHH.js"),
+    import("./notion-FZK76MN2.js"),
+    import("./stripe-LJNPQ3CQ.js"),
+    import("./shopify-R4G3UXM6.js"),
+    import("./paypal-33UADIPR.js"),
+    import("./agent-browser-CERTMCDL.js"),
+    import("./skill-discovery-7INAUP4D.js"),
+    import("./opencli-VIGRJTGH.js"),
+    import("./inference-sh-7AZOLEFI.js"),
+    import("./inference-ai-image-generation-CMI6R5T3.js"),
+    import("./wonda-NGWIORYN.js"),
+    import("./figma-RYOBMENP.js"),
+    import("./canva-FMYN65SM.js"),
+    import("./airtable-BG2Q75G2.js"),
+    import("./huggingface-MJCOXA7E.js"),
+    import("./linear-T4ORUP7N.js"),
+    import("./lovart-PDUXRUHJ.js"),
+    import("./atlassian-LGOEWYC7.js"),
+    import("./sentry-PIWW46VA.js"),
+    import("./posthog-MU5MAJOQ.js"),
+    import("./sherlock-2PKY2E2Y.js"),
+    import("./firebase-OYSY6HPT.js"),
+    import("./firecrawl-IYYXLAZM.js"),
+    import("./playwright-MG5WHK47.js"),
+    import("./browserbase-IUIYVYI7.js"),
+    import("./lark-URVBZNS4.js"),
+    import("./dingtalk-WZGGIAHJ.js"),
+    import("./tencent-docs-C3A4J3CJ.js"),
+    import("./wps-DAEFQHDE.js"),
+    import("./yuque-KRH5O74J.js"),
+    import("./alipay-TZQI34RB.js"),
+    import("./wechat-pay-BCMAJ6UW.js"),
+    import("./amap-KPCLZYYL.js"),
+    import("./baidu-maps-HEPMVP5D.js"),
+    import("./tencent-maps-OQOKHVW2.js"),
+    import("./flyai-7FJ4TRAG.js"),
+    import("./kuaidi100-UHPFCVXP.js"),
+    import("./oceanengine-5BRIJVJE.js"),
+    import("./tencent-ads-IGD33LO7.js"),
+    import("./coze-E6VGRNLV.js"),
+    import("./taobao-aipaas-LRR4GMO3.js"),
+    import("./baidu-appbuilder-6UMESXHW.js"),
+    import("./baidu-netdisk-RS2K5W2M.js"),
+    import("./wechat-miniprogram-skyline-KYCDMQNW.js"),
+    import("./douyin-miniprogram-AIJPPIZH.js"),
+    import("./baidu-smartprogram-JHD3XWF6.js"),
+    import("./miclaw-TPPPS2WN.js"),
+    import("./huawei-xiaoyi-6BSMGJHR.js"),
+    import("./gitee-3N7OFOM7.js"),
+    import("./tapd-3JPVJ7XH.js"),
+    import("./cnb-FLP3QX46.js"),
+    import("./google-ads-A3QAJI4D.js"),
+    import("./meta-ads-V6XPZWX3.js"),
+    import("./seo-suite-4SQ3I67Q.js"),
+    import("./wordpress-woocommerce-RDIUTHYT.js"),
+    import("./cloudflare-HBBABPK6.js"),
+    import("./claude-plugin-577TAQVS.js"),
+    import("./supabase-N4ONFJNQ.js"),
+    import("./google-analytics-XDYZA2B7.js"),
+    import("./hubspot-FTIEMNZO.js"),
+    import("./klaviyo-LDPBWBSS.js"),
+    import("./webflow-FULU5Q2I.js"),
+    import("./salesforce-34FVIJTG.js"),
+    import("./vercel-KOXDDTHX.js"),
+    import("./gitagent-MWI75OIX.js"),
+    import("./agent-pack-RQT27V7R.js")
+  ]);
+  for (const mod of pluginModules) {
+    const plugin = mod.default;
+    if (plugin?.manifest) {
+      registerPlugin(registry, plugin);
+    }
+  }
+}
+
+// src/utils/deep-merge.ts
+function deepMerge(base, override) {
+  const result = { ...base };
+  for (const key of Object.keys(override)) {
+    const baseVal = result[key];
+    const overVal = override[key];
+    if (overVal !== void 0 && typeof baseVal === "object" && baseVal !== null && !Array.isArray(baseVal) && typeof overVal === "object" && overVal !== null && !Array.isArray(overVal)) {
+      result[key] = deepMerge(
+        baseVal,
+        overVal
+      );
+    } else if (overVal !== void 0) {
+      result[key] = overVal;
+    }
+  }
+  return result;
+}
+
+// src/plugins/config-merger.ts
+function pluginLoadPaths(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return [];
+  const load = value.load;
+  if (!load || typeof load !== "object" || Array.isArray(load)) return [];
+  const paths = load.paths;
+  return Array.isArray(paths) ? paths.filter((path) => typeof path === "string" && path.length > 0) : [];
+}
+function mergePluginFragments(base, fragmentOrFragments) {
+  const result = { ...base };
+  const fragments = Array.isArray(fragmentOrFragments) ? fragmentOrFragments : [fragmentOrFragments];
+  for (const fragment of fragments) {
+    if (fragment.channels) {
+      result.channels = deepMerge(
+        result.channels ?? {},
+        fragment.channels
+      );
+    }
+    if (fragment.bindings) {
+      const existingBindings = result.bindings ?? [];
+      result.bindings = [...existingBindings, ...fragment.bindings];
+    }
+    if (fragment.plugins) {
+      if (!result.plugins) result.plugins = {};
+      const existingLoadPaths = pluginLoadPaths(result.plugins);
+      const fragmentLoadPaths = pluginLoadPaths(fragment.plugins);
+      result.plugins = deepMerge(
+        result.plugins,
+        fragment.plugins
+      );
+      const mergedLoadPaths = [...existingLoadPaths, ...fragmentLoadPaths];
+      if (mergedLoadPaths.length > 0) {
+        const plugins = result.plugins;
+        plugins.load = {
+          ...plugins.load ?? {},
+          paths: [...new Set(mergedLoadPaths)]
+        };
+      }
+    }
+    if (fragment.skills) {
+      if (!result.skills) result.skills = {};
+      result.skills = deepMerge(
+        result.skills,
+        fragment.skills
+      );
+    }
+    if (fragment.tools) {
+      if (!result.tools) result.tools = {};
+      result.tools = deepMerge(
+        result.tools,
+        fragment.tools
+      );
+    }
+    if (fragment.agents) {
+      const fragmentAgents = fragment.agents;
+      const existingAgents = result.agents ?? {};
+      if (fragmentAgents.defaults) {
+        result.agents = {
+          ...existingAgents,
+          defaults: deepMerge(
+            existingAgents.defaults ?? {},
+            fragmentAgents.defaults
+          )
+        };
+      }
+    }
+    if (fragment.models) {
+      if (!result.models) result.models = {};
+      result.models = deepMerge(
+        result.models,
+        fragment.models
+      );
+    }
+  }
+  return result;
+}
+function resolveAgentPluginConfig(pluginId, agentId, config) {
+  if (config.use?.length) {
+    const agent = config.deployments?.agents?.find((a) => a.id === agentId);
+    const agentUse = agent?.use;
+    const agentEntry = agentUse?.find((e) => e.plugin === pluginId);
+    if (agentEntry) return agentEntry.options ?? {};
+    const globalEntry = config.use.find((e) => e.plugin === pluginId);
+    if (globalEntry) return globalEntry.options ?? {};
+    return null;
+  }
+  const pluginInstanceConfig = config.plugins?.[pluginId];
+  if (pluginInstanceConfig) {
+    if (pluginInstanceConfig.enabled === false) return null;
+    const globalConfig = pluginInstanceConfig.config ?? {};
+    const agentOverride = pluginInstanceConfig.agents?.[agentId];
+    if (agentOverride?.enabled === false) return null;
+    const agentConfig = agentOverride?.config ?? {};
+    return { ...globalConfig, ...agentConfig };
+  }
+  const useEntry = config.use?.find((e) => e.plugin === pluginId);
+  if (useEntry) {
+    return useEntry.options ?? {};
+  }
+  return null;
+}
+function resolvePluginSecrets(pluginId, config, processEnv) {
+  const pluginInstanceConfig = config.plugins?.[pluginId];
+  const secretsMap = pluginInstanceConfig?.secrets ?? {};
+  if (!pluginInstanceConfig) {
+    const useEntry = config.use?.find((e) => e.plugin === pluginId);
+    if (useEntry?.options) {
+      for (const [key, val] of Object.entries(useEntry.options)) {
+        if (typeof val === "string") {
+          const envMatch = val.match(/^\$\{env:(\w+)\}$/);
+          if (envMatch?.[1]) {
+            const envKey = envMatch[1];
+            const envVal = processEnv[envKey];
+            if (envVal !== void 0) secretsMap[key] = envVal;
+          } else if (/^[A-Z0-9_]+$/.test(key)) {
+            secretsMap[key] = val;
+          }
+        }
+      }
+    }
+  }
+  return resolveSecretRefs(secretsMap, processEnv);
+}
+function resolveSecretRefs(secrets, processEnv) {
+  const resolved = {};
+  for (const [key, ref] of Object.entries(secrets)) {
+    const envMatch = ref.match(/^\$\{env:(\w+)\}$/);
+    if (envMatch) {
+      const envKey = envMatch[1];
+      if (!envKey) continue;
+      const envVal = processEnv[envKey];
+      if (envVal !== void 0) {
+        resolved[key] = envVal;
+      }
+    } else {
+      resolved[key] = ref;
+    }
+  }
+  return resolved;
+}
+
+export {
+  createPluginRegistry,
+  getPluginRegistry,
+  resetPluginRegistry,
+  deepMerge,
+  mergePluginFragments,
+  resolveAgentPluginConfig,
+  resolvePluginSecrets,
+  validateManifest,
+  registerPlugin,
+  loadAllPlugins
+};