@duckmind/dm-linux-x64 0.65.5 → 0.65.6

package/extensions/dm-lens/dist/clients/live-bus-emitter.js

@@ -0,0 +1,53 @@
+import { recordDegradation } from "./degradation-ledger.js";
+import { probeCtxActive } from "./session-lifecycle.js";
+import { logBusEvent } from "./bus-events-logger.js";
+const STALE_CTX_MESSAGE = "This extension ctx is stale after session replacement";
+export function recordStaleBusFailure(subject, error) {
+  const reason = String(error);
+  if (!reason.includes(STALE_CTX_MESSAGE))
+    return;
+  recordDegradation({ kind: "bus-stale", subject, reason });
+}
+export function createLiveBusEmitter() {
+  let emit;
+  let getter;
+  return {
+    wire(next) {
+      emit = next;
+      getter = undefined;
+    },
+    wireGetter(next) {
+      getter = next;
+      emit = undefined;
+    },
+    resolve() {
+      const target = getter?.() ?? emit;
+      if (!target)
+        return { outcome: "unwired", ctxSource: "unwired" };
+      if (typeof target === "function") {
+        return { outcome: "ready", emit: target, ctxSource: "global-fallback" };
+      }
+      const ctxSource = "own";
+      if (probeCtxActive(target.ctx) === false) {
+        return { outcome: "stale-session", ctxSource };
+      }
+      return { outcome: "ready", emit: target.emit, ctxSource };
+    },
+    reset() {
+      emit = undefined;
+      getter = undefined;
+    }
+  };
+}
+export function resolveLiveBusEmitter(liveEmitter, entry) {
+  const resolution = liveEmitter.resolve();
+  if (resolution.outcome === "stale-session") {
+    logBusEvent({
+      ...entry(),
+      outcome: "skipped_stale_session",
+      level: "info",
+      ctxSource: resolution.ctxSource
+    });
+  }
+  return resolution;
+}

package/extensions/dm-lens/dist/clients/log-cleanup.js

