@duckmind/dm-linux-x64 0.66.0 → 0.66.2

package/extensions/dm-lens/dist/clients/event-loop-monitor.js

@@ -1,84 +0,0 @@
-import { logExtension } from "./extension-log.js";
-import { monitorEventLoopDelay } from "node:perf_hooks";
-const NS_PER_MS = 1e6;
-const US_PER_MS = 1000;
-let histogram;
-let monitorUnavailable = false;
-let windowStartWallMs = 0;
-let windowStartCpuMs = 0;
-const cpuTotalMs = () => {
-  const c = process.cpuUsage();
-  return (c.user + c.system) / US_PER_MS;
-};
-export function startEventLoopMonitor(resolutionMs = 20) {
-  if (histogram || monitorUnavailable)
-    return;
-  try {
-    const h = monitorEventLoopDelay({ resolution: resolutionMs });
-    h.enable();
-    histogram = h;
-    windowStartWallMs = Date.now();
-    windowStartCpuMs = cpuTotalMs();
-  } catch (err) {
-    monitorUnavailable = true;
-    logExtension({
-      subsystem: "event-loop-monitor",
-      message: `event-loop occupancy telemetry disabled (runtime lacks monitorEventLoopDelay): ${err?.message ?? String(err)}`
-    });
-  }
-}
-const STALL_CLASSIFY_FLOOR_MS = 1000;
-const STALL_CLASSIFY_SLOP_MS = 250;
-export function classifyLoopBlock(maxMs, windowCpuMs, options = {}) {
-  const { floorMs = STALL_CLASSIFY_FLOOR_MS, slopMs = STALL_CLASSIFY_SLOP_MS, suspendFloorMs, suspendSlopMs } = options;
-  const cpuCoverageRatio = maxMs > 0 ? Math.round(windowCpuMs / maxMs * 100) / 100 : undefined;
-  if (maxMs < floorMs)
-    return { stallClass: "below-floor", cpuCoverageRatio };
-  if (isSuspendSuspectedBlock(maxMs, windowCpuMs, suspendFloorMs, suspendSlopMs))
-    return { stallClass: "system-stall", cpuCoverageRatio };
-  if (windowCpuMs + slopMs < maxMs)
-    return { stallClass: "non-cpu-stall", cpuCoverageRatio };
-  return { stallClass: "cpu-accounted", cpuCoverageRatio };
-}
-const safeMs = (ns) => Number.isFinite(ns) ? Math.round(ns / NS_PER_MS * 10) / 10 : 0;
-export function isSuspendSuspectedBlock(maxMs, windowCpuMs, floorMs = 20000, slopMs = 1000) {
-  if (maxMs < floorMs)
-    return false;
-  return windowCpuMs + slopMs < maxMs;
-}
-export function getEventLoopStats() {
-  if (!histogram)
-    return;
-  const maxMs = safeMs(histogram.max);
-  const windowWallMs = Math.max(0, Date.now() - windowStartWallMs);
-  const windowCpuMs = Math.max(0, cpuTotalMs() - windowStartCpuMs);
-  const classification = classifyLoopBlock(maxMs, windowCpuMs);
-  return {
-    maxMs,
-    p99Ms: safeMs(histogram.percentile(99)),
-    meanMs: safeMs(histogram.mean),
-    windowWallMs: Math.round(windowWallMs),
-    windowCpuMs: Math.round(windowCpuMs),
-    suspectSystemStall: classification.stallClass === "system-stall",
-    stallClass: classification.stallClass,
-    cpuCoverageRatio: classification.cpuCoverageRatio
-  };
-}
-export function resetEventLoopMonitor() {
-  histogram?.reset();
-  windowStartWallMs = Date.now();
-  windowStartCpuMs = cpuTotalMs();
-}
-export function shouldLogWorstBlock(maxMs, lastLoggedMs, minMs = 60, deltaMs = 25) {
-  return maxMs >= minMs && maxMs > lastLoggedMs + deltaMs;
-}
-export function shouldLogLoopBlock(maxMs, minMs = 60) {
-  return maxMs >= minMs;
-}
-export function _stopEventLoopMonitorForTest() {
-  histogram?.disable();
-  histogram = undefined;
-  monitorUnavailable = false;
-  windowStartWallMs = 0;
-  windowStartCpuMs = 0;
-}

