@ashx-j/lunr-dev 0.2.13-dev.8.1 → 0.2.19-dev.10.1

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

@@ -0,0 +1,72 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+
+// packages/coding-agent/dist/utils/photon.js
+import { createRequire } from "module";
+import * as path from "path";
+import { fileURLToPath } from "url";
+var require2 = createRequire(new URL("../utils/photon.js", import.meta.url).href), fs = require2("fs"), WASM_FILENAME = "photon_rs_bg.wasm", photonModule = null, loadPromise = null;
+function pathOrNull(file) {
+  return typeof file == "string" ? file : file instanceof URL ? fileURLToPath(file) : null;
+}
+function getFallbackWasmPaths() {
+  let execDir = path.dirname(process.execPath);
+  return [
+    path.join(execDir, WASM_FILENAME),
+    path.join(execDir, "photon", WASM_FILENAME),
+    path.join(process.cwd(), WASM_FILENAME)
+  ];
+}
+function patchPhotonWasmRead() {
+  let originalReadFileSync = fs.readFileSync.bind(fs), fallbackPaths = getFallbackWasmPaths(), mutableFs = fs, patchedReadFileSync = ((...args) => {
+    let [file, options] = args;
+    if (pathOrNull(file)?.endsWith(WASM_FILENAME))
+      try {
+        return originalReadFileSync(...args);
+      } catch (error) {
+        let err = error;
+        if (err?.code && err.code !== "ENOENT")
+          throw error;
+        for (let fallbackPath of fallbackPaths)
+          if (fs.existsSync(fallbackPath))
+            return options === void 0 ? originalReadFileSync(fallbackPath) : originalReadFileSync(fallbackPath, options);
+        throw error;
+      }
+    return originalReadFileSync(...args);
+  });
+  try {
+    mutableFs.readFileSync = patchedReadFileSync;
+  } catch {
+    Object.defineProperty(fs, "readFileSync", {
+      value: patchedReadFileSync,
+      writable: !0,
+      configurable: !0
+    });
+  }
+  return () => {
+    try {
+      mutableFs.readFileSync = originalReadFileSync;
+    } catch {
+      Object.defineProperty(fs, "readFileSync", {
+        value: originalReadFileSync,
+        writable: !0,
+        configurable: !0
+      });
+    }
+  };
+}
+async function loadPhoton() {
+  return photonModule || loadPromise || (loadPromise = (async () => {
+    let restoreReadFileSync = patchPhotonWasmRead();
+    try {
+      return photonModule = await import("@silvia-odwyer/photon-node"), photonModule;
+    } catch {
+      return photonModule = null, photonModule;
+    } finally {
+      restoreReadFileSync();
+    }
+  })(), loadPromise);
+}
+
+export {
+  loadPhoton
+};

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

