@duckmind/dm-linux-x64 0.66.0 → 0.66.2

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

@@ -1,302 +0,0 @@
-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

@@ -1,137 +0,0 @@
-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 };
-}