@ashx-j/lunr 0.2.24 → 0.2.26

package/dist/node-runtime/{chunk-IGV54Q5V.js → chunk-3MISGG4S.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-RMQZU2YU.js";
 import {
   atomicJson
-} from "./chunk-UWPJL22I.js";
+} from "./chunk-SLVOAQOY.js";
 import {
   noOpUIContext
 } from "./chunk-GJ2RDBRL.js";
@@ -12,12 +12,13 @@ import {
   NO_HANDLER_REASON,
   registerApprovalHandler,
   setPermissionMode
-} from "./chunk-ZXSGTGJ6.js";
+} from "./chunk-WIF24I7G.js";
 import {
+  gatewayConfigPath,
   loadGatewayConfig,
   platformConfigFor,
   saveGatewayConfig
-} from "./chunk-R3K2F5GI.js";
+} from "./chunk-B4HP6ZWM.js";
 import {
   getAgentDir
 } from "./chunk-FQMM2EZ2.js";
@@ -31,15 +32,12 @@ function globalAllowedUsers() {
   let raw = process.env.LUNR_GATEWAY_ALLOWED_USERS;
   return raw ? raw.split(",").map((u) => u.trim()).filter((u) => u.length > 0) : [];
 }
-function isGatewayOwner(source, cfg) {
-  return source.chatType !== "dm" || source.platform !== "telegram" && source.platform !== "discord" ? !1 : cfg.owners?.[source.platform].includes(source.userId) ?? !1;
+function requireAuthorized(source, cfg = loadGatewayConfig()) {
+  if (!isAuthorized(source, cfg))
+    throw new Error("Gateway access is not approved for this user or chat.");
 }
-function requireGatewayOwner(source, cfg = loadGatewayConfig()) {
-  if (!isGatewayOwner(source, cfg))
-    throw new Error("This command is available only to the configured owner in a private chat. Use lunr gateway setup to configure owner access.");
-}
-function isAuthorized(source, cfg, pairing) {
-  if (isGatewayOwner(source, cfg) || envFlagEnabled("LUNR_GATEWAY_ALLOW_ALL_USERS"))
+function isAuthorized(source, cfg, pairing = createPairingStore()) {
+  if ((source.platform === "telegram" || source.platform === "discord") && cfg.owners?.[source.platform].includes(source.userId) || envFlagEnabled("LUNR_GATEWAY_ALLOW_ALL_USERS"))
     return !0;
   let platformCfg = platformConfigFor(cfg, source.platform);
   return !!(platformCfg?.allowedChats.includes(source.chatId) || source.roleAuthorized === !0 || source.userId && pairing.isPaired(source.platform, source.userId) || source.userId && (platformCfg?.allowedUsers.includes(source.userId) || globalAllowedUsers().includes(source.userId)));
@@ -229,8 +227,8 @@ async function handleApprovalCallback(event, adapter) {
     }), !0;
   clearTimeout(entry.timeout), pending.delete(parsed.id);
   let response = parsed.action === "reject" || parsed.action === "cancel" ? "reject" : parsed.action, binding = entry.key ? conversationBinding(entry.key) : void 0;
-  if (binding?.owner && (!isGatewayOwner(entry.source, loadGatewayConfig()) || binding.owner !== event.userId))
-    return entry.resolve("reject"), await entry.adapter.answerCallback(event.id, "Owner access was removed.").catch(() => {
+  if (binding?.owner && binding.owner !== event.userId)
+    return entry.resolve("reject"), await entry.adapter.answerCallback(event.id, "This session belongs to a different user.").catch(() => {
     }), !0;
   if (binding && !isAuthorized(entry.source, loadGatewayConfig(), createPairingStore()))
     return entry.resolve("reject"), !0;
@@ -341,12 +339,12 @@ async function handleCallback(cb, deps) {
     await answerExpired(adapter, cb);
     return;
   }
-  if (picker.validate && !picker.validate()) {
+  if (!picker.completed && picker.validate && !picker.validate()) {
     registry.delete(parsed.id), picker.onCancel?.(), await answerExpired(adapter, cb);
     return;
   }
   if (Date.now() > picker.createdAt + PICKER_TTL_MS) {
-    picker.onCancel?.(), registry.delete(parsed.id);
+    picker.completed || picker.onCancel?.(), registry.delete(parsed.id);
     try {
       await picker.adapter.editMessage(picker.chatId, picker.messageId, "\u23F1 Expired \u2014 run the command again.", []);
     } catch {
@@ -366,6 +364,11 @@ async function handleCallback(cb, deps) {
     await answerUnauthorized(adapter, cb);
     return;
   }
+  if (picker.completed !== void 0) {
+    await adapter.answerCallback(cb.id, "Already completed.").catch(() => {
+    });
+    return;
+  }
   if (parsed.action === "cancel") {
     registry.delete(parsed.id), picker.onCancel?.();
     try {
@@ -417,33 +420,25 @@ async function handleCallback(cb, deps) {
       }
       return;
     }
-    registry.delete(parsed.id);
-    try {
-      await picker.adapter.editMessage(picker.chatId, picker.messageId, result.text, []);
-    } catch {
-    }
+    picker.completed = result.text, await confirmPicker(picker, result.text);
   } catch (err) {
-    registry.delete(parsed.id);
     let message = err instanceof Error ? err.message : String(err);
-    try {
-      await picker.adapter.editMessage(picker.chatId, picker.messageId, `\u26A0 ${message}`, []);
-    } catch {
-    }
+    picker.completed = `\u26A0 ${message}`, await confirmPicker(picker, picker.completed);
   } finally {
     picker.resolving = !1;
   }
 }
+async function confirmPicker(picker, text) {
+  if ((await picker.adapter.editMessage(picker.chatId, picker.messageId, text, []).catch(() => ({ success: !1 }))).success)
+    return;
+  (await picker.adapter.send(picker.chatId, text, { threadId: picker.source.threadId }).catch(() => ({ success: !1 }))).success || console.error(`[gateway] picker confirmation failed on ${picker.adapter.platform}`);
+}
 function startButtonSweeper() {
   sweeper || (sweeper = setInterval(() => {
     let cutoff = Date.now() - PICKER_TTL_MS;
     for (let [id, entry] of registry)
-      if (!(entry.createdAt > cutoff)) {
-        registry.delete(id), entry.onCancel?.();
-        try {
-          entry.adapter.editMessage(entry.chatId, entry.messageId, "\u23F1 Expired \u2014 run the command again.", []);
-        } catch {
-        }
-      }
+      entry.createdAt > cutoff || (registry.delete(id), !entry.completed && (entry.onCancel?.(), entry.adapter.editMessage(entry.chatId, entry.messageId, "\u23F1 Expired \u2014 run the command again.", []).catch(() => {
+      })));
   }, SWEEP_INTERVAL_MS), sweeper.unref?.());
 }
 function stopButtonSweeper() {
@@ -530,13 +525,23 @@ function splitMessage(text, max) {
 }
 
 // packages/coding-agent/dist/gateway/presenter.js
-var epochs = /* @__PURE__ */ new Map(), inputs = /* @__PURE__ */ new Map(), dialogs = /* @__PURE__ */ new Map(), adapters = /* @__PURE__ */ new Map(), timer, sending = !1, path2 = () => join3(getAgentDir(), "gateway-outbox.json"), outbox = [];
+var epochs = /* @__PURE__ */ new Map(), inputs = /* @__PURE__ */ new Map(), dialogs = /* @__PURE__ */ new Map(), adapters = /* @__PURE__ */ new Map(), deliveryConfigs = /* @__PURE__ */ new Map(), roleGrants = /* @__PURE__ */ new Map(), timer, activeDeliveries = /* @__PURE__ */ new Map(), MAX_ATTEMPTS = 5, path2 = () => join3(getAgentDir(), "gateway-outbox.json"), outbox = [];
+function sourceWithCurrentRole(key, source) {
+  let grant = roleGrants.get(key);
+  return {
+    ...source,
+    roleAuthorized: grant?.userId === source.userId && grant.chatId === source.chatId && grant.threadId === source.threadId
+  };
+}
+function rememberGatewayRole(key, source) {
+  source.roleAuthorized === !0 ? roleGrants.set(key, { userId: source.userId, chatId: source.chatId, threadId: source.threadId }) : roleGrants.delete(key);
+}
 function canDeliver(key) {
   let binding = conversationBinding(key);
   if (!binding)
     return !1;
   let cfg = loadGatewayConfig();
-  return binding.owner && (binding.owner !== binding.source.userId || !isGatewayOwner(binding.source, cfg)) ? !1 : isAuthorized(binding.source, cfg, createPairingStore());
+  return binding.owner && binding.owner !== binding.source.userId ? !1 : isAuthorized(sourceWithCurrentRole(key, binding.source), cfg, createPairingStore());
 }
 function gatewayDestination(key) {
   let binding = conversationBinding(key), adapter = binding && adapters.get(binding.source.platform);
@@ -551,56 +556,106 @@ function withGatewayPresentation(key, run) {
 function startGatewayPresenter(connected) {
   if (adapters = connected, existsSync3(path2()))
     try {
-      outbox = JSON.parse(readFileSync3(path2(), "utf8"));
+      let raw = JSON.parse(readFileSync3(path2(), "utf8"));
+      if (!Array.isArray(raw) || !raw.every((item) => item && typeof item.id == "string" && typeof item.key == "string" && typeof item.text == "string"))
+        throw new Error("Invalid outbox");
+      outbox = raw;
     } catch {
       throw new Error("Gateway outbox is invalid. Restore it before starting.");
     }
+  else
+    outbox = [];
+  for (let item of outbox)
+    item.kind === "notice" && epochs.set(item.key, Math.max(epochs.get(item.key) ?? 0, item.epoch ?? 0));
   timer && clearInterval(timer), timer = setInterval(() => {
-    flushOutbox();
-  }, 3e3), timer.unref(), flushOutbox();
+    flushOutbox().catch((error) => console.error("[gateway] outbox flush failed:", error));
+  }, 3e3), timer.unref(), flushOutbox().catch((error) => console.error("[gateway] outbox flush failed:", error));
 }
 function stopGatewayPresenter() {
   timer && clearInterval(timer), timer = void 0;
   for (let key of dialogs.keys())
     invalidateGatewayDialogs(key);
-  adapters = /* @__PURE__ */ new Map();
+  adapters = /* @__PURE__ */ new Map(), deliveryConfigs.clear(), roleGrants.clear();
 }
-async function sendGatewayNotice(key, text) {
+function gatewayEpoch(key) {
+  return epochs.get(key) ?? 0;
+}
+async function sendGatewayNotice(key, text, kind = "notice", epoch = gatewayEpoch(key)) {
   let clean = text.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "").trim();
   if (!clean || !canDeliver(key))
     return;
-  let { adapter } = gatewayDestination(key);
-  for (let chunk of splitMessage(clean, adapter.maxMessageLength))
-    outbox.push({ id: randomUUID(), key, epoch: epochs.get(key) ?? 0, text: chunk });
-  atomicJson(path2(), outbox), await flushOutbox();
-}
-async function flushOutbox() {
-  if (!sending) {
-    sending = !0;
-    try {
-      for (let item of [...outbox]) {
-        if (!canDeliver(item.key)) {
-          outbox = outbox.filter((v) => v.id !== item.id), atomicJson(path2(), outbox);
-          continue;
-        }
-        let target;
-        try {
-          target = gatewayDestination(item.key);
-        } catch {
-          continue;
-        }
-        if ((await target.adapter.send(target.source.chatId, item.text, { threadId: target.source.threadId }).catch(() => ({ success: !1 }))).success)
-          outbox = outbox.filter((v) => v.id !== item.id), atomicJson(path2(), outbox);
-        else
-          break;
+  let { adapter, source } = gatewayDestination(key);
+  await queueGatewayText(key, source, adapter, clean, { kind, epoch });
+}
+async function queueGatewayText(key, source, adapter, text, options) {
+  if (!text || options.kind === "notice" && options.epoch !== void 0 && options.epoch !== gatewayEpoch(key))
+    return;
+  adapters.set(source.platform, adapter), options.cfg && deliveryConfigs.set(key, options.cfg);
+  let chunks = options.chunks ?? splitMessage(text, adapter.maxMessageLength), batchId = randomUUID();
+  for (let [index, chunk] of chunks.entries())
+    outbox.push({
+      id: randomUUID(),
+      batchId,
+      key,
+      source: { ...source, roleAuthorized: void 0 },
+      epoch: options.epoch ?? gatewayEpoch(key),
+      text: chunk,
+      kind: options.kind,
+      replyTo: index === 0 ? options.replyTo : void 0
+    });
+  atomicJson(path2(), outbox), activeDeliveries.has(key) && await activeDeliveries.get(key), await flushKey(key);
+}
+function flushOutbox() {
+  return Promise.all([...new Set(outbox.map((item) => item.key))].map(flushKey)).then(() => {
+  });
+}
+function flushKey(key) {
+  let current = activeDeliveries.get(key);
+  if (current)
+    return current;
+  let running = drainKey(key).finally(() => {
+    activeDeliveries.delete(key);
+  });
+  return activeDeliveries.set(key, running), running;
+}
+async function drainKey(key) {
+  let failedBatches = new Set(outbox.filter((item) => item.failed && item.batchId).map((item) => item.batchId));
+  for (let item of [...outbox].filter((item2) => item2.key === key)) {
+    if (item.failed || item.batchId && failedBatches.has(item.batchId))
+      continue;
+    if (item.kind === "notice" && item.epoch !== (epochs.get(item.key) ?? 0)) {
+      outbox = outbox.filter((v) => v.id !== item.id), atomicJson(path2(), outbox);
+      continue;
+    }
+    let binding = conversationBinding(item.key), source = item.source ?? binding?.source;
+    if (!source)
+      break;
+    let cfg = existsSync3(gatewayConfigPath()) ? loadGatewayConfig() : deliveryConfigs.get(item.key) ?? loadGatewayConfig();
+    if (binding && (binding.source.platform !== source.platform || binding.source.chatId !== source.chatId || binding.source.userId !== source.userId || binding.source.threadId !== source.threadId) || !isAuthorized(sourceWithCurrentRole(key, source), cfg, createPairingStore()) || binding?.owner && binding.owner !== source.userId) {
+      outbox = outbox.filter((v) => v.id !== item.id), atomicJson(path2(), outbox);
+      continue;
+    }
+    let adapter = adapters.get(source.platform);
+    if (!adapter || (item.nextAttempt ?? 0) > Date.now())
+      break;
+    let opts = { threadId: source.threadId, replyTo: item.replyTo }, result = await adapter.send(source.chatId, item.text, opts).catch((error) => ({ success: !1, error: String(error), retryable: !0 }));
+    if (result.success)
+      outbox = outbox.filter((v) => v.id !== item.id), atomicJson(path2(), outbox);
+    else {
+      if (item.attempts = (item.attempts ?? 0) + 1, item.failed = result.retryable === !1 || item.attempts >= MAX_ATTEMPTS, item.nextAttempt = Date.now() + Math.min(6e4, 3e3 * 2 ** (item.attempts - 1)), item.failed && item.batchId) {
+        failedBatches.add(item.batchId);
+        for (let pending2 of outbox)
+          pending2.batchId === item.batchId && (pending2.failed = !0);
       }
-    } finally {
-      sending = !1;
+      atomicJson(path2(), outbox), console.error(`[gateway] delivery ${item.failed ? "failed permanently" : "retry scheduled"} for ${source.platform}: ${result.error ?? "unknown error"}`);
+      break;
     }
   }
 }
 function invalidateGatewayDialogs(key) {
   epochs.set(key, (epochs.get(key) ?? 0) + 1);
+  let remaining = outbox.filter((item) => item.key !== key || item.kind !== "notice");
+  remaining.length !== outbox.length && (outbox = remaining, atomicJson(path2(), outbox));
   for (let cancel of dialogs.get(key) ?? [])
     cancel();
   dialogs.delete(key), inputs.delete(key);
@@ -642,42 +697,45 @@ ${item.value}` })
   });
 }
 function gatewayInput(key, title, placeholder, opts) {
-  return inputs.has(key) ? Promise.reject(new Error("Answer or cancel the existing question first.")) : dialog(key, opts, async (done) => {
+  if (inputs.has(key))
+    return Promise.reject(new Error("Answer or cancel the existing question first."));
+  let epoch = gatewayEpoch(key);
+  return dialog(key, opts, async (done) => {
     let { source } = gatewayDestination(key);
     inputs.set(key, { userId: source.userId, resolve: done }), await sendGatewayNotice(key, `${title}${placeholder ? `
 ${placeholder}` : ""}
-Reply with text, or /cancel.`);
+Reply with text, or /cancel.`, "notice", epoch);
   });
 }
 function createGatewayUI(key) {
+  let epoch = gatewayEpoch(key);
   return {
     ...noOpUIContext,
-    select: (title, options, opts) => gatewaySelect(key, title, options, opts),
-    confirm: async (title, message, opts) => await gatewaySelect(key, `${title}
+    select: (title, options, opts) => gatewayEpoch(key) === epoch ? gatewaySelect(key, title, options, opts) : Promise.resolve(void 0),
+    confirm: async (title, message, opts) => gatewayEpoch(key) === epoch && await gatewaySelect(key, `${title}
 ${message}`, ["Approve", "Decline"], opts) === "Approve",
-    input: (title, placeholder, opts) => gatewayInput(key, title, placeholder, opts),
-    editor: (title, prefill) => gatewayInput(key, title, prefill),
+    input: (title, placeholder, opts) => gatewayEpoch(key) === epoch ? gatewayInput(key, title, placeholder, opts) : Promise.resolve(void 0),
+    editor: (title, prefill) => gatewayEpoch(key) === epoch ? gatewayInput(key, title, prefill) : Promise.resolve(void 0),
     notify: (message) => {
-      sendGatewayNotice(key, message).catch(() => {
+      sendGatewayNotice(key, message, "notice", epoch).catch(() => {
       });
     },
     custom: async () => {
       throw new Error("This command requires the terminal interface. Use the gateway's text commands or button pickers.");
     },
     pasteToEditor: (text) => {
-      sendGatewayNotice(key, text).catch(() => {
+      sendGatewayNotice(key, text, "notice", epoch).catch(() => {
       });
     },
     setEditorText: (text) => {
-      sendGatewayNotice(key, text).catch(() => {
+      sendGatewayNotice(key, text, "notice", epoch).catch(() => {
       });
     }
   };
 }
 
 export {
-  isGatewayOwner,
-  requireGatewayOwner,
+  requireAuthorized,
   isAuthorized,
   addAllowedUser,
   conversationBinding,
@@ -696,10 +754,13 @@ export {
   startButtonSweeper,
   stopButtonSweeper,
   splitMessage,
+  rememberGatewayRole,
   withGatewayPresentation,
   startGatewayPresenter,
   stopGatewayPresenter,
+  gatewayEpoch,
   sendGatewayNotice,
+  queueGatewayText,
   invalidateGatewayDialogs,
   acceptGatewayInput,
   gatewaySelect,