@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

package/extensions/dm-lens/clients/lsp/launch.js

@@ -1,3 +1,4 @@
+import { AsyncLocalStorage } from "node:async_hooks";
 import {
   execFileSync,
   spawn as nodeSpawn
@@ -9,16 +10,25 @@ import { isTestMode } from "../env-utils.js";
 import { getGlobalDmLensDir } from "../file-utils.js";
 import { getGlobalDmLensLogDir } from "../probe-home-state.js";
 import { isFullyQualified } from "../path-utils.js";
-import { findGlobalBinary } from "../package-manager.js";
+import { findGlobalBinary, isProjectLocalBinPath } from "../package-manager.js";
+import {
+  getDegradationLedgerGeneration,
+  recordDegradationOnce
+} from "../degradation-ledger.js";
+import { getProjectTrustState } from "../project-trust.js";
+import { logExtension } from "../extension-log.js";
+import { OWNER_TAG_ENV, ownerTagForChildren } from "../process-snapshot.js";
 import { redactSecrets } from "../redact/secrets.js";
 import {
   classifySpawnFailure,
   holdOwnChildPid,
   isOwnLiveChild,
+  resolveWindowsCommandForEnvironment,
   SpawnFailureError
 } from "../safe-spawn.js";
 import { getRubyVersionDirNamesAsync } from "./ruby-drive-dirs.js";
 const isWindows = process.platform === "win32";
+const OWNER_TAG_READ_MS = 5000;
 function computeNeedsShell(resolvedCommand) {
   return isWindows && (resolvedCommand.includes(" ") || /\.(cmd|bat)$/i.test(resolvedCommand) || !/\.(exe|cmd|bat)$/i.test(resolvedCommand));
 }
@@ -160,6 +170,16 @@ export function isCmdShimValid(cmdPath) {
     return true;
   }
 }
