@duckmind/dm-linux-x64 0.65.8 → 0.66.2

package/extensions/dm-lens/dist/clients/workspace-topology.js

@@ -1,261 +0,0 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { PROJECT_CONFIG_BASENAMES, isResolvedGlobalConfigPath } from "./config-locations.js";
-import { logLatency } from "./latency-logger.js";
-import { isAtOrAboveHomeDir, nameMatchesMarkerGlob, walkUpDirs } from "./path-utils.js";
-const MAX_WALK_DEPTH = 64;
-const DM_LENS_CONFIG_BASENAMES = PROJECT_CONFIG_BASENAMES;
-const dirMarkerCache = new Map;
-const topologyDerivedCacheResets = [];
-export function registerWorkspaceTopologyReset(reset) {
-  topologyDerivedCacheResets.push(reset);
-}
-const walkCache = new Map;
-const TOPOLOGY_MAX_DIR_ENTRIES = 256;
-const TOPOLOGY_MAX_WALK_ENTRIES = 512;
-const TOPOLOGY_IDLE_EVICT_MS_DEFAULT = 20 * 60000;
-function topologyIdleEvictMs() {
-  const value = Number.parseInt(process.env.DM_LENS_WORKSPACE_TOPOLOGY_IDLE_EVICT_MS ?? "", 10);
-  return Number.isSafeInteger(value) && value > 0 ? value : TOPOLOGY_IDLE_EVICT_MS_DEFAULT;
-}
-function deleteDirMarker(key) {
-  const entry = dirMarkerCache.get(key);
-  if (entry?.idleTimer)
-    clearTimeout(entry.idleTimer);
-  dirMarkerCache.delete(key);
-}
-function deleteWalk(key) {
-  const entry = walkCache.get(key);
-  if (entry?.idleTimer)
-    clearTimeout(entry.idleTimer);
-  walkCache.delete(key);
-}
-function touchDirMarker(key, entry) {
-  entry.lastUsedAt = Date.now();
-  if (entry.idleTimer)
-    clearTimeout(entry.idleTimer);
-  const stamp = entry.lastUsedAt;
-  entry.idleTimer = setTimeout(() => {
-    if (dirMarkerCache.get(key) === entry && entry.lastUsedAt === stamp)
-      deleteDirMarker(key);
-  }, topologyIdleEvictMs());
-  entry.idleTimer.unref?.();
-}
-function touchWalk(key, entry) {
-  entry.lastUsedAt = Date.now();
-  if (entry.idleTimer)
-    clearTimeout(entry.idleTimer);
-  const stamp = entry.lastUsedAt;
-  entry.idleTimer = setTimeout(() => {
-    if (walkCache.get(key) === entry && entry.lastUsedAt === stamp)
-      deleteWalk(key);
-  }, topologyIdleEvictMs());
-  entry.idleTimer.unref?.();
-}
-export function resetWorkspaceTopology() {
-  for (const key of dirMarkerCache.keys())
-    deleteDirMarker(key);
-  for (const key of walkCache.keys())
-    deleteWalk(key);
-  for (const reset of topologyDerivedCacheResets)
-    reset();
-}
-export function releaseWorkspaceTopologyIdleTimers() {
-  for (const entry of dirMarkerCache.values()) {
-    if (entry.idleTimer !== undefined)
-      clearTimeout(entry.idleTimer);
-    entry.idleTimer = undefined;
-  }
-  for (const entry of walkCache.values()) {
-    if (entry.idleTimer !== undefined)
-      clearTimeout(entry.idleTimer);
-    entry.idleTimer = undefined;
-  }
-}
-function safeDirMtimeMs(dir) {
-  try {
-    return fs.statSync(dir).mtimeMs;
-  } catch {
-    return -1;
-  }
-}
-function safeIsFile(filePath) {
-  try {
-    return fs.statSync(filePath).isFile();
-  } catch {
-    return false;
-  }
-}
-export function getDirectoryMarkers(dir) {
-  const resolvedDir = path.resolve(dir);
-  const dirMtimeMs = safeDirMtimeMs(resolvedDir);
-  const cached = dirMarkerCache.get(resolvedDir);
-  if (cached && cached.dirMtimeMs === dirMtimeMs) {
-    touchDirMarker(resolvedDir, cached);
-    return cached.markers;
-  }
-  let entries = [];
-  try {
-    entries = fs.readdirSync(resolvedDir, { withFileTypes: true });
-  } catch {
-    entries = [];
-  }
-  const present = new Set(entries.map((e) => e.name));
-  const fileNames = new Set(entries.filter((entry) => entry.isFile() || entry.isSymbolicLink()).map((entry) => entry.name));
-  const resolveMarker = (basename) => {
-    if (!present.has(basename))
-      return;
-    const candidate = path.join(resolvedDir, basename);
-    return safeIsFile(candidate) ? candidate : undefined;
-  };
-  const piLensConfigPath = resolveMarker(DM_LENS_CONFIG_BASENAMES[0]) ?? resolveMarker(DM_LENS_CONFIG_BASENAMES[1]);
-  const markers = {
-    dir: resolvedDir,
-    dirMtimeMs,
-    entryNames: present,
-    entryFileNames: fileNames,
-    piLensConfigPath,
-    tsconfigPath: resolveMarker("tsconfig.json"),
-    packageJsonPath: resolveMarker("package.json"),
-    pnpmWorkspaceYamlPath: resolveMarker("pnpm-workspace.yaml"),
-    cargoTomlPath: resolveMarker("Cargo.toml"),
-    goWorkPath: resolveMarker("go.work"),
-    chartYamlPath: resolveMarker("Chart.yaml")
-  };
-  const entry = { dirMtimeMs, markers, lastUsedAt: Date.now() };
-  const outgoing = dirMarkerCache.get(resolvedDir);
-  if (outgoing?.idleTimer !== undefined) {
-    clearTimeout(outgoing.idleTimer);
-    outgoing.idleTimer = undefined;
-  }
-  dirMarkerCache.set(resolvedDir, entry);
-  touchDirMarker(resolvedDir, entry);
-  while (dirMarkerCache.size > TOPOLOGY_MAX_DIR_ENTRIES) {
-    const victim = [...dirMarkerCache.entries()].sort(([, a], [, b]) => a.lastUsedAt - b.lastUsedAt)[0];
-    if (!victim)
-      break;
-    deleteDirMarker(victim[0]);
-  }
-  return markers;
-}
-function walkCacheKey(startDir, markerKey) {
-  return `${path.resolve(startDir)}\x00${markerKey}`;
-}
-export function dirMtimesStillFresh(dirMtimes) {
-  return dirMtimes.every(({ dir, mtimeMs }) => safeDirMtimeMs(dir) === mtimeMs);
-}
-export function dirMtimesStillFreshAsync(dirMtimes) {
-  return Promise.all(dirMtimes.map(({ dir }) => dirMtimeMsAsync(dir))).then((current) => dirMtimes.every(({ mtimeMs }, index) => current[index] === mtimeMs));
-}
-function dirMtimeMsAsync(dir) {
-  return fs.promises.stat(dir).then((stats) => stats.mtimeMs, () => -1);
-}
-export function dirMtimeRecordsAsync(dirs) {
-  return Promise.all(dirs.map((dir) => dirMtimeMsAsync(dir).then((mtimeMs) => ({ dir, mtimeMs }))));
-}
-export function unknownDirMtimeRecords(dirs) {
-  return dirs.map((dir) => ({ dir, mtimeMs: Number.NaN }));
-}
-function walkToNearestMatch(startDir, cacheSuffix, matches, capMetadata, homeDir) {
-  const key = walkCacheKey(startDir, cacheSuffix);
-  const cached = walkCache.get(key);
-  if (cached && dirMtimesStillFresh(cached.dirMtimes)) {
-    touchWalk(key, cached);
-    return cached.dir;
-  }
-  const dirMtimes = [];
-  let found;
-  let depth = 0;
-  for (const dir of walkUpDirs(startDir)) {
-    if (isAtOrAboveHomeDir(dir, homeDir))
-      break;
-    if (depth >= MAX_WALK_DEPTH) {
-      logLatency({
-        type: "phase",
-        filePath: startDir,
-        phase: "workspace-topology-walk-cap",
-        durationMs: 0,
-        metadata: { ...capMetadata, depth, homeDir }
-      });
-      break;
-    }
-    const markers = getDirectoryMarkers(dir);
-    dirMtimes.push({ dir, mtimeMs: markers.dirMtimeMs });
-    if (matches(markers)) {
-      found = dir;
-      break;
-    }
-    depth += 1;
-  }
-  const entry = {
-    dir: found,
-    dirMtimes,
-    lastUsedAt: Date.now()
-  };
-  const outgoing = walkCache.get(key);
-  if (outgoing?.idleTimer !== undefined) {
-    clearTimeout(outgoing.idleTimer);
-    outgoing.idleTimer = undefined;
-  }
-  walkCache.set(key, entry);
-  touchWalk(key, entry);
-  while (walkCache.size > TOPOLOGY_MAX_WALK_ENTRIES) {
-    const victim = [...walkCache.entries()].sort(([, a], [, b]) => a.lastUsedAt - b.lastUsedAt)[0];
-    if (!victim)
-      break;
-    deleteWalk(victim[0]);
-  }
-  return found;
-}
-export function findNearestDirWithMarker(startDir, markerKey, homeDir = os.homedir()) {
-  return walkToNearestMatch(startDir, markerKey, (markers) => Boolean(markers[markerKey]), { markerKey }, homeDir);
-}
-function hasBasenameMarker(markers, basename) {
-  if (basename.includes("/") || basename.includes("\\")) {
-    return fs.existsSync(path.join(markers.dir, basename));
-  }
-  if (basename.includes("*")) {
-    return [...markers.entryFileNames].some((entryName) => nameMatchesMarkerGlob(entryName, basename));
-  }
-  return markers.entryNames.has(basename);
-}
-export function findNearestDirWithAnyBasename(startDir, basenames, homeDir = os.homedir()) {
-  if (basenames.length === 0)
-    return;
-  return walkToNearestMatch(startDir, `any:${basenames.join(String.fromCodePoint(1))}`, (markers) => basenames.some((basename) => hasBasenameMarker(markers, basename)), { basenames }, homeDir);
-}
-export function findDmLensConfigMarkerInDir(dir) {
-  const markers = getDirectoryMarkers(dir);
-  if (!markers.piLensConfigPath)
-    return;
-  if (isResolvedGlobalConfigPath(markers.piLensConfigPath))
-    return;
-  const stat = (() => {
-    try {
-      return fs.statSync(markers.piLensConfigPath);
-    } catch {
-      return;
-    }
-  })();
-  if (!stat?.isFile())
-    return;
-  return {
-    path: markers.piLensConfigPath,
-    dir: markers.dir,
-    mtimeMs: stat.mtimeMs,
-    size: stat.size
-  };
-}
-export function findGoverningTsconfigDir(startDir, homeDir = os.homedir()) {
-  return findNearestDirWithMarker(startDir, "tsconfigPath", homeDir);
-}
-export function getWorkspaceManifestMarkers(dir) {
-  const markers = getDirectoryMarkers(dir);
-  return {
-    hasPnpmWorkspaceYaml: markers.pnpmWorkspaceYamlPath !== undefined,
-    hasGoWork: markers.goWorkPath !== undefined,
-    hasCargoToml: markers.cargoTomlPath !== undefined,
-    hasPackageJson: markers.packageJsonPath !== undefined
-  };
-}