package/extensions/dm-lens/dist/clients/extension-log.js

@@ -1,230 +0,0 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-import * as path from "node:path";
-import { isTestMode } from "./env-utils.js";
-import { getGlobalDmLensLogDir } from "./probe-home-state.js";
-import { getMaxLogSizeMB } from "./log-cleanup.js";
-import { createNdjsonLogger } from "./ndjson-logger.js";
-import { getTurnId } from "./turn-context.js";
-export const EXTENSION_LOG_FILE = path.join(getGlobalDmLensLogDir(), "extension.log");
-const writer = createNdjsonLogger({
-  filePath: EXTENSION_LOG_FILE,
-  maxBytes: getMaxLogSizeMB() * 1024 * 1024
-});
-export function logExtension(entry) {
-  if (isTestMode())
-    return;
-  writer.log({
-    ts: new Date().toISOString(),
-    pid: process.pid,
-    turnId: getTurnId(),
-    level: entry.level ?? "error",
-    subsystem: entry.subsystem,
-    message: entry.message,
-    ...entry.metadata ? { metadata: entry.metadata } : {}
-  });
-}
-export function createSubsystemLogger(subsystem, defaultLevel = "debug") {
-  const at = (level) => (message, metadata) => {
-    logExtension({ subsystem, message, level, metadata });
-  };
-  const logger = at(defaultLevel);
-  logger.error = at("error");
-  logger.warn = at("warn");
-  logger.debug = at("debug");
-  return logger;
-}
-export function noopSubsystemLogger() {
-  const noop = () => {};
-  noop.error = () => {};
-  noop.warn = () => {};
-  noop.debug = () => {};
-  return noop;
-}
-export function getExtensionLogPath() {
-  return EXTENSION_LOG_FILE;
-}
-export function flushExtensionLog() {
-  return writer.flush();
-}
-export function flushExtensionLogSync() {
-  writer.flushSync();
-}
-const CONSOLE_METHODS = [
-  "log",
-  "info",
-  "warn",
-  "error",
-  "debug",
-  "trace",
-  "dir"
-];
-let consoleGuardInstalled = false;
-const originalConsoleMethods = new Map;
-const installedConsoleMethods = new Map;
-let consoleCaptureStorage;
-function getConsoleCaptureStorage() {
-  if (!consoleGuardInstalled)
-    return;
-  if (consoleCaptureStorage === undefined) {
-    consoleCaptureStorage = new AsyncLocalStorage;
-  }
-  return consoleCaptureStorage;
-}
-let moduleLoadWindowOpen = false;
-export function isConsoleCaptureActive() {
-  return moduleLoadWindowOpen || consoleCaptureStorage?.getStore() === true;
-}
-export function openModuleLoadConsoleWindow() {
-  if (moduleLoadWindowOpen)
-    return;
-  moduleLoadWindowOpen = true;
-  const backstop = setImmediate(() => {
-    moduleLoadWindowOpen = false;
-  });
-  backstop.unref?.();
-}
-export function closeModuleLoadConsoleWindow() {
-  moduleLoadWindowOpen = false;
-}
-export function runInConsoleCaptureWindow(fn) {
-  const storage = getConsoleCaptureStorage();
-  if (!storage)
-    return fn();
-  return storage.run(true, fn);
-}
-function inCaptureWindow(fn) {
-  return function(...args) {
-    return runInConsoleCaptureWindow(() => fn.apply(this, args));
-  };
-}
-function isCaptureSeam(prop) {
-  return prop === "on" || typeof prop === "string" && prop.startsWith("register");
-}
-function isCallableSchema(value) {
-  return typeof value === "function" && typeof value.toJsonSchema === "function" && typeof value.assert === "function";
-}
-function wrapFunctionsInPlace(value) {
-  if (typeof value === "function") {
-    return inCaptureWindow(value);
-  }
-  if (value === null || typeof value !== "object" || Array.isArray(value)) {
-    return value;
-  }
-  const obj = value;
-  for (const key of Object.keys(obj)) {
-    const propValue = obj[key];
-    if (typeof propValue === "function" && !isCallableSchema(propValue)) {
-      assignWrapped(obj, key, propValue);
-    }
-  }
-  return value;
-}
-function assignWrapped(obj, key, fn) {
-  const wrapped = inCaptureWindow(fn);
-  try {
-    obj[key] = wrapped;
-    return;
-  } catch {}
-  try {
-    Object.defineProperty(obj, key, {
-      value: wrapped,
-      writable: true,
-      configurable: true,
-      enumerable: true
-    });
-  } catch {}
-}
-export function withConsoleCaptureWindows(api) {
-  const wrapperCache = new Map;
-  const proxy = new Proxy(api, {
-    get(target, prop) {
-      const descriptor = Reflect.getOwnPropertyDescriptor(target, prop);
-      if (descriptor && descriptor.writable === false && descriptor.configurable === false) {
-        return descriptor.value;
-      }
-      const cached = wrapperCache.get(prop);
-      if (cached !== undefined)
-        return cached;
-      const value = Reflect.get(target, prop, target);
-      if (typeof value !== "function")
-        return value;
-      const method = value;
-      const keepProxy = (result) => Object.is(result, target) ? proxy : result;
-      const wrapper = isCaptureSeam(prop) ? (...args) => {
-        const wrapped = args.map((arg) => wrapFunctionsInPlace(arg));
-        return keepProxy(method.apply(target, wrapped));
-      } : (...args) => {
-        const current = Reflect.get(target, prop, target);
-        return current.apply(target, args);
-      };
-      wrapperCache.set(prop, wrapper);
-      return wrapper;
-    }
-  });
-  return proxy;
-}
-function formatConsoleArgs(args) {
-  return args.map((arg) => {
-    if (typeof arg === "string")
-      return arg;
-    if (arg instanceof Error)
-      return arg.stack ?? arg.message;
-    try {
-      return JSON.stringify(arg) ?? String(arg);
-    } catch {
-      return String(arg);
-    }
-  }).join(" ");
-}
-export function installConsoleGuard() {
-  if (consoleGuardInstalled)
-    return false;
-  if (isTestMode())
-    return false;
-  if (process.env.DM_LENS_CONSOLE_GUARD === "0")
-    return false;
-  consoleGuardInstalled = true;
-  const target = console;
-  for (const method of CONSOLE_METHODS) {
-    const original = target[method];
-    if (typeof original !== "function")
-      continue;
-    const originalFn = original;
-    originalConsoleMethods.set(method, originalFn);
-    const replacement = (...args) => {
-      if (!isConsoleCaptureActive()) {
-        originalFn.apply(console, args);
-        return;
-      }
-      logExtension({
-        subsystem: "console",
-        level: method === "warn" ? "warn" : method === "error" ? "error" : "debug",
-        message: formatConsoleArgs(args),
-        metadata: { method }
-      });
-    };
-    installedConsoleMethods.set(method, replacement);
-    target[method] = replacement;
-  }
-  return true;
-}
-export function uninstallConsoleGuard() {
-  if (!consoleGuardInstalled)
-    return false;
-  consoleGuardInstalled = false;
-  const target = console;
-  for (const [method, original] of originalConsoleMethods) {
-    if (target[method] === installedConsoleMethods.get(method)) {
-      target[method] = original;
-    }
-  }
-  originalConsoleMethods.clear();
-  installedConsoleMethods.clear();
-  return true;
-}
-export function _resetConsoleGuardForTests() {
-  uninstallConsoleGuard();
-  consoleGuardInstalled = false;
-  consoleCaptureStorage = undefined;
-  moduleLoadWindowOpen = false;
-}

