@workclaw/openclaw-workclaw 1.0.342 → 1.0.345

package/dist/channel-entry-contract-BDMmGZzs-4ZlSsA7g.js

@@ -0,0 +1,252 @@
+import { n as normalizeLowercaseStringOrEmpty } from "./string-coerce-DyL154ka-BEV0SzzS.js";
+import { l as emptyChannelConfigSchema, m as createProfiler, s as shouldProfilePluginLoader, t as toSafeImportPath, o as formatPluginLoadProfileLine, q as openRootFileSync, u as getCachedPluginSourceModuleLoader, v as resolveLoaderPackageRoot } from "./plugin-load-profile-DOnG9jJ5-B0ymqOTX.js";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import fs__default from "node:fs";
+import path__default from "node:path";
+const nodeRequire = createRequire(import.meta.url);
+const moduleLoaders = /* @__PURE__ */ new Map();
+const loadedModuleExports = /* @__PURE__ */ new Map();
+const disableBundledEntrySourceFallbackEnv = "OPENCLAW_DISABLE_BUNDLED_ENTRY_SOURCE_FALLBACK";
+function isTruthyEnvFlag(value) {
+  return value !== void 0 && !/^(?:0|false)$/iu.test(value.trim());
+}
+function resolveSpecifierCandidates(modulePath) {
+  const ext = normalizeLowercaseStringOrEmpty(path__default.extname(modulePath));
+  if (ext === ".js") return [modulePath, modulePath.slice(0, -3) + ".ts"];
+  if (ext === ".mjs") return [modulePath, modulePath.slice(0, -4) + ".mts"];
+  if (ext === ".cjs") return [modulePath, modulePath.slice(0, -4) + ".cts"];
+  return [modulePath];
+}
+function resolveEntryBoundaryRoot(importMetaUrl) {
+  return path__default.dirname(fileURLToPath(importMetaUrl));
+}
+function addBundledEntryCandidates(candidates, basePath, boundaryRoot) {
+  for (const candidate of resolveSpecifierCandidates(basePath)) {
+    if (candidates.some((entry) => entry.path === candidate && entry.boundaryRoot === boundaryRoot)) continue;
+    candidates.push({
+      path: candidate,
+      boundaryRoot
+    });
+  }
+}
+function resolveBundledEntryModuleCandidates(importMetaUrl, specifier) {
+  const importerPath = fileURLToPath(importMetaUrl);
+  const importerDir = path__default.dirname(importerPath);
+  const boundaryRoot = resolveEntryBoundaryRoot(importMetaUrl);
+  const candidates = [];
+  addBundledEntryCandidates(candidates, path__default.resolve(importerDir, specifier), boundaryRoot);
+  const sourceRelativeSpecifier = specifier.replace(/^\.\/src\//u, "./");
+  if (sourceRelativeSpecifier !== specifier) addBundledEntryCandidates(candidates, path__default.resolve(importerDir, sourceRelativeSpecifier), boundaryRoot);
+  const packageRoot = resolveLoaderPackageRoot({
+    modulePath: importerPath,
+    moduleUrl: importMetaUrl,
+    cwd: importerDir,
+    argv1: process.argv[1]
+  });
+  if (!packageRoot) return candidates;
+  const distExtensionsRoot = path__default.join(packageRoot, "dist", "extensions") + path__default.sep;
+  if (!importerPath.startsWith(distExtensionsRoot)) return candidates;
+  if (isTruthyEnvFlag(process.env[disableBundledEntrySourceFallbackEnv])) return candidates;
+  const pluginDirName = path__default.basename(importerDir);
+  const sourcePluginRoot = path__default.join(packageRoot, "extensions", pluginDirName);
+  if (sourcePluginRoot === boundaryRoot) return candidates;
+  addBundledEntryCandidates(candidates, path__default.resolve(sourcePluginRoot, specifier), sourcePluginRoot);
+  if (sourceRelativeSpecifier !== specifier) addBundledEntryCandidates(candidates, path__default.resolve(sourcePluginRoot, sourceRelativeSpecifier), sourcePluginRoot);
+  return candidates;
+}
+function formatBundledEntryUnknownError(error) {
+  if (typeof error === "string") return error;
+  if (error === void 0) return "boundary validation failed";
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return "non-serializable error";
+  }
+}
+function formatBundledEntryModuleOpenFailure(params) {
+  const importerPath = fileURLToPath(params.importMetaUrl);
+  const errorDetail = params.failure.error instanceof Error ? params.failure.error.message : formatBundledEntryUnknownError(params.failure.error);
+  return [
+    `bundled plugin entry "${params.specifier}" failed to open`,
+    `from "${importerPath}"`,
+    `(resolved "${params.resolvedPath}", plugin root "${params.boundaryRoot}",`,
+    `reason "${params.failure.reason}"): ${errorDetail}`
+  ].join(" ");
+}
+function resolveBundledEntryModulePath(importMetaUrl, specifier) {
+  const candidates = resolveBundledEntryModuleCandidates(importMetaUrl, specifier);
+  const fallbackCandidate = candidates[0] ?? {
+    path: path__default.resolve(path__default.dirname(fileURLToPath(importMetaUrl)), specifier),
+    boundaryRoot: resolveEntryBoundaryRoot(importMetaUrl)
+  };
+  let firstFailure = null;
+  for (const candidate of candidates) {
+    const opened = openRootFileSync({
+      absolutePath: candidate.path,
+      rootPath: candidate.boundaryRoot,
+      boundaryLabel: "plugin root",
+      rejectHardlinks: false,
+      skipLexicalRootCheck: true
+    });
+    if (opened.ok) {
+      fs__default.closeSync(opened.fd);
+      return opened.path;
+    }
+    firstFailure ??= {
+      candidate,
+      failure: opened
+    };
+  }
+  const failure = firstFailure;
+  if (!failure) throw new Error(formatBundledEntryModuleOpenFailure({
+    importMetaUrl,
+    specifier,
+    resolvedPath: fallbackCandidate.path,
+    boundaryRoot: fallbackCandidate.boundaryRoot,
+    failure: {
+      ok: false,
+      reason: "path",
+      error: /* @__PURE__ */ new Error(`ENOENT: no such file or directory, lstat '${fallbackCandidate.path}'`)
+    }
+  }));
+  throw new Error(formatBundledEntryModuleOpenFailure({
+    importMetaUrl,
+    specifier,
+    resolvedPath: failure.candidate.path,
+    boundaryRoot: failure.candidate.boundaryRoot,
+    failure: failure.failure
+  }));
+}
+function getSourceModuleLoader(modulePath, options) {
+  return getCachedPluginSourceModuleLoader({
+    cache: moduleLoaders,
+    modulePath,
+    importerUrl: import.meta.url,
+    preferBuiltDist: true,
+    loaderFilename: import.meta.url,
+    ...options.createLoaderForTest ? { createLoader: options.createLoaderForTest } : {}
+  });
+}
+function canTryNodeRequireBuiltModule(modulePath) {
+  return (modulePath.includes(`${path__default.sep}dist${path__default.sep}`) || modulePath.includes(`${path__default.sep}dist-runtime${path__default.sep}`)) && [
+    ".js",
+    ".mjs",
+    ".cjs"
+  ].includes(normalizeLowercaseStringOrEmpty(path__default.extname(modulePath)));
+}
+function loadBundledEntryModuleSync(importMetaUrl, specifier, options = {}) {
+  const modulePath = resolveBundledEntryModulePath(importMetaUrl, specifier);
+  const cached = loadedModuleExports.get(modulePath);
+  if (cached !== void 0) return cached;
+  let loaded;
+  const profile = shouldProfilePluginLoader();
+  const loadStartMs = profile ? performance.now() : 0;
+  let sourceLoaderReadyMs = 0;
+  if (canTryNodeRequireBuiltModule(modulePath)) try {
+    loaded = nodeRequire(modulePath);
+  } catch {
+    const moduleLoader = getSourceModuleLoader(modulePath, options);
+    sourceLoaderReadyMs = profile ? performance.now() : 0;
+    loaded = moduleLoader(toSafeImportPath(modulePath));
+  }
+  else {
+    const moduleLoader = getSourceModuleLoader(modulePath, options);
+    sourceLoaderReadyMs = profile ? performance.now() : 0;
+    loaded = moduleLoader(toSafeImportPath(modulePath));
+  }
+  if (profile) {
+    const endMs = performance.now();
+    console.error(formatPluginLoadProfileLine({
+      phase: "bundled-entry-module-load",
+      pluginId: "(bundled-entry)",
+      source: modulePath,
+      elapsedMs: endMs - loadStartMs,
+      extras: [["sourceLoaderCreateMs", sourceLoaderReadyMs ? sourceLoaderReadyMs - loadStartMs : 0], ["sourceLoaderCallMs", sourceLoaderReadyMs ? endMs - sourceLoaderReadyMs : 0]]
+    }));
+  }
+  loadedModuleExports.set(modulePath, loaded);
+  return loaded;
+}
+function loadBundledEntryExportSync(importMetaUrl, reference, options) {
+  const loaded = loadBundledEntryModuleSync(importMetaUrl, reference.specifier, options);
+  const resolved = loaded && typeof loaded === "object" && "default" in loaded ? loaded.default : loaded;
+  if (!reference.exportName) return resolved;
+  const record = resolved ?? loaded;
+  if (!record || !(reference.exportName in record)) throw new Error(`missing export "${reference.exportName}" from bundled entry module ${reference.specifier}`);
+  return record[reference.exportName];
+}
+function defineBundledChannelEntry({ id, name, description, importMetaUrl, plugin, outbound, secrets, configSchema, runtime, accountInspect, features, registerCliMetadata, registerFull }) {
+  const resolvedConfigSchema = typeof configSchema === "function" ? configSchema() : configSchema ?? emptyChannelConfigSchema();
+  const loadChannelPlugin = (options) => loadBundledEntryExportSync(importMetaUrl, plugin, options);
+  const loadChannelOutbound = outbound ? (options) => loadBundledEntryExportSync(importMetaUrl, outbound, options) : void 0;
+  const loadChannelSecrets = secrets ? (options) => loadBundledEntryExportSync(importMetaUrl, secrets, options) : void 0;
+  const loadChannelAccountInspector = accountInspect ? (options) => loadBundledEntryExportSync(importMetaUrl, accountInspect, options) : void 0;
+  const setChannelRuntime = runtime ? (pluginRuntime) => {
+    loadBundledEntryExportSync(importMetaUrl, runtime)(pluginRuntime);
+  } : void 0;
+  return {
+    kind: "bundled-channel-entry",
+    id,
+    name,
+    description,
+    configSchema: resolvedConfigSchema,
+    ...features || accountInspect ? { features: {
+      ...features,
+      ...accountInspect ? { accountInspect: true } : {}
+    } } : {},
+    register(api) {
+      if (api.registrationMode === "cli-metadata") {
+        registerCliMetadata?.(api);
+        return;
+      }
+      if (api.registrationMode === "tool-discovery") {
+        createProfiler({
+          pluginId: id,
+          source: importMetaUrl
+        })("bundled-register:registerFull", () => registerFull?.(api));
+        return;
+      }
+      const profile = createProfiler({
+        pluginId: id,
+        source: importMetaUrl
+      });
+      const channelPlugin = profile("bundled-register:loadChannelPlugin", loadChannelPlugin);
+      profile("bundled-register:registerChannel", () => api.registerChannel({ plugin: channelPlugin }));
+      profile("bundled-register:setChannelRuntime", () => setChannelRuntime?.(api.runtime));
+      if (api.registrationMode === "discovery") {
+        profile("bundled-register:registerCliMetadata", () => registerCliMetadata?.(api));
+        return;
+      }
+      if (api.registrationMode !== "full") return;
+      profile("bundled-register:registerCliMetadata", () => registerCliMetadata?.(api));
+      profile("bundled-register:registerFull", () => registerFull?.(api));
+    },
+    loadChannelPlugin,
+    ...loadChannelOutbound ? { loadChannelOutbound } : {},
+    ...loadChannelSecrets ? { loadChannelSecrets } : {},
+    ...loadChannelAccountInspector ? { loadChannelAccountInspector } : {},
+    ...setChannelRuntime ? { setChannelRuntime } : {}
+  };
+}
+function defineBundledChannelSetupEntry({ importMetaUrl, plugin, secrets, runtime, legacyStateMigrations, legacySessionSurface, features }) {
+  const setChannelRuntime = runtime ? (pluginRuntime) => {
+    loadBundledEntryExportSync(importMetaUrl, runtime)(pluginRuntime);
+  } : void 0;
+  const loadLegacyStateMigrationDetector = legacyStateMigrations ? (options) => loadBundledEntryExportSync(importMetaUrl, legacyStateMigrations, options) : void 0;
+  const loadLegacySessionSurface = legacySessionSurface ? (options) => loadBundledEntryExportSync(importMetaUrl, legacySessionSurface, options) : void 0;
+  return {
+    kind: "bundled-channel-setup-entry",
+    loadSetupPlugin: (options) => loadBundledEntryExportSync(importMetaUrl, plugin, options),
+    ...secrets ? { loadSetupSecrets: (options) => loadBundledEntryExportSync(importMetaUrl, secrets, options) } : {},
+    ...loadLegacyStateMigrationDetector ? { loadLegacyStateMigrationDetector } : {},
+    ...loadLegacySessionSurface ? { loadLegacySessionSurface } : {},
+    ...setChannelRuntime ? { setChannelRuntime } : {},
+    ...features ? { features } : {}
+  };
+}
+export {
+  defineBundledChannelSetupEntry as a,
+  defineBundledChannelEntry as d,
+  loadBundledEntryExportSync as l
+};