package/extensions/dm-lens/dist/clients/write-ordering-guard.js

@@ -1,24 +0,0 @@
-export class WriteOrderingGuard {
-  lastSeen = new Map;
-  shouldWrite(key, token) {
-    if (token === undefined)
-      return true;
-    const last = this.lastSeen.get(key);
-    if (last !== undefined && token < last)
-      return false;
-    this.lastSeen.set(key, token);
-    return true;
-  }
-  nextToken(key) {
-    const last = this.lastSeen.get(key);
-    const next = (last ?? 0) + 1;
-    this.lastSeen.set(key, next);
-    return next;
-  }
-  delete(key) {
-    this.lastSeen.delete(key);
-  }
-  clear() {
-    this.lastSeen.clear();
-  }
-}

package/extensions/dm-lens/dist/clients/zizmor-config.js

@@ -1,160 +0,0 @@
-import * as path from "node:path";
-import { safeSpawnAsync } from "./safe-spawn.js";
-import { findLocalToolConfig } from "./path-utils.js";
-import { incrementDegradationCount } from "./degradation-ledger.js";
-import { classifyProbeFailure, createAvailabilityLatch, logAvailabilityDecision, startHostStallSampler } from "./dispatch/runners/utils/availability-policy.js";
-const LOCAL_ZIZMOR_CONFIG_NAMES = [
-  path.join(".github", "zizmor.yml"),
-  path.join(".github", "zizmor.yaml"),
-  "zizmor.yml",
-  "zizmor.yaml"
-];
-export function findLocalZizmorConfig(startDir) {
-  return findLocalToolConfig(startDir, LOCAL_ZIZMOR_CONFIG_NAMES);
-}
-export function isZizmorAuditTarget(filePath) {
-  const normalized = filePath.replace(/\\/g, "/");
-  const base = path.basename(normalized).toLowerCase();
-  if (/(^|\/)\.github\/workflows\/[^/]+\.ya?ml$/i.test(normalized))
-    return true;
-  if (base === "action.yml" || base === "action.yaml")
-    return true;
-  if (/(^|\/)\.github\/dependabot\.ya?ml$/i.test(normalized))
-    return true;
-  return false;
-}
-const ZIZMOR_TOKEN_MAX_COOLDOWN_MS = 120000;
-const ghTokenLatch = createAvailabilityLatch({
-  maxCooldownMs: ZIZMOR_TOKEN_MAX_COOLDOWN_MS
-});
-let cachedToken;
-const GH_TOKEN_PROBE_TIMEOUT_MS = 5000;
-export function resetZizmorTokenAvailability() {
-  ghTokenLatch.reset();
-  cachedToken = undefined;
-}
-export function _getZizmorTokenLatchForTests() {
-  return ghTokenLatch;
-}
-export function _resetZizmorTokenCacheForTests() {
-  resetZizmorTokenAvailability();
-}
-function classifyGhTokenFailure(res, hostStallMs) {
-  const neverAnswered = res.status === null || (res.status ?? 0) < 0;
-  if (!res.error && !neverAnswered) {
-    return {
-      outcome: "non-installable",
-      cause: "probe-rejected",
-      classifiedBy: "caller"
-    };
-  }
-  if (res.spawnFailure?.kind === "tool-not-found") {
-    return { outcome: "missing", cause: "not-found", classifiedBy: "caller" };
-  }
-  const classified = classifyProbeFailure(res, { hostStallMs });
-  if (classified.outcome === "transient" || classified.outcome === "missing") {
-    return { ...classified, classifiedBy: "probe" };
-  }
-  return {
-    outcome: "transient",
-    cause: classified.cause,
-    classifiedBy: "caller"
-  };
-}
-async function deriveGhCliToken(consumer) {
-  const sampler = startHostStallSampler();
-  const startedAt = Date.now();
-  const res = await safeSpawnAsync("gh", ["auth", "token"], {
-    timeout: GH_TOKEN_PROBE_TIMEOUT_MS,
-    ignoreAmbientSignal: true
-  });
-  const hostStallMs = sampler.stop();
-  const elapsedMs = Date.now() - startedAt;
-  if (!res.error && res.status === 0) {
-    const token = res.stdout.trim();
-    if (token.length > 0) {
-      ghTokenLatch.noteAvailable();
-      logAvailabilityDecision({
-        tool: consumer === "zizmor" ? "zizmor-gh-token" : "github-token",
-        verdict: "available",
-        outcome: "success",
-        cause: "ok",
-        elapsedMs,
-        latched: true,
-        hostStallMs,
-        budgetMs: GH_TOKEN_PROBE_TIMEOUT_MS,
-        classifiedBy: "probe"
-      });
-      return token;
-    }
-    return recordGhTokenUnavailable(consumer, {
-      outcome: "non-installable",
-      cause: "empty-result",
-      classifiedBy: "caller"
-    }, elapsedMs, hostStallMs);
-  }
-  return recordGhTokenUnavailable(consumer, classifyGhTokenFailure(res, hostStallMs), elapsedMs, hostStallMs);
-}
-function recordGhTokenUnavailable(consumer, { outcome, cause, classifiedBy }, elapsedMs, hostStallMs) {
-  const retryAfterMs = ghTokenLatch.noteUnavailable(outcome, cause);
-  if (consumer === "zizmor" && outcome === "transient") {
-    recordZizmorOfflineDegradation(`gh auth token probe ${cause}; running offline until the next zizmor start (retry allowed in ${Math.round(retryAfterMs / 1000)}s)`);
-  }
-  logAvailabilityDecision({
-    tool: consumer === "zizmor" ? "zizmor-gh-token" : "github-token",
-    verdict: "unavailable",
-    outcome,
-    cause,
-    elapsedMs,
-    latched: outcome !== "transient",
-    hostStallMs,
-    ...retryAfterMs > 0 && { retryAfterMs },
-    budgetMs: GH_TOKEN_PROBE_TIMEOUT_MS,
-    classifiedBy
-  });
-  return;
-}
-function recordZizmorOfflineDegradation(reason) {
-  incrementDegradationCount({
-    kind: "mode-suppression",
-    subject: "zizmor",
-    reason
-  });
-}
-export async function resolveZizmorGitHubToken() {
-  if (process.env.ZIZMOR_OFFLINE)
-    return;
-  return resolveGitHubToken(["ZIZMOR_GITHUB_TOKEN", "GH_TOKEN", "GITHUB_TOKEN"], { consumer: "zizmor" });
-}
-export async function resolveGitHubToken(envKeys = ["GITHUB_TOKEN", "GH_TOKEN"], options = {}) {
-  const consumer = options.consumer ?? "github-api";
-  const fromEnv = envKeys.map((key) => process.env[key]).find(Boolean);
-  if (fromEnv)
-    return fromEnv;
-  const memo = ghTokenLatch.read();
-  if (memo !== null) {
-    if (consumer === "zizmor" && memo === false && ghTokenLatch.getOutcome() === "transient") {
-      const cause = ghTokenLatch.getCause();
-      if (cause === null) {
-        throw new Error("zizmor gh-token latch: transient outcome with no cause (invariant violated)");
-      }
-      const retryAfterMs = Math.max(0, ghTokenLatch.getRetryAtMs() - Date.now());
-      recordZizmorOfflineDegradation(`gh auth token still cooling down (${cause}); serving cached offline verdict, retry allowed in ${Math.round(retryAfterMs / 1000)}s`);
-      logAvailabilityDecision({
-        tool: "zizmor-gh-token",
-        verdict: "unavailable",
-        outcome: "transient",
-        cause,
-        elapsedMs: 0,
-        latched: false,
-        hostStallMs: 0,
-        ...retryAfterMs > 0 && { retryAfterMs },
-        budgetMs: GH_TOKEN_PROBE_TIMEOUT_MS,
-        classifiedBy: "caller"
-      });
-    }
-    return memo ? cachedToken : undefined;
-  }
-  cachedToken = await deriveGhCliToken(consumer);
-  return cachedToken;
-}

