@duckmind/dm-darwin-x64 0.66.4 → 0.66.6

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

@@ -0,0 +1,268 @@
+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 { FRESHNESS_CADENCE_MS } from "./freshness-cadence.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) {
+    const startDirMtime = cached.dirMtimes[0];
+    const isFresh = cached.dir === undefined ? startDirMtime !== undefined && Date.now() - cached.walkedAtMs < FRESHNESS_CADENCE_MS && safeDirMtimeMs(startDirMtime.dir) === startDirMtime.mtimeMs : dirMtimesStillFresh(cached.dirMtimes);
+    if (isFresh) {
+      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 walkedAtMs = Date.now();
+  const entry = {
+    dir: found,
+    dirMtimes,
+    walkedAtMs,
+    lastUsedAt: walkedAtMs
+  };
+  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

@@ -0,0 +1,28 @@
+export function writeOrderToken(turnIndex, writeIndex) {
+  return turnIndex === undefined || writeIndex === undefined ? undefined : turnIndex * 2 ** 32 + writeIndex;
+}
+
+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

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

@@ -0,0 +1,67 @@
+const translations = {
+  es: {
+    "lens.health.title": "\uD83E\uDE7A SALUD DE DM-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 DM-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 DM-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";
+}