package/extensions/dm-lens/dist/clients/extension-mode.js

@@ -1,20 +0,0 @@
-const KNOWN_MODES = new Set(["tui", "rpc", "json", "print"]);
-export function readExtensionMode(ctx) {
-  try {
-    const mode = ctx?.mode;
-    if (typeof mode !== "string" || !KNOWN_MODES.has(mode))
-      return "unknown";
-    return mode;
-  } catch {
-    return "unknown";
-  }
-}
-export function supportsTuiWidget(mode) {
-  return mode === "tui" || mode === "unknown";
-}
-export function suppressesUserNotify(mode) {
-  return mode === "print" || mode === "json";
-}
-export function modeSuppressionNote(mode) {
-  return `suppressed in "${mode}" mode (no interactive TUI)`;
-}

package/extensions/dm-lens/dist/clients/feature-hints.js

@@ -1,88 +0,0 @@
-import { escapeRegExp } from "./string-utils.js";
-function normalizeHintInput(value) {
-  return value.replace(/\\/g, "/");
-}
-function hasHintToken(value, tokens) {
-  const escaped = tokens.map((token) => escapeRegExp(token));
-  const alternatives = escaped.join("|");
-  return new RegExp(`(?:^|[/_.\\-\\s])(?:${alternatives})(?=[/_.\\-\\s]|$)`, "i").test(value) || new RegExp(`(?:^|(?<=[a-z0-9]))(?:${tokens.flatMap((token) => [
-    token[0].toUpperCase() + token.slice(1),
-    ...token === "openai" ? ["OpenAI"] : [],
-    ...token === "github" ? ["GitHub"] : [],
-    ...token === "gitlab" ? ["GitLab"] : []
-  ]).join("|")})(?=[A-Z]|[/_.\\-\\s]|$)`).test(value);
-}
-export function inferFeatureKind(nameOrPath) {
-  const normalized = normalizeHintInput(nameOrPath);
-  if (hasHintToken(normalized, [
-    "config",
-    "store",
-    "db",
-    "database",
-    "github",
-    "openai",
-    "sync",
-    "service"
-  ])) {
-    return "service";
-  }
-  if (/(^|[/_.\-\s])(cli|command|bin)([/_.\-\s]|$)/i.test(normalized)) {
-    return "cli-command";
-  }
-  return "library";
-}
-export function inferTrustBoundaries(nameOrPath) {
-  const normalized = normalizeHintInput(nameOrPath);
-  const boundaries = new Set;
-  if (hasHintToken(normalized, [
-    "config",
-    "store",
-    "db",
-    "database",
-    "repo",
-    "repository",
-    "model",
-    "migration"
-  ])) {
-    boundaries.add("filesystem");
-    boundaries.add("database");
-  }
-  if (hasHintToken(normalized, [
-    "github",
-    "gitlab",
-    "openai",
-    "anthropic",
-    "stripe",
-    "slack",
-    "sync",
-    "webhook",
-    "api",
-    "client"
-  ])) {
-    boundaries.add("network");
-    boundaries.add("external-api");
-    boundaries.add("serialization");
-  }
-  if (/(^|[/_.\-\s])(cli|command|bin|exec|spawn|process|shell)([/_.\-\s]|$)/i.test(normalized)) {
-    boundaries.add("user-input");
-    boundaries.add("process-exec");
-  }
-  if (hasHintToken(normalized, [
-    "auth",
-    "login",
-    "token",
-    "session",
-    "oauth",
-    "jwt"
-  ])) {
-    boundaries.add("auth");
-    boundaries.add("user-input");
-  }
-  return [...boundaries];
-}
-export function featureHintMetadata(nameOrPath) {
-  return {
-    featureKind: inferFeatureKind(nameOrPath),
-    trustBoundaries: inferTrustBoundaries(nameOrPath)
-  };
-}