@duckmind/dm-darwin-x64 0.66.4 → 0.66.6

package/extensions/dm-lens/dist/clients/bootstrap.js

@@ -0,0 +1,246 @@
+import { logExtension } from "./extension-log.js";
+import { bounded } from "./deadline-utils.js";
+import { logLatency } from "./latency-logger.js";
+import { emitBounded } from "./bounded-telemetry.js";
+import { recordDegradationOnce } from "./degradation-ledger.js";
+import { createSingleFlight } from "./single-flight.js";
+import { agentBehaviorClient } from "./agent-behavior-client.js";
+let residentClients = null;
+export function getAgentBehaviorClient() {
+  return agentBehaviorClient;
+}
+let bootstrapShutdown = false;
+let bootstrapShutdownController = new AbortController;
+let bootstrapFailureStrikes = 0;
+let bootstrapLoadAttempts = 0;
+const BOOTSTRAP_FLIGHT_KEY = "analyzer-bootstrap";
+const bootstrapFlight = createSingleFlight();
+const BOOTSTRAP_LOAD_TIMEOUT_MS = 1e4;
+const BOOTSTRAP_FAILURE_STRIKE_LIMIT = 3;
+export function degradedClient() {
+  return new Proxy({}, {
+    get(_target, prop) {
+      if (typeof prop === "symbol" || prop === "then")
+        return;
+      return () => {
+        return;
+      };
+    }
+  });
+}
+async function logBootstrapFailures(failures) {
+  for (const { name, err } of failures) {
+    logExtension({
+      subsystem: "bootstrap",
+      message: `analyzer "${name}" disabled (degraded mode): ${err?.message ?? String(err)}`,
+      metadata: { analyzer: name }
+    });
+  }
+  try {
+    const { collectInstallDiagnostics, formatInstallDiagnostics } = await import("./install-diagnostics.js");
+    logExtension({
+      subsystem: "bootstrap",
+      message: formatInstallDiagnostics(collectInstallDiagnostics(), failures[0]?.err),
+      metadata: { kind: "install_diagnostics" }
+    });
+  } catch {}
+}
+async function buildBootstrapClients() {
+  const failures = [];
+  async function load(name, make) {
+    try {
+      return await make();
+    } catch (err) {
+      failures.push({ name, err });
+      return degradedClient();
+    }
+  }
+  async function loadList(name, make) {
+    try {
+      return await make();
+    } catch (err) {
+      failures.push({ name, err });
+      return [];
+    }
+  }
+  const [ruffClient, biomeClient, knipClient, todoScanner, jscpdClient, depChecker, testRunnerClient, metricsClient, complexityClient, goClient, govulncheckClient, gitleaksClient, trivyClient, opengrepClient, rustClient, agentBehaviorClient, deadCodeClients] = await Promise.all([
+    load("ruff", async () => new (await import("./ruff-client.js")).RuffClient),
+    load("biome", async () => new (await import("./biome-client.js")).BiomeClient),
+    load("knip", async () => new (await import("./knip-client.js")).KnipClient),
+    load("todo", async () => new (await import("./todo-scanner.js")).TodoScanner),
+    load("jscpd", async () => new (await import("./jscpd-client.js")).JscpdClient),
+    load("dependency-checker", async () => new (await import("./dependency-checker.js")).DependencyChecker),
+    load("test-runner", async () => new (await import("./test-runner-client.js")).TestRunnerClient),
+    load("metrics", async () => new (await import("./metrics-client.js")).MetricsClient),
+    load("complexity", async () => new (await import("./complexity-client.js")).ComplexityClient),
+    load("go", async () => (await import("./go-client.js")).goClient),
+    load("govulncheck", async () => new (await import("./govulncheck-client.js")).GovulncheckClient),
+    load("gitleaks", async () => new (await import("./gitleaks-client.js")).GitleaksClient),
+    load("trivy", async () => new (await import("./trivy-client.js")).TrivyClient),
+    load("opengrep", async () => new (await import("./opengrep-client.js")).OpengrepClient),
+    load("rust", async () => (await import("./rust-client.js")).rustClient),
+    load("agent-behavior", async () => (await import("./agent-behavior-client.js")).agentBehaviorClient),
+    loadList("dead-code", async () => (await import("./dead-code-client.js")).getDeadCodeClients())
+  ]);
+  if (failures.length > 0)
+    await logBootstrapFailures(failures);
+  return {
+    ruffClient,
+    biomeClient,
+    knipClient,
+    todoScanner,
+    jscpdClient,
+    depChecker,
+    testRunnerClient,
+    metricsClient,
+    complexityClient,
+    goClient,
+    govulncheckClient,
+    gitleaksClient,
+    trivyClient,
+    opengrepClient,
+    rustClient,
+    agentBehaviorClient,
+    deadCodeClients
+  };
+}
+const BOOTSTRAP_UNAVAILABLE_REASONS = [
+  "shutdown",
+  "timeout",
+  "aborted",
+  "failed",
+  "latched"
+];
+
+class BootstrapUnavailableError extends Error {
+  unavailableReason;
+  constructor(unavailableReason, message) {
+    super(message);
+    this.name = "BootstrapUnavailableError";
+    this.unavailableReason = unavailableReason;
+  }
+}
+export function peekBootstrapClients() {
+  return residentClients;
+}
+export function residentBootstrapAccess(clients) {
+  return {
+    peek: () => clients,
+    request: async () => clients
+  };
+}
+export function loadBootstrapClients() {
+  if (residentClients)
+    return Promise.resolve(residentClients);
+  if (bootstrapShutdown && !bootstrapFlight.has(BOOTSTRAP_FLIGHT_KEY)) {
+    return Promise.reject(new BootstrapUnavailableError("shutdown", "analyzer bootstrap declined: primary session is shutting down"));
+  }
+  if (bootstrapFailureStrikes >= BOOTSTRAP_FAILURE_STRIKE_LIMIT) {
+    return Promise.reject(new BootstrapUnavailableError("latched", `analyzer bootstrap declined: ${bootstrapFailureStrikes} consecutive load failures`));
+  }
+  return bootstrapFlight.run(BOOTSTRAP_FLIGHT_KEY, async () => {
+    const attempt = bootstrapLoadAttempts += 1;
+    const startedAt = Date.now();
+    let clients;
+    try {
+      clients = await buildBootstrapClients();
+    } catch (err) {
+      noteBootstrapBuildFailure(err);
+      throw err;
+    }
+    bootstrapFailureStrikes = 0;
+    residentClients = clients;
+    logLatency({
+      type: "phase",
+      phase: "bootstrap_clients_load",
+      filePath: process.cwd(),
+      startedAt: new Date(startedAt).toISOString(),
+      durationMs: Date.now() - startedAt,
+      metadata: { attempt }
+    });
+    return clients;
+  });
+}
+function noteBootstrapBuildFailure(err) {
+  bootstrapFailureStrikes += 1;
+  if (bootstrapFailureStrikes !== BOOTSTRAP_FAILURE_STRIKE_LIMIT)
+    return;
+  recordDegradationOnce({
+    kind: "analyzer-bootstrap-latched",
+    subject: BOOTSTRAP_FLIGHT_KEY,
+    reason: `${BOOTSTRAP_FAILURE_STRIKE_LIMIT} consecutive load failures; no further builds this session: ${err?.message ?? String(err)}`
+  });
+}
+export async function requestBootstrapClients(options) {
+  if (residentClients)
+    return residentClients;
+  const shutdownSignal = bootstrapShutdownController.signal;
+  const timeoutMs = options.timeoutMs ?? BOOTSTRAP_LOAD_TIMEOUT_MS;
+  try {
+    const clients = await bounded(loadBootstrapClients(), {
+      ms: timeoutMs,
+      signal: options.signal,
+      shutdownSignal,
+      hook: options.hook,
+      label: `loadBootstrapClients:${options.reason}`
+    });
+    if (clients)
+      return clients;
+    throw abandonedError(options.signal, shutdownSignal, timeoutMs);
+  } catch (err) {
+    const unavailableReason = err instanceof BootstrapUnavailableError ? err.unavailableReason : "failed";
+    if (unavailableReason !== "aborted") {
+      emitBounded("bootstrap_clients_unavailable", options.reason, {
+        durationMs: 0,
+        metadata: {
+          unavailableReason,
+          attempt: bootstrapLoadAttempts,
+          detail: err?.message ?? String(err)
+        }
+      }, {
+        ledgerKind: "analyzer-bootstrap-unavailable",
+        risingEdgePer: "identity",
+        reason: unavailableReason
+      });
+    }
+    return null;
+  }
+}
+function abandonedError(signal, shutdownSignal, timeoutMs) {
+  if (signal?.aborted) {
+    return new BootstrapUnavailableError("aborted", "analyzer bootstrap wait abandoned: caller aborted");
+  }
+  if (shutdownSignal.aborted) {
+    return new BootstrapUnavailableError("shutdown", "analyzer bootstrap wait abandoned: primary session is shutting down");
+  }
+  return new BootstrapUnavailableError("timeout", `analyzer bootstrap wait abandoned after ${timeoutMs}ms`);
+}
+export function markAnalyzerBootstrapShutdown() {
+  bootstrapShutdown = true;
+  bootstrapShutdownController.abort();
+}
+export function resetAnalyzerBootstrapSessionState() {
+  bootstrapShutdown = false;
+  bootstrapShutdownController = new AbortController;
+  bootstrapFailureStrikes = 0;
+}
+export function isAnalyzerBootstrapShutdown() {
+  return bootstrapShutdown;
+}
+export function _analyzerBootstrapFailureStrikes() {
+  return bootstrapFailureStrikes;
+}
+export function _armAnalyzerBootstrapLatchForTests() {
+  bootstrapFailureStrikes = BOOTSTRAP_FAILURE_STRIKE_LIMIT;
+}
+export function _resetAnalyzerBootstrapForTests() {
+  residentClients = null;
+  bootstrapShutdown = false;
+  bootstrapShutdownController = new AbortController;
+  bootstrapFailureStrikes = 0;
+  bootstrapLoadAttempts = 0;
+  bootstrapFlight.clear();
+}
+export function _analyzerBootstrapLoadAttempts() {
+  return bootstrapLoadAttempts;
+}