+function isMissingWindowsStartupCommand(command, spawnCommand, cwd, env) {
+  if (!isWindows)
+    return false;
+  if (/\.(cmd|bat)$/i.test(spawnCommand) && !isCmdShimValid(spawnCommand)) {
+    return true;
+  }
+  if (spawnCommand !== command)
+    return false;
+  return resolveWindowsCommandForEnvironment(command, cwd, env) === null;
+}
 function bypassPs1OnWindows(ps1Path, args) {
   const cmdPath = `${ps1Path.slice(0, -4)}.cmd`;
   if (fs.existsSync(cmdPath)) {
@@ -198,6 +218,65 @@ function findBinaryOnPath(command, env) {
   } catch {}
   return;
 }
+const lspProjectCodePermission = new AsyncLocalStorage;
+export function withLspProjectCodePermission(allowed, spawn) {
+  return lspProjectCodePermission.run(allowed, spawn);
+}
+let unknownProjectLocalNoticeGeneration = -1;
+function recordUntrustedLspExecution(request, trust) {
+  const generation = getDegradationLedgerGeneration();
+  const subject = request.kind === "project-code-server" ? `project-code-server:g${generation}:${request.serverId}:${request.root}` : `project-local-binary:g${generation}:${path.basename(request.command)}`;
+  const metadata = request.kind === "project-code-server" ? {
+    field: request.kind,
+    serverId: request.serverId,
+    root: request.root,
+    trust
+  } : {
+    field: request.kind,
+    trust
+  };
+  recordDegradationOnce({
+    kind: "lsp-registry-decision",
+    subject,
+    reason: (request.kind === "project-local-binary" ? request.reason : undefined) ?? `LSP execution refused: ${request.kind} and project trust is ${trust}`,
+    metadata
+  });
+  if (unknownProjectLocalNoticeGeneration !== generation) {
+    unknownProjectLocalNoticeGeneration = generation;
+    const label = request.kind === "project-code-server" ? "project-code LSP server" : "project-local LSP binary";
+    logExtension({
+      subsystem: "lsp-registry",
+      level: "warn",
+      message: `${label} refused: mark the project trusted in pi or upgrade pi`,
+      metadata: { field: request.kind }
+    });
+  }
+}
+export function refuseUntrustedLspExecution(request) {
+  const trust = getProjectTrustState();
+  const needsTrust = request.kind === "project-code-server" ? trust !== "trusted" : !admitProjectSuppliedTsserver(request.resolvedCommand, request.cwd, true);
+  if (!needsTrust)
+    return;
+  if (request.kind === "project-code-server")
+    recordUntrustedLspExecution(request, trust);
+  throw new SpawnFailureError("spawn-failed", `LSP ${request.kind === "project-code-server" ? "project-code server" : "project-local binary"} refused: project trust is ${trust}`, new Error(`project trust is ${trust}`));
+}
+export function admitProjectSuppliedTsserver(tsserverPath, cwd, projectSupplied, projectCodeAllowed = lspProjectCodePermission.getStore() ?? false) {
+  const trust = getProjectTrustState();
+  if (tsserverPath && (!projectSupplied || projectCodeAllowed && trust === "trusted"))
+    return tsserverPath;
+  recordUntrustedLspExecution({
+    kind: "project-local-binary",
+    command: tsserverPath ?? "tsserver.js",
+    resolvedCommand: tsserverPath ?? "tsserver.js",
+    cwd,
+    reason: tsserverPath ? "LSP execution refused: project compiler requires trusted session ownership" : "LSP execution refused: no admitted absolute TypeScript compiler"
+  }, trust);
+  return;
+}
+export function isProjectLocalLspBinary(resolvedCommand, cwd) {
+  return isProjectLocalBinPath(resolvedCommand, cwd);
+}
 function trySpawn(command, args, cwd, env, needsShell) {
   let proc;
   if (needsShell) {
@@ -226,9 +305,6 @@ function trySpawn(command, args, cwd, env, needsShell) {
   if (!proc.stdin || !proc.stdout || !proc.stderr) {
     throw new Error(`Failed to spawn LSP server: ${command}`);
   }
-  if (proc.exitCode !== null || proc.killed) {
-    throw new Error(`LSP server ${command} exited immediately (code: ${proc.exitCode}). ` + `The binary may be missing or corrupted.`);
-  }
   holdOwnChildPid(proc.pid, "lsp-spawn");
   return proc;
 }
@@ -280,11 +356,16 @@ export async function launchLSP(command, args = [], options = {}) {
   const cwd = String(options.cwd ?? process.cwd());
   const mergedEnv = { ...process.env, ...options.env };
   const augmentedPath = await buildAugmentedPath(resolvePathValue(mergedEnv));
+  const ownerTag = await ownerTagForChildren({ timeoutMs: OWNER_TAG_READ_MS });
   const env = {
     ...mergedEnv,
     PATH: augmentedPath,
     ...isWindows ? { Path: augmentedPath } : {}
   };
+  if (ownerTag === undefined)
+    delete env[OWNER_TAG_ENV];
+  else
+    env[OWNER_TAG_ENV] = ownerTag;
   const isRelativePath = !isFullyQualified(command) && (command.includes(path.sep) || command.includes("/"));
   const explicitCommand = isRelativePath ? path.resolve(cwd, command) : command;
   const resolvedCommand = !isFullyQualified(command) && !command.includes(path.sep) && !command.includes("/") ? findBinaryOnPath(command, env) ?? explicitCommand : explicitCommand;
@@ -297,6 +378,14 @@ export async function launchLSP(command, args = [], options = {}) {
       needsShell = computeNeedsShell(spawnCommand);
     }
   }
+  if (isProjectLocalLspBinary(spawnCommand, cwd)) {
+    refuseUntrustedLspExecution({
+      kind: "project-local-binary",
+      command,
+      resolvedCommand: spawnCommand,
+      cwd
+    });
+  }
   if (isWindows && /\.(cmd|bat)$/i.test(spawnCommand) && !isCmdShimValid(spawnCommand)) {
     logSessionStart(`lsp cmd-shim-invalid: ${spawnCommand} target missing — skipping candidate`);
     const cause = Object.assign(new Error(`LSP .cmd shim target not found: ${spawnCommand}`), { code: "ENOENT" });
@@ -333,7 +422,12 @@ export async function launchLSP(command, args = [], options = {}) {
     throw new Error(`Failed to spawn LSP server: ${command}`);
   }
   if (proc.exitCode !== null || proc.killed) {
-    throw new Error(`LSP server ${command} exited immediately (code: ${proc.exitCode}). ` + `The binary may be missing or corrupted.`);
+    const message = `LSP server ${command} exited immediately (code: ${proc.exitCode}). ` + `The binary may be missing or corrupted.`;
+    const failure = new Error(message);
+    if (proc.exitCode === 1 && isMissingWindowsStartupCommand(command, spawnCommand, cwd, env)) {
+      throw new SpawnFailureError("tool-not-found", message, failure);
+    }
+    throw failure;
   }
   logSessionStart(`lsp launch: command=${command} resolved=${spawnCommand} args=${JSON.stringify(args)} cwd=${cwd} shell=${needsShell ? "true" : "false"} pid=${proc.pid ?? 0}`);
   const formatStartupStderr = (stderr) => {
@@ -366,7 +460,13 @@ export async function launchLSP(command, args = [], options = {}) {
           settled = true;
           const isWindowsCmd = isWindows && command.endsWith(".cmd");
           const errorMsg = isWindowsCmd && code === 1 ? `npm .cmd shim failed (underlying binary not installed). Run 'npm install' in this project or use a global installation.` : `The binary may be missing or corrupted.`;
-          reject(new Error(`LSP server ${command} exited immediately with code ${code}. ${errorMsg}${formatStartupStderr(startupStderr)}`));
+          const message = `LSP server ${command} exited immediately with code ${code}. ${errorMsg}${formatStartupStderr(startupStderr)}`;
+          const failure = new Error(message);
+          if (code === 1 && isMissingWindowsStartupCommand(command, spawnCommand, cwd, env)) {
+            reject(new SpawnFailureError("tool-not-found", message, failure));
+            return;
+          }
+          reject(failure);
         }
       });
       const startupFailureWindowMs = (() => {

package/extensions/dm-lens/clients/lsp/pending-aux-coverage.js

@@ -12,43 +12,73 @@ export function readLateAuxRearmTtlMs() {
     return DEFAULT_LATE_AUX_REARM_TTL_MS;
   return parsed;
 }
+export function captureAuxPublicationBacklog(client, filePath) {
+  const counts = client?.getPublicationCountsForPath?.(filePath);
+  if (!client || !counts)
+    return;
+  const notified = new WeakRef(client);
+  return {
+    unpublished: Math.max(0, counts.sent - counts.published),
+    publishedAtMark: counts.published,
+    readPublished: () => {
+      const live = notified.deref();
+      if (!live || live.isAlive?.() === false)
+        return;
+      return live.getPublicationCountsForPath?.(filePath)?.published;
+    }
+  };
+}
+export function isAuxBacklogPublished(pair) {
+  const backlog = pair.backlog;
+  if (!backlog)
+    return true;
+  const published = backlog.readPublished();
+  if (published === undefined)
+    return true;
+  return published - backlog.publishedAtMark >= backlog.unpublished;
+}
 export function isPendingAuxiliaryPastRearmTtl(pair, nowMs = Date.now()) {
   const anchor = pair.lastRearmedAtMs ?? pair.markedAtMs;
   return nowMs - anchor >= readLateAuxRearmTtlMs();
 }
+export function canRearmPendingAuxiliary(pair, nowMs = Date.now()) {
+  return !isPendingAuxiliaryPastRearmTtl(pair, nowMs) && (pair.rearmCount ?? 0) < MAX_LATE_AUX_REARMS;
+}
 const pending = new BoundedFifoMap(MAX_PENDING_AUX_ENTRIES);
 let capEvictedCount = 0;
 function pairKey(filePath, serverId) {
   return `${normalizeEphemeralMapKey(filePath)}\x00${serverId}`;
 }
-export function markPendingAuxiliaryCoverage(filePath, serverIds, markedAtMs = Date.now(), rearmedAtMs, rearmCount) {
+export function markPendingAuxiliaryCoverage(filePath, serverIds, markedAtMs = Date.now(), rearmedAtMs, rearmCount, backlog) {
   for (const serverId of serverIds) {
     const key = pairKey(filePath, serverId);
     const existing = pending.get(key);
     if (existing) {
       pending.delete(key);
-      pending.set(key, rearmedAtMs === undefined ? { filePath, serverId, markedAtMs } : {
+      pending.set(key, rearmedAtMs === undefined ? { filePath, serverId, markedAtMs, ...backlog && { backlog } } : {
         filePath,
         serverId,
         markedAtMs: existing.markedAtMs,
         lastRearmedAtMs: rearmedAtMs,
-        rearmCount: rearmCount ?? (existing.rearmCount ?? 0) + 1
+        rearmCount: rearmCount ?? (existing.rearmCount ?? 0) + 1,
+        ...existing.backlog && { backlog: existing.backlog }
       });
       continue;
     }
-    const evicted = pending.set(key, rearmedAtMs === undefined ? { filePath, serverId, markedAtMs } : {
+    const evicted = pending.set(key, rearmedAtMs === undefined ? { filePath, serverId, markedAtMs, ...backlog && { backlog } } : {
       filePath,
       serverId,
       markedAtMs,
       lastRearmedAtMs: rearmedAtMs,
-      rearmCount: rearmCount ?? 1
+      rearmCount: rearmCount ?? 1,
+      ...backlog && { backlog }
     });
     capEvictedCount += evicted.length;
   }
 }
-export function rearmPendingAuxiliaryCoverage(pair, rearmedAtMs = Date.now(), refreshBaseline = false) {
+export function rearmPendingAuxiliaryCoverage(pair, rearmedAtMs = Date.now()) {
   const nextCount = (pair.rearmCount ?? 0) + 1;
-  markPendingAuxiliaryCoverage(pair.filePath, [pair.serverId], refreshBaseline ? rearmedAtMs : pair.markedAtMs, rearmedAtMs, nextCount);
+  markPendingAuxiliaryCoverage(pair.filePath, [pair.serverId], pair.markedAtMs, rearmedAtMs, nextCount, pair.backlog);
 }
 export function hasPendingAuxiliaryCoverage(filePath, serverId) {
   return pending.has(pairKey(filePath, serverId));

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

@@ -0,0 +1,188 @@
+import { LEGACY_ROOT_LSP_KEYS } from "../config-locations.js";
+import { DM_LENS_CONFIG_SCHEMA } from "../config-schema.js";
+import { resolveConfig } from "../config-core/resolve.js";
+import {
+  MAX_MIGRATION_RECORDS,
+  MigrationRecordCollector,
+  boundedKeyLabel,
+  migrationSubject
+} from "../config-core/records.js";
+import { customServerSpecsOf } from "./config.js";
+import { isAuxiliary } from "./server-traits.js";
+function object(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function stringItems(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.reduce((out, item) => {
+    if (typeof item === "string")
+      out.push(item);
+    return out;
+  }, []);
+}
+function makeMigrationRecord(source, key, reason) {
+  const safeKey = boundedKeyLabel(key);
+  return {
+    code: "PILENS_CFG_0005",
+    file: source.file ?? "",
+    key: safeKey,
+    subject: migrationSubject(source.file ?? "", safeKey),
+    reason,
+    tier: source.tier
+  };
+}
+function isLegacyLspFile(file) {
+  if (!file)
+    return false;
+  const normalized = file.replaceAll("\\", "/");
+  return /(?:^|\/)(?:dm-lens|pi-lsp)\.json$/.test(normalized) || normalized.endsWith(["", ".dm-lens", "lsp.json"].join("/"));
+}
+function canonicalizeSource(source) {
+  const input = object(source.value);
+  if (!input)
+    return { source, migrationKeys: [] };
+  const legacy = Object.fromEntries(LEGACY_ROOT_LSP_KEYS.reduce((out, key) => {
+    if (Object.hasOwn(input, key))
+      out.push([key, input[key]]);
+    return out;
+  }, []));
+  if (Object.keys(legacy).length === 0)
+    return { source, migrationKeys: [] };
+  const canonical = object(input.lsp) ?? {};
+  const rest = { ...input };
+  for (const key of Object.keys(legacy))
+    delete rest[key];
+  const mergedLsp = { ...legacy, ...canonical };
+  return {
+    source: { ...source, value: { ...rest, lsp: mergedLsp } },
+    migrationKeys: Object.keys(legacy)
+  };
+}
+function normalizeServer(id, input, source, records) {
+  const entry = object(input);
+  if (!entry) {
+    records.push(makeMigrationRecord(source, `/lsp/servers/${id}`, "server entry must be an object"));
+    return;
+  }
+  const command = entry.command;
+  let argv;
+  if (Array.isArray(command)) {
+    if (command.length > 0 && command.every((part) => typeof part === "string") && command[0] !== "") {
+      argv = command;
+    } else {
+      records.push(makeMigrationRecord(source, `/lsp/servers/${id}/command`, "command must be a non-empty argv array"));
+      return;
+    }
+  } else if (typeof command === "string" && command.length > 0) {
+    const args = entry.args === undefined ? ["--stdio"] : entry.args;
+    if (!Array.isArray(args) || !args.every((part) => typeof part === "string")) {
+      records.push(makeMigrationRecord(source, `/lsp/servers/${id}/args`, "args must be an array of strings"));
+      return;
+    }
+    argv = [command, ...args];
+  } else if (command !== undefined) {
+    records.push(makeMigrationRecord(source, `/lsp/servers/${id}/command`, "command must be a string or argv array"));
+    return;
+  }
+  const extensions = entry.extensions;
+  const rootMarkers = entry.rootMarkers;
+  if (extensions !== undefined && (!Array.isArray(extensions) || !extensions.every((x) => typeof x === "string"))) {
+    records.push(makeMigrationRecord(source, `/lsp/servers/${id}/extensions`, "extensions must be an array of strings"));
+    return;
+  }
+  if (rootMarkers !== undefined && (!Array.isArray(rootMarkers) || !rootMarkers.every((x) => typeof x === "string"))) {
+    records.push(makeMigrationRecord(source, `/lsp/servers/${id}/rootMarkers`, "rootMarkers must be an array of strings"));
+    return;
+  }
+  const env = entry.env;
+  const envObject = object(env);
+  if (env !== undefined && (!envObject || Object.values(envObject).some((x) => typeof x !== "string"))) {
+    records.push(makeMigrationRecord(source, `/lsp/servers/${id}/env`, "env values must be strings"));
+    return;
+  }
+  const initializationOptions = entry.initializationOptions;
+  if (initializationOptions !== undefined && !object(initializationOptions)) {
+    records.push(makeMigrationRecord(source, `/lsp/servers/${id}/initializationOptions`, "initializationOptions must be an object"));
+    return;
+  }
+  return {
+    kind: argv ? "custom" : "override",
+    name: typeof entry.name === "string" && entry.name.length > 0 ? entry.name : id,
+    enabled: entry.enabled !== false,
+    role: isAuxiliary(entry) ? "auxiliary" : "language",
+    ...argv ? { command: argv } : {},
+    ...Array.isArray(entry.args) ? { args: entry.args } : {},
+    ...extensions ? { extensions } : {},
+    ...rootMarkers ? { rootMarkers } : {},
+    ...envObject ? { env: envObject } : {},
+    ...initializationOptions ? {
+      initializationOptions
+    } : {},
+    ...Array.isArray(entry.covers) ? { covers: entry.covers } : {}
+  };
+}
+export function resolveLspConfig(options) {
+  const prepared = options.sources.map(canonicalizeSource);
+  const resolution = resolveConfig({
+    sources: prepared.map(({ source }) => source),
+    schema: DM_LENS_CONFIG_SCHEMA,
+    maxRecords: options.maxRecords
+  });
+  const collector = new MigrationRecordCollector(options.maxRecords ?? MAX_MIGRATION_RECORDS, resolution.droppedRecordCount);
+  for (const record of resolution.records)
+    collector.add(record);
+  const seenMigrationRecords = new Set;
+  for (const item of prepared) {
+    for (const key of item.migrationKeys) {
+      const code = isLegacyLspFile(item.source.file) ? "PILENS_CFG_0003" : "PILENS_CFG_0002";
+      const safeKey = boundedKeyLabel(key);
+      const identity = `${code}\x00${item.source.file ?? ""}\x00${safeKey}`;
+      if (seenMigrationRecords.has(identity))
+        continue;
+      seenMigrationRecords.add(identity);
+      collector.add({
+        code,
+        file: item.source.file ?? "",
+        key: safeKey,
+        subject: migrationSubject(item.source.file ?? "", safeKey),
+        canonicalKey: `lsp.${key}`,
+        reason: `deprecated LSP ${code === "PILENS_CFG_0003" ? "file location" : "key"}; use lsp.${safeKey}`,
+        tier: item.source.tier
+      });
+    }
+  }
+  const lsp = object(resolution.resolved.value?.lsp) ?? {};
+  const servers = object(lsp.servers) ?? {};
+  const normalizedServers = {};
+  const serverRecords = [];
+  for (const [id, entry] of Object.entries(servers)) {
+    const normalized = normalizeServer(id, entry, options.sources[0] ?? { tier: "project", value: {} }, serverRecords);
+    if (normalized)
+      normalizedServers[id] = normalized;
+  }
+  for (const record of serverRecords)
+    collector.add(record);
+  const records = collector.records;
+  const covered = customServerSpecsOf({ lsp: { servers: normalizedServers } });
+  for (const [id, server] of Object.entries(covered)) {
+    if (server.covers)
+      normalizedServers[id] = {
+        ...normalizedServers[id],
+        covers: server.covers
+      };
+  }
+  const disabled = stringItems(lsp.disabledServers);
+  const warmFiles = stringItems(lsp.warmFiles);
+  return {
+    value: {
+      ...typeof lsp.enabled === "boolean" ? { enabled: lsp.enabled } : {},
+      warmFiles,
+      disabledServers: disabled,
+      servers: normalizedServers,
+      provenance: resolution.resolved.provenance
+    },
+    records,
+    provenance: resolution.resolved.provenance
+  };
+}

package/extensions/dm-lens/clients/lsp/server-covers.js

@@ -0,0 +1,8 @@
+export const BUILTIN_SERVER_RUNNER_COVERS = new Map([
+  [
+    "bash",
+    { runnerIds: ["shellcheck"], gateCommands: ["bash-language-server"] }
+  ],
+  ["shuck", { runnerIds: ["shellcheck"], gateCommands: ["shuck"] }],
+  ["toml", { runnerIds: ["taplo"], gateCommands: ["taplo"] }]
+]);

package/extensions/dm-lens/clients/lsp/server-traits.js

@@ -0,0 +1,39 @@
+const ROLE_MEMBERS = {
+  language: "language",
+  auxiliary: "auxiliary"
+};
+export const DEFAULT_LSP_SERVER_ROLE = "language";
+export function isAuxiliary(bearer) {
+  const declared = bearer?.role;
+  const role = typeof declared === "string" && Object.hasOwn(ROLE_MEMBERS, declared) ? ROLE_MEMBERS[declared] : DEFAULT_LSP_SERVER_ROLE;
+  switch (role) {
+    case "auxiliary":
+      return true;
+    case "language":
+      return false;
+  }
+}
+export const DEFAULT_NOTIFY_INFLIGHT_LIMIT = 8;
+export const DEFAULT_REPLY_ORDERING = "unmeasured";
+export const STRATEGY_TABLE_TRAITS = [
+  "silentOnClean",
+  "emptyFirstPublish",
+  "diagnosticsFence",
+  "workspaceIndexing"
+];
+export function serverTraits(declaration) {
+  const declaredLimit = declaration.notifyInflightLimit;
+  if (typeof declaredLimit === "number" && Number.isFinite(declaredLimit) && declaredLimit > 0) {
+    return {
+      role: declaration.role,
+      notifyInflightLimit: Math.floor(declaredLimit),
+      replyOrdering: declaration.replyOrdering ?? DEFAULT_REPLY_ORDERING
+    };
+  }
+  const envLimit = Number(process.env.DM_LENS_LSP_AUX_NOTIFY_INFLIGHT);
+  return {
+    role: declaration.role,
+    notifyInflightLimit: Number.isFinite(envLimit) && envLimit > 0 ? Math.floor(envLimit) : DEFAULT_NOTIFY_INFLIGHT_LIMIT,
+    replyOrdering: declaration.replyOrdering ?? DEFAULT_REPLY_ORDERING
+  };
+}