@wrongstack/core 0.310.1 → 0.313.1

package/dist/chunk-CQQL4ZOQ.js

@@ -0,0 +1,151 @@
+import {
+  ensureProjectGitignore
+} from "./chunk-4XV6IR37.js";
+
+// src/utils/config-backup.ts
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+function configHistoryDir(globalRoot) {
+  return path.join(globalRoot, "config-history");
+}
+function configSlug(absolutePath, globalRoot) {
+  const rel = path.relative(globalRoot, absolutePath);
+  const normalized = rel.replace(/\\/g, "/").replace(/\.json$/i, "");
+  return normalized.replace(/\//g, "-");
+}
+async function backupConfigFile(filePath, paths) {
+  let currentContent;
+  try {
+    currentContent = await fs.readFile(filePath, "utf8");
+    if (!currentContent.trim()) return;
+  } catch {
+    return;
+  }
+  const now = /* @__PURE__ */ new Date();
+  const ts = now.toISOString().replace(/[:.]/g, "-").replace(/Z$/, "");
+  const slug = configSlug(filePath, paths.globalRoot);
+  const backupDir = configHistoryDir(paths.globalRoot);
+  const backupFile = path.join(backupDir, `${slug}-${ts}.json`);
+  try {
+    await fs.mkdir(backupDir, { recursive: true });
+    await fs.writeFile(backupFile, currentContent, { mode: 384, encoding: "utf8" });
+  } catch {
+  }
+}
+
+// src/utils/project-state-guard.ts
+import * as fs2 from "node:fs";
+import * as fsp from "node:fs/promises";
+import * as path2 from "node:path";
+var PROJECT_STATE_DIRECTORY = ".wrongstack";
+var DEFAULT_POLL_INTERVAL_MS = 1e3;
+var REPAIR_DEBOUNCE_MS = 25;
+var ACTIVE_GUARD_KEY = /* @__PURE__ */ Symbol.for("wrongstack.activeProjectStateGuard");
+var globalScope = globalThis;
+globalScope[ACTIVE_GUARD_KEY] ??= {};
+var activeGuard = globalScope[ACTIVE_GUARD_KEY];
+function normalizedRoot(root) {
+  const resolved = path2.resolve(root);
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function concernsProjectState(filename) {
+  if (filename === null) return true;
+  const firstSegment = String(filename).replaceAll("\\", "/").split("/")[0];
+  return firstSegment?.toLowerCase() === PROJECT_STATE_DIRECTORY;
+}
+async function startProjectStateGuard(projectRoot, options = {}) {
+  const root = path2.resolve(projectRoot);
+  const directory = path2.join(root, PROJECT_STATE_DIRECTORY);
+  const pollIntervalMs = Math.max(25, options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS);
+  let closed = false;
+  let repairPending = false;
+  let repairInFlight;
+  let repairTimer;
+  const ensureDirectory = async () => {
+    await fsp.mkdir(directory, { recursive: true });
+  };
+  const ensureInvariant = async () => {
+    await ensureDirectory();
+    try {
+      await ensureProjectGitignore(root);
+    } catch (error) {
+      options.onError?.(error);
+    }
+  };
+  const scheduleRepair = () => {
+    if (closed) return;
+    repairPending = true;
+    if (repairInFlight || repairTimer) return;
+    repairTimer = setTimeout(() => {
+      repairTimer = void 0;
+      repairInFlight = (async () => {
+        while (!closed && repairPending) {
+          repairPending = false;
+          try {
+            const rootState = await fsp.stat(root).catch(() => void 0);
+            if (!rootState?.isDirectory()) return;
+            await ensureInvariant();
+          } catch (error) {
+            options.onError?.(error);
+          }
+        }
+      })().finally(() => {
+        repairInFlight = void 0;
+        if (repairPending && !closed) scheduleRepair();
+      });
+    }, REPAIR_DEBOUNCE_MS);
+    repairTimer.unref?.();
+  };
+  await ensureDirectory();
+  await ensureProjectGitignore(root).catch((error) => options.onError?.(error));
+  let watcher;
+  try {
+    watcher = fs2.watch(root, { persistent: false }, (_eventType, filename) => {
+      if (concernsProjectState(filename) || String(filename).toLowerCase() === ".gitignore") {
+        scheduleRepair();
+      }
+    });
+    watcher.on("error", (error) => {
+      options.onError?.(error);
+      watcher = void 0;
+      scheduleRepair();
+    });
+  } catch (error) {
+    options.onError?.(error);
+  }
+  const poll = setInterval(scheduleRepair, pollIntervalMs);
+  poll.unref?.();
+  return {
+    directory,
+    close() {
+      if (closed) return;
+      closed = true;
+      clearInterval(poll);
+      if (repairTimer) clearTimeout(repairTimer);
+      repairTimer = void 0;
+      try {
+        watcher?.close();
+      } catch {
+      }
+      watcher = void 0;
+    }
+  };
+}
+async function activateProjectStateGuard(projectRoot, options = {}) {
+  const root = normalizedRoot(projectRoot);
+  if (activeGuard.root === root && activeGuard.guard) return activeGuard.guard;
+  const next = await startProjectStateGuard(projectRoot, options);
+  const previous = activeGuard.guard;
+  activeGuard.root = root;
+  activeGuard.guard = next;
+  previous?.close();
+  return next;
+}
+
+export {
+  configHistoryDir,
+  backupConfigFile,
+  startProjectStateGuard,
+  activateProjectStateGuard
+};
+//# sourceMappingURL=chunk-CQQL4ZOQ.js.map

package/dist/chunk-DEIQMBD2.js

@@ -0,0 +1,65 @@
+// src/utils/deep-merge.ts
+var FORBIDDEN_PROTO_KEYS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype",
+  "__defineGetter__",
+  "__defineSetter__",
+  "__lookupGetter__",
+  "__lookupSetter__"
+]);
+function isPrimitiveArray(a) {
+  return a.every((v) => v === null || typeof v !== "object" && typeof v !== "function");
+}
+function deepMerge(base, patch, options = {}) {
+  const {
+    conflictResolution = "prefer-patch",
+    arrayMode = "replace",
+    protectProto = true,
+    onNonPrimitiveArrayReplace
+  } = options;
+  if (typeof base !== "object" || base === null) {
+    return conflictResolution === "prefer-patch" ? patch : base;
+  }
+  if (typeof patch !== "object" || patch === null) {
+    return conflictResolution === "prefer-patch" ? patch : base;
+  }
+  if (Array.isArray(base) && Array.isArray(patch)) {
+    if (arrayMode === "concat-primitives" && isPrimitiveArray(base) && isPrimitiveArray(patch)) {
+      return [.../* @__PURE__ */ new Set([...base, ...patch])];
+    }
+    return conflictResolution === "prefer-patch" ? patch : base;
+  }
+  if (Array.isArray(base) || Array.isArray(patch)) {
+    return conflictResolution === "prefer-patch" ? patch : base;
+  }
+  const baseObj = base;
+  const patchObj = patch;
+  const out = { ...baseObj };
+  for (const [k, v] of Object.entries(patchObj)) {
+    if (protectProto && FORBIDDEN_PROTO_KEYS.has(k)) continue;
+    const existing = out[k];
+    if (v !== null && typeof v === "object" && !Array.isArray(v) && existing !== null && typeof existing === "object" && !Array.isArray(existing)) {
+      out[k] = deepMerge(existing, v, options);
+    } else if (Array.isArray(v) && Array.isArray(existing)) {
+      if (onNonPrimitiveArrayReplace && !isPrimitiveArray(v)) {
+        onNonPrimitiveArrayReplace(k, existing.length, v.length);
+      }
+      out[k] = deepMerge(existing, v, options);
+    } else if (v !== void 0) {
+      if (onNonPrimitiveArrayReplace && Array.isArray(v) && !isPrimitiveArray(v)) {
+        const existingLen = Array.isArray(existing) ? existing.length : 0;
+        onNonPrimitiveArrayReplace(k, existingLen, v.length);
+      }
+      out[k] = v;
+    }
+  }
+  return out;
+}
+
+export {
+  FORBIDDEN_PROTO_KEYS,
+  isPrimitiveArray,
+  deepMerge
+};
+//# sourceMappingURL=chunk-DEIQMBD2.js.map