@@ -0,0 +1,138 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getGlobalDmLensLogDir } from "./probe-home-state.js";
+import { getRegisteredLogFiles } from "./ndjson-logger.js";
+import { pathsEqual } from "./path-utils.js";
+const LOG_DIR = getGlobalDmLensLogDir();
+const LOGS_SUBDIR = path.join(LOG_DIR, "logs");
+export function getManagedLogFiles(dir = LOG_DIR) {
+  const names = new Set;
+  for (const absPath of getRegisteredLogFiles()) {
+    if (pathsEqual(path.dirname(absPath), dir)) {
+      names.add(path.basename(absPath));
+    }
+  }
+  try {
+    if (fs.existsSync(dir)) {
+      for (const entry of fs.readdirSync(dir)) {
+        if (entry.endsWith(".log") && !ROTATED_BACKUP_RE.test(entry)) {
+          names.add(entry);
+        }
+      }
+    }
+  } catch {}
+  return [...names].sort((a, b) => a.localeCompare(b));
+}
+export const ROTATED_BACKUP_RE = /(\.\d{4}-\d{2}-\d{2}T.*\.log|\.log\..+)$/;
+export function getMaxLogSizeMB() {
+  return Math.max(1, Number.parseInt(process.env.DM_LENS_MAX_LOG_SIZE_MB ?? "10", 10) || 10);
+}
+function getConfig() {
+  return {
+    retentionDays: Math.max(1, Number.parseInt(process.env.DM_LENS_LOG_RETENTION_DAYS ?? "7", 10) || 7),
+    maxSizeMB: getMaxLogSizeMB()
+  };
+}
+function getFileAgeDays(filePath) {
+  try {
+    const stats = fs.statSync(filePath);
+    const ageMs = Date.now() - stats.mtime.getTime();
+    return ageMs / (1000 * 60 * 60 * 24);
+  } catch {
+    return 0;
+  }
+}
+function getFileSizeMB(filePath) {
+  try {
+    const stats = fs.statSync(filePath);
+    return stats.size / (1024 * 1024);
+  } catch {
+    return 0;
+  }
+}
+export function cleanupOldLogs(directory, pattern, retentionDays) {
+  const config = getConfig();
+  const maxAge = retentionDays ?? config.retentionDays;
+  const deleted = [];
+  const errors = [];
+  try {
+    if (!fs.existsSync(directory)) {
+      return { deleted, errors };
+    }
+    const files = fs.readdirSync(directory);
+    for (const file of files) {
+      if (!pattern.test(file))
+        continue;
+      const filePath = path.join(directory, file);
+      const ageDays = getFileAgeDays(filePath);
+      if (ageDays > maxAge) {
+        try {
+          fs.unlinkSync(filePath);
+          deleted.push(file);
+        } catch (err) {
+          errors.push(`${file}: ${err}`);
+        }
+      }
+    }
+  } catch (err) {
+    errors.push(`Directory read failed: ${err}`);
+  }
+  return { deleted, errors };
+}
+export function rotateLogIfNeeded(logFile, maxSizeMB) {
+  const config = getConfig();
+  const maxSize = maxSizeMB ?? config.maxSizeMB;
+  const sizeMB = getFileSizeMB(logFile);
+  if (sizeMB < maxSize) {
+    return { rotated: false };
+  }
+  try {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const ext = path.extname(logFile);
+    const base = logFile.slice(0, -ext.length);
+    const backupFile = `${base}.${timestamp}${ext}`;
+    fs.renameSync(logFile, backupFile);
+    fs.writeFileSync(logFile, "", "utf8");
+    return { rotated: true, newFile: backupFile };
+  } catch {
+    return { rotated: false };
+  }
+}
+export function runLogCleanup(dbg) {
+  const config = getConfig();
+  const results = {
+    cleaned: 0,
+    rotated: 0,
+    report: ""
+  };
+  const dailyLogs = cleanupOldLogs(LOGS_SUBDIR, /\.jsonl$/, config.retentionDays);
+  results.cleaned += dailyLogs.deleted.length;
+  const rotatedLogs = cleanupOldLogs(LOG_DIR, ROTATED_BACKUP_RE, config.retentionDays);
+  results.cleaned += rotatedLogs.deleted.length;
+  const mainLogs = getManagedLogFiles().map((name) => path.join(LOG_DIR, name));
+  for (const logFile of mainLogs) {
+    const rotation = rotateLogIfNeeded(logFile, config.maxSizeMB);
+    if (rotation.rotated) {
+      results.rotated++;
+      if (rotation.newFile) {
+        const sizeMB = getFileSizeMB(rotation.newFile);
+        dbg?.(`log_cleanup: rotated ${path.basename(logFile)} (${sizeMB.toFixed(1)}MB) → ${path.basename(rotation.newFile)}`);
+      }
+    }
+  }
+  const parts = [];
+  if (dailyLogs.deleted.length > 0) {
+    parts.push(`${dailyLogs.deleted.length} daily logs`);
+  }
+  if (rotatedLogs.deleted.length > 0) {
+    parts.push(`${rotatedLogs.deleted.length} rotated logs`);
+  }
+  if (results.rotated > 0) {
+    parts.push(`${results.rotated} active logs rotated`);
+  }
+  results.report = parts.length > 0 ? `log_cleanup: removed ${parts.join(", ")} (retention: ${config.retentionDays}d, maxSize: ${config.maxSizeMB}MB)` : `log_cleanup: no cleanup needed (retention: ${config.retentionDays}d, maxSize: ${config.maxSizeMB}MB)`;
+  if (dailyLogs.errors.length > 0 || rotatedLogs.errors.length > 0) {
+    dbg?.(`log_cleanup errors: ${[...dailyLogs.errors, ...rotatedLogs.errors].join("; ")}`);
+  }
+  return results;
+}

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

