@duckmind/dm-linux-x64 0.65.5 → 0.65.6

package/extensions/dm-lens/dist/clients/ndjson-logger.js

@@ -0,0 +1,471 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { normalizeFilePath } from "./path-utils.js";
+import { redactSecrets } from "./redact/secrets.js";
+function resolve(v) {
+  return typeof v === "function" ? v() : v;
+}
+function runBestEffort(operation) {
+  try {
+    operation();
+  } catch {
+    return;
+  }
+}
+const NDJSON_GLOBAL_STATE_SCHEMA = "dm-lens.ndjson-logger.state";
+const NDJSON_LEGACY_GLOBAL_STATE_VERSION = 1;
+const NDJSON_GLOBAL_STATE_VERSION = 2;
+const NDJSON_GLOBAL_STATE_KEY = Symbol.for("dm-lens.ndjson-logger.state");
+const globalStateHost = globalThis;
+const existingGlobalState = globalStateHost[NDJSON_GLOBAL_STATE_KEY];
+function isSharedWriterState(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const candidate = value;
+  const knownSchema = candidate.schema === undefined || candidate.schema === NDJSON_GLOBAL_STATE_SCHEMA;
+  const knownVersion = candidate.version === undefined || candidate.version === NDJSON_LEGACY_GLOBAL_STATE_VERSION || candidate.version === NDJSON_GLOBAL_STATE_VERSION;
+  return knownSchema && knownVersion && candidate.writers instanceof Map && candidate.exitFlushers instanceof Set && candidate.registeredLogFiles instanceof Set && typeof candidate.exitHandlerRegistered === "boolean";
+}
+function isLegacyGlobalState(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const candidate = value;
+  return candidate.exitFlushers instanceof Set && candidate.registeredLogFiles instanceof Set && typeof candidate.exitHandlerRegistered === "boolean";
+}
+let ndjsonGlobalState;
+let legacyGlobalState;
+if (isSharedWriterState(existingGlobalState)) {
+  const needsFlusherMigration = existingGlobalState.schema !== NDJSON_GLOBAL_STATE_SCHEMA || existingGlobalState.version !== NDJSON_GLOBAL_STATE_VERSION;
+  if (needsFlusherMigration) {
+    for (const state of existingGlobalState.writers.values()) {
+      const staleExitFlusher = state.exitFlusher;
+      const currentExitFlusher = () => flushStateSync(state);
+      state.exitFlusher = currentExitFlusher;
+      existingGlobalState.exitFlushers.delete(staleExitFlusher);
+      existingGlobalState.exitFlushers.add(currentExitFlusher);
+    }
+  }
+  existingGlobalState.schema = NDJSON_GLOBAL_STATE_SCHEMA;
+  existingGlobalState.version = NDJSON_GLOBAL_STATE_VERSION;
+  ndjsonGlobalState = existingGlobalState;
+} else if (existingGlobalState === undefined) {
+  ndjsonGlobalState = globalStateHost[NDJSON_GLOBAL_STATE_KEY] = {
+    schema: NDJSON_GLOBAL_STATE_SCHEMA,
+    version: NDJSON_GLOBAL_STATE_VERSION,
+    writers: new Map,
+    exitFlushers: new Set,
+    exitHandlerRegistered: false,
+    registeredLogFiles: new Set
+  };
+} else if (isLegacyGlobalState(existingGlobalState)) {
+  legacyGlobalState = existingGlobalState;
+}
+const exitFlushers = ndjsonGlobalState?.exitFlushers ?? legacyGlobalState?.exitFlushers ?? new Set;
+const registeredLogFiles = ndjsonGlobalState?.registeredLogFiles ?? legacyGlobalState?.registeredLogFiles ?? new Set;
+export function _exitFlushersForTest() {
+  return exitFlushers;
+}
+export function getRegisteredLogFiles() {
+  return registeredLogFiles;
+}
+export function getSinkWriteFailures() {
+  if (!ndjsonGlobalState)
+    return [];
+  const result = [];
+  for (const state of ndjsonGlobalState.writers.values()) {
+    if (state.writeFailures > 0) {
+      result.push({ file: state.file, droppedCount: state.writeFailures });
+    }
+  }
+  return result;
+}
+export function resetSinkWriteFailures() {
+  if (!ndjsonGlobalState)
+    return;
+  for (const state of ndjsonGlobalState.writers.values())
+    state.writeFailures = 0;
+}
+export function getSinkRotations() {
+  if (!ndjsonGlobalState)
+    return [];
+  const result = [];
+  for (const state of ndjsonGlobalState.writers.values()) {
+    if (state.rotationCount > 0 || state.rotationFailures > 0) {
+      result.push({
+        file: state.file,
+        rotationCount: state.rotationCount,
+        failureCount: state.rotationFailures
+      });
+    }
+  }
+  return result;
+}
+export function resetSinkRotations() {
+  if (!ndjsonGlobalState)
+    return;
+  for (const state of ndjsonGlobalState.writers.values()) {
+    state.rotationCount = 0;
+    state.rotationFailures = 0;
+    state.rotationRetryAfterMs = 0;
+    state.optionConflictRecorded = false;
+  }
+}
+export function getSinkOptionConflicts() {
+  if (!ndjsonGlobalState)
+    return [];
+  return [...ndjsonGlobalState.writers.values()].filter((state) => state.optionConflictRecorded).map((state) => ({ file: state.file }));
+}
+function requireCurrentGlobalState() {
+  if (ndjsonGlobalState)
+    return ndjsonGlobalState;
+  throw new Error("createNdjsonLogger: incompatible module graph state; a pre-7e4b9120 " + "logger graph may still own private queues. Restart the process before " + "loading the current logger graph");
+}
+function registerWriter(state) {
+  const globalState = requireCurrentGlobalState();
+  if (!exitFlushers.has(state.exitFlusher))
+    exitFlushers.add(state.exitFlusher);
+  if (!globalState.exitHandlerRegistered) {
+    globalState.exitHandlerRegistered = true;
+    process.on("exit", () => {
+      for (const flush of exitFlushers)
+        runBestEffort(flush);
+    });
+  }
+}
+function normalizeLogPath(file) {
+  return normalizeFilePath(path.resolve(file));
+}
+function writeQueueItemSync(state, item) {
+  if (item.kind === "truncate") {
+    fs.writeFileSync(state.file, "");
+    noteTruncated(state);
+  } else {
+    const plan = planBoundedWrite(state, [item.line]);
+    fs.appendFileSync(state.file, plan.joined);
+    noteWriteSucceeded(state, plan.bytes);
+  }
+}
+function applyQueueItemSync(state, item) {
+  ensureDirSync(state);
+  try {
+    writeQueueItemSync(state, item);
+    return;
+  } catch {}
+  state.ensuredDir = false;
+  ensureDirSync(state);
+  try {
+    writeQueueItemSync(state, item);
+  } catch {
+    state.writeFailures += 1;
+  }
+}
+function flushStateSync(state) {
+  const inFlight = state.inFlightBatch;
+  const inFlightAtHead = inFlight !== null && inFlight.every((item, index) => state.queue[index] === item);
+  const repairStart = inFlightAtHead ? inFlight?.[0]?.kind === "truncate" ? 0 : state.queue.findIndex((item) => item.kind === "truncate") : -1;
+  if (state.syncRepairItems) {
+    state.syncRepairItems.push(...state.queue);
+  } else if (repairStart >= 0) {
+    state.syncRepairItems = state.queue.slice(repairStart);
+  }
+  while (state.queue.length > 0) {
+    const item = state.queue.shift();
+    applyQueueItemSync(state, item);
+  }
+}
+function createWriterState(file, maxBytes, backupPath) {
+  const globalState = requireCurrentGlobalState();
+  const existing = globalState.writers.get(file);
+  if (existing) {
+    if (!exitFlushers.has(existing.exitFlusher))
+      registerWriter(existing);
+    if (typeof existing.writeFailures !== "number")
+      existing.writeFailures = 0;
+    if (typeof existing.writesSinceStatSync !== "number")
+      existing.writesSinceStatSync = 0;
+    if (typeof existing.lastStatSyncMs !== "number")
+      existing.lastStatSyncMs = 0;
+    if (typeof existing.rotationCount !== "number")
+      existing.rotationCount = 0;
+    if (typeof existing.rotationFailures !== "number")
+      existing.rotationFailures = 0;
+    if (typeof existing.rotationRetryAfterMs !== "number")
+      existing.rotationRetryAfterMs = 0;
+    if (typeof existing.optionConflictRecorded !== "boolean")
+      existing.optionConflictRecorded = false;
+    const optionsDiffer = existing.maxBytes !== maxBytes || existing.backupPath !== backupPath;
+    if (optionsDiffer) {
+      if (existing.maxBytes === undefined && maxBytes !== undefined)
+        existing.maxBytes = maxBytes;
+      if (existing.backupPath === undefined && backupPath !== undefined)
+        existing.backupPath = backupPath;
+      existing.optionConflictRecorded = true;
+    }
+    return existing;
+  }
+  const state = {};
+  state.file = file;
+  state.maxBytes = maxBytes;
+  state.backupPath = backupPath;
+  state.queue = [];
+  state.drainPromise = null;
+  state.inFlightBatch = null;
+  state.syncRepairItems = null;
+  state.ensuredDir = false;
+  state.exitFlusher = () => flushStateSync(state);
+  state.writeFailures = 0;
+  state.knownSize = undefined;
+  state.writesSinceStatSync = 0;
+  state.lastStatSyncMs = 0;
+  state.rotationCount = 0;
+  state.rotationFailures = 0;
+  state.rotationRetryAfterMs = 0;
+  state.optionConflictRecorded = false;
+  globalState.writers.set(file, state);
+  registerWriter(state);
+  return state;
+}
+function ensureDirSync(state) {
+  if (state.ensuredDir)
+    return;
+  runBestEffort(() => {
+    fs.mkdirSync(path.dirname(state.file), { recursive: true });
+    state.ensuredDir = true;
+  });
+}
+async function ensureDirAsync(state) {
+  if (state.ensuredDir)
+    return;
+  try {
+    await fs.promises.mkdir(path.dirname(state.file), { recursive: true });
+    state.ensuredDir = true;
+  } catch {}
+}
+const ROTATION_STAT_RESYNC_WRITES = 25;
+const ROTATION_STAT_RESYNC_MS = 2000;
+function syncKnownSizeIfDue(state, now) {
+  const due = state.knownSize === undefined || state.writesSinceStatSync >= ROTATION_STAT_RESYNC_WRITES || now - state.lastStatSyncMs >= ROTATION_STAT_RESYNC_MS;
+  if (!due)
+    return;
+  state.writesSinceStatSync = 0;
+  state.lastStatSyncMs = now;
+  try {
+    state.knownSize = fs.statSync(state.file).size;
+  } catch {
+    state.knownSize = 0;
+  }
+}
+const ROTATION_FAILURE_BACKOFF_MS = 1e4;
+function rotateNow(state, incomingBytes, now) {
+  if (state.maxBytes === undefined)
+    return false;
+  if (now < state.rotationRetryAfterMs)
+    return false;
+  let actualSize;
+  try {
+    actualSize = fs.statSync(state.file).size;
+  } catch {
+    state.knownSize = 0;
+    state.writesSinceStatSync = 0;
+    state.lastStatSyncMs = now;
+    return false;
+  }
+  state.knownSize = actualSize;
+  state.writesSinceStatSync = 0;
+  state.lastStatSyncMs = now;
+  if (actualSize === 0)
+    return false;
+  if (actualSize + incomingBytes < state.maxBytes)
+    return false;
+  const backup = state.backupPath ?? `${state.file}.1`;
+  try {
+    runBestEffort(() => fs.rmSync(backup, { force: true }));
+    fs.renameSync(state.file, backup);
+  } catch {
+    state.rotationFailures += 1;
+    state.rotationRetryAfterMs = now + ROTATION_FAILURE_BACKOFF_MS;
+    return false;
+  }
+  state.knownSize = 0;
+  state.rotationCount += 1;
+  state.rotationRetryAfterMs = 0;
+  return true;
+}
+function takeAll(lines) {
+  const joined = lines.join("");
+  return { count: lines.length, joined, bytes: Buffer.byteLength(joined) };
+}
+function planBoundedWrite(state, lines) {
+  if (state.maxBytes === undefined || lines.length === 0)
+    return takeAll(lines);
+  const now = Date.now();
+  syncKnownSizeIfDue(state, now);
+  state.writesSinceStatSync += 1;
+  const firstBytes = Buffer.byteLength(lines[0] ?? "");
+  let known = state.knownSize ?? 0;
+  if (known > 0 && known + firstBytes >= state.maxBytes) {
+    rotateNow(state, firstBytes, now);
+    known = state.knownSize ?? 0;
+    if (known > 0 && known + firstBytes >= state.maxBytes) {
+      return takeAll(lines);
+    }
+  }
+  let bytes = 0;
+  let count = 0;
+  for (const line of lines) {
+    const lineBytes = Buffer.byteLength(line);
+    if (count > 0 && known + bytes + lineBytes >= state.maxBytes)
+      break;
+    bytes += lineBytes;
+    count += 1;
+  }
+  if (count === lines.length)
+    return takeAll(lines);
+  return { count, joined: lines.slice(0, count).join(""), bytes };
+}
+function noteWriteSucceeded(state, bytes) {
+  if (state.maxBytes === undefined)
+    return;
+  state.knownSize = (state.knownSize ?? 0) + bytes;
+}
+function noteTruncated(state) {
+  if (state.maxBytes === undefined)
+    return;
+  state.knownSize = 0;
+  state.writesSinceStatSync = 0;
+  state.lastStatSyncMs = Date.now();
+}
+async function writeQueueItemAsync(state, item) {
+  if (item.kind === "truncate") {
+    await fs.promises.writeFile(state.file, "");
+    noteTruncated(state);
+  } else {
+    const plan = planBoundedWrite(state, [item.line]);
+    await fs.promises.appendFile(state.file, plan.joined);
+    noteWriteSucceeded(state, plan.bytes);
+  }
+}
+async function applyQueueItemAsync(state, item) {
+  await ensureDirAsync(state);
+  try {
+    await writeQueueItemAsync(state, item);
+    return;
+  } catch {}
+  state.ensuredDir = false;
+  await ensureDirAsync(state);
+  try {
+    await writeQueueItemAsync(state, item);
+  } catch {
+    state.writeFailures += 1;
+  }
+}
+async function drainLoop(state) {
+  while (state.queue.length > 0) {
+    const item = state.queue[0];
+    await ensureDirAsync(state);
+    const truncateIndex = item.kind === "line" ? state.queue.findIndex((queued) => queued.kind === "truncate") : 0;
+    const pendingEnd = truncateIndex === -1 ? state.queue.length : truncateIndex;
+    const offered = item.kind === "truncate" ? [item] : state.queue.slice(0, pendingEnd);
+    const plan = item.kind === "truncate" ? null : planBoundedWrite(state, offered.map((queued) => queued.line));
+    const pending = plan === null ? offered : offered.slice(0, plan.count);
+    state.inFlightBatch = pending;
+    const writeBatch = async () => {
+      if (plan === null) {
+        await fs.promises.writeFile(state.file, "");
+        noteTruncated(state);
+      } else {
+        await fs.promises.appendFile(state.file, plan.joined);
+        noteWriteSucceeded(state, plan.bytes);
+      }
+    };
+    try {
+      await writeBatch();
+    } catch {
+      state.ensuredDir = false;
+      await ensureDirAsync(state);
+      try {
+        await writeBatch();
+      } catch {
+        state.writeFailures += pending.length;
+      }
+    }
+    for (const written of pending) {
+      if (state.queue[0] !== written)
+        break;
+      state.queue.shift();
+    }
+    if (state.inFlightBatch === pending) {
+      state.inFlightBatch = null;
+      const repairItems = state.syncRepairItems;
+      state.syncRepairItems = null;
+      if (repairItems) {
+        for (const repairItem of repairItems) {
+          await applyQueueItemAsync(state, repairItem);
+        }
+      }
+    }
+  }
+}
+function drain(state) {
+  if (!state.drainPromise) {
+    state.drainPromise = Promise.resolve().then(() => drainLoop(state)).finally(() => {
+      state.drainPromise = null;
+    });
+  }
+  return state.drainPromise;
+}
+export function createNdjsonLogger(options) {
+  const states = new Set;
+  const canonicalPaths = new Map;
+  const staticFile = typeof options.filePath === "string" ? normalizeLogPath(options.filePath) : undefined;
+  const staticBackupPath = typeof options.backupPath === "string" && options.maxBytes !== undefined ? normalizeLogPath(options.backupPath) : undefined;
+  function canonicalPath(file) {
+    const raw = path.resolve(file);
+    const cached = canonicalPaths.get(raw);
+    if (cached)
+      return cached;
+    const normalized = normalizeLogPath(raw);
+    canonicalPaths.set(raw, normalized);
+    return normalized;
+  }
+  function stateForCall() {
+    const file = staticFile ?? canonicalPath(resolve(options.filePath));
+    const backupPath = options.maxBytes !== undefined && options.backupPath ? staticBackupPath ?? canonicalPath(resolve(options.backupPath)) : undefined;
+    const state = createWriterState(file, options.maxBytes, backupPath);
+    states.add(state);
+    return state;
+  }
+  if (staticFile !== undefined) {
+    const state = stateForCall();
+    registeredLogFiles.add(state.file);
+  }
+  function enqueue(item) {
+    const state = stateForCall();
+    state.queue.push(item);
+    drain(state);
+  }
+  return {
+    log(obj) {
+      const serialized = String(JSON.stringify(obj));
+      enqueue({
+        kind: "line",
+        line: `${redactSecrets(serialized)}
+`
+      });
+    },
+    append(line) {
+      enqueue({ kind: "line", line: `${redactSecrets(line)}
+` });
+    },
+    truncate() {
+      enqueue({ kind: "truncate" });
+    },
+    async flush() {
+      await Promise.all([...states].map((state) => drain(state)));
+    },
+    flushSync() {
+      for (const state of states)
+        flushStateSync(state);
+    }
+  };
+}

