@duckmind/dm-linux-x64 0.65.5 → 0.65.6

package/extensions/dm-mcp-adapter/dist/config.js

@@ -1,13 +1,16 @@
-import { existsSync, readFileSync, writeFileSync, mkdirSync, renameSync } from "node:fs";
+import { chmodSync, existsSync, readFileSync, realpathSync, rmSync, statSync, writeFileSync, mkdirSync, renameSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { parse as parseToml } from "smol-toml";
 import stripJsonComments from "strip-json-comments";
 import { getAgentPath, getConfigDirName } from "./agent-dir.js";
 import { getAgentPluginSummaries, loadAgentPluginConfigs } from "./agent-plugin-loader.js";
+import { cloneBuiltInAgentPluginEntry, isBuiltInAgentPlugin, mergeBuiltInAgentPluginEntries } from "./agent-plugin-provenance.js";
+import { loadClaudePluginBundles } from "./claude-plugin-loader.js";
 import { loadPackageMcpConfigs } from "./package-mcp-loader.js";
-import { isServerDisabled } from "./types.js";
-import { toStringRecord } from "./utils.js";
+import { validateJevSettings } from "./jev-client.js";
+import { formatServerNamespace, isServerDisabled } from "./types.js";
+import { parseJsonWithComments, toStringRecord } from "./utils.js";
 const GENERIC_GLOBAL_CONFIG_PATH = join(homedir(), ".config", "mcp", "mcp.json");
 const AGENTS_GLOBAL_CONFIG_PATHS = [
   join(homedir(), ".agents", "mcp.json"),
@@ -140,7 +143,7 @@ export function getMcpDiscoverySummary(overridePath, cwd = process.cwd(), option
   const sourceSpecs = getConfigSources(overridePath, cwd);
   const sources = getConfigSourceSummaries(sourceSpecs);
   const includeHostConfigs = options.includeHostConfigs !== false;
-  const importKinds = isExclusiveConfigMode() ? readValidatedConfig(getEffectivePiGlobalConfigPath(overridePath), "MCP exclusive config")?.imports ?? [] : Object.keys(IMPORT_PATHS);
+  const importKinds = isExclusiveConfigMode() ? readValidatedConfig(getPiGlobalConfigPath(overridePath), "MCP exclusive config")?.imports ?? [] : Object.keys(IMPORT_PATHS);
   const imports = includeHostConfigs ? importKinds.map((kind) => {
     const imported = loadImportedConfig(kind, cwd, `Failed to inspect imported MCP config from ${kind}:`);
     if (!imported)
@@ -187,7 +190,13 @@ export function getMcpDiscoverySummary(overridePath, cwd = process.cwd(), option
   };
 }
 export function cloneMcpConfig(config) {
-  return structuredClone(config);
+  const cloned = structuredClone(config);
+  for (const [name, source] of Object.entries(config.mcpServers)) {
+    const builtInClone = cloneBuiltInAgentPluginEntry(source);
+    if (builtInClone)
+      cloned.mcpServers[name] = builtInClone;
+  }
+  return cloned;
 }
 export function loadMcpConfig(overridePath, cwd = process.cwd()) {
   const sourceSpecs = getConfigSources(overridePath, cwd);
@@ -200,11 +209,37 @@ export function loadMcpConfig(overridePath, cwd = process.cwd()) {
     config = mergeConfigs(config, expandImports(loaded, cwd));
   }
   if (isExclusiveConfigMode())
-    return config;
+    return resolveConfiguredClaudePluginMcp(config, cwd);
   const packageConfig = loadPackageMcpConfigs(cwd);
   const pluginConfig = loadAgentPluginConfigs(config.settings?.agentPluginPaths, cwd);
   const packageServers = Object.fromEntries(Object.entries(packageConfig.mcpServers).filter(([name]) => !Object.hasOwn(pluginConfig.mcpServers, name)));
-  return mergeConfigs({ mcpServers: packageServers }, mergeConfigs(pluginConfig, config));
+  const higherPrecedenceConfig = mergeConfigs({ mcpServers: packageServers }, mergeConfigs(pluginConfig, config));
+  return mergeClaudePluginMcpDefaults(config.claudePlugins, higherPrecedenceConfig, cwd);
+}
+export function resolveConfiguredClaudePluginMcp(config, cwd = process.cwd()) {
+  return mergeClaudePluginMcpDefaults(config.claudePlugins, config, cwd);
+}
+export function discoverConfiguredClaudePluginSkills(config, cwd = process.cwd()) {
+  return loadClaudePluginBundles(config.claudePlugins, cwd, validateConfig, { mcp: false, skills: true }).skillPaths;
+}
+function mergeClaudePluginMcpDefaults(plugins, higherPrecedenceConfig, cwd) {
+  const pluginServers = loadClaudePluginBundles(plugins, cwd, validateConfig, { mcp: true, skills: false }).mcpServers;
+  const higherNamesByNamespace = new Map(Object.keys(higherPrecedenceConfig.mcpServers).map((name) => [formatServerNamespace(name), name]));
+  const defaults = Object.fromEntries(Object.entries(pluginServers).filter(([name]) => {
+    const higherName = higherNamesByNamespace.get(formatServerNamespace(name));
+    if (!higherName || higherName === name)
+      return true;
+    console.warn(`Claude plugin MCP server "${name}" is shadowed by higher-precedence server "${higherName}" because both normalize to the same namespace`);
+    return false;
+  }));
+  return applySettingDefaults(mergeConfigs({ mcpServers: defaults }, higherPrecedenceConfig));
+}
+function applySettingDefaults(config) {
+  const exposeResources = config.settings?.exposeResources;
+  if (exposeResources === undefined)
+    return config;
+  const mcpServers = Object.fromEntries(Object.entries(config.mcpServers).map(([name, entry]) => [name, entry.exposeResources === undefined ? { ...entry, exposeResources } : entry]));
+  return { ...config, mcpServers };
 }
 function getMergedSettings(overridePath, cwd = process.cwd()) {
   let settings;
@@ -275,7 +310,7 @@ function getConfigConflicts(sourceSpecs, imports, cwd) {
   return [...seen.entries()].filter(([, sources]) => sources.length > 1).map(([serverName, sources]) => ({ serverName, sources, winner: sources[sources.length - 1] })).sort((left, right) => left.serverName.localeCompare(right.serverName));
 }
 function getConfigSources(overridePath, cwd = process.cwd()) {
-  const userPath = getEffectivePiGlobalConfigPath(overridePath);
+  const userPath = getPiGlobalConfigPath(overridePath);
   const projectPath = getProjectConfigPath(cwd);
   const projectPiPath = getProjectPiConfigPath(cwd);
   const sources = [];
@@ -325,6 +360,38 @@ function getConfigSources(overridePath, cwd = process.cwd()) {
     shared: false,
     scope: "global"
   });
+  const reservedPaths = new Set([
+    ...sources.map((source) => getConfigPathIdentity(source.readPath)),
+    getConfigPathIdentity(projectPath),
+    getConfigPathIdentity(projectPiPath)
+  ]);
+  const ancestorSources = new Map;
+  const descriptors = [
+    { id: "shared-project-ancestor", label: "ancestor standard MCP", path: getProjectConfigPath, shared: true },
+    { id: "pi-project-ancestor", label: "ancestor DM override", path: getProjectPiConfigPath, shared: false }
+  ];
+  const ancestorRoot = getConfiguredAncestorRoot(sources, cwd);
+  if (ancestorRoot) {
+    for (const dir of getAncestorProjectDirs(cwd, ancestorRoot)) {
+      for (const descriptor of descriptors) {
+        const path = descriptor.path(dir);
+        const identity = getConfigPathIdentity(path);
+        if (reservedPaths.has(identity) || !existsSync(path))
+          continue;
+        ancestorSources.delete(identity);
+        ancestorSources.set(identity, {
+          id: descriptor.id,
+          label: descriptor.label,
+          readPath: path,
+          writePath: path,
+          kind: "project",
+          shared: descriptor.shared,
+          scope: "project"
+        });
+      }
+    }
+  }
+  sources.push(...ancestorSources.values());
   if (projectPath !== userPath) {
     sources.push({
       id: "shared-project",
@@ -349,22 +416,80 @@ function getConfigSources(overridePath, cwd = process.cwd()) {
   }
   return sources;
 }
+function getConfigPathIdentity(path) {
+  try {
+    return realpathSync(path);
+  } catch {
+    return resolve(path);
+  }
+}
+function isWithin(base, target) {
+  const path = relative(base, target);
+  return path !== ".." && !path.startsWith(`..${sep}`) && !isAbsolute(path);
+}
+function getConfiguredAncestorRoot(globalSources, cwd) {
+  let configured;
+  for (const source of globalSources) {
+    const roots = readValidatedConfig(source.readPath, `MCP config from ${source.readPath}`)?.settings?.ancestorConfigRoots;
+    if (roots !== undefined)
+      configured = roots;
+  }
+  if (configured === undefined || Array.isArray(configured) && configured.length === 0)
+    return;
+  if (!Array.isArray(configured)) {
+    console.warn("Invalid settings.ancestorConfigRoots: expected an array of paths");
+    return;
+  }
+  const home = getConfigPathIdentity(resolve(homedir()));
+  const canonicalCwd = getConfigPathIdentity(resolve(cwd));
+  const valid = [];
+  for (const entry of configured) {
+    const expanded = typeof entry === "string" && entry.startsWith("~/") ? join(homedir(), entry.slice(2)) : entry;
+    if (typeof expanded !== "string" || !isAbsolute(expanded)) {
+      console.warn(`Invalid settings.ancestorConfigRoots entry ${JSON.stringify(entry)}: expected an absolute path or ~/...`);
+      continue;
+    }
+    try {
+      const root = realpathSync(expanded);
+      if (!statSync(root).isDirectory() || !isWithin(home, root) || !isWithin(root, canonicalCwd))
+        throw new Error;
+      valid.push(root);
+    } catch {
+      console.warn(`Invalid settings.ancestorConfigRoots entry ${JSON.stringify(entry)}: expected an existing directory under HOME containing cwd`);
+    }
+  }
+  return valid.sort((left, right) => right.length - left.length)[0];
+}
+function getAncestorProjectDirs(cwd, root) {
+  const start = getConfigPathIdentity(resolve(cwd));
+  const dirs = [];
+  let current = dirname(start);
+  while (isWithin(root, current)) {
+    dirs.unshift(current);
+    if (current === root)
+      break;
+    const parent = dirname(current);
+    if (parent === current)
+      break;
+    current = parent;
+  }
+  return dirs;
+}
 function isExclusiveConfigMode() {
   return (process.env.DM_MCP_CONFIG_MODE ?? process.env.PI_MCP_CONFIG_MODE)?.trim().toLowerCase() === "exclusive";
 }
-function getEffectivePiGlobalConfigPath(overridePath) {
-  return getPiGlobalConfigPath(isExclusiveConfigMode() ? undefined : overridePath);
-}
 function mergeConfigs(base, next) {
   const imports = mergeImports(base.imports, next.imports);
   const settings = next.settings ? { ...base.settings, ...next.settings } : base.settings;
+  const claudePlugins = next.claudePlugins ?? base.claudePlugins;
   return {
     mcpServers: mergeServerMaps(base.mcpServers, next.mcpServers),
     ...imports !== undefined ? { imports } : {},
-    ...settings !== undefined ? { settings } : {}
+    ...settings !== undefined ? { settings } : {},
+    ...claudePlugins !== undefined ? { claudePlugins } : {}
   };
 }
-const URL_BOUND_AUTH_FIELDS = ["headers", "bearerToken", "bearerTokenEnv", "bearerTokenStore", "requestHeadersCommand"];
+const URL_BOUND_AUTH_FIELDS = ["headers", "bearerToken", "bearerTokenEnv", "bearerTokenStore", "requestHeadersCommand", "caFile"];
 function mergeServerMaps(base, next) {
   const merged = { ...base };
   for (const [name, definition] of Object.entries(next)) {
@@ -376,9 +501,11 @@ function mergeServerMaps(base, next) {
         "url",
         "headers",
         "requestHeadersCommand",
+        "caFile",
         "auth",
         "bearerToken",
         "bearerTokenEnv",
+        "bearerTokenStore",
         "oauth",
         "httpTransport",
         "socket"
@@ -394,6 +521,7 @@ function mergeServerMaps(base, next) {
         "cwd",
         "pluginDataDir",
         "literalEnv",
+        "inheritEnv",
         "socket"
       ]) {
         delete baseEntry[field];
@@ -407,12 +535,15 @@ function mergeServerMaps(base, next) {
         "cwd",
         "pluginDataDir",
         "literalEnv",
+        "inheritEnv",
         "url",
         "headers",
         "requestHeadersCommand",
+        "caFile",
         "auth",
         "bearerToken",
         "bearerTokenEnv",
+        "bearerTokenStore",
         "oauth",
         "httpTransport"
       ]) {
@@ -429,7 +560,12 @@ function mergeServerMaps(base, next) {
         delete baseEntry.oauth;
       }
     }
-    merged[name] = { ...baseEntry, ...definition };
+    if (existing && Object.hasOwn(definition, "env") && isBuiltInAgentPlugin(existing, "env") && !Object.hasOwn(definition, "literalEnv")) {
+      if (baseEntry === existing)
+        baseEntry = { ...existing };
+      delete baseEntry.literalEnv;
+    }
+    merged[name] = mergeBuiltInAgentPluginEntries(baseEntry, definition);
   }
   return merged;
 }
@@ -457,6 +593,7 @@ function expandImports(config, cwd = process.cwd()) {
   return {
     imports: config.imports,
     ...config.settings !== undefined ? { settings: config.settings } : {},
+    ...config.claudePlugins !== undefined ? { claudePlugins: config.claudePlugins } : {},
     mcpServers: mergeServerMaps(importedServers, config.mcpServers)
   };
 }
@@ -489,12 +626,9 @@ function resolveImportCandidates(importKind, cwd) {
     return candidate.startsWith(".") ? resolve(cwd, candidate) : candidate;
   });
 }
-function parseJsonConfig(raw) {
-  return JSON.parse(stripJsonComments(raw, { trailingCommas: true }));
-}
 function readImportedConfig(path) {
   const raw = readFileSync(path, "utf-8");
-  return path.endsWith(".toml") ? parseToml(raw) : parseJsonConfig(raw);
+  return path.endsWith(".toml") ? parseToml(raw) : parseJsonWithComments(raw);
 }
 function loadImportedConfig(importKind, cwd, warningPrefix) {
   if (importKind === "opencode") {
@@ -506,7 +640,24 @@ function loadImportedConfig(importKind, cwd, warningPrefix) {
       try {
         const value = readImportedConfig(path);
         if (value && typeof value === "object" && !Array.isArray(value)) {
-          merged = mergeOpenCodeConfigs(merged, value);
+          const imported = value;
+          const mcp = isRecord(imported.mcp) ? imported.mcp : {};
+          const entries = isRecord(mcp.servers) ? { ...Object.fromEntries(Object.entries(mcp).filter(([name]) => name !== "servers" && name !== "timeout")), ...mcp.servers } : mcp;
+          const normalized = Object.fromEntries(Object.entries(entries).map(([name, entry]) => {
+            if (!isRecord(entry) || !isRecord(entry.oauth))
+              return [name, entry];
+            const { client_id, client_secret, auth_server_metadata_url, ...oauth } = entry.oauth;
+            return [name, {
+              ...entry,
+              oauth: {
+                ...oauth,
+                ...client_id !== undefined ? { clientId: client_id } : {},
+                ...client_secret !== undefined ? { clientSecret: client_secret } : {},
+                ...auth_server_metadata_url !== undefined ? { authServerMetadataUrl: auth_server_metadata_url } : {}
+              }
+            }];
+          }));
+          merged = mergeOpenCodeConfigs(merged, { ...imported, mcp: normalized });
           highestPrecedencePath = path;
         }
       } catch (error) {
@@ -533,7 +684,10 @@ function readValidatedConfig(path, label) {
   if (!existsSync(path))
     return null;
   try {
-    return validateConfig(parseJsonConfig(readFileSync(path, "utf-8")));
+    const text = readFileSync(path, "utf-8");
+    if (stripJsonComments(text, { trailingCommas: true }).trim() === "")
+      return null;
+    return validateConfig(parseJsonWithComments(text));
   } catch (error) {
     console.warn(`Failed to load ${label}:`, error);
     return null;
@@ -546,9 +700,47 @@ function validateConfig(raw) {
   return {
     mcpServers: toServerEntries(raw.mcpServers ?? raw["mcp-servers"]),
     ...Array.isArray(raw.imports) ? { imports: raw.imports } : {},
-    ...raw.settings !== undefined ? { settings: raw.settings } : {}
+    ...raw.settings !== undefined ? { settings: parseSettings(raw.settings) } : {},
+    ...raw.claudePlugins !== undefined ? { claudePlugins: parseClaudePlugins(raw.claudePlugins) } : {}
   };
 }
+function parseSettings(value) {
+  if (!isRecord(value))
+    throw new Error("settings must be an object");
+  const settings = { ...value };
+  if (value.jev !== undefined) {
+    validateJevSettings(value.jev);
+    settings.jev = value.jev;
+  }
+  return settings;
+}
+function parseClaudePlugins(value) {
+  if (!Array.isArray(value)) {
+    console.warn("Invalid claudePlugins config: expected an array");
+    return [];
+  }
+  const plugins = [];
+  for (const [index, entry] of value.entries()) {
+    if (!isRecord(entry) || typeof entry.path !== "string" || entry.path.trim().length === 0) {
+      console.warn(`Invalid claudePlugins[${index}]: expected an object with a non-empty path`);
+      continue;
+    }
+    if (entry.mcp !== undefined && typeof entry.mcp !== "boolean" || entry.skills !== undefined && typeof entry.skills !== "boolean") {
+      console.warn(`Invalid claudePlugins[${index}] for ${entry.path}: mcp and skills must be booleans`);
+      continue;
+    }
+    if (entry.mcp !== true && entry.skills !== true) {
+      console.warn(`Invalid claudePlugins[${index}] for ${entry.path}: enable mcp, skills, or both`);
+      continue;
+    }
+    plugins.push({
+      path: entry.path,
+      ...entry.mcp !== undefined ? { mcp: entry.mcp } : {},
+      ...entry.skills !== undefined ? { skills: entry.skills } : {}
+    });
+  }
+  return plugins;
+}
 function toServerEntries(servers) {
   if (!isRecord(servers))
     return {};
@@ -642,7 +834,7 @@ function extractServers(config, kind) {
       if (!entry || typeof entry !== "object" || Array.isArray(entry))
         continue;
       const raw = entry;
-      if (raw.enabled === false)
+      if (raw.enabled === false || raw.disabled === true)
         continue;
       if (raw.type === "local" && Array.isArray(raw.command) && raw.command.length > 0 && raw.command.every((value) => typeof value === "string")) {
         const env = toStringRecord(raw.environment);
@@ -669,11 +861,15 @@ function extractServers(config, kind) {
         } else if (raw.oauth && typeof raw.oauth === "object" && !Array.isArray(raw.oauth)) {
           const oauth = raw.oauth;
           mapped.auth = "oauth";
+          const clientId = oauth.clientId;
+          const clientSecret = oauth.clientSecret;
+          const authServerMetadataUrl = oauth.authServerMetadataUrl;
           mapped.oauth = {
-            ...typeof oauth.clientId === "string" ? { clientId: oauth.clientId } : {},
-            ...typeof oauth.clientSecret === "string" ? { clientSecret: oauth.clientSecret } : {},
+            ...typeof clientId === "string" ? { clientId } : {},
+            ...typeof clientSecret === "string" ? { clientSecret } : {},
+            ...typeof oauth.clientMetadataUrl === "string" ? { clientMetadataUrl: oauth.clientMetadataUrl } : {},
             ...typeof oauth.scope === "string" ? { scope: oauth.scope } : {},
-            ...typeof oauth.authServerMetadataUrl === "string" ? { authServerMetadataUrl: oauth.authServerMetadataUrl } : {},
+            ...typeof authServerMetadataUrl === "string" ? { authServerMetadataUrl } : {},
             ...typeof oauth.skipIssuerMetadataValidation === "boolean" ? { skipIssuerMetadataValidation: oauth.skipIssuerMetadataValidation } : {}
           };
         }
@@ -778,18 +974,72 @@ function readRawConfigObject(filePath) {
   if (!existsSync(filePath))
     return {};
   try {
-    const raw = parseJsonConfig(readFileSync(filePath, "utf-8"));
+    const raw = parseJsonWithComments(readFileSync(filePath, "utf-8"));
     return raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
   } catch {
     return {};
   }
 }
+function writeConfigText(writePath, text) {
+  let mode;
+  try {
+    writePath = realpathSync(writePath);
+    mode = statSync(writePath).mode & 511;
+  } catch {}
+  mkdirSync(dirname(writePath), { recursive: true });
+  const tmpPath = `${writePath}.${process.pid}.tmp`;
+  rmSync(tmpPath, { force: true });
+  try {
+    writeFileSync(tmpPath, text, mode === undefined ? "utf-8" : { encoding: "utf-8", mode });
+    if (mode !== undefined)
+      chmodSync(tmpPath, mode);
+    renameSync(tmpPath, writePath);
+  } catch (error) {
+    try {
+      rmSync(tmpPath, { force: true });
+    } catch {}
+    throw error;
+  }
+}
 function writeRawConfigObject(filePath, raw) {
-  mkdirSync(dirname(filePath), { recursive: true });
-  const tmpPath = `${filePath}.${process.pid}.tmp`;
-  writeFileSync(tmpPath, `${JSON.stringify(raw, null, 2)}
-`, "utf-8");
-  renameSync(tmpPath, filePath);
+  writeConfigText(filePath, `${JSON.stringify(raw, null, 2)}
+`);
+}
+export function writeSharedConfigText(filePath, text) {
+  if (!isRecord(parseJsonWithComments(text)))
+    throw new Error("top-level value must be an object");
+  writeConfigText(filePath, text);
+}
+export function writeJevSemanticSearchConfig(overridePath, cwd, allowedServers, effectiveJev) {
+  const filePath = overridePath ? getPiGlobalConfigPath(overridePath) : getProjectPiConfigPath(cwd);
+  let raw = {};
+  if (existsSync(filePath)) {
+    try {
+      const parsed = parseJsonWithComments(readFileSync(filePath, "utf8"));
+      if (!isRecord(parsed))
+        throw new Error("top-level value must be an object");
+      raw = parsed;
+    } catch (error) {
+      throw new Error(`Failed to update Jev settings at ${filePath}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+    }
+  }
+  if (raw.settings !== undefined && !isRecord(raw.settings)) {
+    throw new Error(`Failed to update Jev settings at ${filePath}: settings must be an object`);
+  }
+  const settings = raw.settings;
+  const currentJev = settings?.jev;
+  if (currentJev !== undefined && currentJev !== false && !isRecord(currentJev)) {
+    throw new Error(`Failed to update Jev settings at ${filePath}: settings.jev must be an object or false`);
+  }
+  const jev = isRecord(effectiveJev) ? effectiveJev : isRecord(currentJev) ? currentJev : {};
+  const nextServers = [...new Set(allowedServers)].sort((a, b) => a.localeCompare(b));
+  const nextJev = { ...jev, semanticSearch: true, allowedServers: nextServers };
+  validateJevSettings(nextJev);
+  if (isRecord(currentJev) && JSON.stringify(currentJev) === JSON.stringify(nextJev))
+    return { path: filePath, changed: false };
+  raw.settings = { ...settings, jev: nextJev };
+  writeRawConfigObject(filePath, raw);
+  return { path: filePath, changed: true };
 }
 function getServersObject(raw) {
   const existing = raw.mcpServers ?? raw["mcp-servers"] ?? {};
@@ -807,7 +1057,7 @@ export function writeProjectServerDisabledOverride(overridePath, cwd, serverName
   let raw = {};
   if (existsSync(filePath)) {
     try {
-      const parsed = parseJsonConfig(readFileSync(filePath, "utf-8"));
+      const parsed = parseJsonWithComments(readFileSync(filePath, "utf-8"));
       if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
         throw new Error("root value must be an object");
       }

package/extensions/dm-mcp-adapter/dist/consent-manager.js

@@ -0,0 +1,84 @@
+import { ConsentError } from "./errors.js";
+import { logger } from "./logger.js";
+
+export class ConsentManager {
+  mode;
+  persistDecision;
+  approvedServers = new Set;
+  deniedServers = new Set;
+  log = logger.child({ component: "ConsentManager" });
+  constructor(mode = "once-per-server", persistDecision) {
+    this.mode = mode;
+    this.persistDecision = persistDecision;
+    this.log.debug("Initialized", { mode });
+  }
+  requiresPrompt(serverName) {
+    if (this.mode === "never")
+      return false;
+    if (this.deniedServers.has(serverName))
+      return true;
+    if (this.mode === "always")
+      return true;
+    return !this.approvedServers.has(serverName);
+  }
+  shouldCacheConsent() {
+    return this.mode !== "always";
+  }
+  registerDecision(serverName, approved) {
+    this.applyDecision(serverName, approved);
+    try {
+      this.persistDecision?.({
+        version: 1,
+        kind: "iframe",
+        decision: approved ? "allow" : "deny",
+        serverName
+      });
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      this.log.debug("Failed to persist consent decision", { server: serverName, error: detail });
+    }
+  }
+  restoreDecision(serverName, approved) {
+    if (this.mode === "always" && approved) {
+      this.approvedServers.delete(serverName);
+      this.deniedServers.delete(serverName);
+      return;
+    }
+    this.applyDecision(serverName, approved);
+  }
+  ensureApproved(serverName) {
+    if (this.mode === "never")
+      return;
+    if (this.deniedServers.has(serverName)) {
+      throw new ConsentError(serverName, { denied: true });
+    }
+    if (!this.approvedServers.has(serverName)) {
+      throw new ConsentError(serverName, { requiresApproval: true });
+    }
+    if (this.mode === "always") {
+      this.approvedServers.delete(serverName);
+    }
+  }
+  clear(serverName) {
+    if (serverName) {
+      this.approvedServers.delete(serverName);
+      this.deniedServers.delete(serverName);
+      this.log.debug("Cleared consent for server", { server: serverName });
+      return;
+    }
+    this.approvedServers.clear();
+    this.deniedServers.clear();
+    this.log.debug("Cleared all consent records");
+  }
+  applyDecision(serverName, approved) {
+    this.deniedServers.delete(serverName);
+    this.approvedServers.delete(serverName);
+    if (approved) {
+      this.approvedServers.add(serverName);
+      this.log.debug("Consent granted", { server: serverName });
+      return;
+    }
+    this.deniedServers.add(serverName);
+    this.log.debug("Consent denied", { server: serverName });
+  }
+}