@ashx-j/lunr 0.2.21 → 0.2.22

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

@@ -0,0 +1,355 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  bindConversation,
+  conversationBinding,
+  createPicker,
+  gatewayInput,
+  gatewaySelect,
+  isGatewayOwner,
+  requireGatewayOwner
+} from "./chunk-VJPTNWAP.js";
+import {
+  getSubagentCancellation
+} from "./chunk-BBUVIEZB.js";
+import {
+  PERMISSION_MODES,
+  getPermissionMode,
+  setPermissionMode
+} from "./chunk-5D7LC2ZQ.js";
+import {
+  SessionManager
+} from "./chunk-XLTL257W.js";
+import {
+  loadGatewayConfig
+} from "./chunk-R3K2F5GI.js";
+
+// packages/coding-agent/dist/gateway/mobile-commands.js
+import { mkdirSync, readdirSync, realpathSync, statSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
+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 manual, yolo, plan, or auto 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(path, roots) {
+  let actual = realpathSync(resolve(path));
+  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 mkdirSync(join(actual, name)), resolveWithinRoots(join(actual, name), roots);
+}
+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(dirname(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 path = resolveWithinRoots(join(current, item.name), roots);
+          statSync(path).isDirectory() && items.push({ label: item.name, value: path });
+        } catch {
+        }
+    return { title: current, items };
+  }, initial = view();
+  await createPicker(adapter, event.source, {
+    kind: "project",
+    sessionKey: key,
+    invokerId: event.source.userId,
+    ...initial,
+    validate: () => isGatewayOwner(event.source, loadGatewayConfig()),
+    resolve: async (item) => {
+      if (requireGatewayOwner(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.");
+        return await bridge.reset(key), bindConversation(key, event.source, { cwd, owner: event.source.userId }), {
+          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 gatewayInput(key, "New folder name");
+        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) {
+  requireGatewayOwner(ctx.event.source);
+  let { requestSessionTransfer, SessionTransferError } = await import("./session-handoff-HC7R5E24.js"), { key, bridge } = ctx;
+  if ((await bridge.getSession(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) || error.code !== "busy")
+      throw error;
+    let choice = await gatewaySelect(key, `${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(), requireGatewayOwner(ctx.event.source);
+        try {
+          await requestSessionTransfer(file, { timeoutMs: 3e3, signal });
+          break;
+        } catch (retryError) {
+          if (!(retryError instanceof SessionTransferError) || retryError.code !== "busy" || Date.now() >= deadline)
+            throw retryError;
+        }
+        await new Promise((resolve2) => setTimeout(resolve2, 500));
+      }
+    }
+  }
+  signal.throwIfAborted(), requireGatewayOwner(ctx.event.source), await bridge.switchSession(key, file);
+  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("manual", id), session?.sessionManager?.setPermissionMode?.("manual"), await gatewaySelect(key, `Continue with ${requested} permissions? Tools can change files and run commands without individual approval.`, ["Keep manual", `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-HC7R5E24.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,
+    invokerId: ctx.event.source.userId,
+    title: "Choose a session. Use /sessions <search> to filter.",
+    items,
+    validate: () => isGatewayOwner(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 (requireGatewayOwner(ctx.event.source, ctx.cfg), 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.");
+  let id = session.sessionManager?.getSessionId();
+  if (command === "usage") {
+    let stats = session.getSessionStats(), plans = await (await import("./usage-service-LFB2SWYV.js")).getAllPlanUsageResults(session.model?.provider, session.modelRuntime);
+    return await ctx.adapter.send(ctx.event.source.chatId, [
+      `Tokens: ${stats.tokens.total} \xB7 cost: $${stats.cost.toFixed(4)}`,
+      ...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-4FAKZQOL.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-4FAKZQOL.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 gatewaySelect(ctx.key, "Choose a skill", names);
+    if (!chosen)
+      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 gatewayInput(ctx.key, "What should this skill do?") || ""}`, !1;
+  }
+  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 gatewaySelect(ctx.key, "Session settings", ["Model", "Thinking", "Permissions"]);
+    if (choice === "Model" || choice === "Thinking") {
+      let { CHAT_COMMANDS, runChatCommand } = await import("./commands-2JVNFGMQ.js"), 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" ? "plan" : args || await gatewaySelect(ctx.key, `Permission mode: ${getPermissionMode(id)}`, [...PERMISSION_MODES]);
+  if (!requested)
+    return !0;
+  if (!PERMISSION_MODES.includes(requested))
+    throw new Error("Choose manual, yolo, plan, or auto.");
+  return setPermissionMode(requested, id), session.sessionManager?.setPermissionMode?.(requested), await ctx.adapter.send(ctx.event.source.chatId, `Permission mode: ${requested}`), command === "plan" && args ? (ctx.event.text = args, !1) : !0;
+}
+
+export {
+  MOBILE_COMMANDS,
+  FORWARDED_COMMANDS,
+  resolveWithinRoots,
+  createProjectFolder,
+  cancelMobileTransfer,
+  handleMobileCommand
+};