package/extensions/dm-lens/dist/i18n.js

@@ -1,67 +0,0 @@
-const translations = {
-  es: {
-    "lens.health.title": "\uD83E\uDE7A SALUD DE PI-LENS",
-    "lens.health.crashes": "Fallos de pipeline (sesión): {count}",
-    "lens.health.files": "Archivos afectados: {count}",
-    "lens.health.topCrashFiles": "Archivos con más fallos:",
-    "lens.health.noLatency": "Aún no hay informes de latencia de dispatch.",
-    "lens.health.diagnosticsShown": "Diagnósticos mostrados: {count}",
-    "lens.health.autoFixed": "Auto-corregidos: {count}",
-    "lens.health.agentFixed": "Corregidos por el agente: {count}",
-    "lens.health.unresolved": "Arrastre sin resolver: {count}",
-    "lens.health.repeatOffenders": "Infractores repetidos:",
-    "lens.health.topNoisyRules": "Reglas más ruidosas:"
-  },
-  fr: {
-    "lens.health.title": "\uD83E\uDE7A SANTÉ DE PI-LENS",
-    "lens.health.crashes": "Plantages du pipeline (session) : {count}",
-    "lens.health.files": "Fichiers concernés : {count}",
-    "lens.health.topCrashFiles": "Fichiers avec le plus de plantages :",
-    "lens.health.noLatency": "Aucun rapport de latence dispatch pour le moment.",
-    "lens.health.diagnosticsShown": "Diagnostics affichés : {count}",
-    "lens.health.autoFixed": "Auto-corrigés : {count}",
-    "lens.health.agentFixed": "Corrigés par l’agent : {count}",
-    "lens.health.unresolved": "Report non résolu : {count}",
-    "lens.health.repeatOffenders": "Récidives :",
-    "lens.health.topNoisyRules": "Règles les plus bruyantes :"
-  },
-  "pt-BR": {
-    "lens.health.title": "\uD83E\uDE7A SAÚDE DO PI-LENS",
-    "lens.health.crashes": "Falhas do pipeline (sessão): {count}",
-    "lens.health.files": "Arquivos afetados: {count}",
-    "lens.health.topCrashFiles": "Arquivos com mais falhas:",
-    "lens.health.noLatency": "Ainda não há relatórios de latência do dispatch.",
-    "lens.health.diagnosticsShown": "Diagnósticos mostrados: {count}",
-    "lens.health.autoFixed": "Corrigidos automaticamente: {count}",
-    "lens.health.agentFixed": "Corrigidos pelo agente: {count}",
-    "lens.health.unresolved": "Pendências não resolvidas: {count}",
-    "lens.health.repeatOffenders": "Infratores recorrentes:",
-    "lens.health.topNoisyRules": "Regras mais ruidosas:"
-  }
-};
-let currentLocale = "en";
-export function initI18n(pi) {
-  pi.events?.emit?.("pi-core/i18n/registerBundle", {
-    namespace: "dm-lens",
-    defaultLocale: "en",
-    locales: translations
-  });
-  pi.events?.emit?.("pi-core/i18n/requestApi", {
-    onReady: (api) => {
-      const next = api.getLocale?.();
-      if (isLocale(next))
-        currentLocale = next;
-      api.onLocaleChange?.((locale) => {
-        if (isLocale(locale))
-          currentLocale = locale;
-      });
-    }
-  });
-}
-export function t(key, fallback, params = {}) {
-  const template = currentLocale === "en" ? fallback : translations[currentLocale]?.[key] ?? fallback;
-  return template.replaceAll(/\{(\w+)\}/g, (_, name) => String(params[name] ?? `{${name}}`));
-}
-function isLocale(locale) {
-  return locale === "en" || locale === "es" || locale === "fr" || locale === "pt-BR";
-}