@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

package/extensions/dm-lens/dist/clients/lsp/config.js

@@ -0,0 +1,471 @@
+import { resetIgnoredConfigWarnCache } from "../config-warn.js";
+import * as os from "node:os";
+import path from "node:path";
+import { LSP_NAMESPACE_KEY } from "../config-locations.js";
+import { migrationSubject } from "../config-core/records.js";
+import { lspSectionOf, reportConfigReadFailure, reportDmLensConfigRecords, resolveDmLensConfig, summarizeConfigResolution } from "../config-resolve.js";
+import { getDegradationLedgerGeneration, recordDegradationOnce } from "../degradation-ledger.js";
+import { isKnownRunnerId, runnerIdentityPopulated } from "../dispatch/known-runner-ids.js";
+import { getGlobalDmLensDir } from "../file-utils.js";
+import { claimPhaseOncePerSession, currentSessionRecordId, logLatency, releaseOncePerSessionPhase, releasePhaseClaim } from "../latency-logger.js";
+import { getDmLensGlobalConfigPath } from "../lens-config.js";
+import { normalizeFilePath } from "../path-utils.js";
+import { logExtension } from "../extension-log.js";
+import { getProjectTrustState } from "../project-trust.js";
+import { isRepoTier, provenanceFor } from "../config-core/provenance.js";
+import { resolveToolCwd } from "../tool-cwd.js";
+import { logSessionStart } from "../sessionstart-logger.js";
+import { launchLSP } from "./launch.js";
+import { registerSessionRoot, resetSessionRootsForTests, sessionRootConfigEntries, setSessionRootConfig } from "./session-roots.js";
+import { LSP_SERVERS, resetLSPCaseSensitivityState, resolveLspServerCwd } from "./server.js";
+import { DEFAULT_LSP_SERVER_ROLE, isAuxiliary } from "./server-traits.js";
+export function resetLSPConfigWarnCache() {
+  resetIgnoredConfigWarnCache("lsp-config");
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+const CONFIG_RESOLVED_PHASE = "config_resolved";
+function configResolutionKey(cwd) {
+  return normalizeFilePath(path.resolve(normalizeFilePath(cwd)));
+}
+function publishConfigResolutionPending(cwd) {
+  logSessionStart(`session_start config_resolution_pending session=${currentSessionRecordId()} ` + `root=${configResolutionKey(cwd)}`);
+}
+function recordConfigResolved(cwd, resolution, lspConfig, homeDir, resolveMs) {
+  const root = configResolutionKey(cwd);
+  if (!claimPhaseOncePerSession(CONFIG_RESOLVED_PHASE, root)) {
+    return;
+  }
+  const summary = summarizeConfigResolution(resolution, homeDir);
+  const sessionId = currentSessionRecordId();
+  const deniedServers = lspConfig.disabledServers?.length ?? 0;
+  const legacyDocuments = summary.documents.filter((document) => document.legacy).length;
+  logLatency({
+    type: "phase",
+    phase: CONFIG_RESOLVED_PHASE,
+    filePath: root,
+    durationMs: resolveMs,
+    metadata: {
+      sessionId,
+      documents: summary.documents,
+      countsByTier: summary.countsByTier,
+      recordCount: summary.recordCount,
+      deniedServers,
+      resolveMs
+    }
+  });
+  logSessionStart(`config resolved documents=${summary.documents.length} legacy=${legacyDocuments} ` + `records=${summary.recordCount} deniedServers=${deniedServers} resolveMs=${resolveMs} ` + `session=${sessionId} root=${root}`);
+}
+export async function loadLSPConfig(cwd, homeDir = os.homedir(), options = {}) {
+  const reporting = options.report !== false;
+  publishConfigResolutionPending(cwd);
+  const resolveStartedAt = Date.now();
+  const resolution = resolveDmLensConfig({
+    cwd,
+    globalDir: getGlobalDmLensDir(),
+    globalConfigPath: getDmLensGlobalConfigPath(),
+    homeDir,
+    ...reporting ? { onReadError: reportConfigReadFailure } : {}
+  });
+  const coversProblems = newCoversClaimProblems();
+  const config = lspConfigOf(resolution.value, coversProblems);
+  Object.defineProperty(config, "__provenance", {
+    value: resolution.provenance,
+    enumerable: false
+  });
+  if (reporting) {
+    reportDmLensConfigRecords([
+      ...resolution.records,
+      ...coversClaimRecords(resolution, coversProblems)
+    ]);
+  }
+  recordCoversUnvalidated(resolution, coversProblems);
+  recordConfigResolved(cwd, resolution, config, homeDir, Date.now() - resolveStartedAt);
+  return config;
+}
+function newCoversClaimProblems() {
+  return { refusals: [], unvalidated: [] };
+}
+function coversPointer(serverId) {
+  return `/${LSP_NAMESPACE_KEY}/servers/${serverId}/covers`;
+}
+function coversClaimSource(resolution, pointer) {
+  let candidate = pointer;
+  while (candidate !== undefined) {
+    const entry = resolution.provenance.get(candidate);
+    if (entry) {
+      return {
+        file: entry.file ?? "",
+        ...entry.tier ? { tier: entry.tier } : {}
+      };
+    }
+    const cut = candidate.lastIndexOf("/");
+    candidate = cut > 0 ? candidate.slice(0, cut) : undefined;
+  }
+  return { file: resolution.documents.at(-1)?.file ?? "" };
+}
+function coversClaimRecords(resolution, problems) {
+  return problems.refusals.map((refusal) => {
+    const pointer = coversPointer(refusal.serverId);
+    const { file, tier } = coversClaimSource(resolution, pointer);
+    const dropped = refusal.declaredCount - refusal.keptCount;
+    return {
+      code: "PILENS_CFG_0005",
+      file,
+      key: pointer,
+      subject: migrationSubject(file, pointer),
+      reason: `lsp.servers.${refusal.serverId}.covers declares member(s) that ` + `are not recognized dispatch runner ids; ${dropped} of ` + `${refusal.declaredCount} member(s) dropped, the server still ` + keptTail(refusal.keptCount),
+      ...tier ? { tier } : {}
+    };
+  });
+}
+function keptTail(keptCount) {
+  return keptCount > 0 ? "registers with the remaining covers claim" : "registers with no covers claim";
+}
+function recordCoversUnvalidated(resolution, problems) {
+  for (const unvalidated of problems.unvalidated) {
+    const pointer = coversPointer(unvalidated.serverId);
+    const { file } = coversClaimSource(resolution, pointer);
+    recordDegradationOnce({
+      kind: "lsp-covers-unvalidated",
+      subject: `${file}\x00${pointer}`,
+      reason: "no runner registry has populated this process yet; the covers " + "claim was accepted without runner-id validation and the next " + "config load validates it",
+      metadata: { pointer }
+    });
+  }
+}
+function coversValidatedServers(servers, problems = undefined) {
+  const out = {};
+  for (const [id, raw] of Object.entries(servers)) {
+    const entry = raw;
+    if (!entry.covers?.length) {
+      out[id] = entry;
+      continue;
+    }
+    if (!runnerIdentityPopulated()) {
+      problems?.unvalidated.push({ serverId: id });
+      out[id] = entry;
+      continue;
+    }
+    const kept = [];
+    for (const member of entry.covers) {
+      if (isKnownRunnerId(member))
+        kept.push(member);
+    }
+    if (kept.length === entry.covers.length) {
+      out[id] = entry;
+      continue;
+    }
+    problems?.refusals.push({
+      serverId: id,
+      declaredCount: entry.covers.length,
+      keptCount: kept.length
+    });
+    const { covers: _dropped, ...rest } = entry;
+    out[id] = kept.length > 0 ? { ...rest, covers: kept } : rest;
+  }
+  return out;
+}
+export function customServerSpecsOf(value) {
+  const servers = asRecord(lspSectionOf(value).servers);
+  return servers ? coversValidatedServers(servers) : {};
+}
+export function lspConfigOf(value, problems, provenance) {
+  const section = lspSectionOf(value);
+  const config = {};
+  const servers = asRecord(section.servers);
+  if (servers)
+    config.servers = coversValidatedServers(servers, problems);
+  const serverOverrides = asRecord(section.serverOverrides);
+  if (serverOverrides) {
+    config.serverOverrides = serverOverrides;
+  }
+  if (Array.isArray(section.disabledServers)) {
+    config.disabledServers = section.disabledServers;
+  }
+  if (Array.isArray(section.warmFiles)) {
+    config.warmFiles = section.warmFiles;
+  }
+  if (provenance) {
+    Object.defineProperty(config, "__provenance", {
+      value: provenance,
+      enumerable: false
+    });
+  }
+  return config;
+}
+export function createCustomServer(config, id) {
+  return {
+    id,
+    name: config.name,
+    custom: true,
+    command: config.command,
+    extensions: config.extensions,
+    role: DEFAULT_LSP_SERVER_ROLE,
+    idleEviction: "unmeasured",
+    ...config.covers ? { covers: config.covers } : {},
+    ...config.rootMarkers ? { rootMarkers: config.rootMarkers } : {},
+    root: config.rootMarkers ? async (file) => resolveToolCwd("lsp", id, file, {
+      cwd: process.cwd(),
+      ...config.rootMarkers ? { rootMarkers: config.rootMarkers } : {}
+    }).cwd : async (file) => resolveToolCwd("lsp", id, file, { cwd: process.cwd() }).cwd,
+    async spawn(root) {
+      const proc = await launchLSP(config.command, config.args ?? ["--stdio"], {
+        cwd: root,
+        env: config.env ? { ...process.env, ...config.env } : process.env
+      });
+      return {
+        process: proc,
+        ...config.initializationOptions ? { initialization: config.initializationOptions } : {}
+      };
+    }
+  };
+}
+const EMPTY_CONFIG = {
+  customServers: [],
+  registeredServers: [],
+  disabledServerIds: new Set,
+  serverOverrides: new Map
+};
+const configInFlight = new Map;
+function normalizeWorkspacePath(cwd) {
+  return path.resolve(cwd);
+}
+let unknownTrustNoticeGeneration = -1;
+function sourceFor(provenance, key) {
+  const direct = provenanceFor({ value: undefined, provenance }, key);
+  if (direct)
+    return direct;
+  let fallback;
+  for (const [candidate, entry] of provenance) {
+    if (!candidate.startsWith(`${key}/`))
+      continue;
+    if (isRepoTier(entry.tier))
+      return entry;
+    fallback ??= entry;
+  }
+  return fallback;
+}
+function executableAllowed(provenance, trust) {
+  return !provenance || !isRepoTier(provenance.tier) || trust === "trusted";
+}
+function registryDecision(id, field, provenance, trust, allowed) {
+  if (allowed || !provenance || !isRepoTier(provenance.tier))
+    return;
+  const subject = `${id}:${field}:${provenance.tier}`;
+  const reason = `project LSP ${field} refused for ${id}: pi project trust is ${trust}`;
+  recordDegradationOnce({
+    kind: "lsp-registry-decision",
+    subject,
+    reason,
+    metadata: { serverId: id, field, tier: provenance.tier, trust }
+  });
+  if (trust === "unknown") {
+    const generation = getDegradationLedgerGeneration();
+    if (unknownTrustNoticeGeneration !== generation) {
+      unknownTrustNoticeGeneration = generation;
+      logExtension({
+        subsystem: "lsp-registry",
+        level: "warn",
+        message: "project LSP executables refused: mark the project trusted in pi or upgrade pi",
+        metadata: { serverId: id, field }
+      });
+    }
+  }
+}
+function isSameOrChildPath(filePath, candidateRoot) {
+  if (filePath === candidateRoot)
+    return true;
+  return filePath.startsWith(`${candidateRoot}${path.sep}`);
+}
+function getConfigForFile(filePath) {
+  const resolvedFilePath = path.resolve(filePath);
+  let bestMatch;
+  for (const [root, config] of sessionRootConfigEntries()) {
+    if (config === undefined)
+      continue;
+    if (!isSameOrChildPath(resolvedFilePath, root))
+      continue;
+    if (!bestMatch || root.length > bestMatch.root.length) {
+      bestMatch = { root, config };
+    }
+  }
+  return bestMatch?.config ?? EMPTY_CONFIG;
+}
+export function registerLSPConfig(config) {
+  return compileLspRegistry(config, config.__provenance);
+}
+export function compileLspRegistry(config, provenance = new Map) {
+  const trust = getProjectTrustState();
+  const customServers = [];
+  const disabledServerIds = new Set(config.disabledServers ?? []);
+  if (config.servers) {
+    for (const [id, serverConfig] of Object.entries(config.servers)) {
+      const commandSource = sourceFor(provenance, `/lsp/servers/${id}/command`);
+      const commandAllowed = executableAllowed(commandSource, trust);
+      registryDecision(id, "command", commandSource, trust, commandAllowed);
+      if (!commandAllowed)
+        continue;
+      const envSource = sourceFor(provenance, `/lsp/servers/${id}/env`);
+      const initSource = sourceFor(provenance, `/lsp/servers/${id}/initializationOptions`);
+      const envAllowed = executableAllowed(envSource, trust);
+      const initAllowed = executableAllowed(initSource, trust);
+      registryDecision(id, "env", envSource, trust, envAllowed);
+      registryDecision(id, "initializationOptions", initSource, trust, initAllowed);
+      const admitted = { ...serverConfig };
+      if (!envAllowed)
+        delete admitted.env;
+      if (!initAllowed)
+        delete admitted.initializationOptions;
+      try {
+        const server = createCustomServer(admitted, id);
+        customServers.push({ ...server, trustAllowed: true });
+      } catch {}
+    }
+  }
+  const serverOverrides = new Map;
+  if (config.serverOverrides) {
+    for (const [id, entry] of Object.entries(config.serverOverrides)) {
+      if (entry && typeof entry === "object" && !Array.isArray(entry)) {
+        const initOpts = entry.initializationOptions;
+        const command = entry.command;
+        const commandSource = sourceFor(provenance, `/lsp/serverOverrides/${id}/command`);
+        const envSource = sourceFor(provenance, `/lsp/serverOverrides/${id}/env`);
+        const initSource = sourceFor(provenance, `/lsp/serverOverrides/${id}/initializationOptions`);
+        const commandAllowed = executableAllowed(commandSource, trust);
+        const envAllowed = executableAllowed(envSource, trust);
+        const overrideInitAllowed = executableAllowed(initSource, trust);
+        registryDecision(id, "command override", commandSource, trust, commandAllowed);
+        registryDecision(id, "env override", envSource, trust, envAllowed);
+        registryDecision(id, "initializationOptions", initSource, trust, overrideInitAllowed);
+        if (command !== undefined || entry.env !== undefined || initOpts !== undefined && typeof initOpts === "object" && initOpts !== null && !Array.isArray(initOpts)) {
+          serverOverrides.set(id, {
+            ...overrideInitAllowed && initOpts !== undefined ? { initializationOptions: initOpts } : {},
+            ...commandAllowed && command !== undefined ? { command } : {},
+            ...envAllowed && entry.env ? { env: entry.env } : {}
+          });
+        }
+      }
+    }
+  }
+  const overriddenBuiltins = LSP_SERVERS.map((server) => {
+    const override = serverOverrides.get(server.id);
+    if (!override?.command)
+      return { ...server };
+    const argv = Array.isArray(override.command) ? override.command : [override.command, "--stdio"];
+    return {
+      ...server,
+      trustAllowed: true,
+      async spawn(root, options) {
+        const program = argv[0];
+        if (!program)
+          throw new Error(`empty command override for ${server.id}`);
+        const proc = await launchLSP(program, argv.slice(1), {
+          cwd: root,
+          env: override.env ? { ...process.env, ...override.env } : process.env
+        });
+        return { process: proc };
+      }
+    };
+  });
+  return {
+    customServers,
+    registeredServers: overriddenBuiltins,
+    disabledServerIds,
+    serverOverrides
+  };
+}
+function forgetConfigResolvedClaims(evictedRoots) {
+  for (const root of evictedRoots) {
+    releasePhaseClaim(CONFIG_RESOLVED_PHASE, configResolutionKey(root));
+  }
+}
+export async function initLSPConfig(cwd) {
+  const normalizedCwd = normalizeWorkspacePath(cwd);
+  forgetConfigResolvedClaims(registerSessionRoot(normalizedCwd));
+  const existing = configInFlight.get(normalizedCwd);
+  if (existing)
+    return existing;
+  const promise = (async () => {
+    const config = registerLSPConfig(await loadLSPConfig(cwd, os.homedir()));
+    forgetConfigResolvedClaims(setSessionRootConfig(normalizedCwd, config));
+  })();
+  configInFlight.set(normalizedCwd, promise);
+  try {
+    await promise;
+  } finally {
+    if (configInFlight.get(normalizedCwd) === promise) {
+      configInFlight.delete(normalizedCwd);
+    }
+  }
+}
+function registeredServers(config) {
+  const builtins = config.registeredServers.length ? config.registeredServers : LSP_SERVERS;
+  return [...builtins, ...config.customServers];
+}
+export function getAllServers(filePath) {
+  const config = filePath ? getConfigForFile(filePath) : EMPTY_CONFIG;
+  return registeredServers(config).filter((s) => !config.disabledServerIds.has(s.id));
+}
+export function isServerDisabled(serverId, filePath) {
+  const config = filePath ? getConfigForFile(filePath) : EMPTY_CONFIG;
+  return config.disabledServerIds.has(serverId);
+}
+function selectionReason(server, config, filePath, ext, base) {
+  if (config.disabledServerIds.has(server.id))
+    return "disabled-by-config";
+  let matched = false;
+  for (const value of server.extensions) {
+    const lower = value.toLowerCase();
+    if (lower === ext || lower === base) {
+      matched = true;
+      break;
+    }
+  }
+  if (!matched)
+    return "extension-mismatch";
+  if (server.pathFilter && !server.pathFilter(filePath))
+    return "path-filter";
+  return "selected";
+}
+export function explainServersForFile(filePath, config = getConfigForFile(filePath)) {
+  const ext = path.extname(filePath).toLowerCase();
+  const base = path.basename(filePath).toLowerCase();
+  return registeredServers(config).map((server) => {
+    const reason = selectionReason(server, config, filePath, ext, base);
+    return { server, selected: reason === "selected", reason };
+  });
+}
+export function getServersForFileWithConfig(filePath) {
+  const config = getConfigForFile(filePath);
+  const ext = path.extname(filePath).toLowerCase();
+  const base = path.basename(filePath).toLowerCase();
+  return registeredServers(config).filter((server) => selectionReason(server, config, filePath, ext, base) === "selected");
+}
+function primaryServerEntry(filePath) {
+  return getServersForFileWithConfig(filePath).find((s) => !isAuxiliary(s));
+}
+export function primaryServerId(filePath) {
+  return primaryServerEntry(filePath)?.id;
+}
+export async function resolveLspCwdForFile(filePath, sessionCwd, onRootFallback) {
+  const primary = primaryServerEntry(filePath);
+  if (!primary)
+    return;
+  return resolveLspServerCwd(primary, filePath, sessionCwd, undefined, onRootFallback);
+}
+export function getServerInitOverride(serverId, filePath) {
+  return getConfigForFile(filePath).serverOverrides.get(serverId);
+}
+export function resetLSPConfigStateForTests() {
+  resetLSPCaseSensitivityState();
+  resetSessionRootsForTests();
+  resetLSPConfigWarnCache();
+  releaseOncePerSessionPhase(CONFIG_RESOLVED_PHASE);
+}
+export function _peekConfigInFlightForTests() {
+  return configInFlight;
+}
+
+export { getAllServers as getServersForFile };

package/extensions/dm-lens/dist/clients/lsp/content-limits.js

@@ -0,0 +1,21 @@
+import { RUNTIME_CONFIG } from "../runtime-config.js";
+const LSP_MAX_FILE_BYTES = RUNTIME_CONFIG.pipeline.lspMaxFileBytes;
+const LSP_MAX_FILE_LINES = RUNTIME_CONFIG.pipeline.lspMaxFileLines;
+export function exceedsLspSyncLimits(content) {
+  const sizeBytes = Buffer.byteLength(content, "utf-8");
+  if (sizeBytes > LSP_MAX_FILE_BYTES) {
+    return {
+      tooLarge: true,
+      reason: `${sizeBytes} bytes > ${LSP_MAX_FILE_BYTES} limit`
+    };
+  }
+  const lineCount = content.split(`
+`).length;
+  if (lineCount > LSP_MAX_FILE_LINES) {
+    return {
+      tooLarge: true,
+      reason: `${lineCount} lines > ${LSP_MAX_FILE_LINES} limit`
+    };
+  }
+  return { tooLarge: false, reason: "" };
+}

package/extensions/dm-lens/dist/clients/lsp/diagnostic-binding.js

@@ -0,0 +1,79 @@
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import { PathKeyedMap } from "../path-keyed-map.js";
+import { normalizeEphemeralMapKey } from "../path-utils.js";
+export function resolveTouchVerdict(input) {
+  const notifyIds = [...new Set(input.primaryNotifyWriteTimedOutServerIds)];
+  const waitIds = input.diagnosticsTimedOut ? [...new Set(input.diagnosticsUnansweredServerIds)] : [];
+  if (notifyIds.length === 0 && !input.diagnosticsTimedOut) {
+    return { inconclusive: false };
+  }
+  const serverIds = [...new Set([...notifyIds, ...waitIds])];
+  const reason = notifyIds.length > 0 && input.diagnosticsTimedOut ? "mixed" : notifyIds.length > 0 ? "notify-write" : "diagnostics-wait";
+  return {
+    inconclusive: true,
+    ...serverIds.length > 0 && { inconclusiveServerIds: serverIds },
+    inconclusiveReason: reason
+  };
+}
+export function touchCoverageGap(result) {
+  return result?.unconfirmedServerIds ?? [];
+}
+export function touchCompletedConfirmationPolicy(result) {
+  return result?.confirmation !== undefined;
+}
+export function auxiliaryPublicationEvidence({ bindingMatchesContent, baseline, currentPathVersion, raced = true }) {
+  return bindingMatchesContent || raced && Number.isFinite(baseline) && currentPathVersion !== undefined && currentPathVersion > baseline;
+}
+export function auxiliaryCoverageGap(evidence) {
+  return evidence.filter((aux) => aux.outcome !== "answered" && aux.publishedThisContent !== true).map((aux) => aux.serverId);
+}
+export function hashDiagnosticContent(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+export function composeBoundToCurrentDisk(values) {
+  if (values.some((v) => v === false))
+    return false;
+  if (values.every((v) => v === "unknown")) {
+    return "unknown";
+  }
+  return true;
+}
+export function bindingStateLabel(value) {
+  if (value === true)
+    return "bound";
+  if (value === false)
+    return "mismatch";
+  return "unknown";
+}
+const DISK_BINDING_MEMO_MAX = 4096;
+export function createDiskBindingCache() {
+  const diskHashByPath = new PathKeyedMap(normalizeEphemeralMapKey);
+  return {
+    boundToCurrentDisk(filePath, stored) {
+      if (stored.contentHash === undefined)
+        return "unknown";
+      let stat;
+      try {
+        stat = fs.statSync(filePath);
+      } catch {
+        return "unknown";
+      }
+      let cached = diskHashByPath.get(filePath);
+      if (!cached || cached.mtimeMs !== stat.mtimeMs || cached.size !== stat.size) {
+        let diskHash;
+        try {
+          diskHash = hashDiagnosticContent(fs.readFileSync(filePath, "utf-8"));
+        } catch {
+          return "unknown";
+        }
+        cached = { mtimeMs: stat.mtimeMs, size: stat.size, hash: diskHash };
+        if (diskHashByPath.size >= DISK_BINDING_MEMO_MAX) {
+          diskHashByPath.clear();
+        }
+        diskHashByPath.set(filePath, cached);
+      }
+      return cached.hash === stored.contentHash;
+    }
+  };
+}