@@ -0,0 +1,88 @@
+export async function raceToCompletion(promises, shouldComplete, options = { timeoutMs: 1500 }) {
+  const results = [];
+  results.length = promises.length;
+  results.fill(undefined);
+  let graceTimer;
+  let auxGraceTimer;
+  let completed = false;
+  let remaining = promises.length;
+  const descriptors = options.descriptors ?? [];
+  const hasAuxiliaries = descriptors.some((d) => d.role === "auxiliary");
+  const auxIndices = hasAuxiliaries ? new Set(descriptors.map((d, i) => d.role === "auxiliary" ? i : -1).filter((i) => i >= 0)) : new Set;
+  const primaryCount = promises.length - auxIndices.size;
+  let primaryRemaining = primaryCount;
+  let auxGraceStarted = false;
+  return new Promise((resolve) => {
+    const timeout = setTimeout(() => {
+      completed = true;
+      if (graceTimer)
+        clearTimeout(graceTimer);
+      if (auxGraceTimer)
+        clearTimeout(auxGraceTimer);
+      resolve(results.filter((r) => r !== undefined));
+    }, options.timeoutMs);
+    const finalize = () => {
+      if (completed)
+        return;
+      completed = true;
+      clearTimeout(timeout);
+      if (graceTimer)
+        clearTimeout(graceTimer);
+      if (auxGraceTimer)
+        clearTimeout(auxGraceTimer);
+      resolve(results.filter((r) => r !== undefined));
+    };
+    const startAuxGrace = () => {
+      if (auxGraceStarted || completed)
+        return;
+      auxGraceStarted = true;
+      const ceilingMs = options.auxGraceMs ?? 500;
+      const pendingAuxBudgets = [...auxIndices].filter((i) => results[i] === undefined).map((i) => descriptors[i]?.budgetMs).filter((b) => typeof b === "number" && b >= 0);
+      const graceMs = pendingAuxBudgets.length > 0 ? Math.min(ceilingMs, Math.max(...pendingAuxBudgets)) : ceilingMs;
+      if (graceMs <= 0) {
+        finalize();
+        return;
+      }
+      auxGraceTimer = setTimeout(() => finalize(), graceMs);
+    };
+    const check = () => {
+      if (completed)
+        return;
+      if (remaining === 0) {
+        finalize();
+        return;
+      }
+      if (hasAuxiliaries && primaryRemaining === 0 && !auxGraceStarted) {
+        startAuxGrace();
+      }
+      const collected = results.filter((r) => r !== undefined);
+      if (shouldComplete(collected)) {
+        if (options.graceMs !== undefined && options.graceMs > 0 && !graceTimer) {
+          graceTimer = setTimeout(() => finalize(), options.graceMs);
+        } else if (auxGraceStarted) {} else if (!hasAuxiliaries || primaryRemaining === 0) {
+          finalize();
+        }
+      }
+    };
+    for (let i = 0;i < promises.length; i++) {
+      const index = i;
+      const isAux = auxIndices.has(index);
+      promises[i].then((result) => {
+        if (!completed) {
+          results[index] = result;
+          remaining--;
+          if (!isAux)
+            primaryRemaining--;
+          check();
+        }
+      }).catch(() => {
+        if (!completed) {
+          remaining--;
+          if (!isAux)
+            primaryRemaining--;
+          check();
+        }
+      });
+    }
+  });
+}

package/extensions/dm-lens/dist/clients/lsp/cascade-tier.js

