@ashx-j/lunr 0.2.21 → 0.2.22

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

@@ -0,0 +1,708 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  createPairingStore
+} from "./chunk-RMQZU2YU.js";
+import {
+  atomicJson
+} from "./chunk-UWPJL22I.js";
+import {
+  noOpUIContext
+} from "./chunk-5BNJ4JUH.js";
+import {
+  NO_HANDLER_REASON,
+  registerApprovalHandler,
+  setPermissionMode
+} from "./chunk-5D7LC2ZQ.js";
+import {
+  loadGatewayConfig,
+  platformConfigFor,
+  saveGatewayConfig
+} from "./chunk-R3K2F5GI.js";
+import {
+  getAgentDir
+} from "./chunk-FQMM2EZ2.js";
+
+// packages/coding-agent/dist/gateway/authz.js
+function envFlagEnabled(name) {
+  let raw = process.env[name];
+  return raw === void 0 ? !1 : ["1", "true", "yes", "on"].includes(raw.toLowerCase());
+}
+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 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"))
+    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)));
+}
+function addAllowedUser(platform, userId) {
+  let cfg = loadGatewayConfig(), platformCfg = platformConfigFor(cfg, platform);
+  if (!platformCfg)
+    throw new Error(`Unknown platform "${platform}"`);
+  platformCfg.allowedUsers.includes(userId) || (platformCfg.allowedUsers.push(userId), saveGatewayConfig(cfg));
+}
+
+// packages/coding-agent/dist/gateway/conversations.js
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+var path = () => join(getAgentDir(), "gateway-conversations.json");
+function conversationBindings() {
+  if (!existsSync(path()))
+    return {};
+  let raw = JSON.parse(readFileSync(path(), "utf8"));
+  if (!raw || typeof raw != "object" || Array.isArray(raw))
+    throw new Error("Invalid gateway conversation store. Restore it before continuing.");
+  return raw;
+}
+function conversationBinding(key) {
+  return conversationBindings()[key];
+}
+function bindConversation(key, source, options = {}) {
+  let all = conversationBindings(), old = all[key];
+  all[key] = {
+    ...old,
+    ...options,
+    source,
+    recentProjects: options.cwd ? [.../* @__PURE__ */ new Set([options.cwd, ...old?.recentProjects ?? []])].slice(0, 12) : old?.recentProjects ?? []
+  }, atomicJson(path(), all);
+}
+
+// packages/coding-agent/dist/gateway/store.js
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, renameSync, writeFileSync } 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 path3 = storePath();
+  if (!existsSync2(path3))
+    return {};
+  try {
+    let parsed = JSON.parse(readFileSync2(path3, "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 v = value;
+      typeof v.sessionId != "string" || typeof v.sessionFile != "string" || (out[key] = {
+        sessionId: v.sessionId,
+        sessionFile: v.sessionFile,
+        createdAt: typeof v.createdAt == "string" ? v.createdAt : (/* @__PURE__ */ new Date(0)).toISOString(),
+        lastActiveAt: typeof v.lastActiveAt == "string" ? v.lastActiveAt : (/* @__PURE__ */ new Date(0)).toISOString()
+      });
+    }
+    return out;
+  } catch {
+    return {};
+  }
+}
+function writeStore(data) {
+  let path3 = storePath(), dir = dirname(path3);
+  existsSync2(dir) || mkdirSync(dir, { recursive: !0 });
+  let tmp = `${path3}.tmp-${process.pid}`;
+  writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
+`, "utf-8"), renameSync(tmp, path3);
+}
+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/approval.js
+import { AsyncLocalStorage } from "node:async_hooks";
+import { randomBytes } from "node:crypto";
+var CALLBACK_PREFIX = "ap:", ID_LENGTH = 8, CODE_ALPHABET = "ABCDEFGHJKMNPQRSTUVWXYZ23456789", DEFAULT_TIMEOUT_MS = 300 * 1e3, approvalContext = new AsyncLocalStorage(), pending = /* @__PURE__ */ new Map();
+function generateId() {
+  let id = "", bytes = randomBytes(ID_LENGTH);
+  for (let i = 0; i < ID_LENGTH; i++)
+    id += CODE_ALPHABET[bytes[i] % CODE_ALPHABET.length];
+  return id;
+}
+function makeCallbackData(id, action) {
+  return `${CALLBACK_PREFIX}${id}:${action}`;
+}
+function parseCallbackData(data) {
+  if (!data.startsWith(CALLBACK_PREFIX))
+    return null;
+  let rest = data.slice(CALLBACK_PREFIX.length), colon = rest.indexOf(":");
+  if (colon === -1)
+    return null;
+  let id = rest.slice(0, colon), action = rest.slice(colon + 1);
+  return action === "once" || action === "session" || action === "reject" || action === "cancel" ? { id, action } : null;
+}
+function runWithApprovalContext(ctx, fn) {
+  return approvalContext.run(ctx, fn);
+}
+async function createApprovalPrompt(adapter, source, req, timeoutMs = DEFAULT_TIMEOUT_MS, key) {
+  let id = generateId(), title = req.kind === "large-subagent-launch" ? `Approve large subagent launch?
+${req.detail}` : `Approve ${req.toolName}?
+${req.detail}`, rows = [
+    [
+      { label: "\u2713 Approve once", data: makeCallbackData(id, "once") },
+      { label: "\u2713 Approve session", data: makeCallbackData(id, "session") }
+    ],
+    [{ label: "\u2717 Reject", data: makeCallbackData(id, "reject") }]
+  ];
+  return new Promise((resolve, reject) => {
+    let messageId, timeout = setTimeout(() => {
+      pending.delete(id), reject(new Error("Approval request timed out")), messageId && adapter.editMessage(source.chatId, messageId, "\u23F1 Approval expired.", []).catch(() => {
+      });
+    }, timeoutMs), entry = {
+      key,
+      source,
+      plan: req.kind === "plan",
+      resolve,
+      reject,
+      timeout,
+      adapter,
+      chatId: source.chatId,
+      threadId: source.threadId,
+      userId: source.userId
+    };
+    pending.set(id, entry), (async () => {
+      try {
+        let result = await adapter.sendButtons(source.chatId, title, rows, { threadId: source.threadId });
+        if (!result.success || !result.messageId)
+          throw new Error(result.error ?? "Failed to send approval prompt");
+        if (messageId = result.messageId, pending.get(id) !== entry) {
+          await adapter.editMessage(source.chatId, messageId, "Approval cancelled or expired.", []).catch(() => {
+          });
+          return;
+        }
+        entry.messageId = messageId;
+      } catch (err) {
+        clearTimeout(timeout), pending.delete(id), reject(err);
+      }
+    })();
+  });
+}
+async function createGatewayApprovalRequest(req) {
+  let ctx = approvalContext.getStore();
+  if (!ctx)
+    throw new Error(NO_HANDLER_REASON);
+  return createApprovalPrompt(ctx.adapter, ctx.source, req, ctx.timeoutMs, ctx.key);
+}
+function registerGatewayApprovalHandler() {
+  registerApprovalHandler(createGatewayApprovalRequest);
+}
+async function handleApprovalCallback(event, adapter) {
+  let parsed = parseCallbackData(event.data);
+  if (!parsed)
+    return !1;
+  let entry = pending.get(parsed.id);
+  if (!entry)
+    return await adapter?.answerCallback(event.id, "Approval expired.").catch(() => {
+    }), !0;
+  if (event.userId !== entry.userId || event.chatId !== entry.chatId || event.threadId !== entry.threadId || adapter && adapter.platform !== entry.adapter.platform)
+    return await entry.adapter.answerCallback(event.id, "\u26D4 Not your approval.").catch(() => {
+    }), !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(() => {
+    }), !0;
+  if (binding && !isAuthorized(entry.source, loadGatewayConfig(), createPairingStore()))
+    return entry.resolve("reject"), !0;
+  if (entry.plan && response !== "reject" && entry.key) {
+    let sessionId = getSession(entry.key)?.sessionId;
+    sessionId && setPermissionMode("manual", sessionId);
+  }
+  entry.resolve(response);
+  let label = parsed.action === "reject" || parsed.action === "cancel" ? "Rejected." : `Approved (${parsed.action}).`;
+  return await entry.adapter.editMessage(entry.chatId, entry.messageId ?? "", label, []).catch(() => {
+  }), await entry.adapter.answerCallback(event.id).catch(() => {
+  }), !0;
+}
+function cancelGatewayApprovals(key) {
+  for (let [id, entry] of pending)
+    entry.key === key && (clearTimeout(entry.timeout), pending.delete(id), entry.resolve("reject"), entry.messageId && entry.adapter.editMessage(entry.chatId, entry.messageId, "Approval cancelled.", []).catch(() => {
+    }));
+}
+
+// packages/coding-agent/dist/gateway/buttons.js
+import { randomBytes as randomBytes2 } from "node:crypto";
+var PICKER_TTL_MS = 900 * 1e3, SWEEP_INTERVAL_MS = 60 * 1e3, DEFAULT_PER_PAGE = 8, BUTTONS_PER_ROW = 2, CODE_ALPHABET2 = "ABCDEFGHJKMNPQRSTUVWXYZ23456789", CODE_LENGTH = 8, CALLBACK_PREFIX2 = "cp:", registry = /* @__PURE__ */ new Map(), sweeper;
+function generatePickerId() {
+  let id = "", bytes = randomBytes2(CODE_LENGTH);
+  for (let i = 0; i < CODE_LENGTH; i++)
+    id += CODE_ALPHABET2[bytes[i] % CODE_ALPHABET2.length];
+  return id;
+}
+function makeCallbackData2(id, action, payload) {
+  return action === "noop" ? `${CALLBACK_PREFIX2}${id}:` : action === "cancel" ? `${CALLBACK_PREFIX2}${id}:x` : action === "page" ? `${CALLBACK_PREFIX2}${id}:p${payload ?? "0"}` : `${CALLBACK_PREFIX2}${id}:${payload ?? ""}`;
+}
+function parseCallbackData2(data) {
+  if (!data.startsWith(CALLBACK_PREFIX2))
+    return null;
+  let rest = data.slice(CALLBACK_PREFIX2.length), colon = rest.indexOf(":");
+  if (colon === -1)
+    return null;
+  let id = rest.slice(0, colon), tail = rest.slice(colon + 1);
+  return tail === "" ? { id, action: "noop" } : tail === "x" ? { id, action: "cancel" } : tail.startsWith("p") ? { id, action: "page", payload: tail.slice(1) } : { id, action: "select", payload: tail };
+}
+function isSameChat(a, b) {
+  return a.platform === b.platform && a.chatId === b.chatId && a.threadId === b.threadId;
+}
+function sourceForAuth(picker, cb) {
+  return {
+    platform: picker.source.platform,
+    chatId: cb.chatId,
+    chatType: picker.source.chatType,
+    userId: cb.userId,
+    userName: cb.userName,
+    threadId: cb.threadId,
+    // Do NOT inherit the original invoker's role authorization.
+    roleAuthorized: void 0
+  };
+}
+function renderPage(picker) {
+  let { id, title, breadcrumbs, items, page, perPage } = picker, totalPages = Math.max(1, Math.ceil(items.length / perPage)), clampedPage = Math.max(0, Math.min(page, totalPages - 1)), start = clampedPage * perPage, pageItems = items.slice(start, start + perPage), rows = [];
+  for (let i = 0; i < pageItems.length; i += BUTTONS_PER_ROW) {
+    let row = [];
+    for (let j = 0; j < BUTTONS_PER_ROW && i + j < pageItems.length; j++) {
+      let index = start + i + j;
+      row.push({ label: pageItems[i + j].label, data: makeCallbackData2(id, "select", String(index)) });
+    }
+    rows.push(row);
+  }
+  if (totalPages > 1) {
+    let nav = [];
+    clampedPage > 0 && nav.push({ label: "\u25C0 Prev", data: makeCallbackData2(id, "page", String(clampedPage - 1)) }), nav.push({ label: `${clampedPage + 1}/${totalPages}`, data: makeCallbackData2(id, "noop") }), clampedPage < totalPages - 1 && nav.push({ label: "Next \u25B6", data: makeCallbackData2(id, "page", String(clampedPage + 1)) }), rows.push(nav);
+  }
+  rows.push([{ label: "\u2717 Cancel", data: makeCallbackData2(id, "cancel") }]);
+  let header = breadcrumbs ? `${title} \xB7 ${breadcrumbs}` : title;
+  return { text: items.length === 0 ? `${header}
+
+No options available.` : `${header} (${clampedPage + 1}/${totalPages}):`, buttons: rows };
+}
+async function createPicker(adapter, source, spec, opts) {
+  let id = generatePickerId(), pending2 = {
+    ...spec,
+    id,
+    chatId: source.chatId,
+    source,
+    adapter,
+    messageId: "",
+    page: 0,
+    perPage: spec.perPage ?? DEFAULT_PER_PAGE,
+    createdAt: Date.now()
+  }, { text, buttons } = renderPage(pending2), result = await adapter.sendButtons(source.chatId, text, buttons, opts);
+  return result.success && result.messageId && (pending2.messageId = result.messageId, registry.set(id, pending2)), result;
+}
+async function answerExpired(adapter, cb) {
+  await adapter.answerCallback(cb.id, "Picker expired \u2014 run the command again.").catch(() => {
+  });
+}
+async function answerUnauthorized(adapter, cb) {
+  await adapter.answerCallback(cb.id, "\u26D4 Not authorized.").catch(() => {
+  });
+}
+async function answerNotYourPicker(adapter, cb) {
+  await adapter.answerCallback(cb.id, "\u26D4 Not your picker.").catch(() => {
+  });
+}
+async function handleCallback(cb, deps) {
+  let { adapter, cfg, pairing } = deps, parsed = parseCallbackData2(cb.data);
+  if (!parsed)
+    return;
+  let picker = registry.get(parsed.id);
+  if (!picker) {
+    await answerExpired(adapter, cb);
+    return;
+  }
+  if (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);
+    try {
+      await picker.adapter.editMessage(picker.chatId, picker.messageId, "\u23F1 Expired \u2014 run the command again.", []);
+    } catch {
+    }
+    await answerExpired(adapter, cb);
+    return;
+  }
+  if (!isSameChat(picker.source, sourceForAuth(picker, cb))) {
+    await answerExpired(adapter, cb);
+    return;
+  }
+  if (cb.userId !== picker.invokerId) {
+    await answerNotYourPicker(adapter, cb);
+    return;
+  }
+  if (!isAuthorized(sourceForAuth(picker, cb), cfg, pairing)) {
+    await answerUnauthorized(adapter, cb);
+    return;
+  }
+  if (parsed.action === "cancel") {
+    registry.delete(parsed.id), picker.onCancel?.();
+    try {
+      await picker.adapter.editMessage(picker.chatId, picker.messageId, "Cancelled.", []);
+    } catch {
+    }
+    await adapter.answerCallback(cb.id).catch(() => {
+    });
+    return;
+  }
+  if (parsed.action === "noop") {
+    await adapter.answerCallback(cb.id).catch(() => {
+    });
+    return;
+  }
+  if (parsed.action === "page") {
+    let page = Number.parseInt(parsed.payload ?? "0", 10), totalPages = Math.max(1, Math.ceil(picker.items.length / picker.perPage));
+    picker.page = Math.max(0, Math.min(page, totalPages - 1));
+    let { text, buttons } = renderPage(picker);
+    try {
+      await picker.adapter.editMessage(picker.chatId, picker.messageId, text, buttons);
+    } catch {
+    }
+    await adapter.answerCallback(cb.id).catch(() => {
+    });
+    return;
+  }
+  let index = Number.parseInt(parsed.payload ?? "", 10), item = picker.items[index];
+  if (!item) {
+    await adapter.answerCallback(cb.id, "Invalid selection.").catch(() => {
+    });
+    return;
+  }
+  if (picker.resolving) {
+    await adapter.answerCallback(cb.id, "Selection is still running.").catch(() => {
+    });
+    return;
+  }
+  picker.resolving = !0, await adapter.answerCallback(cb.id).catch(() => {
+  });
+  try {
+    let result = await picker.resolve(item);
+    if (!result.done) {
+      picker.items = result.items, picker.title = result.title, picker.breadcrumbs = result.breadcrumbs, picker.page = 0;
+      let { text, buttons } = renderPage(picker);
+      try {
+        await picker.adapter.editMessage(picker.chatId, picker.messageId, text, buttons);
+      } catch {
+      }
+      return;
+    }
+    registry.delete(parsed.id);
+    try {
+      await picker.adapter.editMessage(picker.chatId, picker.messageId, result.text, []);
+    } catch {
+    }
+  } 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 {
+    }
+  } finally {
+    picker.resolving = !1;
+  }
+}
+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 {
+        }
+      }
+  }, SWEEP_INTERVAL_MS), sweeper.unref?.());
+}
+function stopButtonSweeper() {
+  sweeper && (clearInterval(sweeper), sweeper = void 0);
+}
+
+// packages/coding-agent/dist/gateway/presenter.js
+import { randomUUID } from "node:crypto";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import { join as join3 } from "node:path";
+
+// packages/coding-agent/dist/gateway/text.js
+function utf16Len(s) {
+  return s.length;
+}
+var graphemeSegmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+function surrogateSafeCut(s, cut) {
+  if (cut > 0) {
+    let code = s.charCodeAt(cut - 1);
+    if (code >= 55296 && code <= 56319)
+      return cut - 1;
+  }
+  return cut;
+}
+function graphemeSafeCut(s, maxIndex) {
+  if (maxIndex <= 0)
+    return 0;
+  let end = 0;
+  for (let segment of graphemeSegmenter.segment(s)) {
+    let nextEnd = segment.index + segment.segment.length;
+    if (nextEnd > maxIndex)
+      break;
+    end = nextEnd;
+  }
+  return surrogateSafeCut(s, end);
+}
+function findSplitPoint(window, limit) {
+  let blank = window.lastIndexOf(`
+
+`);
+  if (blank > 0)
+    return blank + 1;
+  let newline = window.lastIndexOf(`
+`);
+  if (newline > 0)
+    return newline + 1;
+  let space = window.lastIndexOf(" ");
+  return space > 0 ? space + 1 : graphemeSafeCut(window, limit);
+}
+var FENCE_RE = /^\s*```/;
+function openFenceAtEnd(chunk) {
+  let opener;
+  for (let line of chunk.split(`
+`))
+    FENCE_RE.test(line) && (opener = opener === void 0 ? line.trim() : void 0);
+  return opener;
+}
+var FENCE_CLOSE = "\n```";
+function splitRaw(text, limit) {
+  let chunks = [], rest = text;
+  for (; utf16Len(rest) > limit; ) {
+    let cut = findSplitPoint(rest.slice(0, limit), limit), chunk = rest.slice(0, cut).replace(/\s+$/, ""), opener = openFenceAtEnd(chunk);
+    for (; opener !== void 0 && chunk.length + FENCE_CLOSE.length > limit; )
+      cut = findSplitPoint(rest.slice(0, limit - FENCE_CLOSE.length), limit - FENCE_CLOSE.length), chunk = rest.slice(0, cut).replace(/\s+$/, ""), opener = openFenceAtEnd(chunk);
+    opener !== void 0 && chunk === opener && (cut = graphemeSafeCut(rest, Math.max(1, limit - FENCE_CLOSE.length)), chunk = rest.slice(0, cut), opener = openFenceAtEnd(chunk), opener !== void 0 && chunk === opener && (cut = graphemeSafeCut(rest, limit), chunk = rest.slice(0, cut), opener = void 0)), rest = rest.slice(cut).replace(/^\n+/, ""), opener !== void 0 && (chunk += FENCE_CLOSE, rest = `${opener}
+${rest}`), chunk.length > 0 && chunks.push(chunk);
+  }
+  return rest.length > 0 && chunks.push(rest), chunks;
+}
+function indicatorReserve(m) {
+  return 4 + 2 * String(m).length;
+}
+function splitMessage(text, max) {
+  if (max < 1)
+    throw new RangeError("max must be >= 1");
+  if (utf16Len(text) <= max)
+    return [text];
+  let chunks = splitRaw(text, max);
+  if (chunks.length > 1 && max - indicatorReserve(chunks.length) >= 1) {
+    let reserve = indicatorReserve(chunks.length), adjusted = splitRaw(text, max - reserve);
+    chunks = indicatorReserve(adjusted.length) === reserve ? adjusted : splitRaw(text, max - indicatorReserve(adjusted.length));
+  }
+  return chunks.length <= 1 ? chunks : chunks.map((chunk, i) => `${chunk} (${i + 1}/${chunks.length})`);
+}
+
+// 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 = [];
+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());
+}
+function gatewayDestination(key) {
+  let binding = conversationBinding(key), adapter = binding && adapters.get(binding.source.platform);
+  if (!binding || !adapter || !canDeliver(key))
+    throw new Error("This chat is no longer authorized or its platform is disconnected.");
+  return { adapter, source: binding.source };
+}
+function withGatewayPresentation(key, run) {
+  let { adapter, source } = gatewayDestination(key);
+  return runWithApprovalContext({ adapter, source, key }, run);
+}
+function startGatewayPresenter(connected) {
+  if (adapters = connected, existsSync3(path2()))
+    try {
+      outbox = JSON.parse(readFileSync3(path2(), "utf8"));
+    } catch {
+      throw new Error("Gateway outbox is invalid. Restore it before starting.");
+    }
+  timer && clearInterval(timer), timer = setInterval(() => {
+    flushOutbox();
+  }, 3e3), timer.unref(), flushOutbox();
+}
+function stopGatewayPresenter() {
+  timer && clearInterval(timer), timer = void 0;
+  for (let key of dialogs.keys())
+    invalidateGatewayDialogs(key);
+  adapters = /* @__PURE__ */ new Map();
+}
+async function sendGatewayNotice(key, text) {
+  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;
+      }
+    } finally {
+      sending = !1;
+    }
+  }
+}
+function invalidateGatewayDialogs(key) {
+  epochs.set(key, (epochs.get(key) ?? 0) + 1);
+  for (let cancel of dialogs.get(key) ?? [])
+    cancel();
+  dialogs.delete(key), inputs.delete(key);
+}
+function acceptGatewayInput(key, event) {
+  let input = inputs.get(key);
+  return !input || input.userId !== event.source.userId || !canDeliver(key) || event.text.startsWith("/") && event.text !== "/cancel" ? !1 : (input.resolve(event.text === "/cancel" ? void 0 : event.text), !0);
+}
+function dialog(key, opts, show) {
+  let epoch = epochs.get(key) ?? 0;
+  return new Promise((resolve, reject) => {
+    let settled = !1, finish = (value, error) => {
+      settled || (settled = !0, clearTimeout(timeout), opts?.signal?.removeEventListener("abort", cancel), inputs.delete(key), dialogs.get(key)?.delete(cancel), error !== void 0 ? reject(error) : resolve(value));
+    }, done = (value) => finish(value), cancel = () => done(void 0), timeout = setTimeout(cancel, opts?.timeout ?? 3e5), set = dialogs.get(key) ?? /* @__PURE__ */ new Set();
+    if (set.add(cancel), dialogs.set(key, set), opts?.signal?.addEventListener("abort", cancel, { once: !0 }), opts?.signal?.aborted) {
+      cancel();
+      return;
+    }
+    show(done, () => !settled && (epochs.get(key) ?? 0) === epoch && canDeliver(key)).catch((error) => {
+      finish(void 0, error);
+    });
+  });
+}
+function gatewaySelect(key, title, options, opts) {
+  return dialog(key, opts, async (done, valid) => {
+    let { adapter, source } = gatewayDestination(key), result = await createPicker(adapter, source, {
+      kind: "dialog",
+      sessionKey: key,
+      invokerId: source.userId,
+      title,
+      items: options.map((value) => ({ label: value, value })),
+      validate: valid,
+      onCancel: () => done(void 0),
+      resolve: async (item) => (done(item.value), { done: !0, text: `${title}
+${item.value}` })
+    }, { threadId: source.threadId });
+    if (!result.success)
+      throw new Error(result.error ?? "Could not send picker.");
+  });
+}
+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) => {
+    let { source } = gatewayDestination(key);
+    inputs.set(key, { userId: source.userId, resolve: done }), await sendGatewayNotice(key, `${title}${placeholder ? `
+${placeholder}` : ""}
+Reply with text, or /cancel.`);
+  });
+}
+function createGatewayUI(key) {
+  return {
+    ...noOpUIContext,
+    select: (title, options, opts) => gatewaySelect(key, title, options, opts),
+    confirm: async (title, message, opts) => 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),
+    notify: (message) => {
+      sendGatewayNotice(key, message).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(() => {
+      });
+    },
+    setEditorText: (text) => {
+      sendGatewayNotice(key, text).catch(() => {
+      });
+    }
+  };
+}
+
+export {
+  isGatewayOwner,
+  requireGatewayOwner,
+  isAuthorized,
+  addAllowedUser,
+  conversationBinding,
+  bindConversation,
+  getSession,
+  putSession,
+  touchSession,
+  removeSession,
+  listSessions,
+  runWithApprovalContext,
+  registerGatewayApprovalHandler,
+  handleApprovalCallback,
+  cancelGatewayApprovals,
+  createPicker,
+  handleCallback,
+  startButtonSweeper,
+  stopButtonSweeper,
+  splitMessage,
+  withGatewayPresentation,
+  startGatewayPresenter,
+  stopGatewayPresenter,
+  sendGatewayNotice,
+  invalidateGatewayDialogs,
+  acceptGatewayInput,
+  gatewaySelect,
+  gatewayInput,
+  createGatewayUI
+};