@@ -0,0 +1,429 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  VERSION,
+  appendDebugLog,
+  getAgentDir
+} from "./chunk-PCIGF2XK.js";
+
+// packages/coding-agent/dist/gateway/config.js
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+function gatewayConfigPath() {
+  return join(getAgentDir(), "gateway.json");
+}
+function defaultPlatformConfig(requireMention) {
+  return {
+    enabled: !1,
+    allowedUsers: [],
+    allowedChats: [],
+    requireMention,
+    freeResponseChats: []
+  };
+}
+function defaultGatewayConfig() {
+  return {
+    telegram: defaultPlatformConfig(!1),
+    discord: { ...defaultPlatformConfig(!0), ignoredChannels: [], autoThread: !0 },
+    groupSessionsPerUser: !0,
+    unauthorizedDmBehavior: "pair",
+    streaming: { enabled: !0, editIntervalMs: 800, bufferThreshold: 24 }
+  };
+}
+function asStringArray(value) {
+  if (Array.isArray(value))
+    return value.every((v) => typeof v == "string") ? value : void 0;
+}
+function asBoolean(value) {
+  return typeof value == "boolean" ? value : void 0;
+}
+function asNumber(value) {
+  return typeof value == "number" && Number.isFinite(value) ? value : void 0;
+}
+function sanitizePlatform(raw, base) {
+  if (raw == null || typeof raw != "object" || Array.isArray(raw))
+    return base;
+  let r = raw;
+  return {
+    enabled: asBoolean(r.enabled) ?? base.enabled,
+    token: typeof r.token == "string" ? r.token : base.token,
+    allowedUsers: asStringArray(r.allowedUsers) ?? base.allowedUsers,
+    allowedChats: asStringArray(r.allowedChats) ?? base.allowedChats,
+    requireMention: asBoolean(r.requireMention) ?? base.requireMention,
+    freeResponseChats: asStringArray(r.freeResponseChats) ?? base.freeResponseChats,
+    homeChannel: typeof r.homeChannel == "string" ? r.homeChannel : base.homeChannel
+  };
+}
+function sanitizeDiscord(raw, base) {
+  let platform = sanitizePlatform(raw, base), r = raw != null && typeof raw == "object" && !Array.isArray(raw) ? raw : {};
+  return {
+    ...platform,
+    ignoredChannels: asStringArray(r.ignoredChannels) ?? base.ignoredChannels,
+    autoThread: asBoolean(r.autoThread) ?? base.autoThread
+  };
+}
+function sanitizeConfig(raw) {
+  let base = defaultGatewayConfig();
+  if (raw == null || typeof raw != "object" || Array.isArray(raw))
+    return base;
+  let r = raw, streamingRaw = r.streaming != null && typeof r.streaming == "object" && !Array.isArray(r.streaming) ? r.streaming : {};
+  return {
+    telegram: sanitizePlatform(r.telegram, base.telegram),
+    discord: sanitizeDiscord(r.discord, base.discord),
+    groupSessionsPerUser: asBoolean(r.groupSessionsPerUser) ?? base.groupSessionsPerUser,
+    unauthorizedDmBehavior: r.unauthorizedDmBehavior === "ignore" ? "ignore" : "pair",
+    streaming: {
+      enabled: asBoolean(streamingRaw.enabled) ?? base.streaming.enabled,
+      editIntervalMs: asNumber(streamingRaw.editIntervalMs) ?? base.streaming.editIntervalMs,
+      bufferThreshold: asNumber(streamingRaw.bufferThreshold) ?? base.streaming.bufferThreshold
+    }
+  };
+}
+function loadGatewayConfig() {
+  let path = gatewayConfigPath();
+  if (!existsSync(path))
+    return defaultGatewayConfig();
+  try {
+    return sanitizeConfig(JSON.parse(readFileSync(path, "utf-8")));
+  } catch (err) {
+    return console.error(`[gateway] Failed to load config from ${path}: ${err}`), defaultGatewayConfig();
+  }
+}
+function saveGatewayConfig(config) {
+  let path = gatewayConfigPath(), dir = getAgentDir();
+  existsSync(dir) || mkdirSync(dir, { recursive: !0 });
+  let tmp = `${path}.tmp-${process.pid}`;
+  writeFileSync(tmp, `${JSON.stringify(config, null, 2)}
+`, "utf-8"), renameSync(tmp, path);
+  try {
+    chmodSync(path, 384);
+  } catch {
+  }
+}
+function resolvePlatformToken(platform, platformCfg) {
+  let upper = platform.toUpperCase();
+  return process.env[`LUNR_${upper}_BOT_TOKEN`] ?? process.env[`${upper}_BOT_TOKEN`] ?? platformCfg.token;
+}
+function platformConfigFor(cfg, platform) {
+  if (platform === "telegram")
+    return cfg.telegram;
+  if (platform === "discord")
+    return cfg.discord;
+}
+
+// packages/coding-agent/dist/core/install-features.js
+import { chmodSync as chmodSync2, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+var FEATURE_CATALOG = [
+  {
+    id: "chat-platforms",
+    title: "Chat platforms",
+    summary: "Discord + Telegram gateway so lunR can talk in chat apps.",
+    defaultEnabled: !1,
+    options: [
+      {
+        id: "autostart",
+        type: "boolean",
+        prompt: "Auto-start the lunR gateway daemon when you log in?",
+        default: !1,
+        askWhen: "chat-platforms"
+      },
+      {
+        id: "telegram-token",
+        type: "secret",
+        prompt: "Telegram bot token (empty skips; stored in gateway.json)",
+        askWhen: "chat-platforms"
+      },
+      {
+        id: "discord-token",
+        type: "secret",
+        prompt: "Discord bot token (empty skips; stored in gateway.json)",
+        askWhen: "chat-platforms"
+      }
+    ]
+  }
+], CHAT_PLATFORMS_INFER_UNTIL = "0.2.0";
+function installFeaturesPath() {
+  return join2(getAgentDir(), "install-features.json");
+}
+function getFeatureSpec(id) {
+  return FEATURE_CATALOG.find((f) => f.id === id);
+}
+function getFeatureOptionSpec(id, option) {
+  return getFeatureSpec(id)?.options.find((o) => o.id === option);
+}
+function versionGte(a, b) {
+  let pa = a.split(".").map((p) => Number.parseInt(p, 10) || 0), pb = b.split(".").map((p) => Number.parseInt(p, 10) || 0);
+  for (let i = 0; i < 3; i++) {
+    let d = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (d !== 0)
+      return d > 0;
+  }
+  return !0;
+}
+function emptyFile(now = (/* @__PURE__ */ new Date()).toISOString()) {
+  return {
+    schemaVersion: 1,
+    installerVersion: VERSION,
+    installMethod: "binary",
+    installedAt: now,
+    updatedAt: now,
+    features: {}
+  };
+}
+function sanitizeState(raw) {
+  if (raw == null || typeof raw != "object" || Array.isArray(raw))
+    return;
+  let r = raw;
+  if (typeof r.enabled != "boolean")
+    return;
+  let options = {};
+  if (r.options != null && typeof r.options == "object" && !Array.isArray(r.options))
+    for (let [k, v] of Object.entries(r.options))
+      (typeof v == "boolean" || typeof v == "string" || typeof v == "number") && (options[k] = v);
+  return { enabled: r.enabled, options };
+}
+function sanitizeFile(raw) {
+  if (raw == null || typeof raw != "object" || Array.isArray(raw))
+    return;
+  let r = raw;
+  if (r.schemaVersion !== 1)
+    return;
+  let features = {};
+  if (r.features != null && typeof r.features == "object" && !Array.isArray(r.features))
+    for (let [id, state] of Object.entries(r.features)) {
+      let sanitized = sanitizeState(state);
+      sanitized && (features[id] = sanitized);
+    }
+  let now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    schemaVersion: 1,
+    installerVersion: typeof r.installerVersion == "string" ? r.installerVersion : VERSION,
+    installMethod: "binary",
+    installedAt: typeof r.installedAt == "string" ? r.installedAt : now,
+    updatedAt: typeof r.updatedAt == "string" ? r.updatedAt : now,
+    inferUntil: typeof r.inferUntil == "string" ? r.inferUntil : void 0,
+    features
+  };
+}
+function gatewayHasEnabledFileToken() {
+  let cfg = loadGatewayConfig();
+  for (let platform of [cfg.telegram, cfg.discord])
+    if (platform.enabled && typeof platform.token == "string" && platform.token.length > 0)
+      return !0;
+  return !1;
+}
+function inferPathActive() {
+  return VERSION.startsWith("0.80.") ? !0 : !versionGte(VERSION, CHAT_PLATFORMS_INFER_UNTIL);
+}
+function inferFromGateway() {
+  if (!inferPathActive() || !gatewayHasEnabledFileToken())
+    return;
+  let now = (/* @__PURE__ */ new Date()).toISOString(), file = {
+    ...emptyFile(now),
+    inferUntil: CHAT_PLATFORMS_INFER_UNTIL,
+    features: {
+      "chat-platforms": { enabled: !0, options: { autostart: !1 } }
+    }
+  };
+  return saveInstallFeatures(file), appendDebugLog("install-features: inferred chat-platforms enabled (file token, autostart false)"), file;
+}
+function loadInstallFeatures() {
+  let path = installFeaturesPath();
+  if (!existsSync2(path))
+    return inferFromGateway() ?? emptyFile();
+  try {
+    return sanitizeFile(JSON.parse(readFileSync2(path, "utf-8"))) ?? inferFromGateway() ?? emptyFile();
+  } catch {
+    return inferFromGateway() ?? emptyFile();
+  }
+}
+function saveInstallFeatures(file) {
+  let path = installFeaturesPath(), dir = getAgentDir();
+  existsSync2(dir) || mkdirSync2(dir, { recursive: !0 });
+  let tmp = `${path}.tmp-${process.pid}`;
+  writeFileSync2(tmp, `${JSON.stringify(file, null, 2)}
+`, "utf-8"), renameSync2(tmp, path);
+  try {
+    chmodSync2(path, 420);
+  } catch {
+  }
+}
+function isFeatureEnabled(id) {
+  let state = loadInstallFeatures().features[id];
+  return state ? state.enabled : getFeatureSpec(id)?.defaultEnabled ?? !1;
+}
+function coerceBooleanSetValue(raw) {
+  if (raw === "true" || raw === "1")
+    return !0;
+  if (raw === "false" || raw === "0")
+    return !1;
+}
+function parseSetAssignment(raw) {
+  let eq = raw.indexOf("=");
+  if (eq <= 0)
+    return;
+  let lhs = raw.slice(0, eq), value = raw.slice(eq + 1), dot = lhs.indexOf(".");
+  if (!(dot <= 0 || dot === lhs.length - 1))
+    return { id: lhs.slice(0, dot), option: lhs.slice(dot + 1), value };
+}
+function parseFeatureFlags(argv) {
+  let yes = !1, reconfigure = !1, features = [], noFeatures = [], sets = [];
+  for (let i = 0; i < argv.length; i++) {
+    let arg = argv[i];
+    if (arg === "--yes" || arg === "-y") {
+      yes = !0;
+      continue;
+    }
+    if (arg === "--reconfigure") {
+      reconfigure = !0;
+      continue;
+    }
+    if (arg === "--feature") {
+      let id = argv[++i];
+      if (!id)
+        return { ok: !1, error: "--feature requires an id" };
+      features.push(id);
+      continue;
+    }
+    if (arg === "--no-feature") {
+      let id = argv[++i];
+      if (!id)
+        return { ok: !1, error: "--no-feature requires an id" };
+      noFeatures.push(id);
+      continue;
+    }
+    if (arg === "--set") {
+      let raw = argv[++i];
+      if (!raw)
+        return { ok: !1, error: "--set requires <id.option>=<value>" };
+      let parsed = parseSetAssignment(raw);
+      if (!parsed)
+        return { ok: !1, error: `invalid --set ${raw}` };
+      sets.push(parsed);
+      continue;
+    }
+    if (arg.startsWith("--feature=")) {
+      features.push(arg.slice(10));
+      continue;
+    }
+    if (arg.startsWith("--no-feature=")) {
+      noFeatures.push(arg.slice(13));
+      continue;
+    }
+    if (arg.startsWith("--set=")) {
+      let parsed = parseSetAssignment(arg.slice(6));
+      if (!parsed)
+        return { ok: !1, error: `invalid --set ${arg}` };
+      sets.push(parsed);
+      continue;
+    }
+    return { ok: !1, error: `unknown flag ${arg}` };
+  }
+  return { ok: !0, yes, reconfigure, features, noFeatures, sets };
+}
+function applyFeatureFlags(current, flags) {
+  let next = {
+    ...current,
+    installerVersion: VERSION,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    features: { ...current.features }
+  }, secrets = {}, enabledIds = [], disabledIds = [];
+  for (let id of flags.features) {
+    if (!getFeatureSpec(id))
+      return { ok: !1, error: `unknown feature ${id}`, exitCode: 2 };
+    let prev = next.features[id];
+    next.features[id] = { enabled: !0, options: { ...prev?.options } }, enabledIds.push(id);
+  }
+  for (let id of flags.noFeatures) {
+    if (!getFeatureSpec(id))
+      return { ok: !1, error: `unknown feature ${id}`, exitCode: 2 };
+    let prev = next.features[id];
+    next.features[id] = { enabled: !1, options: { ...prev?.options } }, disabledIds.push(id);
+  }
+  for (let set of flags.sets) {
+    if (!getFeatureSpec(set.id))
+      return { ok: !1, error: `unknown feature ${set.id}`, exitCode: 2 };
+    let option = getFeatureOptionSpec(set.id, set.option);
+    if (!option)
+      return { ok: !1, error: `unknown option ${set.id}.${set.option}`, exitCode: 2 };
+    if (option.type === "secret")
+      return {
+        ok: !1,
+        error: `cannot --set a secret option (${set.id}.${set.option}). set LUNR_TELEGRAM_BOT_TOKEN / LUNR_DISCORD_BOT_TOKEN, or run setup in a TTY`,
+        exitCode: 2
+      };
+    if (!(flags.features.includes(set.id) || next.features[set.id]?.enabled === !0))
+      return { ok: !1, error: `enable the feature first (${set.id})`, exitCode: 2 };
+    if (option.type === "boolean") {
+      let coerced = coerceBooleanSetValue(set.value);
+      if (coerced === void 0)
+        return { ok: !1, error: `${set.id}.${set.option} must be true|false|1|0`, exitCode: 2 };
+      let prev = next.features[set.id] ?? { enabled: !0, options: {} };
+      next.features[set.id] = { ...prev, enabled: !0, options: { ...prev.options, [set.option]: coerced } };
+    }
+  }
+  return { ok: !0, next, secrets, enabledIds, disabledIds };
+}
+function persistEnvAndSecretTokens(secrets) {
+  let cfg = loadGatewayConfig(), telegram = secrets["telegram-token"] || process.env.LUNR_TELEGRAM_BOT_TOKEN || process.env.TELEGRAM_BOT_TOKEN, discord = secrets["discord-token"] || process.env.LUNR_DISCORD_BOT_TOKEN || process.env.DISCORD_BOT_TOKEN;
+  telegram && (cfg.telegram.token = telegram, cfg.telegram.enabled = !0), discord && (cfg.discord.token = discord, cfg.discord.enabled = !0), saveGatewayConfig(cfg);
+}
+var chatPlatformsHandler = {
+  async apply(ctx) {
+    persistEnvAndSecretTokens(ctx.secrets);
+    let cfg = loadGatewayConfig();
+    if (cfg.telegram.token && (cfg.telegram.enabled = !0), cfg.discord.token && (cfg.discord.enabled = !0), saveGatewayConfig(cfg), ctx.next.options.autostart === !0) {
+      let hasFileToken = !!(cfg.telegram.token || cfg.discord.token);
+      console.error(hasFileToken ? "chat-platforms: autostart recorded; login item install is not in this build yet." : "chat-platforms: autostart requested but no file token in gateway.json \u2014 unit not enabled.");
+    }
+  },
+  async disable(opts) {
+    let cfg = loadGatewayConfig();
+    cfg.telegram.enabled = !1, cfg.discord.enabled = !1, opts.purgeSecrets && (delete cfg.telegram.token, delete cfg.discord.token), saveGatewayConfig(cfg);
+  }
+}, FEATURE_HANDLERS = {
+  "chat-platforms": chatPlatformsHandler
+};
+function appendInstallLog(line) {
+  try {
+    let dir = getAgentDir();
+    existsSync2(dir) || mkdirSync2(dir, { recursive: !0 });
+    let path = join2(dir, "install.log");
+    writeFileSync2(path, `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
+`, { encoding: "utf-8", flag: "a" });
+  } catch {
+  }
+}
+var PRODUCT_UNINSTALL_FLAGS = /* @__PURE__ */ new Set(["--purge", "--yes", "-y"]);
+function isProductUninstallArgv(rest) {
+  return rest.every((arg) => PRODUCT_UNINSTALL_FLAGS.has(arg));
+}
+function deliverMentionsChatPlatform(deliver) {
+  return deliver.split(",").some((part) => {
+    let name = part.trim().split(":")[0]?.toLowerCase();
+    return name === "telegram" || name === "discord";
+  });
+}
+function chatPlatformDeliverBlockedMessage() {
+  return "chat platforms are not enabled. Enable with: lunr features enable chat-platforms";
+}
+
+export {
+  gatewayConfigPath,
+  loadGatewayConfig,
+  saveGatewayConfig,
+  resolvePlatformToken,
+  platformConfigFor,
+  FEATURE_CATALOG,
+  getFeatureSpec,
+  loadInstallFeatures,
+  saveInstallFeatures,
+  isFeatureEnabled,
+  parseFeatureFlags,
+  applyFeatureFlags,
+  FEATURE_HANDLERS,
+  appendInstallLog,
+  isProductUninstallArgv,
+  deliverMentionsChatPlatform,
+  chatPlatformDeliverBlockedMessage
+};

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

@@ -0,0 +1,17 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+
+// packages/coding-agent/dist/utils/await-with-abort.js
+function awaitWithAbort(pending, signal) {
+  return signal ? new Promise((resolve, reject) => {
+    let abort = () => reject(signal.reason);
+    signal.aborted ? abort() : signal.addEventListener("abort", abort, { once: !0 }), pending.then((value) => {
+      signal.removeEventListener("abort", abort), resolve(value);
+    }, (error) => {
+      signal.removeEventListener("abort", abort), reject(error);
+    });
+  }) : pending;
+}
+
+export {
+  awaitWithAbort
+};