package/extensions/dm-lens/dist/clients/bounded-cache.js

@@ -0,0 +1,105 @@
+export class BoundedFifoMap {
+  entries = new Map;
+  maxEntries;
+  constructor(maxEntries) {
+    this.maxEntries = maxEntries;
+  }
+  get(key) {
+    return this.entries.get(key);
+  }
+  has(key) {
+    return this.entries.has(key);
+  }
+  set(key, value) {
+    this.entries.set(key, value);
+    return this.evictOverflow();
+  }
+  setMaxEntries(maxEntries) {
+    this.maxEntries = maxEntries;
+    return this.evictOverflow();
+  }
+  getMaxEntries() {
+    return this.maxEntries;
+  }
+  evictOverflow() {
+    const evicted = [];
+    while (this.entries.size > this.maxEntries) {
+      const oldest = this.entries.entries().next().value;
+      if (oldest === undefined)
+        break;
+      this.entries.delete(oldest[0]);
+      evicted.push(oldest);
+    }
+    return evicted;
+  }
+  delete(key) {
+    return this.entries.delete(key);
+  }
+  clear() {
+    this.entries.clear();
+  }
+  get size() {
+    return this.entries.size;
+  }
+  keys() {
+    return this.entries.keys();
+  }
+  values() {
+    return this.entries.values();
+  }
+  entriesArray() {
+    return [...this.entries.entries()];
+  }
+  [Symbol.iterator]() {
+    return this.entries[Symbol.iterator]();
+  }
+}
+
+export class BoundedSet {
+  entries;
+  constructor(maxEntries) {
+    this.entries = new BoundedFifoMap(maxEntries);
+  }
+  has(value) {
+    return this.entries.has(value);
+  }
+  add(value) {
+    return this.entries.set(value, true).map(([evicted]) => evicted);
+  }
+  setMaxEntries(maxEntries) {
+    return this.entries.setMaxEntries(maxEntries).map(([evicted]) => evicted);
+  }
+  getMaxEntries() {
+    return this.entries.getMaxEntries();
+  }
+  delete(value) {
+    return this.entries.delete(value);
+  }
+  clear() {
+    this.entries.clear();
+  }
+  get size() {
+    return this.entries.size;
+  }
+  values() {
+    return this.entries.keys();
+  }
+  [Symbol.iterator]() {
+    return this.entries.keys();
+  }
+}
+
+export class BoundedLruCache extends BoundedFifoMap {
+  get(key) {
+    const value = this.entries.get(key);
+    if (value !== undefined) {
+      this.entries.delete(key);
+      this.entries.set(key, value);
+    }
+    return value;
+  }
+  set(key, value) {
+    this.entries.delete(key);
+    return super.set(key, value);
+  }
+}