@@ -0,0 +1,203 @@
+import { logCascade } from "../cascade-logger.js";
+import { incrementDegradationCount } from "../degradation-ledger.js";
+import { logLatency } from "../latency-logger.js";
+import { normalizeMapKey } from "../path-utils.js";
+import { registerQuietWindowTask } from "../quiet-window.js";
+import { classifyCascadeWaitTier as classifySharedCascadeWaitTier, classifyServerWaitTier, resolvePrimaryServerForWaitPolicy } from "./wait-policy/classification.js";
+
+export { classifyServerWaitTier };
+export { classifyObservedRunner, observeRunnerLatency, resetObservedRunnerLatency } from "../dispatch/collect-later-tier.js";
+export function classifyCascadeWaitTier(lspService, filePath, snapshots) {
+  const primary = resolvePrimaryServerForWaitPolicy(filePath, snapshots);
+  if (primary?.serverId === "typescript" && primary.snapshot?.launchVariant === "native-ts7" && primary.snapshot.workspaceDiagnosticsSupport?.mode === "push-only") {
+    return "collect-later";
+  }
+  return classifySharedCascadeWaitTier(lspService, filePath, snapshots);
+}
+let _enabledCache;
+export function isTierAwareCascadeEnabled() {
+  if (_enabledCache !== undefined)
+    return _enabledCache;
+  _enabledCache = process.env.DM_LENS_TIER_AWARE_CASCADE !== "0";
+  return _enabledCache;
+}
+export function _resetTierAwareCascadeEnabledForTests() {
+  _enabledCache = undefined;
+}
+const MAX_OUTSTANDING_TOUCHES = 256;
+const OUTSTANDING_TOUCH_MAX_AGE_MS = 15 * 60000;
+const _outstandingTouches = new Map;
+let _expiredSinceLastSweep = 0;
+let _evictedSinceLastSweep = 0;
+function pruneExpiredOutstandingTouches(now) {
+  for (const [key, touch] of _outstandingTouches) {
+    if (now - touch.touchedAt <= OUTSTANDING_TOUCH_MAX_AGE_MS)
+      break;
+    _outstandingTouches.delete(key);
+    _expiredSinceLastSweep++;
+  }
+}
+export function recordOutstandingCascadeTouch(entry) {
+  const key = normalizeMapKey(entry.filePath);
+  _outstandingTouches.delete(key);
+  pruneExpiredOutstandingTouches(Date.now());
+  _outstandingTouches.set(key, entry);
+  while (_outstandingTouches.size > MAX_OUTSTANDING_TOUCHES) {
+    const oldest = _outstandingTouches.keys().next();
+    if (oldest.done)
+      break;
+    _outstandingTouches.delete(oldest.value);
+    _evictedSinceLastSweep++;
+    incrementDegradationCount({
+      kind: "cascade-tier3-backlog-evicted",
+      subject: `cap=${MAX_OUTSTANDING_TOUCHES}`,
+      reason: "tier-3 outstanding-touch registry hit its cap before a quiet-window reconcile drained it; the oldest touch was dropped unanswered"
+    });
+  }
+}
+export function resetCascadeTierSessionState() {
+  _outstandingTouches.clear();
+  _expiredSinceLastSweep = 0;
+  _evictedSinceLastSweep = 0;
+}
+export function _resetOutstandingCascadeTouchesForTests() {
+  resetCascadeTierSessionState();
+}
+export function _getOutstandingCascadeTouchesForTests() {
+  return [..._outstandingTouches.values()];
+}
+export function _getCascadeTierSweepCountersForTests() {
+  return { expired: _expiredSinceLastSweep, evicted: _evictedSinceLastSweep };
+}
+export async function reconcileOutstandingCascadeTouches(lspService) {
+  const outcomes = [];
+  pruneExpiredOutstandingTouches(Date.now());
+  const entries = [..._outstandingTouches.entries()];
+  _outstandingTouches.clear();
+  for (const [key, touch] of entries) {
+    const ageMs = Date.now() - touch.touchedAt;
+    try {
+      const spawned = await lspService.getWarmClientForFile(touch.filePath);
+      if (!spawned || spawned.client.serverId !== touch.serverId) {
+        outcomes.push({
+          filePath: touch.filePath,
+          serverId: touch.serverId,
+          outcome: "unresolved",
+          unresolvedReason: spawned ? "server-mismatch" : "warm-miss",
+          ageMs
+        });
+        continue;
+      }
+      const entry = spawned.client.getAllDiagnostics().get(normalizeMapKey(touch.filePath));
+      if (!entry || entry.ts <= touch.touchedAt) {
+        outcomes.push({
+          filePath: touch.filePath,
+          serverId: touch.serverId,
+          outcome: "unresolved",
+          unresolvedReason: entry ? "no-publish-since-touch" : "no-publish",
+          ageMs
+        });
+        continue;
+      }
+      const found = entry.diags.length > 0;
+      outcomes.push({
+        filePath: touch.filePath,
+        serverId: touch.serverId,
+        outcome: found ? "resolved-found" : "resolved-clean",
+        ageMs,
+        diagnosticCount: entry.diags.length,
+        publishedAt: entry.ts,
+        ...found && { diagnostics: entry.diags }
+      });
+    } catch (err) {
+      outcomes.push({
+        filePath: touch.filePath,
+        serverId: touch.serverId,
+        outcome: "unresolved",
+        unresolvedReason: "error",
+        ageMs
+      });
+      logLatency({
+        type: "phase",
+        phase: "cascade_tier3_reconcile_error",
+        filePath: key,
+        durationMs: 0,
+        metadata: { error: String(err) }
+      });
+    }
+  }
+  return outcomes;
+}
+let _reconcileTaskRegistered = false;
+export function registerCascadeTierReconcileTask(getLspService, options = {}) {
+  if (_reconcileTaskRegistered)
+    return;
+  _reconcileTaskRegistered = true;
+  registerQuietWindowTask("cascade_tier3_reconcile", async () => {
+    if (!isTierAwareCascadeEnabled())
+      return;
+    const outcomes = await reconcileOutstandingCascadeTouches(getLspService());
+    for (const o of outcomes) {
+      try {
+        if (o.outcome === "resolved-found" && o.diagnostics?.length) {
+          options.onResolvedFound?.({
+            filePath: o.filePath,
+            serverId: o.serverId,
+            diagnostics: o.diagnostics,
+            ...o.publishedAt !== undefined ? { publishedAt: o.publishedAt } : {}
+          });
+        } else if (o.outcome === "resolved-clean" && o.publishedAt != null) {
+          options.onResolvedClean?.({
+            filePath: o.filePath,
+            serverId: o.serverId,
+            publishedAt: o.publishedAt
+          });
+        }
+      } catch {}
+    }
+    let resolvedFound = 0;
+    let resolvedClean = 0;
+    let unresolved = 0;
+    let ageSumMs = 0;
+    let maxAgeMs = 0;
+    const unresolvedByReason = {};
+    for (const o of outcomes) {
+      if (o.outcome === "resolved-found")
+        resolvedFound++;
+      else if (o.outcome === "resolved-clean")
+        resolvedClean++;
+      else {
+        unresolved++;
+        const reason = o.unresolvedReason ?? "no-publish";
+        unresolvedByReason[reason] = (unresolvedByReason[reason] ?? 0) + 1;
+      }
+      ageSumMs += o.ageMs;
+      if (o.ageMs > maxAgeMs)
+        maxAgeMs = o.ageMs;
+    }
+    const avgAgeMs = outcomes.length ? Math.round(ageSumMs / outcomes.length) : 0;
+    logCascade({
+      phase: "cascade_tier3_reconcile",
+      filePath: "<quiet-window>",
+      metadata: {
+        count: outcomes.length,
+        resolvedFound,
+        resolvedClean,
+        unresolved,
+        unresolvedByReason,
+        avgAgeMs,
+        maxAgeMs,
+        expired: _expiredSinceLastSweep,
+        evicted: _evictedSinceLastSweep,
+        capacity: MAX_OUTSTANDING_TOUCHES,
+        maxAgeCapMs: OUTSTANDING_TOUCH_MAX_AGE_MS,
+        outcomes
+      }
+    });
+    _expiredSinceLastSweep = 0;
+    _evictedSinceLastSweep = 0;
+  });
+}
+export function _resetCascadeTierReconcileRegistrationForTests() {
+  _reconcileTaskRegistered = false;
+}