@duckmind/dm-linux-x64 0.65.5 → 0.65.7

package/extensions/dm-lens/dist/clients/config-core/records.js

@@ -0,0 +1,79 @@
+import { DEGRADATION_ENTRIES_PER_KIND } from "../ledger-bounds.js";
+import { redactSecrets } from "../redact/secrets.js";
+export const MAX_MIGRATION_RECORDS = DEGRADATION_ENTRIES_PER_KIND;
+export const MAX_RECORD_KEY_LENGTH = 120;
+const UNBOUNDED_RECORD_CODES = new Set(["PILENS_CFG_0008"]);
+const SUBJECT_SEPARATOR = String.fromCharCode(0);
+export function migrationSubject(file, key) {
+  return key.length > 0 ? `${file}${SUBJECT_SEPARATOR}${key}` : file;
+}
+function stripControlCharacters(text) {
+  let out = "";
+  for (const character of text) {
+    const code = character.codePointAt(0) ?? 0;
+    out += code < 32 || code === 127 ? " " : character;
+  }
+  return out;
+}
+export function boundedKeyLabel(key) {
+  const printable = stripControlCharacters(key).trim();
+  const bounded = printable.length > MAX_RECORD_KEY_LENGTH ? `${printable.slice(0, MAX_RECORD_KEY_LENGTH)}...` : printable;
+  return redactSecrets(bounded);
+}
+export function jsonTypeName(value) {
+  if (value === null)
+    return "null";
+  if (Array.isArray(value))
+    return "array";
+  return typeof value;
+}
+const UNANCHORED_RECORD_LABEL = "(config resolution)";
+
+export class MigrationRecordCollector {
+  kept = [];
+  dropped;
+  limit;
+  constructor(limit = MAX_MIGRATION_RECORDS, priorDropped = 0) {
+    this.limit = Math.max(0, Math.trunc(limit));
+    this.dropped = Math.max(0, Math.trunc(priorDropped));
+  }
+  add(record) {
+    if (this.kept.length >= this.limit) {
+      if (UNBOUNDED_RECORD_CODES.has(record.code)) {
+        this.kept.push(record);
+        return;
+      }
+      this.dropped += 1;
+      return;
+    }
+    this.kept.push(record);
+  }
+  get records() {
+    return this.kept;
+  }
+  get droppedCount() {
+    return this.dropped;
+  }
+  finalize(anchor) {
+    if (this.dropped === 0)
+      return this.kept;
+    const file = anchor?.file ?? UNANCHORED_RECORD_LABEL;
+    return [
+      ...this.kept,
+      {
+        code: "PILENS_CFG_0007",
+        file,
+        key: "",
+        subject: migrationSubject(file, ""),
+        reason: `${this.dropped} further config notices were suppressed by the bound of ${MAX_MIGRATION_RECORDS}`,
+        ...anchor?.tier === undefined ? {} : { tier: anchor.tier }
+      }
+    ];
+  }
+}
+export function finalizeRecords(records, anchor, priorDropped = 0) {
+  const collector = new MigrationRecordCollector(MAX_MIGRATION_RECORDS - 1, priorDropped);
+  for (const record of records)
+    collector.add(record);
+  return collector.finalize(anchor);
+}

package/extensions/dm-lens/dist/clients/config-core/resolve.js

@@ -0,0 +1,48 @@
+import { errorClassName } from "../error-class.js";
+import { merge } from "./merge.js";
+import { validate } from "./normalize.js";
+import { MigrationRecordCollector, migrationSubject } from "./records.js";
+function anchorSource(sources) {
+  try {
+    const last = sources?.[sources.length - 1];
+    return last === undefined || typeof last.file !== "string" ? undefined : { file: last.file, tier: last.tier };
+  } catch {
+    return;
+  }
+}
+export function resolveConfig(options) {
+  const collector = new MigrationRecordCollector(options.maxRecords);
+  try {
+    const normalized = options.sources.map((source) => ({
+      tier: source.tier,
+      ...source.file === undefined ? {} : { file: source.file },
+      ...source.trust === undefined ? {} : { trust: source.trust },
+      value: validate(source.value, options.schema, {
+        file: source.file ?? "",
+        tier: source.tier,
+        collector
+      }).value
+    }));
+    return {
+      resolved: merge(normalized, options.schema, { collector }),
+      records: collector.records,
+      droppedRecordCount: collector.droppedCount
+    };
+  } catch (error) {
+    const anchor = anchorSource(options.sources);
+    const file = anchor?.file ?? "";
+    collector.add({
+      code: "PILENS_CFG_0008",
+      file,
+      key: "",
+      subject: migrationSubject(file, ""),
+      reason: `config resolution failed internally (${errorClassName(error)}); configuration ignored`,
+      ...anchor ? { tier: anchor.tier } : {}
+    });
+    return {
+      resolved: merge([], options.schema),
+      records: collector.records,
+      droppedRecordCount: collector.droppedCount
+    };
+  }
+}

