@duckmind/dm-linux-x64 0.66.0 → 0.66.2

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

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

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