@wrongstack/core 0.313.0 → 0.313.1

package/dist/chunk-FFSX2QDQ.js

@@ -0,0 +1,362 @@
+import {
+  FORBIDDEN_PROTO_KEYS
+} from "./chunk-DEIQMBD2.js";
+import {
+  atomicWrite
+} from "./chunk-7ZHZE5EO.js";
+
+// src/utils/config-json.ts
+import * as fs from "node:fs/promises";
+async function readJsonObjectFile(filePath) {
+  try {
+    const parsed = JSON.parse(await fs.readFile(filePath, "utf8"));
+    return isJsonObject(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+async function jsonObjectFileExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function writeJsonObjectFile(filePath, value) {
+  await atomicWrite(filePath, JSON.stringify(value, null, 2), { mode: 384 });
+}
+async function updateJsonObjectFile(filePath, mutator) {
+  const config = await readJsonObjectFile(filePath);
+  const maybeNext = await mutator(config);
+  const next = maybeNext && isJsonObject(maybeNext) ? maybeNext : config;
+  await writeJsonObjectFile(filePath, next);
+  return next;
+}
+function isForbiddenSegment(segment) {
+  return typeof segment === "string" && FORBIDDEN_PROTO_KEYS.has(segment);
+}
+function assertSafePath(path) {
+  for (const segment of path) {
+    if (isForbiddenSegment(segment)) {
+      throw new Error(`Refusing to use reserved key "${String(segment)}" in a JSON path`);
+    }
+  }
+}
+function getJsonPath(root, path) {
+  if (path.some(isForbiddenSegment)) return void 0;
+  let current = root;
+  for (const segment of path) {
+    if (typeof segment === "number") {
+      if (!Array.isArray(current)) return void 0;
+      current = current[segment];
+      continue;
+    }
+    if (!isJsonObject(current)) return void 0;
+    current = current[segment];
+  }
+  return current;
+}
+function setJsonPath(root, path, value) {
+  assertSafePath(path);
+  if (path.length === 0) {
+    if (!isJsonObject(value)) throw new Error("Root config value must be an object");
+    return value;
+  }
+  const parent = ensureJsonParent(root, path);
+  const leaf = lastPathSegment(path);
+  if (typeof leaf === "number") {
+    if (!Array.isArray(parent))
+      throw new Error(`Cannot set numeric segment ${leaf} on non-array parent`);
+    parent[leaf] = value;
+  } else {
+    if (!isJsonObject(parent)) throw new Error(`Cannot set property ${leaf} on non-object parent`);
+    parent[leaf] = value;
+  }
+  return root;
+}
+function removeJsonPath(root, path) {
+  if (path.some(isForbiddenSegment)) return false;
+  if (path.length === 0) return false;
+  const parent = getJsonPath(root, path.slice(0, -1));
+  const leaf = lastPathSegment(path);
+  if (typeof leaf === "number") {
+    if (!Array.isArray(parent) || leaf < 0 || leaf >= parent.length) return false;
+    parent.splice(leaf, 1);
+    return true;
+  }
+  if (!isJsonObject(parent) || !(leaf in parent)) return false;
+  delete parent[leaf];
+  return true;
+}
+async function setJsonPathInFile(filePath, path, value) {
+  return updateJsonObjectFile(filePath, (config) => setJsonPath(config, path, value));
+}
+async function removeJsonPathInFile(filePath, path) {
+  return updateJsonObjectFile(filePath, (config) => {
+    removeJsonPath(config, path);
+  });
+}
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function lastPathSegment(path) {
+  const segment = path[path.length - 1];
+  if (segment === void 0) throw new Error("Invalid empty JSON path");
+  return segment;
+}
+function ensureJsonParent(root, path) {
+  assertSafePath(path);
+  let current = root;
+  for (let i = 0; i < path.length - 1; i += 1) {
+    const segment = path[i];
+    const nextSegment = path[i + 1];
+    if (segment === void 0) throw new Error("Invalid empty JSON path segment");
+    const nextContainer = typeof nextSegment === "number" ? [] : {};
+    if (typeof segment === "number") {
+      if (!Array.isArray(current))
+        throw new Error(`Cannot traverse numeric segment ${segment} on non-array parent`);
+      if (!isJsonObject(current[segment]) && !Array.isArray(current[segment]))
+        current[segment] = nextContainer;
+      current = current[segment];
+    } else {
+      if (!isJsonObject(current))
+        throw new Error(`Cannot traverse property ${segment} on non-object parent`);
+      if (!isJsonObject(current[segment]) && !Array.isArray(current[segment]))
+        current[segment] = nextContainer;
+      current = current[segment];
+    }
+  }
+  return current;
+}
+
+// src/utils/json-schema-validate.ts
+function validateAgainstSchema(value, schema) {
+  const errors = [];
+  walk(value, schema, "", errors, 0);
+  return { ok: errors.length === 0, errors };
+}
+var MAX_SCHEMA_DEPTH = 64;
+function walk(value, schema, path, errors, depth) {
+  if (depth > MAX_SCHEMA_DEPTH) {
+    errors.push({
+      path: path || "<root>",
+      message: `schema nesting exceeds maximum depth (${MAX_SCHEMA_DEPTH})`
+    });
+    return;
+  }
+  if (schema.enum !== void 0) {
+    if (!enumIncludes(schema.enum, value)) {
+      errors.push({
+        path: path || "<root>",
+        message: `expected one of ${JSON.stringify(schema.enum)}, got ${JSON.stringify(value)}`
+      });
+      return;
+    }
+  }
+  if (typeof schema.type === "string") {
+    if (!checkType(value, schema.type)) {
+      errors.push({
+        path: path || "<root>",
+        message: `expected ${schema.type}, got ${describeType(value)} (${previewValue(value)})`
+      });
+      return;
+    }
+  }
+  if (schema.type === "object" && isPlainObject(value)) {
+    const obj = value;
+    for (const req of schema.required ?? []) {
+      if (!(req in obj)) {
+        const expected = schema.properties?.[req]?.type;
+        errors.push({
+          path: joinPath(path, req),
+          message: `required property missing${typeof expected === "string" ? ` (expected ${expected})` : ""}`
+        });
+      }
+    }
+    if (schema.properties) {
+      for (const [key, subSchema] of Object.entries(schema.properties)) {
+        if (key in obj) {
+          walk(obj[key], subSchema, joinPath(path, key), errors, depth + 1);
+        }
+      }
+    }
+  }
+  if (schema.type === "array" && Array.isArray(value) && schema.items) {
+    for (let i = 0; i < value.length; i++) {
+      walk(value[i], schema.items, `${path}[${i}]`, errors, depth + 1);
+    }
+  }
+}
+function coerceAgainstSchema(value, schema) {
+  return coerceWalk(value, schema, 0);
+}
+function coerceWalk(value, schema, depth) {
+  if (depth > MAX_SCHEMA_DEPTH) return { value, changed: false };
+  const type = typeof schema.type === "string" ? schema.type : void 0;
+  if (type && !checkType(value, type)) {
+    if (type === "string" && (typeof value === "number" || typeof value === "boolean")) {
+      return { value: String(value), changed: true };
+    }
+    if ((type === "number" || type === "integer") && typeof value === "string") {
+      const trimmed = value.trim();
+      if (trimmed !== "" && /^-?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/.test(trimmed)) {
+        const num = Number(trimmed);
+        if (!Number.isNaN(num) && (type === "number" || Number.isInteger(num))) {
+          return { value: num, changed: true };
+        }
+      }
+      return { value, changed: false };
+    }
+    if (type === "boolean" && typeof value === "string") {
+      const lowered = value.trim().toLowerCase();
+      if (lowered === "true") return { value: true, changed: true };
+      if (lowered === "false") return { value: false, changed: true };
+      return { value, changed: false };
+    }
+    if ((type === "object" || type === "array") && typeof value === "string") {
+      try {
+        const parsed = JSON.parse(value);
+        if (checkType(parsed, type)) {
+          return { value: coerceWalk(parsed, schema, depth + 1).value, changed: true };
+        }
+      } catch {
+      }
+      return { value, changed: false };
+    }
+    return { value, changed: false };
+  }
+  if (type === "object" && isPlainObject(value) && schema.properties) {
+    const obj = value;
+    let changed = false;
+    const out = { ...obj };
+    for (const [key, subSchema] of Object.entries(schema.properties)) {
+      if (!(key in obj)) continue;
+      const r = coerceWalk(obj[key], subSchema, depth + 1);
+      if (r.changed) {
+        out[key] = r.value;
+        changed = true;
+      }
+    }
+    return changed ? { value: out, changed } : { value, changed: false };
+  }
+  if (type === "array" && Array.isArray(value) && schema.items) {
+    let changed = false;
+    const out = value.map((item) => {
+      const r = coerceWalk(item, schema.items, depth + 1);
+      if (r.changed) changed = true;
+      return r.value;
+    });
+    return changed ? { value: out, changed } : { value, changed: false };
+  }
+  return { value, changed: false };
+}
+function checkType(value, type) {
+  switch (type) {
+    case "string":
+      return typeof value === "string";
+    case "number":
+      return typeof value === "number" && !Number.isNaN(value);
+    case "integer":
+      return typeof value === "number" && Number.isInteger(value);
+    case "boolean":
+      return typeof value === "boolean";
+    case "null":
+      return value === null;
+    case "array":
+      return Array.isArray(value);
+    case "object":
+      return isPlainObject(value);
+    default:
+      return true;
+  }
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function describeType(v) {
+  if (v === null) return "null";
+  if (Array.isArray(v)) return "array";
+  return typeof v;
+}
+function previewValue(v) {
+  try {
+    const s = JSON.stringify(v);
+    if (s === void 0) return String(v);
+    return s.length > 80 ? `${s.slice(0, 80)}\u2026` : s;
+  } catch {
+    return String(v);
+  }
+}
+function joinPath(parent, key) {
+  if (!parent) return key;
+  return `${parent}.${key}`;
+}
+function enumIncludes(values, value) {
+  if (value === null || typeof value !== "object") return values.includes(value);
+  return values.some((candidate) => deepEqual(candidate, value));
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (typeof a !== typeof b) return false;
+  if (a === null || b === null) return a === b;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return a.length === b.length && a.every((v, i) => deepEqual(v, b[i]));
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    const ak = Object.keys(a);
+    const bk = Object.keys(b);
+    if (ak.length !== bk.length) return false;
+    return ak.every(
+      (k) => deepEqual(a[k], b[k])
+    );
+  }
+  return false;
+}
+
+// src/utils/tool-name.ts
+import { createHash } from "node:crypto";
+var WIRE_TOOL_NAME_MAX_LENGTH = 128;
+var WIRE_TOOL_NAME_PATTERN = /^[a-zA-Z0-9_-]{1,128}$/;
+var MCP_SERVER_SEGMENT_MAX_LENGTH = 48;
+var MCP_IDENTITY_HASH_LENGTH = 10;
+function sanitizeWireToolName(name) {
+  const replaced = name.replace(/[^a-zA-Z0-9_-]/g, "_");
+  const clamped = replaced.slice(0, WIRE_TOOL_NAME_MAX_LENGTH);
+  return clamped.length > 0 ? clamped : "tool";
+}
+function collisionSafeMcpSegment(value, maxLength) {
+  const replaced = value.replace(/[^a-zA-Z0-9_-]/g, "_") || "tool";
+  if (replaced === value && replaced.length <= maxLength) return replaced;
+  const suffix = `_${createHash("sha256").update(value, "utf8").digest("hex").slice(0, MCP_IDENTITY_HASH_LENGTH)}`;
+  return `${replaced.slice(0, Math.max(1, maxLength - suffix.length))}${suffix}`;
+}
+function mcpServerToolPrefix(serverName) {
+  return `mcp__${collisionSafeMcpSegment(serverName, MCP_SERVER_SEGMENT_MAX_LENGTH)}__`;
+}
+function mcpQualifiedToolName(serverName, toolName) {
+  const prefix = mcpServerToolPrefix(serverName);
+  const toolSegment = collisionSafeMcpSegment(toolName, WIRE_TOOL_NAME_MAX_LENGTH - prefix.length);
+  return `${prefix}${toolSegment}`;
+}
+
+export {
+  readJsonObjectFile,
+  jsonObjectFileExists,
+  writeJsonObjectFile,
+  updateJsonObjectFile,
+  getJsonPath,
+  setJsonPath,
+  removeJsonPath,
+  setJsonPathInFile,
+  removeJsonPathInFile,
+  isJsonObject,
+  validateAgainstSchema,
+  coerceAgainstSchema,
+  WIRE_TOOL_NAME_MAX_LENGTH,
+  WIRE_TOOL_NAME_PATTERN,
+  sanitizeWireToolName,
+  mcpServerToolPrefix,
+  mcpQualifiedToolName
+};
+//# sourceMappingURL=chunk-FFSX2QDQ.js.map