package/extensions/dm-lens/dist/clients/observed-mutation-sources.js

@@ -0,0 +1,43 @@
+import { getLSPService } from "./lsp/index.js";
+import { getMutationBridge } from "./mutation-bridge.js";
+import { getFileDiagnosticSummaries } from "./widget-state.js";
+export function collectTrackedPaths(args) {
+  const tracked = new Set;
+  const add = (paths) => {
+    for (const filePath of paths) {
+      if (tracked.size >= args.limit)
+        return;
+      if (typeof filePath === "string" && filePath.length > 0)
+        tracked.add(filePath);
+    }
+  };
+  try {
+    add(args.readGuard?.getTrackedPaths?.() ?? []);
+  } catch {}
+  try {
+    add(getFileDiagnosticSummaries().map((summary) => summary.filePath));
+  } catch {}
+  if (args.cwd) {
+    try {
+      add(getLSPService().getOpenDocumentPaths(args.cwd));
+    } catch {}
+  }
+  return [...tracked];
+}
+export function storedLineHashesFor(readGuard, filePath) {
+  try {
+    const history = readGuard?.getReadHistory?.(filePath) ?? [];
+    for (let index = history.length - 1;index >= 0; index -= 1) {
+      const hashes = history[index]?.lineHashes;
+      if (hashes && Object.keys(hashes).length > 0)
+        return hashes;
+    }
+  } catch {}
+  return;
+}
+export function replayThroughMutationBridge(entry) {
+  const bridge = getMutationBridge();
+  if (!bridge)
+    return false;
+  return bridge.recordMutation(entry);
+}