@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

package/extensions/dm-mcp-adapter/dist/output-shape.js

@@ -0,0 +1,312 @@
+import { logger } from "./logger.js";
+import { outputShapeKey, saveObservedOutput } from "./metadata-cache.js";
+import { formatPropertyName } from "./ts-shape.js";
+const MAX_DEPTH = 6;
+const MAX_ARRAY_SAMPLE = 5;
+const MAX_OBJECT_KEYS = 40;
+const FIELD_NAME = /^[A-Za-z_$][A-Za-z0-9_$]{0,39}$/;
+const MAX_UNION = 4;
+const MAX_NODES_PER_CALL = 1000;
+const MAX_SHAPE_CHARS = 4 * 1024;
+const MAX_JSON_TEXT_CHARS = 256 * 1024;
+const MIN_ALIAS_CHARS = 80;
+const SHAPE_TYPES = new Set(["null", "boolean", "number", "string", "object", "array"]);
+export function observedOutputRecorder(state, serverName, toolName) {
+  const tool = findTool(state, serverName, toolName);
+  const listingIsPrivate = () => state.manager.getConnection(serverName)?.toolListHints?.cacheScope === "private";
+  const privateAtStart = listingIsPrivate();
+  return (result) => recordObservedOutput(state, serverName, tool, privateAtStart || listingIsPrivate(), result);
+}
+function recordObservedOutput(state, serverName, tool, observedPrivately, result) {
+  if (!tool || tool.outputSchema !== undefined)
+    return;
+  const toolName = tool.originalName;
+  const observed = readResultValue(result);
+  if (!observed)
+    return;
+  const definition = state.config.mcpServers[serverName];
+  if (!definition)
+    return;
+  const shape = inferShape(observed.value, 0, { nodes: MAX_NODES_PER_CALL });
+  const byTool = observedOutputsFor(state, definition);
+  const toolKey = outputShapeKey(tool);
+  const previous = byTool.get(toolName);
+  const mergeable = previous?.source === observed.source && previous.toolKey === toolKey;
+  const next = {
+    source: observed.source,
+    shape: fitShape(mergeable ? mergeShapes(previous.shape, shape) : shape),
+    toolKey,
+    private: observedPrivately || mergeable && previous.private
+  };
+  byTool.set(toolName, next);
+  if (state.scriptTool === true && !next.private && JSON.stringify(next) !== JSON.stringify(previous)) {
+    try {
+      saveObservedOutput(serverName, definition, toolName, toolKey, { source: next.source, shape: next.shape });
+    } catch (error) {
+      logger.debug(`MCP: failed to save output shape for ${serverName}/${toolName}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+}
+export function seedObservedOutputs(state, serverName, entry) {
+  const definition = state.config.mcpServers[serverName];
+  const saved = entry.outputShapes;
+  if (!definition || typeof saved !== "object" || saved === null)
+    return;
+  const byTool = observedOutputsFor(state, definition);
+  for (const [toolName, value] of Object.entries(saved)) {
+    const cachedTool = Array.isArray(entry.tools) ? entry.tools.find((tool) => tool?.name === toolName) : undefined;
+    if (!cachedTool || typeof value !== "object" || value === null)
+      continue;
+    const toolKey = outputShapeKey(cachedTool);
+    if (byTool.get(toolName)?.toolKey === toolKey)
+      continue;
+    const { source, shape } = value;
+    if (source !== "structuredContent" && source !== "jsonText")
+      continue;
+    const parsed = readSavedShape(shape, 0);
+    if (parsed && !isUnknown(parsed))
+      byTool.set(toolName, { source, shape: fitShape(parsed), toolKey, private: false });
+  }
+}
+export function getObservedOutput(state, serverName, tool) {
+  if (tool.outputSchema !== undefined)
+    return;
+  const definition = state.config.mcpServers[serverName];
+  const observed = definition && state.observedOutputs?.get(definition)?.get(tool.originalName);
+  return observed && observed.toolKey === outputShapeKey(tool) && !isUnknown(observed.shape) ? observed : undefined;
+}
+export function renderOutputShape(shape) {
+  const plain = new Map;
+  const uses = new Map;
+  const once = renderShape(shape, "item", (node, field, text) => {
+    plain.set(node, text);
+    const use = uses.get(text);
+    if (use)
+      use.count++;
+    else
+      uses.set(text, { count: 1, field });
+    return text;
+  });
+  const names = new Map;
+  const taken = new Set(["Record"]);
+  for (const [text, use] of uses) {
+    if (use.count < 2 || text.length < MIN_ALIAS_CHARS)
+      continue;
+    const words = use.field.split(/[^A-Za-z0-9]+/).filter(Boolean).map((part) => part[0].toUpperCase() + part.slice(1)).join("");
+    const base = /^[A-Za-z]/.test(words) ? words : `T${words}`;
+    let name = base;
+    for (let suffix = 2;taken.has(name); suffix++)
+      name = `${base}${suffix}`;
+    taken.add(name);
+    names.set(text, name);
+  }
+  if (names.size === 0)
+    return once;
+  const definitions = new Map;
+  const main = renderShape(shape, "item", (node, _field, text) => {
+    const name = names.get(plain.get(node));
+    if (!name)
+      return text;
+    if (!definitions.has(name))
+      definitions.set(name, text);
+    return name;
+  });
+  return [...[...definitions].map(([name, body]) => `type ${name} = ${body};`), main].join(`
+`);
+}
+function renderShape(shape, field, onObject) {
+  if (shape.anyOf)
+    return shape.anyOf.map((variant) => renderShape(variant, field, onObject)).join(" | ");
+  switch (shape.type) {
+    case undefined:
+      return "unknown";
+    case "object": {
+      if (shape.additionalProperties)
+        return `Record<string, ${renderShape(shape.additionalProperties, field, onObject)}>`;
+      const required = new Set(shape.required);
+      const properties = Object.entries(shape.properties ?? {}).map(([name, property]) => `${formatPropertyName(name)}${required.has(name) ? "" : "?"}: ${renderShape(property, name, onObject)};`);
+      return onObject(shape, field, properties.length === 0 ? "{}" : `{ ${properties.join(" ")} }`);
+    }
+    case "array": {
+      if (!shape.items)
+        return "unknown[]";
+      const item = renderShape(shape.items, field, onObject);
+      return shape.items.anyOf ? `(${item})[]` : `${item}[]`;
+    }
+    default:
+      return shape.type;
+  }
+}
+function observedOutputsFor(state, definition) {
+  const observedOutputs = state.observedOutputs ??= new WeakMap;
+  let byTool = observedOutputs.get(definition);
+  if (!byTool)
+    observedOutputs.set(definition, byTool = new Map);
+  return byTool;
+}
+function readSavedShape(value, depth) {
+  if (typeof value !== "object" || value === null || Array.isArray(value) || depth > MAX_DEPTH)
+    return;
+  const raw = value;
+  if (raw.anyOf !== undefined) {
+    if (!Array.isArray(raw.anyOf) || raw.anyOf.length < 2 || raw.anyOf.length > MAX_UNION || raw.anyOf.some((variant) => typeof variant !== "object" || variant === null || ("anyOf" in variant)))
+      return;
+    const variants = raw.anyOf.map((variant) => readSavedShape(variant, depth));
+    return variants.every((variant) => variant?.type !== undefined) ? { anyOf: variants } : undefined;
+  }
+  if (raw.type === undefined)
+    return {};
+  if (typeof raw.type !== "string" || !SHAPE_TYPES.has(raw.type))
+    return;
+  const shape = { type: raw.type };
+  for (const key of ["items", "additionalProperties"]) {
+    if (raw[key] === undefined)
+      continue;
+    const child = readSavedShape(raw[key], depth + 1);
+    if (!child)
+      return;
+    shape[key] = child;
+  }
+  if (raw.properties !== undefined) {
+    if (typeof raw.properties !== "object" || raw.properties === null || Array.isArray(raw.properties))
+      return;
+    const entries = Object.entries(raw.properties);
+    if (entries.length > MAX_OBJECT_KEYS)
+      return;
+    const properties = {};
+    for (const [key, child] of entries) {
+      const property = key !== "__proto__" && FIELD_NAME.test(key) ? readSavedShape(child, depth + 1) : undefined;
+      if (!property)
+        return;
+      properties[key] = property;
+    }
+    shape.properties = properties;
+    shape.required = Array.isArray(raw.required) ? raw.required.filter((key) => typeof key === "string" && Object.hasOwn(properties, key)) : [];
+  }
+  return shape;
+}
+function findTool(state, serverName, toolName) {
+  return state.toolMetadata.get(serverName)?.find((tool) => tool.originalName === toolName && !tool.resourceUri);
+}
+function readResultValue(result) {
+  const structured = result.structuredContent;
+  if (typeof structured === "object" && structured !== null)
+    return { source: "structuredContent", value: structured };
+  const content = result.content;
+  if (!Array.isArray(content) || content.length !== 1)
+    return;
+  const block = content[0];
+  if (block.type !== "text" || typeof block.text !== "string" || block.text.length > MAX_JSON_TEXT_CHARS)
+    return;
+  const text = block.text.trim();
+  if (!text.startsWith("{") && !text.startsWith("["))
+    return;
+  try {
+    return { source: "jsonText", value: JSON.parse(text) };
+  } catch {
+    return;
+  }
+}
+function inferShape(value, depth, budget) {
+  if (--budget.nodes < 0)
+    return {};
+  if (value === null)
+    return { type: "null" };
+  if (typeof value === "boolean" || typeof value === "number" || typeof value === "string")
+    return { type: typeof value };
+  if (typeof value !== "object" || depth >= MAX_DEPTH)
+    return {};
+  if (Array.isArray(value)) {
+    const items = value.slice(0, MAX_ARRAY_SAMPLE).map((item) => inferShape(item, depth + 1, budget));
+    return items.length === 0 ? { type: "array" } : { type: "array", items: items.reduce(mergeShapes) };
+  }
+  const record = value;
+  const keys = [];
+  let isMap = false;
+  for (const key in record) {
+    if (!Object.hasOwn(record, key))
+      continue;
+    keys.push(key);
+    if (keys.length > MAX_OBJECT_KEYS || !FIELD_NAME.test(key) || /\d{4}/.test(key) || key === "__proto__") {
+      isMap = true;
+      break;
+    }
+  }
+  if (isMap) {
+    const values = keys.slice(0, MAX_ARRAY_SAMPLE).map((key) => inferShape(record[key], depth + 1, budget));
+    return { type: "object", additionalProperties: values.reduce(mergeShapes) };
+  }
+  const properties = {};
+  for (const key of keys)
+    properties[key] = inferShape(record[key], depth + 1, budget);
+  return { type: "object", properties, required: keys };
+}
+function isUnknown(shape) {
+  return shape.type === undefined && shape.anyOf === undefined;
+}
+function mergeShapes(left, right) {
+  if (isUnknown(left) || isUnknown(right))
+    return {};
+  const variants = [...left.anyOf ?? [left]];
+  for (const variant of right.anyOf ?? [right]) {
+    const index = variants.findIndex((existing) => existing.type === variant.type);
+    if (index === -1)
+      variants.push(variant);
+    else
+      variants[index] = mergeSameType(variants[index], variant);
+  }
+  if (variants.length > MAX_UNION)
+    return {};
+  return variants.length === 1 ? variants[0] : { anyOf: variants };
+}
+function mergeSameType(left, right) {
+  if (left.type === "array") {
+    const items = left.items && right.items ? mergeShapes(left.items, right.items) : left.items ?? right.items;
+    return items ? { type: "array", items } : { type: "array" };
+  }
+  if (left.type !== "object")
+    return left;
+  const keys = new Set([...Object.keys(left.properties ?? {}), ...Object.keys(right.properties ?? {})]);
+  if (left.additionalProperties || right.additionalProperties || keys.size > MAX_OBJECT_KEYS) {
+    const values = [
+      left.additionalProperties,
+      right.additionalProperties,
+      ...Object.values(left.properties ?? {}),
+      ...Object.values(right.properties ?? {})
+    ].filter((shape) => shape !== undefined);
+    return { type: "object", additionalProperties: values.reduce(mergeShapes) };
+  }
+  const properties = {};
+  for (const key of keys) {
+    const leftProperty = left.properties?.[key];
+    const rightProperty = right.properties?.[key];
+    properties[key] = leftProperty && rightProperty ? mergeShapes(leftProperty, rightProperty) : leftProperty ?? rightProperty;
+  }
+  const rightRequired = new Set(right.required);
+  return { type: "object", properties, required: (left.required ?? []).filter((key) => rightRequired.has(key)) };
+}
+function fitShape(shape) {
+  for (let depth = MAX_DEPTH;depth > 0; depth--) {
+    const pruned = pruneShape(shape, depth);
+    if (renderOutputShape(pruned).length <= MAX_SHAPE_CHARS)
+      return pruned;
+  }
+  return {};
+}
+function pruneShape(shape, depth) {
+  if (shape.anyOf) {
+    const variants = shape.anyOf.map((variant) => pruneShape(variant, depth));
+    return variants.some(isUnknown) ? {} : { anyOf: variants };
+  }
+  if (shape.type !== "object" && shape.type !== "array")
+    return shape;
+  if (depth === 0)
+    return {};
+  const prune = (child) => pruneShape(child, depth - 1);
+  return {
+    ...shape,
+    ...shape.properties ? { properties: Object.fromEntries(Object.entries(shape.properties).map(([key, child]) => [key, prune(child)])) } : {},
+    ...shape.items ? { items: prune(shape.items) } : {},
+    ...shape.additionalProperties ? { additionalProperties: prune(shape.additionalProperties) } : {}
+  };
+}

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

@@ -0,0 +1,144 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { isAbsolute, join, resolve } from "node:path";
+import { getAgentDir, getConfigDirName } from "./agent-dir.js";
+import { parseJsonWithComments, resolveContainedPath, resolveRealContainedPath } from "./utils.js";
+export function loadPackageMcpConfigs(cwd = process.cwd()) {
+  const mcpServers = {};
+  const serverSources = new Map;
+  const seen = new Set;
+  for (const packageSource of getConfiguredPackageRoots(cwd)) {
+    const { packageRoot } = packageSource;
+    const manifest = readPackageManifest(packageRoot);
+    if (!manifest || typeof manifest.name !== "string" || !manifest.name)
+      continue;
+    const manifestMcp = manifest.dm?.mcp ?? manifest.pi?.mcp;
+    const manifestKey = manifest.dm?.mcp !== undefined ? "dm.mcp" : "pi.mcp";
+    const paths = getManifestMcpPaths(manifestMcp, manifest.name, manifestKey);
+    if (!paths)
+      continue;
+    const packagePrefix = formatPackageName(manifest.name);
+    const packageServers = new Set;
+    for (const path of paths) {
+      const configPath = resolvePackageConfigPath(packageRoot, path);
+      if (!configPath) {
+        console.warn(`DM package ${manifest.name} skips MCP config ${path}: file must stay inside the package`);
+        continue;
+      }
+      const config = readMcpConfig(configPath, manifest.name);
+      if (!config)
+        continue;
+      for (const [serverName, server] of Object.entries(config.mcpServers)) {
+        const normalizedName = `${packagePrefix}__${formatServerName(serverName)}`;
+        if (packageServers.has(normalizedName) || seen.has(normalizedName)) {
+          console.warn(`DM package ${manifest.name} skips duplicate normalized MCP server ${normalizedName}`);
+          continue;
+        }
+        packageServers.add(normalizedName);
+        seen.add(normalizedName);
+        mcpServers[normalizedName] = server;
+        serverSources.set(normalizedName, packageSource);
+      }
+    }
+  }
+  return { mcpServers, serverSources };
+}
+function getConfiguredPackageRoots(cwd) {
+  const roots = [];
+  for (const [settingsPath, scope] of [
+    [join(cwd, getConfigDirName(), "settings.json"), "project"],
+    [join(getAgentDir(), "settings.json"), "user"]
+  ]) {
+    const settings = readOptionalJson(settingsPath, `${scope} DM settings`);
+    if (settings === undefined)
+      continue;
+    if (typeof settings !== "object" || settings === null || Array.isArray(settings)) {
+      throw new Error(`${scope} DM settings ${settingsPath} must be a JSON object`);
+    }
+    const packages = settings.packages;
+    if (packages === undefined)
+      continue;
+    if (!Array.isArray(packages))
+      throw new Error(`${scope} DM settings ${settingsPath} packages must be an array`);
+    for (const entry of packages) {
+      const source = typeof entry === "string" ? entry : entry && typeof entry === "object" && !Array.isArray(entry) && typeof entry.source === "string" ? entry.source : undefined;
+      if (!source)
+        throw new Error(`${scope} DM settings ${settingsPath} package entries must be strings or objects with a string source`);
+      const root = resolvePackageRoot(source, scope, cwd);
+      if (root && !roots.some((entry) => entry.packageRoot === root)) {
+        roots.push({ packageRoot: root, scope, settingsPath });
+      }
+    }
+  }
+  return roots;
+}
+function resolvePackageRoot(source, scope, cwd) {
+  const baseDir = scope === "user" ? getAgentDir() : join(cwd, getConfigDirName());
+  if (source.startsWith("npm:")) {
+    const name = source.slice(4).trim().match(/^(@?[^@]+(?:\/[^@]+)?)/)?.[1];
+    return name ? resolveContainedPath(join(baseDir, "npm", "node_modules"), name) : null;
+  }
+  const gitSource = source.startsWith("git:") ? source.slice(4).trim() : /^(?:(?:https?|ssh):\/\/|git@[^:]+:)/.test(source) ? source : null;
+  if (gitSource) {
+    const isUrl = /^[a-z]+:\/\//i.test(gitSource);
+    if (isUrl && !URL.canParse(gitSource))
+      return null;
+    const url = isUrl ? new URL(gitSource) : null;
+    const value = url ? url.hostname + url.pathname : gitSource.replace(/^git@([^:]+):/, "$1/");
+    const refStart = value.indexOf("@", value.indexOf("/"));
+    const path = (refStart < 0 || refStart === value.length - 1 ? value : value.slice(0, refStart)).replace(/\.git$/, "");
+    return path && !path.startsWith("/") ? resolveContainedPath(join(baseDir, "git"), path) : null;
+  }
+  return isAbsolute(source) ? resolve(source) : resolve(baseDir, source);
+}
+function readPackageManifest(packageRoot) {
+  const manifest = readOptionalJson(join(packageRoot, "package.json"), `DM package manifest ${packageRoot}`);
+  return manifest && typeof manifest === "object" && !Array.isArray(manifest) ? manifest : null;
+}
+function getManifestMcpPaths(value, packageName, manifestKey) {
+  const paths = typeof value === "string" ? [value] : Array.isArray(value) && value.every((path) => typeof path === "string") ? value : null;
+  if (value !== undefined && !paths)
+    console.warn(`DM package ${packageName} ignores invalid ${manifestKey} manifest entry`);
+  return paths;
+}
+function readMcpConfig(path, packageName) {
+  const config = readRequiredJson(path, `DM package ${packageName} MCP config`);
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    throw new Error(`DM package ${packageName} MCP config ${path} must be a JSON object`);
+  }
+  const servers = config.mcpServers;
+  if (!servers || typeof servers !== "object" || Array.isArray(servers)) {
+    throw new Error(`DM package ${packageName} MCP config ${path} must contain a JSON object mcpServers field`);
+  }
+  const mcpServers = {};
+  for (const [name, server] of Object.entries(servers)) {
+    if (!server || typeof server !== "object" || Array.isArray(server)) {
+      throw new Error(`DM package ${packageName} MCP config ${path} server ${name} must be a JSON object`);
+    }
+    mcpServers[name] = server;
+  }
+  return { mcpServers };
+}
+function readRequiredJson(path, description) {
+  try {
+    return parseJsonWithComments(readFileSync(path, "utf8"));
+  } catch (error) {
+    throw new Error(`${description} ${path} contains invalid JSON: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+  }
+}
+function readOptionalJson(path, description) {
+  if (!existsSync(path))
+    return;
+  return readRequiredJson(path, description);
+}
+function resolvePackageConfigPath(packageRoot, path) {
+  const lexicalPath = resolveContainedPath(packageRoot, path);
+  if (!lexicalPath || !existsSync(lexicalPath) || !statSync(lexicalPath).isFile())
+    return null;
+  return resolveRealContainedPath(packageRoot, lexicalPath);
+}
+function formatPackageName(name) {
+  return name.replace(/[^A-Za-z0-9_-]+/g, "_").replace(/^[_-]+|[_-]+$/g, "") || "package";
+}
+function formatServerName(name) {
+  return name.replace(/[^A-Za-z0-9_-]+/g, "_").replace(/^[_-]+|[_-]+$/g, "") || "server";
+}

package/extensions/dm-mcp-adapter/dist/project-server-trust.js

@@ -0,0 +1,186 @@
+import { createHash } from "node:crypto";
+import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, renameSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import { getAgentPath } from "./agent-dir.js";
+import { isServerDisabled } from "./types.js";
+const APPROVALS_VERSION = 1;
+const APPROVALS_FILE = "mcp-project-approvals.json";
+const DENY_PROJECT_SERVER = "Don't allow";
+const ALLOW_PROJECT_SERVER = "Allow";
+const PROJECT_SERVER_CHOICES = [DENY_PROJECT_SERVER, ALLOW_PROJECT_SERVER];
+const MCP_CONFIG_SOURCE_METADATA = Symbol.for("dm-mcp-adapter/config-source-metadata");
+export function describeProjectServerBlock(reason) {
+  switch (reason) {
+    case "untrusted":
+      return "blocked by project trust — trust the project to review and approve this server";
+    case "approval-required":
+      return 'blocked: project server approval required — approve it in a trusted interactive session or set user-global settings.projectServers to "allow"';
+    case "denied":
+      return "blocked: project server approval denied — reload in a trusted interactive session to approve it";
+  }
+}
+export function disabledServerReason(blocked, name) {
+  const block = blocked?.get(name);
+  return block ? describeProjectServerBlock(block.reason) : `disabled. Run /mcp-adapter enable ${name} and /reload to enable it.`;
+}
+function asLoadedConfig(config) {
+  const metadata = config[MCP_CONFIG_SOURCE_METADATA];
+  return {
+    config,
+    projectServers: metadata?.projectServers ?? new Map,
+    projectServerPolicy: metadata?.projectServerPolicy ?? "ask"
+  };
+}
+export function hasProjectServerDefinitions(config) {
+  return asLoadedConfig(config).projectServers.size > 0;
+}
+function canonicalize(value) {
+  if (Array.isArray(value))
+    return value.map(canonicalize);
+  if (!value || typeof value !== "object")
+    return value;
+  return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, canonicalize(entry)]));
+}
+export function hashProjectServerDefinition(definition) {
+  return createHash("sha256").update(JSON.stringify(canonicalize(definition))).digest("hex");
+}
+export function canonicalProjectRoot(cwd) {
+  try {
+    return realpathSync(cwd);
+  } catch {
+    return resolve(cwd);
+  }
+}
+function projectApprovalScope(cwd) {
+  const root = canonicalProjectRoot(cwd);
+  for (let dir = root;; dir = dirname(dir)) {
+    const dotGit = join(dir, ".git");
+    if (existsSync(dotGit)) {
+      const repoScope = linkedWorktreeRepoScope(dotGit);
+      return repoScope ? join(repoScope, relative(dir, root)) : root;
+    }
+    if (dirname(dir) === dir)
+      return root;
+  }
+}
+function linkedWorktreeRepoScope(dotGit) {
+  try {
+    if (!lstatSync(dotGit).isFile())
+      return;
+    const pointer = /^gitdir: (.+)$/m.exec(readFileSync(dotGit, "utf8"))?.[1]?.trim();
+    if (!pointer)
+      return;
+    const adminDir = realpathSync(resolve(dirname(dotGit), pointer));
+    const backLink = readFileSync(join(adminDir, "gitdir"), "utf8").trim();
+    if (realpathSync(resolve(adminDir, backLink)) !== realpathSync(dotGit))
+      return;
+    const commonDir = dirname(dirname(adminDir));
+    const bare = /^\s*bare\s*=\s*(true|yes|on|1)\s*$/im.test(readFileSync(join(commonDir, "config"), "utf8"));
+    return basename(commonDir) === ".git" && !bare ? dirname(commonDir) : `git-dir:${commonDir}`;
+  } catch {
+    return;
+  }
+}
+function approvalPath() {
+  return getAgentPath(APPROVALS_FILE);
+}
+function loadApprovals() {
+  const path = approvalPath();
+  if (!existsSync(path))
+    return { version: APPROVALS_VERSION, approvals: [] };
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (parsed.version !== APPROVALS_VERSION || !Array.isArray(parsed.approvals))
+      throw new Error("invalid format");
+    const approvals = parsed.approvals.filter((entry) => !!entry && typeof entry.projectRoot === "string" && typeof entry.serverName === "string" && typeof entry.definitionHash === "string" && typeof entry.approvedAt === "string");
+    return { version: APPROVALS_VERSION, approvals };
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    console.warn(`MCP: ignoring invalid project-server approval store ${path}: ${detail}`);
+    return { version: APPROVALS_VERSION, approvals: [] };
+  }
+}
+function saveApproval(record) {
+  const path = approvalPath();
+  const store = loadApprovals();
+  store.approvals = store.approvals.filter((entry) => entry.projectRoot !== record.projectRoot || entry.serverName !== record.serverName);
+  store.approvals.push(record);
+  mkdirSync(dirname(path), { recursive: true, mode: 448 });
+  const temporary = `${path}.${process.pid}.${Math.random().toString(16).slice(2)}.tmp`;
+  writeFileSync(temporary, `${JSON.stringify(store, null, 2)}
+`, { encoding: "utf8", mode: 384 });
+  if (process.platform !== "win32")
+    chmodSync(temporary, 384);
+  renameSync(temporary, path);
+  if (process.platform !== "win32")
+    chmodSync(path, 384);
+}
+export function approveProjectServer(cwd, serverName, definition) {
+  saveApproval({
+    projectRoot: projectApprovalScope(cwd),
+    serverName,
+    definitionHash: hashProjectServerDefinition(definition),
+    approvedAt: new Date().toISOString()
+  });
+}
+function describeServer(definition) {
+  if (definition.command) {
+    return [definition.command, ...definition.args ?? []].map((value) => JSON.stringify(value)).join(" ");
+  }
+  if (definition.url)
+    return definition.url;
+  if (definition.socket)
+    return definition.socket;
+  return "(no command or endpoint)";
+}
+export async function applyProjectServerTrust(loaded, ctx) {
+  const config = { ...loaded.config, mcpServers: { ...loaded.config.mcpServers } };
+  const blockedServers = new Map;
+  if (loaded.projectServers.size === 0)
+    return { config, blockedServers };
+  let projectTrusted = false;
+  try {
+    projectTrusted = ctx.isProjectTrusted();
+  } catch {
+    projectTrusted = false;
+  }
+  const projectRoot = projectApprovalScope(ctx.cwd);
+  const approvals = loadApprovals();
+  for (const [name, source] of loaded.projectServers) {
+    const definition = config.mcpServers[name];
+    if (!definition || isServerDisabled(definition))
+      continue;
+    const definitionHash = hashProjectServerDefinition(definition);
+    const approved = approvals.approvals.some((entry) => entry.projectRoot === projectRoot && entry.serverName === name && entry.definitionHash === definitionHash);
+    if (projectTrusted && (approved || !ctx.hasUI && loaded.projectServerPolicy === "allow"))
+      continue;
+    let reason;
+    if (!projectTrusted) {
+      reason = "untrusted";
+    } else if (!ctx.hasUI) {
+      reason = "approval-required";
+    } else if (await ctx.ui.select(`Allow project MCP server “${name}”?
+Project config: ${source.path}
+Endpoint: ${describeServer(definition)}
+
+This server can run local commands or make network requests with your user permissions.`, PROJECT_SERVER_CHOICES) === ALLOW_PROJECT_SERVER) {
+      approveProjectServer(ctx.cwd, name, definition);
+      continue;
+    } else {
+      reason = "denied";
+    }
+    config.mcpServers[name] = { ...definition, disabled: true };
+    blockedServers.set(name, { reason, source });
+  }
+  return { config, blockedServers };
+}
+export function applyProjectServerTrustToConfig(config, ctx) {
+  return applyProjectServerTrust(asLoadedConfig(config), ctx);
+}
+export function excludeProjectServersAtLoadTime(loadedOrConfig) {
+  const loaded = "config" in loadedOrConfig && "projectServers" in loadedOrConfig ? loadedOrConfig : asLoadedConfig(loadedOrConfig);
+  const config = { ...loaded.config, mcpServers: { ...loaded.config.mcpServers } };
+  for (const name of loaded.projectServers.keys())
+    delete config.mcpServers[name];
+  return config;
+}