@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

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

@@ -0,0 +1,564 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { execFileSync, spawn as nodeSpawn } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+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, 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));
+}
+const DEFAULT_STARTUP_FAILURE_WINDOW_MS = 50;
+const WINDOWS_NAV_STARTUP_FAILURE_WINDOW_MS = 500;
+const SESSIONSTART_LOG_DIR = getGlobalDmLensLogDir();
+const SESSIONSTART_LOG = path.join(SESSIONSTART_LOG_DIR, "sessionstart.log");
+const DM_LENS_BIN_DIR = path.join(getGlobalDmLensDir(), "bin");
+const DM_LENS_TOOLS_BIN_DIR = path.join(getGlobalDmLensDir(), "tools", "node_modules", ".bin");
+function logSessionStart(msg) {
+  if (isTestMode()) {
+    return;
+  }
+  const line = redactSecrets(`[${new Date().toISOString()}] ${msg}
+`);
+  try {
+    fs.mkdirSync(SESSIONSTART_LOG_DIR, { recursive: true });
+    fs.appendFileSync(SESSIONSTART_LOG, line);
+  } catch {}
+}
+function compactLogValue(value, max = 280) {
+  const normalized = value.replace(/\s+/g, " ").trim();
+  if (!normalized)
+    return "";
+  return normalized.length > max ? `${normalized.slice(0, max)}...` : normalized;
+}
+function delimiterForPlatform(platform) {
+  return platform === "win32" ? ";" : ":";
+}
+function splitPathEntries(value, delimiter) {
+  if (!value)
+    return [];
+  return value.split(delimiter).map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+}
+function normalizePathEntry(entry, platform) {
+  if (platform !== "win32")
+    return path.posix.normalize(entry);
+  return path.win32.normalize(entry).toLowerCase();
+}
+export function combinePathValuesForPlatform(values, platform = process.platform) {
+  const unique = [];
+  const seen = new Set;
+  const delimiter = delimiterForPlatform(platform);
+  for (const value of values) {
+    for (const entry of splitPathEntries(value, delimiter)) {
+      const key = normalizePathEntry(entry, platform);
+      if (seen.has(key))
+        continue;
+      seen.add(key);
+      unique.push(entry);
+    }
+  }
+  return unique.join(delimiter);
+}
+function resolvePathValue(env) {
+  return combinePathValuesForPlatform([env.PATH, env.Path, env.path]);
+}
+export function runStderrGuardedProbe(command, args) {
+  try {
+    const { execFileSync } = require("node:child_process");
+    const out = execFileSync(command, args, {
+      timeout: 3000,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return out.trim();
+  } catch {
+    return "";
+  }
+}
+function readWindowsRegistryPath() {
+  return runStderrGuardedProbe("powershell.exe", [
+    "-NoProfile",
+    "-NonInteractive",
+    "-Command",
+    "[System.Environment]::GetEnvironmentVariable('Path','Machine') + ';' + [System.Environment]::GetEnvironmentVariable('Path','User')"
+  ]);
+}
+let _liveWindowsPath = null;
+function getLiveWindowsPath() {
+  if (_liveWindowsPath === null) {
+    _liveWindowsPath = readWindowsRegistryPath();
+  }
+  return _liveWindowsPath;
+}
+async function buildAugmentedPath(basePath) {
+  const candidates = [];
+  const nodeDir = path.dirname(process.execPath);
+  if (nodeDir) {
+    candidates.push(nodeDir);
+  }
+  if (isWindows) {
+    const home = os.homedir();
+    const driveRoot = path.parse(home).root;
+    candidates.push(path.join(home, ".cargo", "bin"));
+    candidates.push(path.join(home, "go", "bin"));
+    candidates.push(path.join(home, ".dotnet", "tools"));
+    candidates.push(DM_LENS_BIN_DIR);
+    candidates.push(DM_LENS_TOOLS_BIN_DIR);
+    candidates.push(path.join(driveRoot, "Program Files", "Go", "bin"));
+    candidates.push(path.join(driveRoot, "Go", "bin"));
+    for (const entry of await getRubyVersionDirNamesAsync(driveRoot)) {
+      candidates.push(path.join(driveRoot, entry, "bin"));
+    }
+  }
+  const effectiveBase = isWindows ? combinePathValuesForPlatform([basePath, getLiveWindowsPath()]) : basePath;
+  const existing = new Set;
+  for (const entry of splitPathEntries(effectiveBase, path.delimiter)) {
+    if (!entry)
+      continue;
+    existing.add(normalizePathEntry(entry, process.platform));
+  }
+  const toAppend = [];
+  for (const candidate of candidates) {
+    if (!candidate || !fs.existsSync(candidate))
+      continue;
+    const normalized = normalizePathEntry(candidate, process.platform);
+    if (existing.has(normalized))
+      continue;
+    toAppend.push(candidate);
+    existing.add(normalized);
+  }
+  if (toAppend.length === 0)
+    return basePath ?? "";
+  if (!basePath)
+    return toAppend.join(path.delimiter);
+  return `${basePath}${path.delimiter}${toAppend.join(path.delimiter)}`;
+}
+export function isCmdShimValid(cmdPath) {
+  try {
+    const content = fs.readFileSync(cmdPath, "utf-8");
+    const match = content.match(/"%~dp0[/\\]\.\.[/\\]((?:[\w./@-]|\\)+\.(?:mjs|cjs|js))"/i);
+    if (!match)
+      return true;
+    const relPath = match[1].replace(/[/\\]/g, path.sep);
+    const target = path.resolve(path.dirname(cmdPath), "..", relPath);
+    return fs.existsSync(target);
+  } catch {
+    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)) {
+    return { command: cmdPath, args, needsShell: true };
+  }
+  try {
+    const content = fs.readFileSync(ps1Path, "utf-8");
+    const match = content.match(/"\$basedir[/\\]\.\.[/\\]((?:[\w./@-]|\\)+\.(?:mjs|cjs|js))"/i);
+    if (match) {
+      const relPath = match[1].replace(/[/\\]/g, path.sep);
+      const jsPath = path.resolve(path.dirname(ps1Path), "..", relPath);
+      if (fs.existsSync(jsPath)) {
+        return {
+          command: process.execPath,
+          args: [jsPath, ...args],
+          needsShell: false
+        };
+      }
+    }
+  } catch {}
+  return;
+}
+function findBinaryOnPath(command, env) {
+  try {
+    const result = execFileSync(isWindows ? "where" : "which", [command], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      env,
+      timeout: 5000
+    }).split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    for (const candidate of result) {
+      if (fs.existsSync(candidate)) {
+        return candidate;
+      }
+    }
+  } 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) {
+    const escapeCmdArg = (s) => {
+      const escaped = s.replace(/([&|<>^()!])/g, "^$1");
+      return /[\s"]/.test(escaped) ? `"${escaped.replace(/"/g, '""')}"` : escaped;
+    };
+    const shellCommand = `"${command}" ${args.map(escapeCmdArg).join(" ")}`;
+    proc = nodeSpawn(shellCommand, [], {
+      cwd,
+      env,
+      stdio: ["pipe", "pipe", "pipe"],
+      detached: !isWindows,
+      windowsHide: true,
+      shell: true
+    });
+  } else {
+    proc = nodeSpawn(command, args, {
+      cwd,
+      env,
+      stdio: ["pipe", "pipe", "pipe"],
+      detached: !isWindows,
+      windowsHide: isWindows
+    });
+  }
+  if (!proc.stdin || !proc.stdout || !proc.stderr) {
+    throw new Error(`Failed to spawn LSP server: ${command}`);
+  }
+  holdOwnChildPid(proc.pid, "lsp-spawn");
+  return proc;
+}
+function unrefLspProcessHandles(proc) {
+  try {
+    proc.unref();
+  } catch {}
+  for (const stream of [proc.stdin, proc.stdout, proc.stderr]) {
+    try {
+      stream?.unref?.();
+    } catch {}
+  }
+}
+function _attachErrorHandler(proc, context, logContext, rejectOnImmediateError) {
+  let stderrPreview = "";
+  let closeLogged = false;
+  const onStderr = (chunk) => {
+    if (stderrPreview.length >= 4000)
+      return;
+    stderrPreview += chunk.toString();
+  };
+  proc.stderr?.on("data", onStderr);
+  proc.on("error", (err) => {
+    if (logContext) {
+      logSessionStart("lsp process " + context + ": spawn-error command=" + logContext.command + " args=" + JSON.stringify(logContext.args) + " cwd=" + logContext.cwd + " pid=" + (logContext.pid ?? 0) + " error=" + err.message + (stderrPreview ? " stderr=" + compactLogValue(stderrPreview) : ""));
+    }
+    if (rejectOnImmediateError && logContext) {
+      classifySpawnFailure(err, {
+        command: logContext.command,
+        cwd: logContext.cwd
+      }).then(rejectOnImmediateError);
+    }
+  });
+  proc.on("close", (code, signal) => {
+    if (closeLogged)
+      return;
+    closeLogged = true;
+    proc.stderr?.off("data", onStderr);
+    if (code !== 0 && code !== null) {
+      if (logContext) {
+        logSessionStart("lsp process " + context + ": closed code=" + code + (signal ? " signal=" + signal : "") + " command=" + logContext.command + " args=" + JSON.stringify(logContext.args) + " cwd=" + logContext.cwd + " pid=" + (logContext.pid ?? 0) + (stderrPreview ? " stderr=" + compactLogValue(stderrPreview) : ""));
+      }
+    } else if (signal && logContext) {
+      logSessionStart("lsp process " + context + ": closed signal=" + signal + " command=" + logContext.command + " args=" + JSON.stringify(logContext.args) + " cwd=" + logContext.cwd + " pid=" + (logContext.pid ?? 0) + (stderrPreview ? " stderr=" + compactLogValue(stderrPreview) : ""));
+    }
+  });
+}
+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;
+  let needsShell = computeNeedsShell(resolvedCommand);
+  let spawnCommand = resolvedCommand;
+  if (!isFullyQualified(command) && !command.includes(path.sep) && !command.includes("/")) {
+    const globalBinPath = await findGlobalBinary(command);
+    if (globalBinPath) {
+      spawnCommand = globalBinPath;
+      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" });
+    throw await classifySpawnFailure(cause, { command, cwd });
+  }
+  if (isWindows && /\.ps1$/i.test(spawnCommand)) {
+    const bypass = bypassPs1OnWindows(spawnCommand, args);
+    if (bypass) {
+      logSessionStart(`lsp ps1-bypass: ${spawnCommand} → ${bypass.command} shell=${bypass.needsShell}`);
+      spawnCommand = bypass.command;
+      args = bypass.args;
+      needsShell = bypass.needsShell;
+    } else {
+      logSessionStart(`lsp ps1-bypass: no .cmd or JS entry found for ${spawnCommand}, spawn may hang`);
+    }
+  }
+  let proc;
+  try {
+    proc = trySpawn(spawnCommand, args, cwd, env, needsShell);
+  } catch (err) {
+    if (!isFullyQualified(command) && !command.includes(path.sep) && !command.includes("/")) {
+      const globalBinPath = await findGlobalBinary(command);
+      if (globalBinPath && globalBinPath !== spawnCommand) {
+        const needsShellGlobal = computeNeedsShell(globalBinPath);
+        proc = trySpawn(globalBinPath, args, cwd, env, needsShellGlobal);
+      } else {
+        throw await classifySpawnFailure(err, { command, cwd });
+      }
+    } else {
+      throw await classifySpawnFailure(err, { command, cwd });
+    }
+  }
+  if (!proc.stdin || !proc.stdout || !proc.stderr) {
+    throw new Error(`Failed to spawn LSP server: ${command}`);
+  }
+  if (proc.exitCode !== null || proc.killed) {
+    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) => {
+    const normalized = compactLogValue(stderr);
+    if (!normalized)
+      return "";
+    return ` stderr=${normalized}`;
+  };
+  let startupStderr = "";
+  const onStartupStderr = (chunk) => {
+    if (startupStderr.length >= 4000)
+      return;
+    startupStderr += chunk.toString();
+  };
+  proc.stderr?.on("data", onStartupStderr);
+  try {
+    await new Promise((resolve, reject) => {
+      let settled = false;
+      proc.on("error", (err) => {
+        if (!settled) {
+          settled = true;
+          classifySpawnFailure(err, { command, cwd }).then((failure) => {
+            const detail = formatStartupStderr(startupStderr);
+            reject(detail ? new SpawnFailureError(failure.kind, `${failure.message}${detail}`, failure.cause) : failure);
+          });
+        }
+      });
+      proc.on("exit", (code) => {
+        if (!settled && code !== null) {
+          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.`;
+          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 = (() => {
+        if (options?.startupFailureWindowMs) {
+          return options.startupFailureWindowMs;
+        }
+        if (isWindows && needsShell) {
+          return WINDOWS_NAV_STARTUP_FAILURE_WINDOW_MS;
+        }
+        return DEFAULT_STARTUP_FAILURE_WINDOW_MS;
+      })();
+      setTimeout(() => {
+        if (!settled) {
+          settled = true;
+          resolve();
+        }
+      }, startupFailureWindowMs);
+    });
+  } finally {
+    proc.stderr?.off("data", onStartupStderr);
+  }
+  _attachErrorHandler(proc, command, {
+    command: spawnCommand,
+    args,
+    cwd,
+    pid: proc.pid ?? 0
+  });
+  unrefLspProcessHandles(proc);
+  return {
+    process: proc,
+    stdin: proc.stdin,
+    stdout: proc.stdout,
+    stderr: proc.stderr,
+    pid: proc.pid ?? 0,
+    command: spawnCommand,
+    args
+  };
+}
+export async function launchViaNode(scriptPath, args = [], options = {}) {
+  return launchLSP(process.execPath, [scriptPath, ...args], options);
+}
+export async function launchViaPython(moduleName, args = [], options = {}) {
+  const pythonCmd = process.platform === "win32" ? "py" : "python3";
+  return launchLSP(pythonCmd, ["-m", moduleName, ...args], options);
+}
+export async function stopLSP(handle) {
+  if (handle.process.exitCode !== null || handle.process.signalCode !== null) {
+    return;
+  }
+  return new Promise((resolve) => {
+    let settled = false;
+    let forceTimeout;
+    let giveUpTimeout;
+    const done = () => {
+      if (settled)
+        return;
+      settled = true;
+      if (forceTimeout)
+        clearTimeout(forceTimeout);
+      if (giveUpTimeout)
+        clearTimeout(giveUpTimeout);
+      handle.process.off("exit", done);
+      handle.process.off("error", done);
+      resolve();
+    };
+    handle.process.once("exit", done);
+    handle.process.once("error", done);
+    const killWindowsTree = () => {
+      if (!isWindows)
+        return false;
+      if (!isOwnLiveChild(handle.pid, "lsp-stop-windows-tree", handle.process))
+        return false;
+      try {
+        const taskkill = `${process.env.SystemRoot ?? "C:\\Windows"}\\System32\\taskkill.exe`;
+        const killer = nodeSpawn(taskkill, ["/F", "/T", "/PID", String(handle.pid)], {
+          shell: false,
+          windowsHide: true
+        });
+        killer.once("error", done);
+        return true;
+      } catch {
+        return false;
+      }
+    };
+    try {
+      if (!killWindowsTree()) {
+        handle.process.kill("SIGTERM");
+      }
+    } catch {
+      done();
+      return;
+    }
+    forceTimeout = setTimeout(() => {
+      if (settled)
+        return;
+      try {
+        if (!killWindowsTree()) {
+          handle.process.kill("SIGKILL");
+        }
+      } catch {
+        done();
+        return;
+      }
+      giveUpTimeout = setTimeout(done, 500);
+    }, 5000);
+  });
+}