@duckmind/dm-linux-x64 0.65.8 → 0.66.2

package/extensions/dm-mcp-adapter/dist/npx-resolver.js

@@ -1,465 +0,0 @@
-import { existsSync, readFileSync, realpathSync, readdirSync, statSync, writeFileSync, renameSync, mkdirSync, openSync, readSync, closeSync, unlinkSync } from "node:fs";
-import { join, dirname, extname, resolve, sep } from "node:path";
-import { getAgentPath } from "./agent-dir.js";
-import { throwIfAborted } from "./abort.js";
-import crossSpawn from "cross-spawn";
-const CACHE_VERSION = 2;
-const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
-const EXACT_PACKAGE_VERSION_RE = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z][0-9A-Za-z.-]*)?(?:\+[0-9A-Za-z][0-9A-Za-z.-]*)?$/;
-export async function resolveNpxBinary(command, args, signal) {
-  throwIfAborted(signal);
-  const parsed = command === "npx" ? parseNpxArgs(args) : command === "npm" ? parseNpmExecArgs(args) : null;
-  if (!parsed)
-    return null;
-  const packageSpec = parsePackageSpec(parsed.packageSpec);
-  const cacheKey = JSON.stringify([command, parsed.packageSpec, parsed.binName ?? ""]);
-  const cache = loadCache();
-  const cached = cache?.entries?.[cacheKey];
-  if (cached && Date.now() - cached.resolvedAt < CACHE_TTL_MS && existsSync(cached.resolvedBin) && (!packageSpec?.exactVersion || cached.packageVersion === packageSpec.exactVersion)) {
-    return { binPath: cached.resolvedBin, extraArgs: parsed.extraArgs, isJs: cached.isJs };
-  }
-  const resolved = resolveFromNpmCache(parsed.packageSpec, parsed.binName);
-  if (resolved) {
-    saveCacheEntry(cacheKey, resolved);
-    return { binPath: resolved.resolvedBin, extraArgs: parsed.extraArgs, isJs: resolved.isJs };
-  }
-  await forceNpxCache(parsed.packageSpec, signal);
-  const resolvedAfterInstall = resolveFromNpmCache(parsed.packageSpec, parsed.binName);
-  if (resolvedAfterInstall) {
-    saveCacheEntry(cacheKey, resolvedAfterInstall);
-    return { binPath: resolvedAfterInstall.resolvedBin, extraArgs: parsed.extraArgs, isJs: resolvedAfterInstall.isJs };
-  }
-  return null;
-}
-function parseNpxArgs(args) {
-  const separatorIndex = args.indexOf("--");
-  const before = separatorIndex >= 0 ? args.slice(0, separatorIndex) : args;
-  const after = separatorIndex >= 0 ? args.slice(separatorIndex + 1) : [];
-  const positionals = [];
-  let packageSpec;
-  let sawPackageFlag = false;
-  let foundFirstPositional = false;
-  for (let i = 0;i < before.length; i++) {
-    const arg = before[i];
-    if (arg === undefined)
-      return null;
-    if (foundFirstPositional) {
-      positionals.push(arg);
-      continue;
-    }
-    if (arg === "-y" || arg === "--yes")
-      continue;
-    if (arg === "-p" || arg === "--package") {
-      const value = before[i + 1];
-      if (!value || value.startsWith("-"))
-        return null;
-      if (!packageSpec)
-        packageSpec = value;
-      sawPackageFlag = true;
-      i++;
-      continue;
-    }
-    if (arg.startsWith("--package=")) {
-      const value = arg.slice("--package=".length);
-      if (!value)
-        return null;
-      if (!packageSpec)
-        packageSpec = value;
-      sawPackageFlag = true;
-      continue;
-    }
-    if (arg.startsWith("-")) {
-      return null;
-    }
-    positionals.push(arg);
-    foundFirstPositional = true;
-  }
-  const separatedAfter = separatorIndex >= 0 && after.length > 0 ? ["--", ...after] : after;
-  if (sawPackageFlag) {
-    const binName = positionals[0];
-    if (!packageSpec || !binName)
-      return null;
-    const extraArgs = positionals.slice(1).concat(separatedAfter);
-    return { packageSpec, binName, extraArgs };
-  }
-  const packagePositional = positionals[0];
-  if (!packagePositional)
-    return null;
-  const extraArgs = positionals.slice(1).concat(separatedAfter);
-  return { packageSpec: packagePositional, extraArgs };
-}
-function parseNpmExecArgs(args) {
-  if (args[0] !== "exec")
-    return null;
-  const execArgs = args.slice(1);
-  const separatorIndex = execArgs.indexOf("--");
-  if (separatorIndex < 0)
-    return null;
-  const before = execArgs.slice(0, separatorIndex);
-  const after = execArgs.slice(separatorIndex + 1);
-  let packageSpec;
-  for (let i = 0;i < before.length; i++) {
-    const arg = before[i];
-    if (arg === undefined)
-      return null;
-    if (arg === "-y" || arg === "--yes")
-      continue;
-    if (arg === "--package") {
-      const value = before[i + 1];
-      if (!value || value.startsWith("-"))
-        return null;
-      if (!packageSpec)
-        packageSpec = value;
-      i++;
-      continue;
-    }
-    if (arg.startsWith("--package=")) {
-      const value = arg.slice("--package=".length);
-      if (!value)
-        return null;
-      if (!packageSpec)
-        packageSpec = value;
-      continue;
-    }
-    if (arg.startsWith("-")) {
-      return null;
-    }
-  }
-  const binName = after[0];
-  if (!packageSpec || !binName)
-    return null;
-  const extraArgs = after.slice(1);
-  return { packageSpec, binName, extraArgs };
-}
-function resolveFromNpmCache(packageSpec, binName) {
-  const cacheDir = getNpmCacheDir();
-  if (!cacheDir)
-    return null;
-  const parsedSpec = parsePackageSpec(packageSpec);
-  if (!parsedSpec)
-    return null;
-  const { packageName, exactVersion } = parsedSpec;
-  const packageDir = findCachedPackageDir(cacheDir, packageName, exactVersion);
-  if (!packageDir)
-    return null;
-  const packageJsonPath = join(packageDir, "package.json");
-  if (!existsSync(packageJsonPath))
-    return null;
-  let pkg = null;
-  try {
-    pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
-  } catch {
-    return null;
-  }
-  const binField = pkg?.bin;
-  if (!binField)
-    return null;
-  const candidates = buildBinCandidates(packageName, binName);
-  let chosenBinName;
-  let binRel;
-  if (typeof binField === "string") {
-    chosenBinName = defaultBinName(packageName);
-    binRel = binField;
-  } else {
-    for (const candidate of candidates) {
-      if (binField[candidate]) {
-        chosenBinName = candidate;
-        binRel = binField[candidate];
-        break;
-      }
-    }
-    if (!binRel) {
-      const firstEntry = Object.entries(binField)[0];
-      if (firstEntry) {
-        chosenBinName = firstEntry[0];
-        binRel = firstEntry[1];
-      }
-    }
-  }
-  if (!binRel)
-    return null;
-  const nodeModulesDir = findNodeModulesDir(packageDir);
-  const binLink = chosenBinName ? join(nodeModulesDir, ".bin", chosenBinName) : null;
-  let resolvedBin = binLink && existsSync(binLink) ? safeRealpath(binLink) : "";
-  if (!resolvedBin) {
-    resolvedBin = resolve(packageDir, binRel);
-    if (!existsSync(resolvedBin))
-      return null;
-  }
-  const isJs = detectJsBinary(resolvedBin);
-  return {
-    resolvedBin,
-    resolvedAt: Date.now(),
-    ...pkg?.version !== undefined ? { packageVersion: pkg.version } : {},
-    isJs
-  };
-}
-const FORCE_CACHE_TIMEOUT_MS = 30000;
-async function forceNpxCache(packageSpec, signal) {
-  throwIfAborted(signal);
-  try {
-    await new Promise((resolve, reject) => {
-      const proc = crossSpawn("npm", ["exec", "--yes", "--package", packageSpec, "--", "node", "-e", "1"], { stdio: "ignore" });
-      const timer = setTimeout(() => {
-        proc.kill();
-        reject(new Error("timeout"));
-      }, FORCE_CACHE_TIMEOUT_MS);
-      const abort = () => {
-        proc.kill();
-        reject(signal?.reason instanceof Error ? signal.reason : new Error("MCP request aborted"));
-      };
-      signal?.addEventListener("abort", abort, { once: true });
-      timer.unref();
-      proc.on("close", () => {
-        clearTimeout(timer);
-        signal?.removeEventListener("abort", abort);
-        resolve();
-      });
-      proc.on("error", (err) => {
-        clearTimeout(timer);
-        signal?.removeEventListener("abort", abort);
-        reject(err);
-      });
-    });
-  } catch (error) {
-    if (signal?.aborted)
-      throwIfAborted(signal);
-  }
-  throwIfAborted(signal);
-}
-function buildBinCandidates(packageName, explicitBin) {
-  const candidates = [];
-  if (explicitBin)
-    candidates.push(explicitBin);
-  if (packageName.startsWith("@")) {
-    const namePart = packageName.split("/")[1] ?? "";
-    const scopePart = packageName.split("/")[0]?.replace("@", "") ?? "";
-    if (namePart)
-      candidates.push(namePart);
-    if (scopePart && namePart)
-      candidates.push(`${scopePart}-${namePart}`);
-  } else {
-    candidates.push(packageName);
-  }
-  return [...new Set(candidates.filter(Boolean))];
-}
-function parsePackageSpec(spec) {
-  const trimmed = spec.trim();
-  if (!trimmed)
-    return null;
-  let packageName;
-  let requestedVersion;
-  if (trimmed.startsWith("@")) {
-    const slashIndex = trimmed.indexOf("/");
-    if (slashIndex < 0)
-      return null;
-    const atIndex = trimmed.lastIndexOf("@");
-    if (atIndex > slashIndex) {
-      packageName = trimmed.slice(0, atIndex);
-      requestedVersion = trimmed.slice(atIndex + 1);
-    } else {
-      packageName = trimmed;
-    }
-  } else {
-    const atIndex = trimmed.indexOf("@");
-    if (atIndex >= 0) {
-      packageName = trimmed.slice(0, atIndex);
-      requestedVersion = trimmed.slice(atIndex + 1);
-    } else {
-      packageName = trimmed;
-    }
-  }
-  if (!packageName)
-    return null;
-  const normalizedVersion = requestedVersion?.replace(/^=/, "").replace(/^v/i, "");
-  return {
-    packageName,
-    ...normalizedVersion && EXACT_PACKAGE_VERSION_RE.test(normalizedVersion) ? { exactVersion: normalizedVersion } : {}
-  };
-}
-function defaultBinName(packageName) {
-  if (packageName.startsWith("@")) {
-    const parts = packageName.split("/");
-    return parts[1] ?? packageName.replace("@", "").replace("/", "-");
-  }
-  return packageName;
-}
-function findCachedPackageDir(cacheDir, packageName, exactVersion) {
-  const npxDir = join(cacheDir, "_npx");
-  if (!existsSync(npxDir))
-    return null;
-  const packagePathParts = packageName.startsWith("@") ? packageName.split("/") : [packageName];
-  const candidates = readdirSync(npxDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => {
-    const full = join(npxDir, entry.name);
-    const mtime = safeStatMtime(full);
-    return { name: entry.name, mtime };
-  }).sort((a, b) => b.mtime - a.mtime);
-  for (const entry of candidates) {
-    const pkgDir = join(npxDir, entry.name, "node_modules", ...packagePathParts);
-    const packageJsonPath = join(pkgDir, "package.json");
-    if (!existsSync(packageJsonPath))
-      continue;
-    if (exactVersion) {
-      try {
-        const pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
-        if (pkg.version !== exactVersion)
-          continue;
-      } catch {
-        continue;
-      }
-    }
-    return pkgDir;
-  }
-  return null;
-}
-function findNodeModulesDir(packageDir) {
-  const parts = packageDir.split(sep);
-  const idx = parts.lastIndexOf("node_modules");
-  if (idx >= 0) {
-    return parts.slice(0, idx + 1).join(sep);
-  }
-  return join(packageDir, "..");
-}
-function detectJsBinary(binPath) {
-  const ext = extname(binPath).toLowerCase();
-  if (ext === ".js" || ext === ".mjs" || ext === ".cjs")
-    return true;
-  try {
-    const fd = openSync(binPath, "r");
-    try {
-      const buf = Buffer.alloc(256);
-      readSync(fd, buf, 0, 256, 0);
-      const firstLine = buf.toString("utf-8").split(`
-`)[0] ?? "";
-      return firstLine.startsWith("#!") && firstLine.includes("node");
-    } finally {
-      closeSync(fd);
-    }
-  } catch {
-    return false;
-  }
-}
-let npmCacheDirCached;
-function getNpmCacheDir() {
-  if (npmCacheDirCached !== undefined)
-    return npmCacheDirCached;
-  if (process.env.NPM_CONFIG_CACHE) {
-    npmCacheDirCached = process.env.NPM_CONFIG_CACHE;
-    return npmCacheDirCached;
-  }
-  try {
-    const result = crossSpawn.sync("npm", ["config", "get", "cache"], { encoding: "utf-8" });
-    if (result.status === 0) {
-      const path = String(result.stdout).trim();
-      npmCacheDirCached = path || null;
-      return npmCacheDirCached;
-    }
-  } catch {
-    npmCacheDirCached = null;
-    return null;
-  }
-  npmCacheDirCached = null;
-  return null;
-}
-function getNpxCachePath() {
-  return getAgentPath("mcp-npx-cache.json");
-}
-function readNpxCachePayload(cachePath) {
-  if (!existsSync(cachePath))
-    return null;
-  try {
-    return JSON.parse(readFileSync(cachePath, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function asRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
-}
-function createCacheEntries() {
-  return Object.create(null);
-}
-function toNpxCacheEntry(value) {
-  const raw = asRecord(value);
-  if (!raw)
-    return null;
-  if (typeof raw.resolvedBin !== "string")
-    return null;
-  if (typeof raw.resolvedAt !== "number" || !Number.isFinite(raw.resolvedAt))
-    return null;
-  if (typeof raw.isJs !== "boolean")
-    return null;
-  if (raw.packageVersion !== undefined && typeof raw.packageVersion !== "string")
-    return null;
-  return {
-    resolvedBin: raw.resolvedBin,
-    resolvedAt: raw.resolvedAt,
-    ...raw.packageVersion !== undefined ? { packageVersion: raw.packageVersion } : {},
-    isJs: raw.isJs
-  };
-}
-function toNpxCache(value) {
-  const raw = asRecord(value);
-  if (!raw || raw.version !== CACHE_VERSION)
-    return null;
-  const rawEntries = asRecord(raw.entries);
-  if (!rawEntries)
-    return null;
-  const entries = createCacheEntries();
-  for (const [key, rawEntry] of Object.entries(rawEntries)) {
-    const entry = toNpxCacheEntry(rawEntry);
-    if (entry)
-      entries[key] = entry;
-  }
-  return { version: CACHE_VERSION, entries };
-}
-function clearLegacyCache() {
-  const cachePath = getNpxCachePath();
-  const raw = asRecord(readNpxCachePayload(cachePath));
-  if (raw?.version !== 1)
-    return false;
-  try {
-    unlinkSync(cachePath);
-  } catch {
-    try {
-      writeFileSync(cachePath, "", "utf-8");
-    } catch {}
-  }
-  return true;
-}
-clearLegacyCache();
-function loadCache() {
-  if (clearLegacyCache())
-    return null;
-  return toNpxCache(readNpxCachePayload(getNpxCachePath()));
-}
-function saveCacheEntry(key, entry) {
-  try {
-    const cachePath = getNpxCachePath();
-    const dir = dirname(cachePath);
-    mkdirSync(dir, { recursive: true });
-    const existing = toNpxCache(readNpxCachePayload(cachePath));
-    const entries = createCacheEntries();
-    if (existing)
-      Object.assign(entries, existing.entries);
-    const merged = { version: CACHE_VERSION, entries };
-    merged.entries[key] = entry;
-    const tmpPath = `${cachePath}.${process.pid}.tmp`;
-    writeFileSync(tmpPath, JSON.stringify(merged, null, 2), "utf-8");
-    renameSync(tmpPath, cachePath);
-  } catch {}
-}
-function safeRealpath(path) {
-  try {
-    return realpathSync(path);
-  } catch {
-    return "";
-  }
-}
-function safeStatMtime(path) {
-  try {
-    return statSync(path).mtimeMs;
-  } catch {
-    return 0;
-  }
-}

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

@@ -1,135 +0,0 @@
-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 seen = new Set;
-  for (const packageRoot of getConfiguredPackageRoots(cwd)) {
-    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;
-      }
-    }
-  }
-  return { mcpServers };
-}
-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.includes(root))
-        roots.push(root);
-    }
-  }
-  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 value = gitSource.replace(/^ssh:\/\/git@/, "").replace(/^git@([^:]+):/, "$1/").replace(/^[a-z]+:\/\//i, "");
-    const path = value.replace(/@[^/]+$/, "").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";
-}