package/extensions/dm-lens/dist/clients/config-core/safe-object.js

@@ -0,0 +1,22 @@
+export const MAX_CONFIG_DEPTH = 32;
+export const UNSAFE_CONFIG_KEYS = [
+  "__proto__",
+  "constructor",
+  "prototype"
+];
+const UNSAFE_KEY_SET = new Set(UNSAFE_CONFIG_KEYS);
+export function isUnsafeConfigKey(name) {
+  return UNSAFE_KEY_SET.has(name);
+}
+export const UNSAFE_KEY_REASON = "config key would modify the object prototype; ignored";
+export function safeAssign(target, name, value) {
+  if (isUnsafeConfigKey(name))
+    return false;
+  Object.defineProperty(target, name, {
+    value,
+    writable: true,
+    enumerable: true,
+    configurable: true
+  });
+  return true;
+}

package/extensions/dm-lens/dist/clients/config-core/schema.js

@@ -0,0 +1,90 @@
+export function isConfigObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export const MERGE_STRATEGY_KEY = "x-merge-strategy";
+const DEFAULT_MERGE_STRATEGY = "replace";
+const KEYED_PREFIX = "keyed:";
+export function isMergeStrategy(value) {
+  if (typeof value !== "string")
+    return false;
+  if (value === "replace" || value === "append")
+    return true;
+  return value.startsWith(KEYED_PREFIX) && value.length > KEYED_PREFIX.length;
+}
+export function mergeStrategyOf(node) {
+  const declared = node?.[MERGE_STRATEGY_KEY];
+  return isMergeStrategy(declared) ? declared : DEFAULT_MERGE_STRATEGY;
+}
+export function keyedField(strategy) {
+  return strategy.startsWith(KEYED_PREFIX) ? strategy.slice(KEYED_PREFIX.length) : undefined;
+}
+export const DENY_KEY = "x-deny";
+const DENY_POLICIES = ["boolean-false", "array-union"];
+export function isDenyPolicy(value) {
+  return typeof value === "string" && DENY_POLICIES.includes(value);
+}
+export function denyPolicyOf(node) {
+  const declared = node?.[DENY_KEY];
+  return isDenyPolicy(declared) ? declared : undefined;
+}
+export function isSchemaNode(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function schemaType(node) {
+  const declared = node?.type;
+  return typeof declared === "string" ? declared : undefined;
+}
+const SCHEMA_TYPES = [
+  "object",
+  "array",
+  "string",
+  "number",
+  "integer",
+  "boolean",
+  "null"
+];
+const SCHEMA_TYPE_SET = new Set(SCHEMA_TYPES);
+export function isKnownSchemaType(declared) {
+  return declared !== undefined && SCHEMA_TYPE_SET.has(declared);
+}
+export function propertySchema(node, name) {
+  if (!node)
+    return;
+  const properties = node.properties;
+  if (isSchemaNode(properties) && Object.hasOwn(properties, name)) {
+    const child = properties[name];
+    if (isSchemaNode(child))
+      return child;
+  }
+  const patterns = node.patternProperties;
+  if (isSchemaNode(patterns)) {
+    for (const [pattern, child] of Object.entries(patterns)) {
+      if (!isSchemaNode(child))
+        continue;
+      let matcher;
+      try {
+        matcher = new RegExp(pattern);
+      } catch {
+        continue;
+      }
+      if (matcher.test(name))
+        return child;
+    }
+  }
+  return;
+}
+export function additionalPropertyPolicy(node) {
+  const declared = node?.additionalProperties;
+  if (declared === true)
+    return { kind: "keep" };
+  if (isSchemaNode(declared))
+    return { kind: "validate", schema: declared };
+  return { kind: "drop" };
+}
+export function itemsSchema(node) {
+  const declared = node?.items;
+  return isSchemaNode(declared) ? declared : undefined;
+}

package/extensions/dm-lens/dist/clients/config-diagnostic-codes.js

@@ -0,0 +1,90 @@
+export const STABILITY_TIER_KEY = "x-stability";
+const STABILITY_TIERS = ["experimental", "stable"];
+export function isStabilityTier(value) {
+  return typeof value === "string" && STABILITY_TIERS.includes(value);
+}
+export const CONFIG_SCHEMA_ID = "https://raw.githubusercontent.com/apmantza/dm-lens/master/docs/schema/dm-lens-config-v1.json";
+export const CONFIG_SCHEMA_ANCHOR_KEY = "$schema";
+export const CONFIG_DIAGNOSTIC_CODES = {
+  PILENS_CFG_0001: "config file unreadable or unparsable; ignored",
+  PILENS_CFG_0002: "deprecated config key accepted",
+  PILENS_CFG_0003: "deprecated config file location accepted",
+  PILENS_CFG_0004: "unknown config field ignored",
+  PILENS_CFG_0005: "config field value rejected by schema; ignored",
+  PILENS_CFG_0006: "config key would modify the object prototype; ignored",
+  PILENS_CFG_0007: "further config notices suppressed by the per-resolution bound",
+  PILENS_CFG_0008: "config resolution failed; whole configuration ignored",
+  PILENS_CFG_0009: "unknown or non-disableable tool config key ignored",
+  PILENS_CFG_0010: "lower-precedence global config file shadowed"
+};
+export const CONFIG_DIAGNOSTIC_CODE_PATTERN = /^PILENS_CFG_\d{4}$/;
+export function isConfigDiagnosticCode(value) {
+  return typeof value === "string" && Object.hasOwn(CONFIG_DIAGNOSTIC_CODES, value);
+}
+export function getConfigDiagnosticCode(code) {
+  return isConfigDiagnosticCode(code) ? CONFIG_DIAGNOSTIC_CODES[code] : undefined;
+}
+export function configDiagnosticMarker(code) {
+  return `[${code}]`;
+}
+export function withConfigDiagnosticCode(message, code) {
+  const marker = configDiagnosticMarker(code);
+  return message.includes(marker) ? message : `${message} ${marker}`;
+}
+export const CONFIG_DIAGNOSTIC_MARKER_PATTERN = /\[(PILENS_CFG_\d{4})\]/;
+const LSP_DEPRECATION_WINDOW = {
+  deprecatedSince: "4.1.4",
+  removeNotBefore: "5.0.0"
+};
+const LEGACY_KEY = {
+  kind: "key",
+  code: "PILENS_CFG_0002",
+  ...LSP_DEPRECATION_WINDOW
+};
+const LEGACY_FILE = {
+  kind: "file",
+  code: "PILENS_CFG_0003",
+  ...LSP_DEPRECATION_WINDOW
+};
+export const DEPRECATED_CONFIG_SURFACES = [
+  {
+    ...LEGACY_KEY,
+    surface: "servers",
+    reason: "custom-server definitions move to the unified catalog schema; the bare string command + args form is replaced by the trust-gated ProcessSpec (#2416)."
+  },
+  {
+    ...LEGACY_KEY,
+    surface: "serverOverrides",
+    reason: "per-server initializationOptions overrides fold into the catalog's field-wise merge, keyed by the same public server IDs (#2416)."
+  },
+  {
+    ...LEGACY_KEY,
+    surface: "disabledServers",
+    reason: "replaced by the catalog's per-entry `enabled: false`, which carries monotonic deny precedence (#1416/#2415)."
+  },
+  {
+    ...LEGACY_KEY,
+    surface: "warmFiles",
+    reason: "session warm-up seeds become a per-server catalog field rather than a config-root list (#2416)."
+  },
+  {
+    ...LEGACY_FILE,
+    surface: ".dm-lens/lsp.json",
+    reason: "project LSP settings consolidate into `.dm-lens.json` under the unified envelope (#2426)."
+  },
+  {
+    ...LEGACY_FILE,
+    surface: "pi-lsp.json",
+    reason: "pre-rename project location; superseded by `.dm-lens.json` (#2426)."
+  },
+  {
+    ...LEGACY_FILE,
+    surface: "dm-lens.json",
+    reason: "undotted project-config basename; superseded by `.dm-lens.json` (#2426)."
+  },
+  {
+    ...LEGACY_FILE,
+    surface: "~/.dm-lens/lsp.json",
+    reason: "global LSP settings consolidate into `~/.dm-lens/config.json` (#2426)."
+  }
+];

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

@@ -0,0 +1,175 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { DEPRECATED_CONFIG_SURFACES } from "./config-diagnostic-codes.js";
+import { errorClassName } from "./error-class.js";
+import { isAtOrAboveHomeDir, isWindowsPath, normalizeFilePath, realpathOrResolve, walkUpDirs } from "./path-utils.js";
+export const CANONICAL_PROJECT_CONFIG_FILE = ".dm-lens.json";
+export const CANONICAL_GLOBAL_CONFIG_FILE = "config.json";
+export const LSP_NAMESPACE_KEY = "lsp";
+const GLOBAL_SURFACE_PREFIX = "~/.dm-lens/";
+const LEGACY_FILE_SURFACES = DEPRECATED_CONFIG_SURFACES.filter((row) => row.kind === "file").map((row) => row.surface);
+export const LEGACY_ROOT_LSP_KEYS = DEPRECATED_CONFIG_SURFACES.filter((row) => row.kind === "key").map((row) => row.surface);
+function isLspScoped(relativePath) {
+  const base = path.posix.basename(relativePath.replace(/\\/g, "/"));
+  return base === "lsp.json" || base === "pi-lsp.json";
+}
+function legacyLocation(relativePath, surface) {
+  return {
+    relativePath,
+    surface,
+    legacy: true,
+    lspScoped: isLspScoped(relativePath)
+  };
+}
+export const PROJECT_CONFIG_LOCATIONS = [
+  legacyLocation("dm-lens.json", "dm-lens.json"),
+  legacyLocation("pi-lsp.json", "pi-lsp.json"),
+  legacyLocation(path.posix.join(".dm-lens", "lsp.json"), ".dm-lens/lsp.json"),
+  {
+    relativePath: CANONICAL_PROJECT_CONFIG_FILE,
+    legacy: false,
+    lspScoped: false
+  }
+];
+export const PROJECT_CONFIG_BASENAMES = PROJECT_CONFIG_LOCATIONS.filter((location) => !location.lspScoped).map((location) => location.relativePath).reverse();
+export const GLOBAL_CONFIG_LOCATIONS = [
+  legacyLocation("lsp.json", `${GLOBAL_SURFACE_PREFIX}lsp.json`),
+  {
+    relativePath: CANONICAL_GLOBAL_CONFIG_FILE,
+    legacy: false,
+    lspScoped: false
+  }
+];
+export const DECLARED_LEGACY_FILE_SURFACES = [
+  ...PROJECT_CONFIG_LOCATIONS,
+  ...GLOBAL_CONFIG_LOCATIONS
+].filter((location) => location.legacy).map((location) => location.surface);
+export const REGISTERED_LEGACY_FILE_SURFACES = LEGACY_FILE_SURFACES;
+export function configSearchDirs(startDir, homeDir = os.homedir()) {
+  const dirs = [];
+  for (const dir of walkUpDirs(startDir)) {
+    if (isAtOrAboveHomeDir(dir, homeDir))
+      break;
+    dirs.push(dir);
+  }
+  return dirs;
+}
+function defaultGlobalConfigExists(file) {
+  try {
+    return fs.statSync(file).isFile();
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return false;
+    throw error;
+  }
+}
+function agentConfigPathFor(agentDir) {
+  return isWindowsPath(agentDir) ? path.win32.join(path.win32.resolve(agentDir), "extensions", "dm-lens.json") : path.join(path.resolve(agentDir), "extensions", "dm-lens.json");
+}
+export function resolveGlobalConfigLocation(options) {
+  const owned = options !== undefined;
+  const homeDir = options?.homeDir ?? os.homedir();
+  const legacyDefault = path.join(homeDir, ".dm-lens", CANONICAL_GLOBAL_CONFIG_FILE);
+  const override = process.env.DM_LENS_CONFIG_PATH;
+  if (override) {
+    return { path: path.resolve(override), source: "dm-lens-config-path" };
+  }
+  let probeError;
+  const probe = (file) => {
+    try {
+      return (options?.exists ?? defaultGlobalConfigExists)(file) ? "present" : "absent";
+    } catch (error) {
+      probeError = error;
+      return "error";
+    }
+  };
+  const agentDir = owned ? undefined : process.env.PI_CODING_AGENT_DIR?.trim();
+  const agentPath = agentDir ? agentConfigPathFor(agentDir) : undefined;
+  const legacyProbe = probe(legacyDefault);
+  if (legacyProbe === "present") {
+    if (agentPath !== undefined && probe(agentPath) === "present") {
+      return {
+        path: legacyDefault,
+        source: "legacy-default-existing",
+        shadowedPath: agentPath
+      };
+    }
+    return { path: legacyDefault, source: "legacy-default-existing" };
+  }
+  if (legacyProbe === "error") {
+    return {
+      path: legacyDefault,
+      source: "legacy-default-unprobed",
+      existsProbeFailed: {
+        path: legacyDefault,
+        errorClassName: errorClassName(probeError)
+      }
+    };
+  }
+  if (agentPath !== undefined) {
+    const agentProbe = probe(agentPath);
+    if (agentProbe === "present") {
+      return { path: agentPath, source: "pi-coding-agent-dir" };
+    }
+    if (agentProbe === "error") {
+      return {
+        path: agentPath,
+        source: "pi-coding-agent-dir-unprobed",
+        existsProbeFailed: {
+          path: agentPath,
+          errorClassName: errorClassName(probeError)
+        }
+      };
+    }
+  }
+  return { path: legacyDefault, source: "canonical-default" };
+}
+let memoizedGlobalConfigResolution;
+function globalConfigEnvFingerprint() {
+  return JSON.stringify([
+    process.env.DM_LENS_CONFIG_PATH,
+    process.env.PI_CODING_AGENT_DIR
+  ]);
+}
+export function getProductionGlobalConfigResolution() {
+  const fingerprint = globalConfigEnvFingerprint();
+  if (memoizedGlobalConfigResolution?.fingerprint !== fingerprint) {
+    memoizedGlobalConfigResolution = {
+      fingerprint,
+      resolution: resolveGlobalConfigLocation()
+    };
+  }
+  return memoizedGlobalConfigResolution.resolution;
+}
+export function resetGlobalConfigLocationCache() {
+  memoizedGlobalConfigResolution = undefined;
+}
+export function getDmLensGlobalConfigPath(homeDir) {
+  return homeDir === undefined ? getProductionGlobalConfigResolution().path : resolveGlobalConfigLocation({ homeDir }).path;
+}
+export function isResolvedGlobalConfigPath(candidate) {
+  return recognizedGlobalConfigPaths().has(canonicalPathIdentity(candidate));
+}
+export function canonicalPathIdentity(candidate) {
+  if (isWindowsPath(candidate)) {
+    return normalizeFilePath(path.win32.resolve(candidate));
+  }
+  return normalizeFilePath(realpathOrResolve(candidate));
+}
+let recognizedCache;
+function recognizedGlobalConfigPaths() {
+  const fingerprint = globalConfigEnvFingerprint();
+  if (recognizedCache?.fingerprint !== fingerprint) {
+    const paths = new Set;
+    const override = process.env.DM_LENS_CONFIG_PATH;
+    if (override)
+      paths.add(canonicalPathIdentity(path.resolve(override)));
+    paths.add(canonicalPathIdentity(path.join(os.homedir(), ".dm-lens", CANONICAL_GLOBAL_CONFIG_FILE)));
+    const agentDir = process.env.PI_CODING_AGENT_DIR?.trim();
+    if (agentDir)
+      paths.add(canonicalPathIdentity(agentConfigPathFor(agentDir)));
+    recognizedCache = { fingerprint, paths };
+  }
+  return recognizedCache.paths;
+}