@ashx-j/lunr 0.2.21 → 0.2.23

package/dist/node-runtime/chunk-UAEOTO52.js

@@ -0,0 +1,119 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+
+// packages/coding-agent/dist/core/session-ownership.js
+import { randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, rmdirSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { hostname } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+var instance = randomUUID(), SessionOwnershipError = class extends Error {
+  file;
+  constructor(file, message = "Session is owned by another runtime. Request a transfer or close its owner first.") {
+    super(`${message} ${file}`), this.name = "SessionOwnershipError", this.file = file;
+  }
+};
+function canonicalSessionPath(file) {
+  let absolute = resolve(file), canonical;
+  if (existsSync(absolute))
+    canonical = realpathSync.native(absolute);
+  else {
+    let parent = dirname(absolute);
+    canonical = parent === absolute ? absolute : join(canonicalSessionPath(parent), basename(absolute));
+  }
+  return process.platform === "win32" ? canonical.toLowerCase() : canonical;
+}
+function sessionOwnershipDirectory(file) {
+  return `${canonicalSessionPath(file)}.owner`;
+}
+function readSessionOwner(file) {
+  let directory = sessionOwnershipDirectory(file);
+  if (existsSync(directory)) {
+    try {
+      let value = JSON.parse(readFileSync(join(directory, "owner.json"), "utf8"));
+      if (value.version === 1 && value.file === canonicalSessionPath(file) && typeof value.generation == "string" && Number.isSafeInteger(value.pid) && value.pid > 0 && typeof value.host == "string" && typeof value.instance == "string")
+        return value;
+    } catch {
+    }
+    throw new SessionOwnershipError(file, "Session owner is incomplete or unknown; automatic takeover is unsafe.");
+  }
+}
+function isSessionOwnerDead(owner) {
+  if (owner.host !== hostname())
+    return !1;
+  try {
+    return process.kill(owner.pid, 0), !1;
+  } catch (error) {
+    return error.code === "ESRCH";
+  }
+}
+function writeSessionJson(file, value) {
+  let temp = `${file}.${randomUUID()}.tmp`;
+  try {
+    writeFileSync(temp, JSON.stringify(value), { flag: "wx", mode: 384 }), renameSync(temp, file);
+  } finally {
+    existsSync(temp) && unlinkSync(temp);
+  }
+}
+var SessionOwnership = class {
+  owner;
+  released = !1;
+  directory;
+  constructor(file) {
+    if (file = canonicalSessionPath(file), existsSync(file) && statSync(file).nlink > 1)
+      throw new SessionOwnershipError(file, "Hard-linked sessions cannot be owned safely. Use a separate copy.");
+    this.directory = sessionOwnershipDirectory(file), this.owner = { version: 1, file, generation: randomUUID(), pid: process.pid, host: hostname(), instance }, mkdirSync(dirname(file), { recursive: !0 });
+    try {
+      mkdirSync(this.directory);
+    } catch (error) {
+      if (error.code !== "EEXIST")
+        throw error;
+      let old = readSessionOwner(file);
+      if (!old || !isSessionOwnerDead(old))
+        throw new SessionOwnershipError(file);
+      let recovery = `${this.directory}.recovery`;
+      try {
+        writeFileSync(recovery, JSON.stringify(this.owner), { flag: "wx", mode: 384 });
+      } catch {
+        throw new SessionOwnershipError(file, "Session recovery is already in progress or requires manual inspection.");
+      }
+      try {
+        let current = readSessionOwner(file);
+        if (current?.generation !== old.generation || !isSessionOwnerDead(current))
+          throw new SessionOwnershipError(file);
+        unlinkSync(join(this.directory, "owner.json")), rmdirSync(this.directory);
+        try {
+          mkdirSync(this.directory);
+        } catch {
+          throw new SessionOwnershipError(file);
+        }
+      } finally {
+        unlinkSync(recovery);
+      }
+    }
+    writeSessionJson(join(this.directory, "owner.json"), this.owner);
+  }
+  bindSession(sessionId) {
+    this.assert(), this.owner.sessionId = sessionId, writeSessionJson(join(this.directory, "owner.json"), this.owner);
+  }
+  assert() {
+    if (existsSync(this.owner.file) && statSync(this.owner.file).nlink > 1)
+      throw new SessionOwnershipError(this.owner.file, "Session acquired a hard-link alias; writes are blocked.");
+    if (this.released || readSessionOwner(this.owner.file)?.generation !== this.owner.generation)
+      throw new SessionOwnershipError(this.owner.file, "This runtime no longer owns the session. Reclaim or reopen it before continuing.");
+  }
+  release() {
+    if (this.released)
+      return;
+    this.assert(), this.released = !0;
+    let releasedDirectory = `${this.directory}.released-${this.owner.generation}`;
+    renameSync(this.directory, releasedDirectory), unlinkSync(join(releasedDirectory, "owner.json")), rmdirSync(releasedDirectory);
+  }
+};
+
+export {
+  SessionOwnershipError,
+  canonicalSessionPath,
+  readSessionOwner,
+  isSessionOwnerDead,
+  writeSessionJson,
+  SessionOwnership
+};

package/dist/node-runtime/{chunk-AY6CAJSL.js → chunk-UJOCPOMX.js}

@@ -1,15 +1,18 @@
 import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  runtimeScope
+} from "./chunk-IMLCWLPI.js";
 
 // packages/coding-agent/dist/core/memory-cap.js
 var MEMORY_CAP_BRIDGE_SYMBOL = /* @__PURE__ */ Symbol.for("@lunr/memory-cap"), MEMORY_CHAR_CAP_DEFAULT = 5e3, MEMORY_CHAR_CAP_MIN = 1, MEMORY_CHAR_CAP_MAX = 3e4, MEMORY_TOOL_NAMES = /* @__PURE__ */ new Set(["memory_add", "memory_remove", "memory_load"]), activeSettingsManager, bridge = {
   isEnabled() {
-    return activeSettingsManager?.getMemoryEnabled() ?? !0;
+    return (runtimeScope.getStore()?.settingsManager ?? activeSettingsManager)?.getMemoryEnabled() ?? !0;
   },
   getCharCap() {
-    return activeSettingsManager?.getMemoryCharCap() ?? MEMORY_CHAR_CAP_DEFAULT;
+    return (runtimeScope.getStore()?.settingsManager ?? activeSettingsManager)?.getMemoryCharCap() ?? MEMORY_CHAR_CAP_DEFAULT;
   },
   setCharCap(cap) {
-    activeSettingsManager?.setMemoryCharCap(cap);
+    (runtimeScope.getStore()?.settingsManager ?? activeSettingsManager)?.setMemoryCharCap(cap);
   }
 };
 function registerMemoryCapBridge(settingsManager) {

package/dist/node-runtime/chunk-UP2XBVH5.js

@@ -0,0 +1,40 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  loadInstallFeatures
+} from "./chunk-VWCE2HSZ.js";
+import {
+  getAgentDir
+} from "./chunk-FQMM2EZ2.js";
+
+// packages/coding-agent/dist/core/browser/settings.js
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+var listeners = /* @__PURE__ */ new Set();
+function browserEnabledDefault() {
+  return loadInstallFeatures().features.browser?.enabled !== !1;
+}
+function readBrowserSettings() {
+  let settings = {};
+  try {
+    settings = JSON.parse(readFileSync(join(getAgentDir(), "settings.json"), "utf8")) ?? {};
+  } catch {
+  }
+  return {
+    enabled: typeof settings.browserEnabled == "boolean" ? settings.browserEnabled : browserEnabledDefault(),
+    allowPrivate: typeof settings.browserAllowPrivateNetwork == "boolean" ? settings.browserAllowPrivateNetwork : loadInstallFeatures().features.browser?.options["allow-private-network"] === !0
+  };
+}
+function onBrowserEnabledChange(listener) {
+  return listeners.add(listener), () => listeners.delete(listener);
+}
+function notifyBrowserEnabledChange(enabled) {
+  for (let listener of listeners)
+    listener(enabled);
+}
+
+export {
+  browserEnabledDefault,
+  readBrowserSettings,
+  onBrowserEnabledChange,
+  notifyBrowserEnabledChange
+};

package/dist/node-runtime/{chunk-WJVFOIB5.js → chunk-UQUCFAJ3.js}

@@ -6,7 +6,7 @@ import {
   loadPdfExtract,
   loadVideoExtract,
   loadYoutubeExtract
-} from "./chunk-7NBZ5P7I.js";
+} from "./chunk-NAY6UUQZ.js";
 import {
   activityMonitor
 } from "./chunk-DAPBPCBP.js";