package/dist/channel-plugin-api.d.ts

@@ -0,0 +1,2 @@
+export { workclawPlugin } from './src/channel.js';
+//# sourceMappingURL=channel-plugin-api.d.ts.map

package/dist/channel-plugin-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel-plugin-api.d.ts","sourceRoot":"","sources":["../channel-plugin-api.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/channel-plugin-api.js

@@ -0,0 +1,4 @@
+import { w } from "./channel-DRvDqBYj.js";
+export {
+  w as workclawPlugin
+};

package/dist/{cleanup-i9QIMqva-CYcFSfZC.js → cleanup-i9QIMqva-1f5yGy3c.js}

@@ -1,5 +1,5 @@
-import { o as isPathInside } from "./plugin-load-profile-DOnG9jJ5-zOQuKNoi.js";
-import { aI as resolveTrajectoryPointerFilePath, aJ as resolveTrajectoryFilePath, aF as resolveSessionFilePath, aK as safeTrajectorySessionFileName } from "./index-ZWLWkJXc.js";
+import { x as isPathInside } from "./plugin-load-profile-DOnG9jJ5-B0ymqOTX.js";
+import { aI as resolveTrajectoryPointerFilePath, aJ as resolveTrajectoryFilePath, aF as resolveSessionFilePath, aK as safeTrajectorySessionFileName } from "./channel-DRvDqBYj.js";
 import fs__default from "node:fs";
 import path__default from "node:path";
 function isRecord(value) {

package/dist/config-B7WCpONg.js

@@ -0,0 +1,94 @@
+import { C, a, b, D, N, S, T, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, x, y, z, A, B, E, F, G, H, I, J, K, L, M, O, P, Q, R, U, V, W, X, Y, Z, _, $, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, aa, ab, ac, ad, ae, af, ag, ah, ai } from "./channel-DRvDqBYj.js";
+import { D as D2, E as E2, L as L2, a as a10, M as M2, b as b2, c as c2, d as d2, h as h2, i as i2, e as e2, f as f2, n as n2, g as g2, p as p2, j as j2, r as r2, k as k2 } from "./plugin-load-profile-DOnG9jJ5-B0ymqOTX.js";
+export {
+  C as CONFIG_PATH,
+  a as ConfigMutationConflictError,
+  b as ConfigRuntimeRefreshError,
+  D as DEFAULT_GATEWAY_PORT,
+  D2 as DEFAULT_SECRET_PROVIDER_ALIAS,
+  E2 as ENV_SECRET_REF_ID_RE,
+  L2 as LEGACY_DOUBLE_UNDERSCORE_ENV_MARKER_PREFIX,
+  a10 as LEGACY_SECRETREF_ENV_MARKER_PREFIX,
+  M2 as MODEL_APIS,
+  b2 as MODEL_THINKING_FORMATS,
+  N as NixModeConfigMutationError,
+  S as STATE_DIR,
+  T as TOOLS_BY_SENDER_KEY_TYPES,
+  c as applyConfigOverrides,
+  d as assertConfigWriteAllowedInCurrentMode,
+  c2 as assertSecretInputResolved,
+  e as clearConfigCache,
+  f as clearRuntimeConfigSnapshot,
+  d2 as coerceSecretRef,
+  g as createConfigIO,
+  h as getConfigOverrides,
+  i as getRuntimeConfig,
+  j as getRuntimeConfigSnapshot,
+  k as getRuntimeConfigSnapshotMetadata,
+  l as getRuntimeConfigSourceSnapshot,
+  h2 as hasConfiguredSecretInput,
+  m as hashRuntimeConfigValue,
+  i2 as isModelThinkingFormat,
+  n as isNixMode,
+  o as isPluginLocalInvalidConfigSnapshot,
+  e2 as isSecretRef,
+  f2 as isValidEnvSecretRefId,
+  p as loadConfig,
+  q as mutateConfigFile,
+  r as mutateConfigFileWithRetry,
+  n2 as normalizeResolvedSecretInputString,
+  g2 as normalizeSecretInputString,
+  s as normalizeStateDirEnv,
+  t as parseConfigJson5,
+  p2 as parseEnvTemplateSecretRef,
+  j2 as parseLegacySecretRefEnvMarker,
+  u as parseToolsBySenderTypedKey,
+  v as projectConfigOntoRuntimeSourceSnapshot,
+  x as promoteConfigSnapshotToLastKnownGood,
+  y as readBestEffortConfig,
+  z as readConfigFileSnapshot,
+  A as readConfigFileSnapshotForWrite,
+  B as readConfigFileSnapshotWithPluginMetadata,
+  E as readSourceConfigBestEffort,
+  F as readSourceConfigSnapshot,
+  G as readSourceConfigSnapshotForWrite,
+  H as recoverConfigFromJsonRootSuffix,
+  I as recoverConfigFromLastKnownGood,
+  J as registerConfigWriteListener,
+  K as replaceConfigFile,
+  L as resetConfigOverrides,
+  M as resetConfigRuntimeState,
+  O as resolveCanonicalConfigPath,
+  P as resolveConfigPath,
+  Q as resolveConfigPathCandidate,
+  R as resolveConfigSnapshotHash,
+  U as resolveConfigWriteAfterWrite,
+  V as resolveConfigWriteFollowUp,
+  W as resolveDefaultConfigCandidates,
+  X as resolveGatewayLockDir,
+  Y as resolveGatewayPort,
+  Z as resolveIncludeRoots,
+  _ as resolveIsNixMode,
+  $ as resolveLegacyStateDir,
+  a0 as resolveLegacyStateDirs,
+  a1 as resolveNewStateDir,
+  a2 as resolveOAuthDir,
+  a3 as resolveOAuthPath,
+  a4 as resolveRuntimeConfigCacheKey,
+  r2 as resolveSecretInputRef,
+  k2 as resolveSecretInputString,
+  a5 as resolveStateDir,
+  a6 as selectApplicableRuntimeConfig,
+  a7 as setConfigOverride,
+  a8 as setRuntimeConfigSnapshot,
+  a9 as setRuntimeConfigSnapshotRefreshHandler,
+  aa as shouldAttemptLastKnownGoodRecovery,
+  ab as transformConfigFile,
+  ac as transformConfigFileWithRetry,
+  ad as unsetConfigOverride,
+  ae as validateConfigObject,
+  af as validateConfigObjectRaw,
+  ag as validateConfigObjectRawWithPlugins,
+  ah as validateConfigObjectWithPlugins,
+  ai as writeConfigFile
+};

package/dist/{cron-tasks-handler-BIpSoLIG.js → cron-tasks-handler-CIhnDbA3.js}

@@ -3,7 +3,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { promisify } from "node:util";
-import { at as logger } from "./index-ZWLWkJXc.js";
+import { l as logger } from "./runtime-api-DU-e2Pen.js";
 const execAsync = promisify(exec);
 function resolvePreferredCliPathEnv() {
   const defaultAliasPath = join(homedir(), ".nvm", "alias", "default");

package/dist/{google-BhYq3yh7.js → google-CO2HXSN_.js}

@@ -1,5 +1,5 @@
-import { i as isThinkingPart, r as retainThoughtSignature, m as mapStopReason, G as GoogleGenAI, c as convertMessages, a as convertTools, b as mapToolChoice } from "./google-shared-sAeUdThk.js";
-import { aL as getEnvApiKey, aN as clampThinkingLevel, aO as AssistantMessageEventStream, aP as calculateCost } from "./index-ZWLWkJXc.js";
+import { i as isThinkingPart, r as retainThoughtSignature, m as mapStopReason, G as GoogleGenAI, c as convertMessages, a as convertTools, b as mapToolChoice } from "./google-shared-BzJ3YIh8.js";
+import { aL as getEnvApiKey, aN as clampThinkingLevel, aO as AssistantMessageEventStream, aP as calculateCost } from "./channel-DRvDqBYj.js";
 import { s as sanitizeSurrogates } from "./sanitize-unicode-BvtkLirb.js";
 import { b as buildBaseOptions } from "./transform-messages-CKtg-kNk.js";
 let toolCallCounter = 0;

package/dist/{google-shared-sAeUdThk.js → google-shared-BzJ3YIh8.js}

@@ -1,4 +1,4 @@
-import { aZ as getDefaultExportFromCjs } from "./index-ZWLWkJXc.js";
+import { aZ as getDefaultExportFromCjs } from "./channel-DRvDqBYj.js";
 import { s as sanitizeSurrogates } from "./sanitize-unicode-BvtkLirb.js";
 import { t as transformMessages } from "./transform-messages-CKtg-kNk.js";
 var pRetry$2 = { exports: {} };

package/dist/{google-vertex-CFbea9mm.js → google-vertex-BD9-XVFI.js}

@@ -1,5 +1,5 @@
-import { i as isThinkingPart, r as retainThoughtSignature, m as mapStopReason, G as GoogleGenAI, c as convertMessages, a as convertTools, b as mapToolChoice, T as ThinkingLevel, R as ResourceScope } from "./google-shared-sAeUdThk.js";
-import { aN as clampThinkingLevel, aO as AssistantMessageEventStream, aP as calculateCost } from "./index-ZWLWkJXc.js";
+import { i as isThinkingPart, r as retainThoughtSignature, m as mapStopReason, G as GoogleGenAI, c as convertMessages, a as convertTools, b as mapToolChoice, T as ThinkingLevel, R as ResourceScope } from "./google-shared-BzJ3YIh8.js";
+import { aN as clampThinkingLevel, aO as AssistantMessageEventStream, aP as calculateCost } from "./channel-DRvDqBYj.js";
 import { s as sanitizeSurrogates } from "./sanitize-unicode-BvtkLirb.js";
 import { b as buildBaseOptions } from "./transform-messages-CKtg-kNk.js";
 const API_VERSION = "v1";

package/dist/{host-hook-cleanup-BNlJQu7G-DZh9GtcC.js → host-hook-cleanup-BNlJQu7G-B6gPaEXw.js}

@@ -1,5 +1,6 @@
-import { l as normalizeLowercaseStringOrEmpty } from "./plugin-load-profile-DOnG9jJ5-zOQuKNoi.js";
-import { au as getActivePluginRegistry, i as getRuntimeConfig, av as withPluginHostCleanupTimeout, aw as cleanupPluginSessionSchedulerJobs, ax as makePluginSessionSchedulerJobKey, ay as clearPluginRunContext, az as normalizeSessionEntrySlotKey, aA as resolveAllAgentSessionStoreTargetsSync, aB as updateSessionStore } from "./index-ZWLWkJXc.js";
+import { n as normalizeLowercaseStringOrEmpty } from "./string-coerce-DyL154ka-BEV0SzzS.js";
+import { au as getActivePluginRegistry, i as getRuntimeConfig, av as withPluginHostCleanupTimeout, aw as cleanupPluginSessionSchedulerJobs, ax as makePluginSessionSchedulerJobKey, ay as clearPluginRunContext, az as normalizeSessionEntrySlotKey, aA as resolveAllAgentSessionStoreTargetsSync, aB as updateSessionStore } from "./channel-DRvDqBYj.js";
+import "./plugin-load-profile-DOnG9jJ5-B0ymqOTX.js";
 import fs__default from "node:fs";
 function shouldCleanPlugin(pluginId, filterPluginId) {
   return !filterPluginId || pluginId === filterPluginId;

package/dist/{index-CXEk4j12.js → index-D9W7_ln2.js}

@@ -1,4 +1,4 @@
-import { aZ as getDefaultExportFromCjs } from "./index-ZWLWkJXc.js";
+import { aZ as getDefaultExportFromCjs } from "./channel-DRvDqBYj.js";
 const WINDOWS_1252_EXTRA = {
   128: "€",
   130: "‚",