@duckmind/dm-linux-x64 0.66.0 → 0.66.2

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

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

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

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

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