@ashx-j/lunr-dev 0.2.16-dev.9.1 → 0.2.19-dev.10.1

package/dist/node-runtime/{chunk-ECD5L7YI.js → chunk-LCACDWHJ.js}

@@ -9,6 +9,13 @@ import {
   beginCronFire,
   endCronFire
 } from "./chunk-CJECDQKP.js";
+import {
+  processImage
+} from "./chunk-5Q45AVQG.js";
+import {
+  createPermissionContext,
+  deletePermissionContext
+} from "./chunk-ZRDIMBEQ.js";
 import {
   getAgentDir
 } from "./chunk-PCIGF2XK.js";
@@ -1080,6 +1087,362 @@ function startScheduler(deps) {
   };
 }
 
+// packages/coding-agent/dist/gateway/store.js
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname, join as join2 } from "node:path";
+var storePathOverride;
+function storePath() {
+  return storePathOverride ?? join2(getAgentDir(), "gateway-sessions.json");
+}
+function readStore() {
+  let path = storePath();
+  if (!existsSync2(path))
+    return {};
+  try {
+    let parsed = JSON.parse(readFileSync2(path, "utf-8"));
+    if (parsed == null || typeof parsed != "object" || Array.isArray(parsed))
+      return {};
+    let out = {};
+    for (let [key, value] of Object.entries(parsed)) {
+      if (value == null || typeof value != "object")
+        continue;
+      let v2 = value;
+      typeof v2.sessionId != "string" || typeof v2.sessionFile != "string" || (out[key] = {
+        sessionId: v2.sessionId,
+        sessionFile: v2.sessionFile,
+        createdAt: typeof v2.createdAt == "string" ? v2.createdAt : (/* @__PURE__ */ new Date(0)).toISOString(),
+        lastActiveAt: typeof v2.lastActiveAt == "string" ? v2.lastActiveAt : (/* @__PURE__ */ new Date(0)).toISOString()
+      });
+    }
+    return out;
+  } catch {
+    return {};
+  }
+}
+function writeStore(data) {
+  let path = storePath(), dir = dirname(path);
+  existsSync2(dir) || mkdirSync2(dir, { recursive: !0 });
+  let tmp = `${path}.tmp-${process.pid}`;
+  writeFileSync2(tmp, `${JSON.stringify(data, null, 2)}
+`, "utf-8"), renameSync2(tmp, path);
+}
+function getSession(key) {
+  return readStore()[key];
+}
+function putSession(key, entry) {
+  let data = readStore(), existing = data[key], stored = {
+    sessionId: entry.sessionId,
+    sessionFile: entry.sessionFile,
+    createdAt: existing?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    lastActiveAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return data[key] = stored, writeStore(data), stored;
+}
+function touchSession(key) {
+  let data = readStore(), existing = data[key];
+  existing && (existing.lastActiveAt = (/* @__PURE__ */ new Date()).toISOString(), writeStore(data));
+}
+function removeSession(key) {
+  let data = readStore();
+  return key in data ? (delete data[key], writeStore(data), !0) : !1;
+}
+function listSessions() {
+  return readStore();
+}
+
+// packages/coding-agent/dist/gateway/agent-bridge.js
+import { existsSync as existsSync3 } from "node:fs";
+function isUserMessageEntry(entry) {
+  return entry.type === "message";
+}
+var QUEUED = "__lunr_gateway_queued__", CACHE_CAP = 20, QUEUE_CAP = 5, runDepth = 0;
+async function shutdownBridgeSession(session, reason, targetSessionFile) {
+  try {
+    session.extensionRunner?.hasHandlers("session_shutdown") && await session.extensionRunner.emit({
+      type: "session_shutdown",
+      reason,
+      ...targetSessionFile ? { targetSessionFile } : {}
+    });
+  } catch (error) {
+    console.error("[gateway] session shutdown handler failed", error);
+  } finally {
+    session.dispose?.();
+  }
+}
+async function defaultSessionFactory(key, reopen) {
+  let [{ loadAllBuiltinExtensions }, { getAgentDir: getAgentDir2 }, { registerCustomizeBridge }, { registerMemoryCapBridge }, { registerModelTierBridge }, { createAgentSessionFromServices, createAgentSessionServices }, { SessionManager }, { SettingsManager }, { bindRuntimeBridges }] = await Promise.all([
+    import("./builtin-extensions-7STLFW3A.js"),
+    import("./config-FMEOZSWE.js"),
+    import("./customize-XEXL2DGQ.js"),
+    import("./memory-cap-3S4XRLNP.js"),
+    import("./model-tiers-NJLHUEGK.js"),
+    import("./agent-session-services-RSGP5GDN.js"),
+    import("./session-manager-QEMZBMTM.js"),
+    import("./settings-manager-K6IPIQTI.js"),
+    import("./runtime-bridges-UJ5WJJLN.js")
+  ]), cwd = process.cwd(), agentDir = getAgentDir2(), settingsManager = SettingsManager.create(cwd, agentDir, { projectTrusted: !1 });
+  registerModelTierBridge(settingsManager), registerMemoryCapBridge(settingsManager), registerCustomizeBridge(settingsManager);
+  let sessionManager;
+  reopen && existsSync3(reopen.sessionFile) ? sessionManager = SessionManager.open(reopen.sessionFile) : (reopen && console.warn(`[gateway] stored session file missing for ${key}; starting a fresh session`), sessionManager = SessionManager.create(cwd));
+  let services = await createAgentSessionServices({
+    cwd,
+    agentDir,
+    settingsManager,
+    resourceLoaderOptions: { extensionFactories: await loadAllBuiltinExtensions() }
+  }), { session } = await createAgentSessionFromServices({ services, sessionManager });
+  return bindRuntimeBridges({ session, services }), await session.bindExtensions({
+    mode: "print",
+    onError: (err) => console.error(`[gateway] extension error (${err.extensionPath}): ${err.error}`)
+  }), session;
+}
+function extractFinalText(session) {
+  let messages = session.state.messages, last = messages[messages.length - 1];
+  if (last?.role !== "assistant")
+    return "";
+  let assistant = last;
+  if (assistant.stopReason === "error" || assistant.stopReason === "aborted")
+    throw new Error(assistant.errorMessage || `Request ${assistant.stopReason}`);
+  let text = "";
+  for (let content of assistant.content)
+    content.type === "text" && (text += content.text);
+  return text;
+}
+var AgentBridge = class {
+  cap;
+  sessionFactory;
+  cache = /* @__PURE__ */ new Map();
+  redoStack = /* @__PURE__ */ new Map();
+  creating = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.cap = options.cacheCap ?? CACHE_CAP, this.sessionFactory = options.sessionFactory ?? defaultSessionFactory;
+  }
+  /**
+   * Run one conversational turn. Resolves with the final assistant text, or
+   * the QUEUED sentinel when the session was busy (router must not reply).
+   */
+  async runTurn(key, event, callbacks = {}) {
+    let entry = await this.getOrCreate(key);
+    if (entry.busy)
+      return entry.queue.length >= QUEUE_CAP && (entry.queue.shift(), entry.dropped++), entry.queue.push(event), QUEUED;
+    entry.busy = !0;
+    let result;
+    try {
+      result = await this.runPrompt(entry, event.text, callbacks, event.source, event.attachments);
+    } catch (err) {
+      throw entry.busy = !1, err;
+    }
+    return touchSession(key), this.drainQueue(entry, callbacks).finally(() => {
+      entry.busy = !1;
+    }), result;
+  }
+  async abort(key) {
+    await this.cache.get(key)?.session.abort();
+  }
+  /** Return the live session for a key, or null when none exists yet. */
+  async getSession(key) {
+    let cached = this.cache.get(key);
+    return cached ? cached.session : getSession(key) ? (await this.getOrCreate(key)).session : null;
+  }
+  /** Switch the chat to a different persisted session file. */
+  async switchSession(key, sessionFile) {
+    let entry = this.cache.get(key);
+    if (entry?.busy)
+      throw new Error("Session is busy \u2014 /stop first or wait");
+    if (entry) {
+      let oldSessionId = entry.session.sessionManager?.getSessionId();
+      entry.unsubscribe?.(), this.cache.delete(key), await shutdownBridgeSession(entry.session, "resume", sessionFile), oldSessionId && deletePermissionContext(oldSessionId);
+    }
+    removeSession(key), this.redoStack.delete(key);
+    let session = await this.sessionFactory(key, { sessionFile }), newFile = session.sessionManager?.getSessionFile(), newSessionId = session.sessionManager?.getSessionId();
+    newFile && putSession(key, { sessionId: newSessionId ?? key, sessionFile: newFile }), newSessionId && createPermissionContext(newSessionId);
+    let newEntry = { session, busy: !1, queue: [], dropped: 0 };
+    this.cache.set(key, newEntry), newEntry.unsubscribe = this._subscribeToSession(key, newEntry), await this._enforceCacheCap(key);
+  }
+  /** Undo the last user turn and push the previous leaf onto the redo stack. */
+  async undo(key) {
+    let session = await this.getSession(key);
+    if (!session)
+      throw new Error("No session");
+    if (session.isStreaming)
+      throw new Error("Wait for the current response to finish");
+    let branch = session.sessionManager?.getBranch() ?? [], lastUserIndex = -1;
+    for (let i = branch.length - 1; i >= 0; i--) {
+      let entry = branch[i];
+      if (isUserMessageEntry(entry) && entry.message.role === "user") {
+        lastUserIndex = i;
+        break;
+      }
+    }
+    if (lastUserIndex === -1)
+      throw new Error("Nothing to undo");
+    let lastUser = branch[lastUserIndex];
+    if (!isUserMessageEntry(lastUser))
+      throw new Error("Nothing to undo");
+    let leafId = session.sessionManager?.getLeafId() ?? null, targetId;
+    if (lastUser.id === leafId) {
+      if (!lastUser.parentId)
+        throw new Error("Nothing to undo");
+      targetId = lastUser.parentId;
+    } else
+      targetId = lastUser.id;
+    if ((await session.navigateTree(targetId, {})).cancelled)
+      throw new Error("Navigation cancelled");
+    if (leafId) {
+      let stack = this.redoStack.get(key) ?? [];
+      stack.push(leafId), this.redoStack.set(key, stack);
+    }
+    return { userText: extractUserText(lastUser.message) };
+  }
+  /** Redo to the leaf saved by the most recent undo. */
+  async redo(key) {
+    let session = await this.getSession(key);
+    if (!session)
+      throw new Error("No session");
+    if (session.isStreaming)
+      throw new Error("Wait for the current response to finish");
+    let stack = this.redoStack.get(key) ?? [], targetId = stack.pop();
+    if (!targetId)
+      throw new Error("Nothing to redo");
+    if (this.redoStack.set(key, stack), (await session.navigateTree(targetId, {})).cancelled)
+      throw stack.push(targetId), this.redoStack.set(key, stack), new Error("Navigation cancelled");
+  }
+  /** Test/debug hook: how many redo targets are saved for a key. */
+  getRedoStackLength(key) {
+    return this.redoStack.get(key)?.length ?? 0;
+  }
+  /** Drop the cached session (disposing it) and forget the store entry (/new, /reset). */
+  async reset(key) {
+    let entry = this.cache.get(key);
+    if (entry) {
+      entry.queue.length = 0, entry.dropped = 0;
+      try {
+        await entry.session.abort();
+      } catch {
+      }
+      entry.unsubscribe?.(), this.cache.delete(key), await shutdownBridgeSession(entry.session, "new");
+    }
+    removeSession(key), this.redoStack.delete(key);
+  }
+  getStatus(key) {
+    let entry = this.cache.get(key);
+    return {
+      busy: entry?.busy ?? !1,
+      queueDepth: entry?.queue.length ?? 0,
+      createdAt: getSession(key)?.createdAt
+    };
+  }
+  /** One prompt → final text. Increments runDepth; streams deltas when asked. */
+  async runPrompt(entry, text, callbacks, source, attachments) {
+    let { session } = entry, unsubscribe;
+    if (callbacks.onDelta) {
+      let onDelta = callbacks.onDelta, streamedLen = 0;
+      unsubscribe = session.subscribe((event) => {
+        if (event.type !== "message_update")
+          return;
+        let assistantEvent = event.assistantMessageEvent;
+        if (assistantEvent.type !== "text_delta")
+          return;
+        let full = "";
+        for (let content of assistantEvent.partial.content)
+          content.type === "text" && (full += content.text);
+        full.length < streamedLen && (streamedLen = 0), full.length > streamedLen && (onDelta(full.slice(streamedLen)), streamedLen = full.length);
+      });
+    }
+    runDepth++;
+    try {
+      let images = [], notes = [];
+      for (let attachment of attachments ?? []) {
+        let bytes = Buffer.from(attachment.data, "base64"), processed = await processImage(new Uint8Array(bytes), attachment.mimeType);
+        if (processed.ok) {
+          images.push({ type: "image", data: processed.data, mimeType: processed.mimeType });
+          for (let hint of processed.hints)
+            notes.push(hint);
+        } else
+          notes.push(processed.message);
+      }
+      let promptText = notes.length > 0 ? `${text}
+
+${notes.join(" ")}` : text;
+      await runWithOrigin({
+        platform: source.platform,
+        chatId: source.chatId,
+        threadId: source.threadId,
+        chatType: source.chatType
+      }, () => session.prompt(promptText, { source: "extension", ...images.length ? { images } : {} }));
+    } finally {
+      runDepth--, unsubscribe?.();
+    }
+    return extractFinalText(session);
+  }
+  /** Drain the queue FIFO: all queued messages become one concatenated turn. */
+  async drainQueue(entry, callbacks) {
+    for (; entry.queue.length > 0; ) {
+      let items = entry.queue.splice(0), parts = items.map((item) => item.text), attachments = items.flatMap((item) => item.attachments ?? []);
+      entry.dropped > 0 && (parts.unshift(`[gateway: ${entry.dropped} earlier message(s) were dropped \u2014 the queue was full]`), entry.dropped = 0);
+      try {
+        let text = await this.runPrompt(entry, parts.join(`
+
+`), {}, items[items.length - 1].source, attachments);
+        callbacks.onFollowUpResult?.(text);
+      } catch (err) {
+        callbacks.onError?.(err instanceof Error ? err.message : String(err));
+        return;
+      }
+    }
+  }
+  async getOrCreate(key) {
+    let cached = this.cache.get(key);
+    if (cached)
+      return this.cache.delete(key), this.cache.set(key, cached), cached;
+    let pending = this.creating.get(key);
+    if (!pending) {
+      pending = this.createEntry(key), this.creating.set(key, pending);
+      try {
+        await pending;
+      } finally {
+        this.creating.delete(key);
+      }
+    }
+    return pending;
+  }
+  async createEntry(key) {
+    let stored = getSession(key), session = await this.sessionFactory(key, stored ? { sessionFile: stored.sessionFile } : void 0), sessionFile = session.sessionManager?.getSessionFile(), sessionId = session.sessionManager?.getSessionId();
+    sessionFile && putSession(key, { sessionId: sessionId ?? key, sessionFile }), sessionId && createPermissionContext(sessionId);
+    let entry = { session, busy: !1, queue: [], dropped: 0, unsubscribe: void 0 };
+    return this.cache.set(key, entry), entry.unsubscribe = this._subscribeToSession(key, entry), await this._enforceCacheCap(key), entry;
+  }
+  async _enforceCacheCap(protectedKey) {
+    for (; this.cache.size > this.cap; ) {
+      let oldestKey, oldest;
+      for (let [key, entry] of this.cache)
+        if (key !== protectedKey && !entry.busy) {
+          oldestKey = key, oldest = entry;
+          break;
+        }
+      if (!oldest || !oldestKey) {
+        this.cap = this.cache.size;
+        break;
+      }
+      oldest.unsubscribe?.(), this.cache.delete(oldestKey), await shutdownBridgeSession(oldest.session, "quit");
+      let evictedSessionId = oldest.session.sessionManager?.getSessionId();
+      evictedSessionId && deletePermissionContext(evictedSessionId);
+    }
+  }
+  _subscribeToSession(key, entry) {
+    return entry.session.subscribe((event) => this._handleSessionEvent(key, event));
+  }
+  _handleSessionEvent(key, event) {
+    event.type === "message_start" && event.message?.role === "user" && this.redoStack.delete(key);
+  }
+};
+function extractUserText(message) {
+  let text = "";
+  if ("content" in message && Array.isArray(message.content))
+    for (let block of message.content)
+      block && typeof block == "object" && "type" in block && block.type === "text" && "text" in block && typeof block.text == "string" && (text += block.text);
+  return text;
+}
+
 // packages/coding-agent/dist/gateway/text.js
 function utf16Len(s2) {
   return s2.length;
@@ -1158,15 +1521,15 @@ function splitMessage(text, max) {
 var DELIVERY_BRIDGE_SYMBOL = /* @__PURE__ */ Symbol.for("@lunr/cron-delivery"), KNOWN_PLATFORMS = ["telegram", "discord"];
 async function defaultCronSessionFactory(job, modelOverride) {
   let [{ loadAllBuiltinExtensions }, { getAgentDir: getAgentDir2 }, { registerCustomizeBridge }, { registerMemoryCapBridge }, { registerModelTierBridge }, { createAgentSessionFromServices, createAgentSessionServices }, { SessionManager }, { SettingsManager }, { bindRuntimeBridges }] = await Promise.all([
-    import("./builtin-extensions-LYZ3BFWQ.js"),
+    import("./builtin-extensions-7STLFW3A.js"),
     import("./config-FMEOZSWE.js"),
     import("./customize-XEXL2DGQ.js"),
     import("./memory-cap-3S4XRLNP.js"),
     import("./model-tiers-NJLHUEGK.js"),
-    import("./agent-session-services-IFJMSX7Z.js"),
-    import("./session-manager-MQNBYACL.js"),
-    import("./settings-manager-5LF2VQWC.js"),
-    import("./runtime-bridges-PPHNBFWL.js")
+    import("./agent-session-services-RSGP5GDN.js"),
+    import("./session-manager-QEMZBMTM.js"),
+    import("./settings-manager-K6IPIQTI.js"),
+    import("./runtime-bridges-UJ5WJJLN.js")
   ]), cwd = job.workdir ?? process.cwd(), agentDir = getAgentDir2(), settingsManager = SettingsManager.create(cwd, agentDir, { projectTrusted: !1 });
   registerModelTierBridge(settingsManager), registerMemoryCapBridge(settingsManager), registerCustomizeBridge(settingsManager);
   let sessionManager = SessionManager.inMemory(cwd), services = await createAgentSessionServices({
@@ -1183,13 +1546,22 @@ async function defaultCronSessionFactory(job, modelOverride) {
       throw new Error(`no configured auth for provider: ${modelOverride.provider}`);
     model = resolved;
   }
-  let { session } = await createAgentSessionFromServices({ services, sessionManager, model });
-  return bindRuntimeBridges({ session, services }), await session.bindExtensions({
-    mode: "print",
-    onError: (err) => console.error(`[gateway cron] extension error (${err.extensionPath}): ${err.error}`)
-  }), session;
+  let { session } = await createAgentSessionFromServices({ services, sessionManager, model }), permissionId = sessionManager.getSessionId();
+  createPermissionContext(permissionId, settingsManager.getDefaultPermissionMode(), !1);
+  let dispose = session.dispose.bind(session);
+  session.dispose = () => {
+    deletePermissionContext(permissionId), dispose();
+  };
+  try {
+    return bindRuntimeBridges({ session, services }), await session.bindExtensions({
+      mode: "print",
+      onError: (err) => console.error(`[gateway cron] extension error (${err.extensionPath}): ${err.error}`)
+    }), session;
+  } catch (error) {
+    throw await shutdownBridgeSession(session, "quit"), error;
+  }
 }
-function extractFinalText(session) {
+function extractFinalText2(session) {
   let messages = session.state.messages, last = messages[messages.length - 1];
   if (last?.role !== "assistant")
     return "";
@@ -1299,7 +1671,7 @@ async function readCronFallbackModels() {
   try {
     let [{ getAgentDir: getAgentDir2 }, { SettingsManager }] = await Promise.all([
       import("./config-FMEOZSWE.js"),
-      import("./settings-manager-5LF2VQWC.js")
+      import("./settings-manager-K6IPIQTI.js")
     ]), settingsManager = SettingsManager.create(process.cwd(), getAgentDir2(), { projectTrusted: !1 }), out = [];
     for (let entry of settingsManager.getCronFallbackModels()) {
       let idx = entry.indexOf("/");
@@ -1325,13 +1697,13 @@ function startGatewayCron(options) {
         let label = candidate ? `${candidate.provider}/${candidate.modelId}` : "default model", session;
         try {
           session = await sessionFactory(job, candidate), globalThis[DELIVERY_BRIDGE_SYMBOL] = platformDeliverer, await withAttemptTimeout(session.prompt(prompt, { source: "extension" }), attemptTimeoutMs);
-          let text = extractFinalText(session);
+          let text = extractFinalText2(session);
           return candidate ? `[fell back to ${label}]
 ${text}` : text;
         } catch (err) {
           errors.push(`${label}: ${err instanceof Error ? err.message : String(err)}`);
         } finally {
-          session?.dispose?.();
+          session && await shutdownBridgeSession(session, "quit");
         }
       }
       throw new Error(errors.join(" | ") || "no model candidates");
@@ -1359,10 +1731,12 @@ export {
   pauseJob,
   resumeJob,
   removeJob,
-  runWithOrigin,
   currentOrigin,
   executeJob,
   startScheduler,
+  listSessions,
+  QUEUED,
+  AgentBridge,
   splitMessage,
   createDeliverValidator,
   startGatewayCron

package/dist/node-runtime/{chunk-2QKLKMKC.js → chunk-LTXUQJI4.js}

@@ -1,7 +1,7 @@
 import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
 import {
   require_proper_lockfile
-} from "./chunk-AJX357CL.js";
+} from "./chunk-URD2SLIT.js";
 import {
   CONFIG_DIR_NAME,
   canonicalizePath,