package/dist/chunk-E6I5RXVK.js

@@ -0,0 +1,58 @@
+import {
+  assertUnixSocketPathWithinLimit
+} from "./chunk-FAYRX2AD.js";
+
+// src/session-catalog/protocol.ts
+var SESSION_CATALOG_PROTOCOL_VERSION = 1;
+var SESSION_CATALOG_MAX_FRAME_CHARS = 4 * 1024 * 1024;
+var SESSION_CATALOG_DEFAULT_LEASE_MS = 3e4;
+var SESSION_CATALOG_DEFAULT_RESERVATION_MS = 15e3;
+var SESSION_CATALOG_MAX_AGENTS = 128;
+function encodeSessionCatalogMessage(message) {
+  return `${JSON.stringify(message)}
+`;
+}
+
+// src/session-catalog/endpoint.ts
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+var SESSION_CATALOG_METADATA_FILE = ".session-catalog-server.json";
+function normalizedPath(value) {
+  const resolved = path.resolve(value);
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function sessionCatalogProjectServerKey(projectDir) {
+  return createHash("sha256").update(normalizedPath(projectDir)).digest("hex").slice(0, 24);
+}
+function sessionCatalogProjectServerEndpoint(projectDir) {
+  const key = sessionCatalogProjectServerKey(projectDir);
+  if (process.platform === "win32") {
+    return `\\\\.\\pipe\\wrongstack-session-catalog-v${SESSION_CATALOG_PROTOCOL_VERSION}-${key}`;
+  }
+  return path.join(os.tmpdir(), `wssc-v${SESSION_CATALOG_PROTOCOL_VERSION}`, `${key}.sock`);
+}
+function sessionCatalogProjectServerMetadataPath(projectDir) {
+  return path.join(projectDir, SESSION_CATALOG_METADATA_FILE);
+}
+function ensureSessionCatalogSocketDirectory(endpoint) {
+  if (process.platform === "win32") return;
+  assertUnixSocketPathWithinLimit(endpoint, "session-catalog");
+  fs.mkdirSync(path.dirname(endpoint), { recursive: true, mode: 448 });
+}
+
+export {
+  SESSION_CATALOG_PROTOCOL_VERSION,
+  SESSION_CATALOG_MAX_FRAME_CHARS,
+  SESSION_CATALOG_DEFAULT_LEASE_MS,
+  SESSION_CATALOG_DEFAULT_RESERVATION_MS,
+  SESSION_CATALOG_MAX_AGENTS,
+  encodeSessionCatalogMessage,
+  SESSION_CATALOG_METADATA_FILE,
+  sessionCatalogProjectServerKey,
+  sessionCatalogProjectServerEndpoint,
+  sessionCatalogProjectServerMetadataPath,
+  ensureSessionCatalogSocketDirectory
+};
+//# sourceMappingURL=chunk-E6I5RXVK.js.map