@ashx-j/lunr 0.2.26 → 0.2.28

package/dist/node-runtime/chunk-4QRUZ64T.js

@@ -0,0 +1,1203 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  createPairingStore
+} from "./chunk-NNNR3QIY.js";
+import {
+  atomicJson
+} from "./chunk-WXYNALHD.js";
+import {
+  noOpUIContext
+} from "./chunk-BYC6RKCN.js";
+import {
+  getSubagentCancellation
+} from "./chunk-BBUVIEZB.js";
+import {
+  NO_HANDLER_REASON,
+  PERMISSION_MODES,
+  getPermissionMode,
+  registerApprovalHandler,
+  setPermissionMode
+} from "./chunk-APVM5NEU.js";
+import {
+  SessionManager
+} from "./chunk-PWHTSQC4.js";
+import {
+  gatewayConfigPath,
+  loadGatewayConfig,
+  platformConfigFor,
+  saveGatewayConfig
+} from "./chunk-RHCGYWO7.js";
+import {
+  getAgentDir
+} from "./chunk-64XTQNLA.js";
+
+// packages/coding-agent/dist/gateway/mobile-commands.js
+import { mkdirSync as mkdirSync2, readdirSync, realpathSync, statSync } from "node:fs";
+import { basename, dirname as dirname2, isAbsolute, join as join4, relative, resolve } from "node:path";
+
+// 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 requireAuthorized(source, cfg = loadGatewayConfig()) {
+  if (!isAuthorized(source, cfg))
+    throw new Error("Gateway access is not approved for this user or chat.");
+}
+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)));
+}
+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/buttons.js
+import { randomBytes } from "node:crypto";
+import { existsSync as existsSync2 } from "node:fs";
+
+// 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/buttons.js
+var PICKER_TTL_MS = 900 * 1e3, SWEEP_INTERVAL_MS = 60 * 1e3, DEFAULT_PER_PAGE = 8, BUTTONS_PER_ROW = 2, CODE_ALPHABET = "ABCDEFGHJKMNPQRSTUVWXYZ23456789", CODE_LENGTH = 8, CALLBACK_PREFIX = "cp:", GatewayPickerCancelled = class extends Error {
+}, registry = /* @__PURE__ */ new Map(), generations = /* @__PURE__ */ new Map();
+function gatewayPickerGeneration(key) {
+  return generations.get(key) ?? 0;
+}
+function invalidateGatewayPickers(key) {
+  generations.set(key, gatewayPickerGeneration(key) + 1);
+  for (let [id, picker] of registry)
+    picker.sessionKey !== key || picker.completed !== void 0 || (registry.delete(id), picker.onCancel?.());
+}
+function pickerRequesterValid(picker) {
+  let binding = conversationBinding(picker.sessionKey);
+  return !binding || (!binding.owner || binding.owner === picker.invokerId) && binding.source.platform === picker.source.platform && binding.source.chatId === picker.source.chatId && binding.source.userId === picker.invokerId && binding.source.threadId === picker.source.threadId;
+}
+function pickerValid(picker) {
+  return picker.generation === gatewayPickerGeneration(picker.sessionKey) && pickerRequesterValid(picker) && (!picker.validate || picker.validate());
+}
+var sweeper;
+function generatePickerId() {
+  let id = "", bytes = randomBytes(CODE_LENGTH);
+  for (let i = 0; i < CODE_LENGTH; i++)
+    id += CODE_ALPHABET[bytes[i] % CODE_ALPHABET.length];
+  return id;
+}
+function makeCallbackData(id, action, payload) {
+  return action === "noop" ? `${CALLBACK_PREFIX}${id}:` : action === "cancel" ? `${CALLBACK_PREFIX}${id}:x` : action === "page" ? `${CALLBACK_PREFIX}${id}:p${payload ?? "0"}` : `${CALLBACK_PREFIX}${id}:${payload ?? ""}`;
+}
+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), 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: makeCallbackData(id, "select", String(index)) });
+    }
+    rows.push(row);
+  }
+  if (totalPages > 1) {
+    let nav = [];
+    clampedPage > 0 && nav.push({ label: "\u25C0 Prev", data: makeCallbackData(id, "page", String(clampedPage - 1)) }), nav.push({ label: `${clampedPage + 1}/${totalPages}`, data: makeCallbackData(id, "noop") }), clampedPage < totalPages - 1 && nav.push({ label: "Next \u25B6", data: makeCallbackData(id, "page", String(clampedPage + 1)) }), rows.push(nav);
+  }
+  rows.push([{ label: "\u2717 Cancel", data: makeCallbackData(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,
+    generation: spec.generation ?? gatewayPickerGeneration(spec.sessionKey),
+    id,
+    chatId: source.chatId,
+    source,
+    adapter,
+    messageId: "",
+    page: 0,
+    perPage: spec.perPage ?? DEFAULT_PER_PAGE,
+    createdAt: Date.now()
+  };
+  if (!pickerValid(pending2))
+    return { success: !1, error: "Picker expired." };
+  if (source.userId !== spec.invokerId || existsSync2(gatewayConfigPath()) && !isAuthorized(source, loadGatewayConfig()))
+    return { success: !1, error: "Gateway access is no longer approved." };
+  let { text, buttons } = renderPage(pending2), result = await adapter.sendButtons(source.chatId, text, buttons, opts);
+  return result.success ? pickerValid(pending2) ? (result.messageId && (pending2.messageId = result.messageId, registry.set(id, pending2)), result) : (pending2.onCancel?.(), result) : 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, pairing } = deps, freshConfig = () => existsSync2(gatewayConfigPath()) ? loadGatewayConfig() : deps.cfg, parsed = parseCallbackData(cb.data);
+  if (!parsed)
+    return;
+  let picker = registry.get(parsed.id);
+  if (!picker) {
+    await answerExpired(adapter, cb);
+    return;
+  }
+  if (picker.completed === void 0 && !pickerValid(picker)) {
+    registry.delete(parsed.id), picker.onCancel?.(), await answerExpired(adapter, cb);
+    return;
+  }
+  if (adapter.platform !== picker.source.platform || !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), freshConfig(), pairing)) {
+    await answerUnauthorized(adapter, cb);
+    return;
+  }
+  let authorized = () => pickerRequesterValid(picker) && isAuthorized(sourceForAuth(picker, cb), freshConfig(), pairing);
+  if (Date.now() > picker.createdAt + PICKER_TTL_MS) {
+    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 {
+    }
+    await answerExpired(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 {
+      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 {
+    if (!pickerValid(picker) || !authorized())
+      return;
+    let result = await picker.resolve(item);
+    if (!result.done) {
+      if (!pickerValid(picker) || !authorized())
+        return;
+      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;
+    }
+    picker.completed = result.text, await confirmPicker(picker, result.text, authorized);
+  } catch (err) {
+    if (err instanceof GatewayPickerCancelled)
+      return;
+    let message = err instanceof Error ? err.message : String(err);
+    picker.completed = `\u26A0 ${message}`, await confirmPicker(picker, picker.completed, authorized);
+  } finally {
+    picker.resolving = !1;
+  }
+}
+async function confirmPicker(picker, text, authorized) {
+  if (!authorized() || (await picker.adapter.editMessage(picker.chatId, picker.messageId, text, []).catch(() => ({ success: !1 }))).success || !authorized())
+    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)
+      entry.createdAt > cutoff || (registry.delete(id), !entry.completed && (entry.onCancel?.(), !(!pickerRequesterValid(entry) || !isAuthorized({ ...entry.source, roleAuthorized: void 0 }, loadGatewayConfig())) && 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 existsSync4, readFileSync as readFileSync3 } from "node:fs";
+import { join as join3 } from "node:path";
+
+// packages/coding-agent/dist/gateway/approval.js
+import { AsyncLocalStorage } from "node:async_hooks";
+import { randomBytes as randomBytes2 } from "node:crypto";
+
+// packages/coding-agent/dist/gateway/store.js
+import { existsSync as existsSync3, 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 (!existsSync3(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);
+  existsSync3(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
+var CALLBACK_PREFIX2 = "ap:", ID_LENGTH = 8, CODE_ALPHABET2 = "ABCDEFGHJKMNPQRSTUVWXYZ23456789", DEFAULT_TIMEOUT_MS = 300 * 1e3, approvalContext = new AsyncLocalStorage(), pending = /* @__PURE__ */ new Map();
+function generateId() {
+  let id = "", bytes = randomBytes2(ID_LENGTH);
+  for (let i = 0; i < ID_LENGTH; i++)
+    id += CODE_ALPHABET2[bytes[i] % CODE_ALPHABET2.length];
+  return id;
+}
+function makeCallbackData2(id, action) {
+  return `${CALLBACK_PREFIX2}${id}:${action}`;
+}
+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), 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: makeCallbackData2(id, "once") },
+      { label: "\u2713 Approve session", data: makeCallbackData2(id, "session") }
+    ],
+    [{ label: "\u2717 Reject", data: makeCallbackData2(id, "reject") }]
+  ];
+  return new Promise((resolve2, 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: resolve2,
+      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 = parseCallbackData2(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 && 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;
+  if (entry.plan && response !== "reject" && entry.key) {
+    let sessionId = getSession(entry.key)?.sessionId;
+    sessionId && setPermissionMode("yolo", 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/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(), sessionIdentities = /* @__PURE__ */ new Map();
+function sessionIdentity(key) {
+  let identity = sessionIdentities.get(key);
+  return identity || (identity = {}, sessionIdentities.set(key, identity)), identity;
+}
+function invalidateGatewaySession(key) {
+  let previous = sessionIdentity(key), next = {};
+  return sessionIdentities.set(key, next), invalidateGatewayDialogs(key), () => {
+    sessionIdentities.get(key) === next && (invalidateGatewayDialogs(key), sessionIdentities.set(key, previous));
+  };
+}
+var 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 canDeliverGatewayText(key, source, fallbackConfig, pairing = createPairingStore()) {
+  let binding = conversationBinding(key), cfg = existsSync4(gatewayConfigPath()) ? loadGatewayConfig() : fallbackConfig ?? loadGatewayConfig();
+  return (!binding || binding.source.platform === source.platform && binding.source.chatId === source.chatId && binding.source.userId === source.userId && binding.source.threadId === source.threadId && (!binding.owner || binding.owner === source.userId)) && isAuthorized(sourceWithCurrentRole(key, source), cfg, pairing);
+}
+function canDeliver(key) {
+  let binding = conversationBinding(key);
+  return !!binding && canDeliverGatewayText(key, binding.source);
+}
+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, existsSync4(path2()))
+    try {
+      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().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 /* @__PURE__ */ new Set([...sessionIdentities.keys(), ...dialogs.keys()]))
+    invalidateGatewaySession(key);
+  adapters = /* @__PURE__ */ new Map(), deliveryConfigs.clear(), roleGrants.clear();
+}
+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, 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;
+    if (!canDeliverGatewayText(key, source, deliveryConfigs.get(key))) {
+      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);
+      }
+      atomicJson(path2(), outbox), console.error(`[gateway] delivery ${item.failed ? "failed permanently" : "retry scheduled"} for ${source.platform}: ${result.error ?? "unknown error"}`);
+      break;
+    }
+  }
+}
+function invalidateGatewayDialogs(key) {
+  invalidateGatewayPickers(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);
+}
+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, request) {
+  if (request && request.generation !== gatewayPickerGeneration(key))
+    return Promise.resolve(void 0);
+  let epoch = epochs.get(key) ?? 0, source = request?.source ?? conversationBinding(key)?.source;
+  return new Promise((resolve2, reject) => {
+    let settled = !1, finish = (value, error) => {
+      settled || (settled = !0, clearTimeout(timeout), opts?.signal?.removeEventListener("abort", cancel), inputs.get(key)?.resolve === done && inputs.delete(key), dialogs.get(key)?.delete(cancel), error !== void 0 ? reject(error) : resolve2(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 && !!source && canDeliverGatewayText(key, source)).catch((error) => {
+      finish(void 0, error);
+    });
+  });
+}
+function gatewaySelect(key, title, options, opts, request) {
+  return dialog(key, opts, async (done, valid) => {
+    let { adapter, source: destination } = gatewayDestination(key), source = request?.source ?? destination, result = await createPicker(adapter, source, {
+      kind: "dialog",
+      generation: request?.generation,
+      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.");
+  }, request);
+}
+function gatewayInput(key, title, placeholder, opts, request) {
+  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, valid) => {
+    if (!valid()) {
+      done(void 0);
+      return;
+    }
+    let source = request?.source ?? gatewayDestination(key).source;
+    inputs.set(key, { userId: source.userId, resolve: done }), await sendGatewayNotice(key, `${title}${placeholder ? `
+${placeholder}` : ""}
+Reply with text, or /cancel.`, "notice", epoch);
+  }, request);
+}
+function createGatewayUI(key) {
+  let identity = sessionIdentity(key), source = conversationBinding(key)?.source, valid = () => sessionIdentity(key) === identity && !!source && canDeliverGatewayText(key, source);
+  return {
+    ...noOpUIContext,
+    select: (title, options, opts) => valid() ? gatewaySelect(key, title, options, opts) : Promise.resolve(void 0),
+    confirm: async (title, message, opts) => valid() && await gatewaySelect(key, `${title}
+${message}`, ["Approve", "Decline"], opts) === "Approve",
+    input: (title, placeholder, opts) => valid() ? gatewayInput(key, title, placeholder, opts) : Promise.resolve(void 0),
+    editor: (title, prefill) => valid() ? gatewayInput(key, title, prefill) : Promise.resolve(void 0),
+    notify: (message) => {
+      valid() && 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) => {
+      valid() && sendGatewayNotice(key, text).catch(() => {
+      });
+    },
+    setEditorText: (text) => {
+      valid() && sendGatewayNotice(key, text).catch(() => {
+      });
+    }
+  };
+}
+
+// packages/coding-agent/dist/gateway/mobile-commands.js
+var MOBILE_COMMANDS = [
+  { name: "project", description: "Browse folders and choose a project" },
+  { name: "continue", description: "Continue a handoff or the latest TUI session" },
+  { name: "sessions", description: "Browse saved sessions across projects" },
+  { name: "mode", description: "Choose yolo, auto, or read-only permissions" },
+  { name: "plan", description: "Plan work and approve it from this chat" },
+  { name: "settings", description: "Change this session's model, thinking, or permissions" },
+  { name: "stopall", description: "Stop this session and its background subagents" },
+  { name: "download", description: "Send a file from the current project" },
+  { name: "usage", description: "Show session tokens and subscription usage" },
+  { name: "processes", description: "List or stop this session's shell processes" },
+  { name: "refresh", description: "Refresh available models" },
+  { name: "skill", description: "Choose a skill and send it a task" },
+  { name: "fast", description: "Toggle OpenAI Codex fast mode" }
+], FORWARDED_COMMANDS = [
+  { name: "goal", description: "Set or manage the session goal" },
+  { name: "cron", description: "Schedule prompts and manage scheduled jobs" },
+  { name: "run", description: "Launch a subagent task" },
+  { name: "chain", description: "Run a sequence of subagent tasks" },
+  { name: "parallel", description: "Run independent subagent tasks" },
+  { name: "mcp", description: "Show configured MCP servers" },
+  { name: "lsp", description: "Show language server status" }
+];
+function resolveWithinRoots(path3, roots) {
+  let actual = realpathSync(resolve(path3));
+  if (!roots.some((root) => {
+    try {
+      let rel = relative(realpathSync(root), actual);
+      return rel === "" || !rel.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) && rel !== ".." && !isAbsolute(rel);
+    } catch {
+      return !1;
+    }
+  }))
+    throw new Error("That path is outside the approved folders.");
+  return actual;
+}
+function createProjectFolder(parent, name, roots) {
+  if (!name || name === "." || name === ".." || /[\\/\x00-\x1f<>:"|?*]/.test(name) || /[. ]$/.test(name) || /^(con|prn|aux|nul|com\d|lpt\d)(\.|$)/i.test(name))
+    throw new Error("Use a simple folder name without slashes or reserved characters.");
+  let actual = resolveWithinRoots(parent, roots);
+  return mkdirSync2(join4(actual, name)), resolveWithinRoots(join4(actual, name), roots);
+}
+function commandRequest(ctx) {
+  return { generation: ctx.pickerGeneration ?? gatewayPickerGeneration(ctx.key), source: ctx.event.source };
+}
+function selectForCommand(ctx, title, options, opts) {
+  return gatewaySelect(ctx.key, title, options, opts, commandRequest(ctx));
+}
+function inputForCommand(ctx, title) {
+  return gatewayInput(ctx.key, title, void 0, void 0, commandRequest(ctx));
+}
+async function browseProject(ctx, initialPath) {
+  let { key, event, adapter, bridge } = ctx, roots = ctx.cfg.projectRoots ?? [];
+  if (!roots.length)
+    throw new Error("Add approved project folders with lunr gateway setup first.");
+  let current = initialPath ? resolveWithinRoots(initialPath, ctx.cfg.projectRoots ?? []) : void 0, view = () => {
+    if (!current)
+      return {
+        title: "Choose a project folder",
+        items: [.../* @__PURE__ */ new Set([...conversationBinding(key)?.recentProjects ?? [], ...roots])].filter((p) => {
+          try {
+            return resolveWithinRoots(p, roots), !0;
+          } catch {
+            return !1;
+          }
+        }).map((p) => ({ label: p, value: p }))
+      };
+    current = resolveWithinRoots(current, roots);
+    let items = [
+      { label: "Use this folder", value: "use" },
+      { label: "New folder", value: "new" },
+      { label: "Recent and roots", value: "roots" }
+    ];
+    try {
+      let up = resolveWithinRoots(dirname2(current), roots);
+      up !== current && items.push({ label: "Up", value: up });
+    } catch {
+    }
+    for (let item of readdirSync(current, { withFileTypes: !0 }).sort((a, b) => a.name.localeCompare(b.name)))
+      if (!(!item.isDirectory() && !item.isSymbolicLink()))
+        try {
+          let path3 = resolveWithinRoots(join4(current, item.name), roots);
+          statSync(path3).isDirectory() && items.push({ label: item.name, value: path3 });
+        } catch {
+        }
+    return { title: current, items };
+  }, initial = view();
+  await createPicker(adapter, event.source, {
+    kind: "project",
+    sessionKey: key,
+    generation: ctx.pickerGeneration,
+    invokerId: event.source.userId,
+    ...initial,
+    validate: () => isAuthorized(event.source, loadGatewayConfig()),
+    resolve: async (item) => {
+      if (requireAuthorized(event.source), item.value === "use" && current) {
+        let cwd = resolveWithinRoots(current, loadGatewayConfig().projectRoots ?? []);
+        if (bridge.getStatus(key).busy)
+          throw new Error("Stop the current turn or wait before switching projects.");
+        let committed = !1;
+        if (await bridge.reset(key, {
+          validate: () => {
+            requireAuthorized(event.source);
+            let binding = conversationBinding(key);
+            if (!binding || binding.owner !== event.source.userId || binding.source.userId !== event.source.userId || binding.source.platform !== event.source.platform || binding.source.chatId !== event.source.chatId || binding.source.threadId !== event.source.threadId)
+              throw new GatewayPickerCancelled("Project requester changed before selection completed.");
+            resolveWithinRoots(cwd, loadGatewayConfig().projectRoots ?? []);
+          },
+          commit: () => {
+            bindConversation(key, event.source, { cwd, owner: event.source.userId }), committed = !0;
+          }
+        }), !committed)
+          throw new Error("The gateway did not commit project replacement. Retry with an updated gateway.");
+        return {
+          done: !0,
+          text: `Project selected: ${cwd}
+Send a task to begin. Existing sessions are still available through /sessions.`
+        };
+      }
+      if (item.value === "new" && current) {
+        let name = await inputForCommand(ctx, "New folder name");
+        if (ctx.pickerGeneration !== gatewayPickerGeneration(key))
+          return { done: !0, text: "Selection cancelled." };
+        name && (current = createProjectFolder(current, name, loadGatewayConfig().projectRoots ?? []));
+      } else
+        current = item.value === "roots" ? void 0 : item.value;
+      return { done: !1, ...view() };
+    }
+  }, { threadId: event.source.threadId });
+}
+var transfers = /* @__PURE__ */ new Map();
+function cancelMobileTransfer(key) {
+  transfers.get(key)?.abort();
+}
+async function continueSession(ctx, file) {
+  if (transfers.has(ctx.key))
+    throw new Error("A session transfer is already pending. Use /stop to cancel it.");
+  let controller = new AbortController();
+  transfers.set(ctx.key, controller);
+  try {
+    await performContinue(ctx, file, controller.signal);
+  } finally {
+    transfers.delete(ctx.key);
+  }
+}
+async function performContinue(ctx, file, signal) {
+  requireAuthorized(ctx.event.source);
+  let { requestSessionTransfer, SessionTransferError } = await import("./session-handoff-LYH53ESV.js"), { key, bridge } = ctx;
+  if (bridge.peekSession?.(key)?.sessionManager?.getSessionFile() === file) {
+    await ctx.adapter.send(ctx.event.source.chatId, "This session is already open here.");
+    return;
+  }
+  if (bridge.getStatus(key).busy)
+    throw new Error("Stop the current phone session before switching.");
+  try {
+    await requestSessionTransfer(file, { timeoutMs: 3e3, signal });
+  } catch (error) {
+    if (!(error instanceof SessionTransferError) || !["busy", "timeout"].includes(error.code))
+      throw error;
+    let choice = await selectForCommand(ctx, `${error instanceof Error ? error.message : "Session is in use"}
+How should lunR continue?`, ["Wait until idle", "Stop and continue", "Cancel"], { signal });
+    if (!choice || choice === "Cancel")
+      return;
+    if (choice === "Stop and continue")
+      await requestSessionTransfer(file, { stop: !0, timeoutMs: 3e4, signal });
+    else {
+      let deadline = Date.now() + 12e4;
+      for (; ; ) {
+        signal.throwIfAborted(), requireAuthorized(ctx.event.source);
+        try {
+          await requestSessionTransfer(file, { timeoutMs: 3e3, signal });
+          break;
+        } catch (retryError) {
+          if (!(retryError instanceof SessionTransferError) || !["busy", "timeout"].includes(retryError.code) || Date.now() >= deadline)
+            throw retryError;
+        }
+        await new Promise((resolve2) => setTimeout(resolve2, 500));
+      }
+    }
+  }
+  if (signal.throwIfAborted(), requireAuthorized(ctx.event.source), ctx.pickerGeneration !== gatewayPickerGeneration(key))
+    return;
+  await bridge.switchSession(key, file), ctx.pickerGeneration = gatewayPickerGeneration(key);
+  let session = await bridge.getSession(key), cwd = session?.sessionManager?.getCwd();
+  bindConversation(key, ctx.event.source, { cwd, owner: ctx.event.source.userId });
+  let id = session?.sessionManager?.getSessionId();
+  if (id && ["auto", "yolo"].includes(getPermissionMode(id))) {
+    let requested = getPermissionMode(id);
+    setPermissionMode("read-only", id), session?.sessionManager?.setPermissionMode?.("read-only"), await selectForCommand(ctx, `Continue with ${requested} permissions? Tools can change files and run commands without individual approval.`, ["Keep read-only", `Use ${requested}`]) === `Use ${requested}` && (setPermissionMode(requested, id), session?.sessionManager?.setPermissionMode?.(requested));
+  }
+  await ctx.adapter.send(ctx.event.source.chatId, `Continuing ${session?.sessionManager?.getSessionName() ?? basename(file)}
+Project: ${cwd}
+Send your next instruction.`, { threadId: ctx.event.source.threadId });
+}
+async function browseSessions(ctx, args, quick) {
+  let handoff = await import("./session-handoff-LYH53ESV.js");
+  if (quick) {
+    let candidates = handoff.listHandoffCandidates();
+    if (!candidates.length) {
+      let latest = handoff.latestTuiSession();
+      if (!latest)
+        throw new Error("No recent TUI session found. Use /sessions or mark one in the terminal with /handoff.");
+      await continueSession(ctx, latest.sessionFile);
+      return;
+    }
+    if (candidates.length === 1) {
+      await continueSession(ctx, candidates[0].sessionFile);
+      return;
+    }
+    await sessionPicker(ctx, candidates.map((s) => ({ label: `${s.cwd} \xB7 ${basename(s.sessionFile)}`, value: s.sessionFile })));
+    return;
+  }
+  let sessions = await SessionManager.listAll(), known = new Set(sessions.map((s) => s.path));
+  for (let file of handoff.listRegisteredSessionPaths())
+    if (!known.has(file))
+      try {
+        let manager = SessionManager.openReadOnly(file), header = manager.getHeader();
+        header && sessions.push({
+          id: header.id,
+          path: file,
+          cwd: manager.getCwd(),
+          name: manager.getSessionName(),
+          created: new Date(header.timestamp),
+          modified: statSync(file).mtime,
+          messageCount: manager.getEntries().length,
+          firstMessage: "",
+          allMessagesText: ""
+        });
+      } catch {
+      }
+  let query = args.toLowerCase(), items = sessions.sort((a, b) => b.modified.getTime() - a.modified.getTime()).filter((s) => !query || `${s.name ?? ""} ${s.cwd} ${s.id}`.toLowerCase().includes(query)).map((s) => ({
+    label: `${s.name || s.firstMessage.slice(0, 35) || s.id.slice(0, 8)} \xB7 ${basename(s.cwd)} \xB7 ${s.modified.toLocaleDateString()}`,
+    value: s.path
+  }));
+  await sessionPicker(ctx, items);
+}
+async function sessionPicker(ctx, items) {
+  await createPicker(ctx.adapter, ctx.event.source, {
+    kind: "sessions",
+    sessionKey: ctx.key,
+    generation: ctx.pickerGeneration,
+    invokerId: ctx.event.source.userId,
+    title: "Choose a session. Use /sessions <search> to filter.",
+    items,
+    validate: () => isAuthorized(ctx.event.source, loadGatewayConfig()),
+    resolve: async (item) => (await continueSession(ctx, item.value), { done: !0, text: "Session selection finished." })
+  }, { threadId: ctx.event.source.threadId });
+}
+async function handleMobileCommand(ctx, command, args) {
+  if (!MOBILE_COMMANDS.some((c) => c.name === command) && command !== "resume")
+    return !1;
+  if (requireAuthorized(ctx.event.source, ctx.cfg), command === "project" && invalidateGatewayDialogs(ctx.key), ctx.pickerGeneration = gatewayPickerGeneration(ctx.key), bindConversation(ctx.key, ctx.event.source, { owner: ctx.event.source.userId }), command === "project")
+    return await browseProject(ctx, args.trim() || void 0), !0;
+  if (command === "sessions" || command === "resume" || command === "continue")
+    return await browseSessions(ctx, args, command === "continue"), !0;
+  let session = await ctx.bridge.getSession(ctx.key);
+  if (!session)
+    throw new Error("Select a project and send a task, or use /continue first.");
+  if (ctx.pickerGeneration !== gatewayPickerGeneration(ctx.key))
+    return !0;
+  let id = session.sessionManager?.getSessionId();
+  if (command === "usage") {
+    let stats = session.getSessionStats(), plans = await (await import("./usage-service-CPAGBED5.js")).getAllPlanUsageResults(session.model?.provider, session.modelRuntime);
+    return await ctx.adapter.send(ctx.event.source.chatId, [
+      `Parent tokens including auxiliary requests: ${stats.tokens.total} \xB7 cost: $${stats.cost.toFixed(4)}`,
+      ...stats.childUsage?.requests || stats.childUsage?.total ? [
+        `Children: ${stats.childUsage.total} tokens \xB7 cost: $${stats.childUsage.cost.toFixed(4)}`,
+        `Combined: ${stats.combinedUsage?.total ?? stats.tokens.total + stats.childUsage.total} tokens \xB7 cost: $${(stats.combinedUsage?.cost ?? stats.cost + stats.childUsage.cost).toFixed(4)}`
+      ] : [],
+      ...stats.combinedUsage?.unknownRequests ? [`Usage unavailable for ${stats.combinedUsage.unknownRequests} request(s).`] : [],
+      ...stats.combinedUsage?.partialRequests ? [`Usage incomplete for ${stats.combinedUsage.partialRequests} request(s).`] : [],
+      ...plans.usages.flatMap((p) => p.windows.map((w) => `${p.provider} ${w.label}: ${w.usedPercent.toFixed(1)}% used`)),
+      ...plans.errors
+    ].join(`
+`)), !0;
+  }
+  if (command === "processes") {
+    if (!id)
+      throw new Error("No session identity.");
+    let processes = await import("./process-registry-Q4QWIU33.js"), own = processes.list(id);
+    if (args) {
+      let [action, raw] = args.split(/\s+/), pid = Number(raw);
+      if (action !== "stop" || !own.some((p) => p.pid === pid))
+        throw new Error("Usage: /processes stop <pid> from this session's process list.");
+      processes.kill(pid), await ctx.adapter.send(ctx.event.source.chatId, `Stop requested for process ${pid}.`);
+    } else
+      await ctx.adapter.send(ctx.event.source.chatId, own.length ? own.map((p) => `${p.pid} \xB7 ${p.status} \xB7 ${p.command}`).join(`
+`).slice(0, ctx.adapter.maxMessageLength) : "No tracked processes.");
+    return !0;
+  }
+  if (command === "stopall") {
+    await ctx.bridge.abort(ctx.key);
+    let result = id ? await getSubagentCancellation(id)?.stop() : void 0, processes = await import("./process-registry-Q4QWIU33.js"), count = id ? processes.list(id).filter((p) => p.status !== "exited").length : 0;
+    return id && processes.killAll(id), await ctx.adapter.send(ctx.event.source.chatId, `Stopped the current turn. Requested stop for ${result?.requested ?? 0} background runs and ${count} tracked processes${result?.failed ? `; ${result.failed} requests failed` : ""}. Wait for them to exit before transferring.`), !0;
+  }
+  if (ctx.bridge.getStatus(ctx.key).busy)
+    throw new Error("Wait for the current turn or use /stop first.");
+  if (command === "refresh")
+    return await session.modelRuntime.refresh(), await ctx.adapter.send(ctx.event.source.chatId, "Model catalog refreshed. Use /model to choose."), !0;
+  if (command === "fast") {
+    if (session.model?.provider !== "openai-codex" || !session.settingsManager)
+      throw new Error("Fast mode is available only for OpenAI Codex subscriptions.");
+    let current = session.settingsManager.getOpenAIFastMode();
+    if (args && !["on", "off", "status"].includes(args))
+      throw new Error("Usage: /fast on|off|status");
+    return args !== "status" && session.settingsManager.setOpenAIFastMode(args ? args === "on" : !current), await ctx.adapter.send(ctx.event.source.chatId, `Fast mode: ${session.settingsManager.getOpenAIFastMode() ? "on" : "off"}`), !0;
+  }
+  if (command === "skill") {
+    let names = session.resourceLoader?.getSkills().skills.map((s) => s.name) ?? [], [name, ...task] = args.split(/\s+/).filter(Boolean), chosen = name || await selectForCommand(ctx, "Choose a skill", names);
+    if (!chosen || ctx.pickerGeneration !== gatewayPickerGeneration(ctx.key))
+      return !0;
+    if (!names.includes(chosen))
+      throw new Error("That skill is not loaded for this project.");
+    return ctx.event.text = `/skill:${chosen} ${task.join(" ") || await inputForCommand(ctx, "What should this skill do?") || ""}`, ctx.pickerGeneration !== gatewayPickerGeneration(ctx.key);
+  }
+  if (command === "download") {
+    if (!ctx.adapter.sendFile)
+      throw new Error("This platform cannot send files.");
+    if (!args)
+      throw new Error("Usage: /download <project-relative path>");
+    let cwd = session.sessionManager?.getCwd();
+    if (!cwd)
+      throw new Error("No project selected.");
+    let file = resolveWithinRoots(resolve(cwd, args), [cwd]), stat = statSync(file);
+    if (!stat.isFile() || stat.size > 8 * 1024 * 1024)
+      throw new Error("Choose a file no larger than 8 MB.");
+    if (/(^|[\\/])(?:\.env(?:\.[^\\/]*)?|auth\.json|gateway\.json|credentials[^\\/]*|id_rsa|id_ed25519)([\\/]|$)/i.test(file))
+      throw new Error("Credential files cannot be sent through chat.");
+    let result = await ctx.adapter.sendFile(ctx.event.source.chatId, file, { threadId: ctx.event.source.threadId });
+    if (!result.success)
+      throw new Error(result.error ?? "File delivery failed.");
+    return !0;
+  }
+  if (command === "settings") {
+    let choice = await selectForCommand(ctx, "Session settings", ["Model", "Thinking", "Permissions"]);
+    if (choice === "Model" || choice === "Thinking") {
+      let { CHAT_COMMANDS, runChatCommand } = await import("./commands-2ETOWWRA.js");
+      if (ctx.pickerGeneration !== gatewayPickerGeneration(ctx.key))
+        return !0;
+      let cmd = CHAT_COMMANDS.find((c) => c.name === choice.toLowerCase());
+      return cmd && await runChatCommand(cmd, {
+        ...ctx,
+        args: "",
+        reply: async (text) => {
+          await ctx.adapter.send(ctx.event.source.chatId, text);
+        }
+      }), !0;
+    }
+    if (choice !== "Permissions")
+      return !0;
+  }
+  let requested = command === "plan" ? "read-only" : args || await selectForCommand(ctx, `Permission mode: ${getPermissionMode(id)}`, [...PERMISSION_MODES]);
+  if (!requested || ctx.pickerGeneration !== gatewayPickerGeneration(ctx.key))
+    return !0;
+  let mode = requested === "read" ? "read-only" : requested;
+  if (!PERMISSION_MODES.includes(mode))
+    throw new Error("Choose yolo, auto, or read-only.");
+  return setPermissionMode(mode, id), session.sessionManager?.setPermissionMode?.(mode), await ctx.adapter.send(ctx.event.source.chatId, `Permission mode: ${mode}`), command === "plan" && args ? (ctx.event.text = `Create a plan for: ${args}`, !1) : !0;
+}
+
+export {
+  requireAuthorized,
+  isAuthorized,
+  addAllowedUser,
+  conversationBinding,
+  bindConversation,
+  getSession,
+  putSession,
+  touchSession,
+  removeSession,
+  listSessions,
+  runWithApprovalContext,
+  registerGatewayApprovalHandler,
+  handleApprovalCallback,
+  cancelGatewayApprovals,
+  GatewayPickerCancelled,
+  gatewayPickerGeneration,
+  createPicker,
+  handleCallback,
+  startButtonSweeper,
+  stopButtonSweeper,
+  splitMessage,
+  invalidateGatewaySession,
+  rememberGatewayRole,
+  canDeliverGatewayText,
+  withGatewayPresentation,
+  startGatewayPresenter,
+  stopGatewayPresenter,
+  gatewayEpoch,
+  sendGatewayNotice,
+  queueGatewayText,
+  invalidateGatewayDialogs,
+  acceptGatewayInput,
+  createGatewayUI,
+  MOBILE_COMMANDS,
+  FORWARDED_COMMANDS,
+  resolveWithinRoots,
+  createProjectFolder,
+  cancelMobileTransfer,
+  handleMobileCommand
+};