package/extensions/dm-lens/dist/clients/bounded-pid-file-lock.js

@@ -0,0 +1,275 @@
+import { randomUUID } from "node:crypto";
+import * as fs from "node:fs";
+import fsp from "node:fs/promises";
+import path from "node:path";
+import { BoundedFifoMap } from "./bounded-cache.js";
+import { recordDegradationOnce } from "./degradation-ledger.js";
+import { heartbeatIntervalMs, isLockContention, recordGenerationTakeover, recordLegacyLockHeld, releaseGeneration, startGenerationHeartbeat, topGenerationHolder, tryAcquireGeneration } from "./generation-lock.js";
+const waitArray = new Int32Array(new SharedArrayBuffer(4));
+const UNREADABLE_LOCK_STALE_MS = 5000;
+function generationDir(lockPath) {
+  return `${lockPath}s`;
+}
+function boundedLockIsStale(lockPath) {
+  const [pidText] = fs.readFileSync(lockPath, "utf8").split(":", 1);
+  const pid = Number.parseInt(pidText ?? "", 10);
+  if (Number.isSafeInteger(pid) && pid > 0)
+    return !ownerPidIsLive(pid);
+  return Date.now() - fs.statSync(lockPath).mtimeMs > UNREADABLE_LOCK_STALE_MS;
+}
+function ownerPidIsLive(pid) {
+  if (!Number.isSafeInteger(pid) || pid <= 0)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function quarantinePath(lockPath, token) {
+  return `${lockPath}.quarantine-${process.pid}-${token}`;
+}
+async function restoreQuarantinedLock(lockPath, quarantined) {
+  try {
+    await fsp.rename(quarantined, lockPath);
+  } catch {}
+}
+async function releaseQuarantineLock(lockPath, token) {
+  const quarantined = quarantinePath(lockPath, `release-${token}`);
+  let renamed = false;
+  for (let attempt = 0;attempt < 3; attempt += 1) {
+    try {
+      await fsp.rename(lockPath, quarantined);
+      renamed = true;
+      break;
+    } catch (error) {
+      if (error.code !== "ENOENT" || attempt === 2)
+        return;
+      await new Promise((resolve) => setImmediate(resolve));
+    }
+  }
+  if (!renamed)
+    return;
+  try {
+    const owner = JSON.parse(await fsp.readFile(path.join(quarantined, "owner.json"), "utf8"));
+    if (owner.token === token) {
+      await fsp.rm(quarantined, { recursive: true, force: true });
+    } else {
+      await restoreQuarantinedLock(lockPath, quarantined);
+    }
+  } catch {
+    await restoreQuarantinedLock(lockPath, quarantined);
+  }
+}
+function quarantineOwnerIsStale(owner, staleMs) {
+  const pidUsable = Number.isInteger(owner.pid) && owner.pid > 0;
+  if (pidUsable && !ownerPidIsLive(owner.pid))
+    return true;
+  return Number.isFinite(owner.createdAt) && Date.now() - owner.createdAt > staleMs;
+}
+async function reclaimQuarantineLock(lockPath, staleMs) {
+  const quarantined = quarantinePath(lockPath, `reclaim-${Date.now()}-${randomUUID()}`);
+  try {
+    await fsp.rename(lockPath, quarantined);
+  } catch {
+    return false;
+  }
+  let stale = false;
+  try {
+    const owner = JSON.parse(await fsp.readFile(path.join(quarantined, "owner.json"), "utf8"));
+    stale = quarantineOwnerIsStale(owner, staleMs);
+  } catch {
+    try {
+      stale = Date.now() - (await fsp.stat(quarantined)).mtimeMs > staleMs;
+    } catch {
+      stale = false;
+    }
+  }
+  if (stale) {
+    await fsp.rm(quarantined, { recursive: true, force: true });
+    return true;
+  }
+  await restoreQuarantinedLock(lockPath, quarantined);
+  return false;
+}
+async function tryAcquireQuarantineLock(lockPath, staleMs) {
+  const owner = {
+    pid: process.pid,
+    createdAt: Date.now(),
+    token: `${process.pid}-${Date.now()}-${randomUUID()}`
+  };
+  for (let attempt = 0;attempt < 2; attempt += 1) {
+    try {
+      await fsp.mkdir(lockPath);
+      try {
+        await fsp.writeFile(path.join(lockPath, "owner.json"), JSON.stringify(owner), "utf8");
+      } catch (error) {
+        await fsp.rm(lockPath, { recursive: true, force: true }).catch(() => {});
+        throw error;
+      }
+      return () => releaseQuarantineLock(lockPath, owner.token);
+    } catch (error) {
+      if (error.code !== "EEXIST")
+        throw error;
+    }
+    let stale;
+    try {
+      const existing = JSON.parse(await fsp.readFile(path.join(lockPath, "owner.json"), "utf8"));
+      stale = quarantineOwnerIsStale(existing, staleMs);
+    } catch {
+      try {
+        stale = Date.now() - (await fsp.stat(lockPath)).mtimeMs > staleMs;
+      } catch {
+        stale = true;
+      }
+    }
+    if (!stale || !await reclaimQuarantineLock(lockPath, staleMs))
+      return null;
+  }
+  return null;
+}
+async function tryAcquireQuarantineGeneration(lockPath, staleMs) {
+  const hold = tryAcquireGeneration(generationDir(lockPath), staleMs);
+  if (!hold)
+    return "busy";
+  if (hold.tookOverStale)
+    recordGenerationTakeover(hold);
+  let releaseLegacy;
+  try {
+    releaseLegacy = await tryAcquireQuarantineLock(lockPath, staleMs);
+  } catch (cause) {
+    releaseGeneration(hold);
+    throw cause;
+  }
+  if (releaseLegacy) {
+    const heartbeat = startGenerationHeartbeat(hold, heartbeatIntervalMs(staleMs));
+    return async () => {
+      heartbeat.stop();
+      await releaseLegacy();
+      releaseGeneration(hold);
+    };
+  }
+  releaseGeneration(hold);
+  return "legacy-held";
+}
+export async function acquireQuarantinePidFileLock(lockPath, options) {
+  const deadline = Date.now() + options.waitMs;
+  let legacyHeldRecorded = false;
+  for (;; ) {
+    const release = await tryAcquireQuarantineGeneration(lockPath, options.staleMs);
+    if (typeof release === "function")
+      return release;
+    if (release === "legacy-held" && !legacyHeldRecorded) {
+      legacyHeldRecorded = true;
+      recordLegacyLockHeld(lockPath);
+    }
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) {
+      if (options.onContention === "skip-log") {
+        options.logContention();
+        return null;
+      }
+      throw new Error(options.timeoutMessage);
+    }
+    await new Promise((resolve) => setTimeout(resolve, Math.min(options.retryMs, remaining)));
+  }
+}
+function createLegacyBoundedLock(lockPath, token) {
+  try {
+    fs.writeFileSync(lockPath, token, { encoding: "utf8", flag: "wx" });
+    return true;
+  } catch (cause) {
+    if (isLockContention(cause))
+      return false;
+    throw cause;
+  }
+}
+function takeLegacyBoundedLock(lockPath, token) {
+  if (createLegacyBoundedLock(lockPath, token))
+    return true;
+  try {
+    if (!boundedLockIsStale(lockPath))
+      return false;
+    fs.unlinkSync(lockPath);
+  } catch {
+    return false;
+  }
+  return createLegacyBoundedLock(lockPath, token);
+}
+function releaseLegacyBoundedLock(lockPath, token) {
+  try {
+    if (fs.readFileSync(lockPath, "utf8") === token)
+      fs.unlinkSync(lockPath);
+  } catch {}
+}
+function tryAcquireBoundedLock(lockPath, token) {
+  const hold = tryAcquireGeneration(generationDir(lockPath), UNREADABLE_LOCK_STALE_MS);
+  if (!hold)
+    return "busy";
+  if (hold.tookOverStale)
+    recordGenerationTakeover(hold);
+  let took;
+  try {
+    took = takeLegacyBoundedLock(lockPath, token);
+  } catch (cause) {
+    releaseGeneration(hold);
+    throw cause;
+  }
+  if (took)
+    return hold;
+  releaseGeneration(hold);
+  return "legacy-held";
+}
+const timedOutHolders = new BoundedFifoMap(16);
+function currentHolderIdentity(dir, lockPath, hold) {
+  if (hold === "busy")
+    return topGenerationHolder(dir);
+  try {
+    const content = fs.readFileSync(lockPath, "utf8");
+    return content ? `legacy ${content}` : undefined;
+  } catch {
+    return;
+  }
+}
+export function acquireBoundedPidFileLock(lockPath, options) {
+  const token = `${process.pid}:${Date.now()}:${randomUUID()}`;
+  const deadline = Date.now() + options.waitMs;
+  const dir = generationDir(lockPath);
+  const timedOutHolder = timedOutHolders.get(dir);
+  let legacyHeldRecorded = false;
+  for (;; ) {
+    const hold = tryAcquireBoundedLock(lockPath, token);
+    if (typeof hold === "object") {
+      return () => {
+        releaseLegacyBoundedLock(lockPath, token);
+        releaseGeneration(hold);
+      };
+    }
+    if (hold === "legacy-held" && !legacyHeldRecorded) {
+      legacyHeldRecorded = true;
+      recordLegacyLockHeld(lockPath);
+    }
+    if (timedOutHolder !== undefined && currentHolderIdentity(dir, lockPath, hold) === timedOutHolder) {
+      recordDegradationOnce({
+        kind: "bounded-pid-lock-wait-skipped",
+        subject: path.resolve(dir),
+        reason: `did not wait: ${timedOutHolder} still holds the lock after an earlier wait ran out`
+      });
+      if (options.onContention === "skip-log") {
+        options.logContention();
+        return null;
+      }
+      throw new Error(options.timeoutMessage);
+    }
+    if (Date.now() >= deadline) {
+      timedOutHolders.set(dir, currentHolderIdentity(dir, lockPath, hold));
+      if (options.onContention === "skip-log") {
+        options.logContention();
+        return null;
+      }
+      throw new Error(options.timeoutMessage);
+    }
+    Atomics.wait(waitArray, 0, 0, options.retryMs);
+  }
+}