@duckmind/dm-linux-x64 0.65.5 → 0.65.7

package/extensions/dm-lens/dist/clients/mcp/ipc.js

@@ -0,0 +1,302 @@
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+import * as net from "node:net";
+import * as os from "node:os";
+import * as path from "node:path";
+import { writeFileAtomic } from "../atomic-write.js";
+import { incrementDegradationCount } from "../degradation-ledger.js";
+import { DEFAULT_MAX_OUTPUT_BYTES } from "../spawn-output-cap.js";
+export const WARM_DIAGNOSTICS_SCHEMA_VERSION = 1;
+export const WARM_CODE_ACTION_LOOKUP_LIMIT = 6;
+export function ipcPathForCwd(cwd, platform = process.platform) {
+  const hash = workspaceHash(cwd, platform);
+  if (platform === "win32") {
+    return `\\\\.\\pipe\\dm-lens-mcp-${hash}`;
+  }
+  return path.join(os.tmpdir(), `dm-lens-mcp-${hash}.sock`);
+}
+function workspaceHash(cwd, platform = process.platform) {
+  const resolved = path.resolve(cwd);
+  const root = platform === "win32" || platform === "darwin" ? resolved.toLowerCase() : resolved;
+  return crypto.createHash("sha256").update(root).digest("hex").slice(0, 16);
+}
+export function diagnosticsIpcPathForCwd(cwd, pid, platform = process.platform) {
+  const base = ipcPathForCwd(cwd, platform);
+  if (platform === "win32")
+    return `${base}-diagnostics-${pid}`;
+  return base.replace(/\.sock$/, `-diagnostics-${pid}.sock`);
+}
+function isNoListenerError(error) {
+  const code = error?.code;
+  return code === "ENOENT" || code === "ECONNREFUSED";
+}
+export function contentHash(content) {
+  return crypto.createHash("sha256").update(content).digest("hex");
+}
+function requestOverWarmIpc(endpoint, timeoutMs, buildRequest, validate) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (value) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      socket.destroy();
+      resolve(value);
+    };
+    const deadlineAt = Date.now() + timeoutMs;
+    const socket = net.createConnection(endpoint);
+    socket.setEncoding("utf8");
+    const timer = setTimeout(() => finish({ available: false, reason: "timeout" }), timeoutMs);
+    timer.unref();
+    socket.on("connect", () => {
+      socket.write(`${JSON.stringify(buildRequest(deadlineAt))}
+`);
+    });
+    socket.on("data", createWarmIpcLineReader((line) => {
+      try {
+        const message = JSON.parse(line);
+        const result = message.result;
+        if (message.error || !result) {
+          finish({ available: false, reason: "ipc-error" });
+          return;
+        }
+        const reason = validate(result, deadlineAt);
+        if (reason === undefined) {
+          finish({ available: true, response: result });
+        } else {
+          finish({ available: false, reason });
+        }
+      } catch {
+        finish({ available: false, reason: "schema-mismatch" });
+      }
+    }, {
+      label: "warm-diagnostics-reply",
+      onOverflow: () => finish({ available: false, reason: "ipc-error" })
+    }));
+    socket.on("error", (error) => finish({
+      available: false,
+      reason: isNoListenerError(error) ? "no-listener" : "ipc-error"
+    }));
+    socket.on("close", () => finish({ available: false, reason: "ipc-error" }));
+  });
+}
+export function requestWarmDiagnostics(cwd, incumbentPid, file, content, timeoutMs) {
+  const expectedHash = contentHash(content);
+  return requestOverWarmIpc(diagnosticsIpcPathForCwd(cwd, incumbentPid), timeoutMs, (deadlineAt) => ({
+    route: "diagnostics",
+    version: WARM_DIAGNOSTICS_SCHEMA_VERSION,
+    file,
+    cwd,
+    content,
+    contentHash: expectedHash,
+    deadlineAt
+  }), (result, deadlineAt) => {
+    if (result.route !== "diagnostics" || result.version !== WARM_DIAGNOSTICS_SCHEMA_VERSION) {
+      return "schema-mismatch";
+    }
+    if (!result.fresh || result.inconclusive || result.contentHash !== expectedHash || result.servedAt > deadlineAt) {
+      return "stale-answer";
+    }
+    return;
+  });
+}
+export function requestWarmCodeActions(cwd, incumbentPid, file, expectedContentHash, ranges, timeoutMs) {
+  return requestOverWarmIpc(diagnosticsIpcPathForCwd(cwd, incumbentPid), timeoutMs, (deadlineAt) => ({
+    route: "code-actions",
+    version: WARM_DIAGNOSTICS_SCHEMA_VERSION,
+    file,
+    cwd,
+    contentHash: expectedContentHash,
+    ranges,
+    deadlineAt
+  }), (result, deadlineAt) => {
+    if (result.route !== "code-actions" || result.version !== WARM_DIAGNOSTICS_SCHEMA_VERSION || !Array.isArray(result.actions) || result.actions.length !== ranges.length || result.actions.some((actions) => !Array.isArray(actions))) {
+      return "schema-mismatch";
+    }
+    if (result.contentHash !== expectedContentHash || result.servedAt > deadlineAt) {
+      return "stale-answer";
+    }
+    return;
+  });
+}
+export const WARM_TURN_END_SCHEMA_VERSION = 2;
+export async function requestWarmTurnEnd(cwd, timeoutMs = 55000) {
+  const startedAt = Date.now();
+  const first = await requestOverWarmIpc(ipcPathForCwd(cwd), timeoutMs, () => ({
+    route: "turn-end",
+    version: WARM_TURN_END_SCHEMA_VERSION,
+    cwd
+  }), (result) => result.route === "turn-end" && result.version === WARM_TURN_END_SCHEMA_VERSION ? undefined : "schema-mismatch");
+  if (!first.available || !first.response.deliveryId)
+    return first;
+  const remainingMs = timeoutMs - (Date.now() - startedAt);
+  if (remainingMs <= 0)
+    return { available: false, reason: "timeout" };
+  const ack = await requestOverWarmIpc(ipcPathForCwd(cwd), remainingMs, () => ({
+    route: "turn-end-ack",
+    version: WARM_TURN_END_SCHEMA_VERSION,
+    cwd,
+    deliveryId: first.response.deliveryId
+  }), (result) => result.route === "turn-end-ack" && result.acknowledged === true ? undefined : "ipc-error");
+  return ack.available ? { available: true, response: first.response } : { available: false, reason: ack.reason };
+}
+export function turnEndStatusPathForCwd(cwd, platform = process.platform) {
+  return path.join(os.tmpdir(), `dm-lens-turn-end-${workspaceHash(cwd, platform)}.json`);
+}
+export function readTurnEndStatus(cwd, platform = process.platform) {
+  try {
+    const raw = fs.readFileSync(turnEndStatusPathForCwd(cwd, platform), "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object")
+      return;
+    return {
+      ran: typeof parsed.ran === "number" ? parsed.ran : 0,
+      skipped: typeof parsed.skipped === "number" ? parsed.skipped : 0,
+      lastSkipReason: parsed.lastSkipReason,
+      lastRunAt: parsed.lastRunAt,
+      lastSkipAt: parsed.lastSkipAt
+    };
+  } catch {
+    return;
+  }
+}
+export function recordTurnEndOutcome(cwd, outcome, platform = process.platform) {
+  try {
+    const now = new Date().toISOString();
+    const previous = readTurnEndStatus(cwd, platform) ?? { ran: 0, skipped: 0 };
+    const next = outcome.ran ? { ...previous, ran: previous.ran + 1, lastRunAt: now } : {
+      ...previous,
+      skipped: previous.skipped + 1,
+      lastSkipReason: outcome.reason,
+      lastSkipAt: now
+    };
+    writeFileAtomic(turnEndStatusPathForCwd(cwd, platform), `${JSON.stringify(next)}
+`);
+  } catch {}
+}
+export function requestWarmAnalyze(cwd, file, timeoutMs = 30000) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (value) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const socket = net.createConnection(ipcPathForCwd(cwd));
+    socket.setEncoding("utf8");
+    const timer = setTimeout(() => {
+      socket.destroy();
+      finish(undefined);
+    }, timeoutMs);
+    timer.unref();
+    socket.on("connect", () => {
+      const request = { file, cwd };
+      socket.write(`${JSON.stringify(request)}
+`);
+    });
+    socket.on("data", createWarmIpcLineReader((line) => {
+      try {
+        const message = JSON.parse(line);
+        finish(message.error ? undefined : message.result);
+      } catch {
+        finish(undefined);
+      }
+      socket.end();
+    }, {
+      label: "warm-analyze-reply",
+      onOverflow: () => {
+        socket.destroy();
+        finish(undefined);
+      }
+    }));
+    socket.on("error", () => finish(undefined));
+    socket.on("close", () => finish(undefined));
+  });
+}
+export const MAX_FRAMED_LINE_BYTES = DEFAULT_MAX_OUTPUT_BYTES;
+export function createWarmIpcLineReader(onLine, options) {
+  let buffer = "";
+  let bufferedBytes = 0;
+  let dispatched = false;
+  let resyncing = false;
+  const overflow = (frameBytes, awaitingNewline) => {
+    buffer = "";
+    bufferedBytes = 0;
+    resyncing = awaitingNewline;
+    if (options.continuous !== true)
+      dispatched = true;
+    incrementDegradationCount({
+      kind: "ipc-frame-overflow",
+      subject: options.label,
+      reason: `discarded ${awaitingNewline ? "an unterminated" : "a complete"} line at ${frameBytes} bytes (limit ${MAX_FRAMED_LINE_BYTES})`,
+      metadata: {
+        limitBytes: MAX_FRAMED_LINE_BYTES,
+        overflowBytes: frameBytes,
+        terminated: !awaitingNewline
+      }
+    });
+    options.onOverflow?.();
+  };
+  return (chunk) => {
+    if (dispatched)
+      return;
+    let from = 0;
+    if (resyncing) {
+      const end = chunk.indexOf(`
+`);
+      if (end === -1)
+        return;
+      resyncing = false;
+      from = end + 1;
+    }
+    let newline = chunk.indexOf(`
+`, from);
+    while (newline !== -1) {
+      const segment = chunk.slice(from, newline);
+      from = newline + 1;
+      const frameBytes = bufferedBytes + Buffer.byteLength(segment);
+      if (frameBytes > MAX_FRAMED_LINE_BYTES) {
+        overflow(frameBytes, false);
+        if (dispatched)
+          return;
+        newline = chunk.indexOf(`
+`, from);
+        continue;
+      }
+      const line = buffer + segment;
+      buffer = "";
+      bufferedBytes = 0;
+      if (options.continuous !== true) {
+        dispatched = true;
+        onLine(line);
+        return;
+      }
+      onLine(line);
+      newline = chunk.indexOf(`
+`, from);
+    }
+    if (from < chunk.length) {
+      const rest = chunk.slice(from);
+      buffer += rest;
+      bufferedBytes += Buffer.byteLength(rest);
+    }
+    if (bufferedBytes <= MAX_FRAMED_LINE_BYTES)
+      return;
+    overflow(bufferedBytes, true);
+  };
+}
+export function createWarmIpcRequestQueue() {
+  let chain = Promise.resolve();
+  return {
+    enqueue(work) {
+      const next = chain.then(work);
+      chain = next.catch(() => {
+        return;
+      });
+      return next;
+    }
+  };
+}

package/extensions/dm-lens/dist/clients/mcp/review.js

@@ -0,0 +1,137 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { pmBinary, resolveNodePackageManager, runScriptArgs } from "../package-manager.js";
+import { incrementDegradationCount } from "../degradation-ledger.js";
+import { safeSpawnAsync } from "../safe-spawn.js";
+import { createBoundedOutputSink, DEFAULT_MAX_OUTPUT_BYTES } from "../spawn-output-cap.js";
+export function resolveRebuildScript(serverFilePath) {
+  return serverFilePath.replace(/\\/g, "/").includes("/dist/") ? "build:dist" : "build";
+}
+export function analyzeFileFresh(workerPath, file, cwd, options = {}, timeoutMs = 120000) {
+  return new Promise((resolve) => {
+    const args = [workerPath, `--file=${file}`, `--cwd=${cwd}`];
+    if (options.flags)
+      args.push(`--flags=${JSON.stringify(options.flags)}`);
+    let child;
+    try {
+      child = spawn(process.execPath, args, {
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+    } catch (err) {
+      resolve({
+        error: `failed to fork worker: ${err instanceof Error ? err.message : String(err)}`
+      });
+      return;
+    }
+    const stdout = createBoundedOutputSink();
+    const stderr = createBoundedOutputSink();
+    let settled = false;
+    const finish = (outcome) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(outcome);
+    };
+    const timer = setTimeout(() => {
+      child.kill();
+      finish({ error: `fresh analyze timed out after ${timeoutMs}ms` });
+    }, timeoutMs);
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      if (settled)
+        return;
+      stdout.append(chunk);
+      if (!stdout.truncated)
+        return;
+      incrementDegradationCount({
+        kind: "spawn-output-cap-truncated",
+        subject: "mcp-fresh-analyze",
+        reason: `worker stdout reached the ${DEFAULT_MAX_OUTPUT_BYTES}-byte default cap after ${stdout.observedBytes} bytes; worker terminated`,
+        metadata: {
+          capBytes: DEFAULT_MAX_OUTPUT_BYTES,
+          capSource: "default",
+          observedBytes: stdout.observedBytes,
+          killed: true
+        }
+      });
+      try {
+        child.kill();
+      } catch {}
+      finish({
+        error: `worker output exceeded ${DEFAULT_MAX_OUTPUT_BYTES} bytes`
+      });
+    });
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => {
+      if (settled)
+        return;
+      stderr.append(chunk);
+    });
+    child.on("error", (err) => finish({ error: `failed to fork worker: ${err.message}` }));
+    child.on("close", (code) => {
+      if (code !== 0) {
+        finish({
+          error: `worker exited ${code}: ${stderr.text.trim() || "(no stderr)"}`
+        });
+        return;
+      }
+      try {
+        finish({ result: JSON.parse(stdout.text) });
+      } catch {
+        finish({
+          error: `worker produced invalid JSON (${stderr.text.trim() || stdout.text.slice(0, 200)})`
+        });
+      }
+    });
+  });
+}
+export function canRebuildDmLens(repoRoot) {
+  const inNodeModules = /(^|[\\/])node_modules([\\/]|$)/i.test(repoRoot);
+  return !inNodeModules && existsSync(join(repoRoot, "tsconfig.dist.json"));
+}
+export const REBUILD_UNAVAILABLE_MESSAGE = "dmlens_rebuild is unavailable in an installed dm-lens package. Rebuilding is only safe from a source checkout containing tsconfig.dist.json; reinstall or update dm-lens through your package manager instead.";
+export async function runRebuild(repoRoot, script, timeoutMs = 300000) {
+  const start = Date.now();
+  if (!canRebuildDmLens(repoRoot)) {
+    return {
+      ok: false,
+      script,
+      durationMs: Date.now() - start,
+      output: REBUILD_UNAVAILABLE_MESSAGE
+    };
+  }
+  const packageManager = await resolveNodePackageManager(repoRoot);
+  const res = await safeSpawnAsync(pmBinary(packageManager), runScriptArgs(script), {
+    cwd: repoRoot,
+    timeout: timeoutMs,
+    ignoreAmbientSignal: true
+  });
+  const output = `${res.stdout}
+${res.stderr}`.trim();
+  return {
+    ok: !res.error && res.status === 0,
+    script,
+    packageManager,
+    durationMs: Date.now() - start,
+    output: output.slice(-2000)
+  };
+}
+export function summarizeScan(diagnostics) {
+  const seen = new Set;
+  const deduped = [];
+  const byRule = {};
+  const byFile = {};
+  for (const diagnostic of diagnostics) {
+    const ruleId = diagnostic.rule ?? diagnostic.runner ?? diagnostic.tool ?? "unknown";
+    const key = `${diagnostic.filePath}|${diagnostic.line ?? "?"}|${diagnostic.column ?? "?"}|${ruleId}`;
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    deduped.push(diagnostic);
+    byRule[ruleId] = (byRule[ruleId] ?? 0) + 1;
+    byFile[diagnostic.filePath] = (byFile[diagnostic.filePath] ?? 0) + 1;
+  }
+  return { deduped, byRule, byFile };
+}