@ashx-j/lunr 0.2.24 → 0.2.26

package/dist/node-runtime/{chunk-WHLRAGUQ.js → chunk-5B5QN3ZQ.js}

@@ -5,9 +5,9 @@ import {
   createPicker,
   gatewayInput,
   gatewaySelect,
-  isGatewayOwner,
-  requireGatewayOwner
-} from "./chunk-IGV54Q5V.js";
+  isAuthorized,
+  requireAuthorized
+} from "./chunk-3MISGG4S.js";
 import {
   getSubagentCancellation
 } from "./chunk-BBUVIEZB.js";
@@ -15,13 +15,13 @@ import {
   PERMISSION_MODES,
   getPermissionMode,
   setPermissionMode
-} from "./chunk-ZXSGTGJ6.js";
+} from "./chunk-WIF24I7G.js";
 import {
   SessionManager
 } from "./chunk-2KIPT4HJ.js";
 import {
   loadGatewayConfig
-} from "./chunk-R3K2F5GI.js";
+} from "./chunk-B4HP6ZWM.js";
 
 // packages/coding-agent/dist/gateway/mobile-commands.js
 import { mkdirSync, readdirSync, realpathSync, statSync } from "node:fs";
@@ -109,9 +109,9 @@ async function browseProject(ctx, initialPath) {
     sessionKey: key,
     invokerId: event.source.userId,
     ...initial,
-    validate: () => isGatewayOwner(event.source, loadGatewayConfig()),
+    validate: () => isAuthorized(event.source, loadGatewayConfig()),
     resolve: async (item) => {
-      if (requireGatewayOwner(event.source), item.value === "use" && current) {
+      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.");
@@ -146,9 +146,9 @@ async function continueSession(ctx, file) {
   }
 }
 async function performContinue(ctx, file, signal) {
-  requireGatewayOwner(ctx.event.source);
+  requireAuthorized(ctx.event.source);
   let { requestSessionTransfer, SessionTransferError } = await import("./session-handoff-GWARVEWT.js"), { key, bridge } = ctx;
-  if ((await bridge.getSession(key))?.sessionManager?.getSessionFile() === file) {
+  if (bridge.peekSession?.(key)?.sessionManager?.getSessionFile() === file) {
     await ctx.adapter.send(ctx.event.source.chatId, "This session is already open here.");
     return;
   }
@@ -157,7 +157,7 @@ async function performContinue(ctx, file, signal) {
   try {
     await requestSessionTransfer(file, { timeoutMs: 3e3, signal });
   } catch (error) {
-    if (!(error instanceof SessionTransferError) || error.code !== "busy")
+    if (!(error instanceof SessionTransferError) || !["busy", "timeout"].includes(error.code))
       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 });
@@ -168,19 +168,19 @@ How should lunR continue?`, ["Wait until idle", "Stop and continue", "Cancel"],
     else {
       let deadline = Date.now() + 12e4;
       for (; ; ) {
-        signal.throwIfAborted(), requireGatewayOwner(ctx.event.source);
+        signal.throwIfAborted(), requireAuthorized(ctx.event.source);
         try {
           await requestSessionTransfer(file, { timeoutMs: 3e3, signal });
           break;
         } catch (retryError) {
-          if (!(retryError instanceof SessionTransferError) || retryError.code !== "busy" || Date.now() >= deadline)
+          if (!(retryError instanceof SessionTransferError) || !["busy", "timeout"].includes(retryError.code) || Date.now() >= deadline)
             throw retryError;
         }
         await new Promise((resolve2) => setTimeout(resolve2, 500));
       }
     }
   }
-  signal.throwIfAborted(), requireGatewayOwner(ctx.event.source), await bridge.switchSession(key, file);
+  signal.throwIfAborted(), requireAuthorized(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();
@@ -241,14 +241,14 @@ async function sessionPicker(ctx, items) {
     invokerId: ctx.event.source.userId,
     title: "Choose a session. Use /sessions <search> to filter.",
     items,
-    validate: () => isGatewayOwner(ctx.event.source, loadGatewayConfig()),
+    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 (requireGatewayOwner(ctx.event.source, ctx.cfg), bindConversation(ctx.key, ctx.event.source, { owner: ctx.event.source.userId }), command === "project")
+  if (requireAuthorized(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;
@@ -325,7 +325,7 @@ async function handleMobileCommand(ctx, command, args) {
   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-QFDKNQTL.js"), cmd = CHAT_COMMANDS.find((c) => c.name === choice.toLowerCase());
+      let { CHAT_COMMANDS, runChatCommand } = await import("./commands-NAAL7KNT.js"), cmd = CHAT_COMMANDS.find((c) => c.name === choice.toLowerCase());
       return cmd && await runChatCommand(cmd, {
         ...ctx,
         args: "",

package/dist/node-runtime/chunk-5B6VKFEV.js

@@ -0,0 +1,180 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  require_proper_lockfile
+} from "./chunk-URD2SLIT.js";
+import {
+  getPackageDir
+} from "./chunk-FQMM2EZ2.js";
+import {
+  __toESM
+} from "./chunk-BRJX2PRC.js";
+
+// packages/coding-agent/dist/core/computer-use/runtime.js
+var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
+import { execFile } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { lstat, mkdir, readdir, readFile, readlink, realpath, rename, rm } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { userInfo } from "node:os";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { promisify } from "node:util";
+
+// packages/coding-agent/dist/core/computer-use/release.generated.js
+var computerRelease = {
+  version: "0.28.1",
+  tag: "cua-driver-rs-v0.28.1",
+  sourceCommit: "d8028a7943087ee258dc1b4d19dc12a7cd27669c",
+  repository: "https://github.com/trycua/cua",
+  prerelease: !0,
+  approval: "production-approved",
+  artifacts: [
+    {
+      platform: "win32",
+      arch: "x64",
+      packageName: "@ashx-j/lunr-computer-win32-x64",
+      name: "cua-driver-rs-0.28.1-windows-x86_64-binary.zip",
+      bytes: 28930759,
+      sha256: "ab90418a54f84102f549cde4537daef3a0e20ba8254b7e24524a50fc5f4174d3"
+    },
+    {
+      platform: "win32",
+      arch: "arm64",
+      packageName: "@ashx-j/lunr-computer-win32-arm64",
+      name: "cua-driver-rs-0.28.1-windows-arm64-binary.zip",
+      bytes: 27246194,
+      sha256: "d260e6110e029680d543d317f3c3c09569475f8d65855fcedda202e2ee989bf0"
+    },
+    {
+      platform: "darwin",
+      arch: "arm64",
+      packageName: "@ashx-j/lunr-computer-darwin-arm64",
+      name: "cua-driver-rs-0.28.1-darwin-arm64.tar.gz",
+      bytes: 70074352,
+      sha256: "b3cb3781feb9855dfcdd616bc5c9c8e627453e3e16a073c1446326691a549b24"
+    }
+  ]
+};
+
+// packages/coding-agent/dist/core/computer-use/runtime.js
+var exec = promisify(execFile), CUA_VERSION = computerRelease.version;
+async function resolveRuntimeArchive(packageDirectory = getPackageDir(), platform = process.platform, arch = process.arch) {
+  let payload = computerRelease.artifacts.find((item) => item.platform === platform && item.arch === arch);
+  if (!payload)
+    throw new Error("Computer use is unsupported on this platform or architecture.");
+  let archive = join(packageDirectory, "native", "computer-use", payload.name);
+  try {
+    await lstat(archive);
+  } catch (error) {
+    if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
+      throw error;
+    let manifestPath;
+    try {
+      manifestPath = createRequire(join(packageDirectory, "package.json")).resolve(`${payload.packageName}/package.json`);
+    } catch {
+      throw new Error("Computer-use payload is missing. Reinstall lunR with optional dependencies enabled. No runtime was downloaded.");
+    }
+    let manifest = JSON.parse(await readFile(manifestPath, "utf8")), cli = JSON.parse(await readFile(join(packageDirectory, "package.json"), "utf8"));
+    if (manifest.name !== payload.packageName || manifest.version !== cli.version)
+      throw new Error("Computer-use payload package version does not match lunR. Reinstall lunR with optional dependencies enabled.");
+    archive = join(dirname(manifestPath), payload.name);
+  }
+  let info = await lstat(archive);
+  if (!info.isFile() || info.isSymbolicLink() || info.size !== payload.bytes)
+    throw new Error("Bundled computer-use archive is not a regular file of the pinned size.");
+  return { archive, sha256: payload.sha256 };
+}
+function runtimeEnvironment(inherited = process.env) {
+  return {
+    ...Object.fromEntries(Object.entries(inherited).filter((entry) => entry[1] !== void 0 && !entry[0].toUpperCase().startsWith("CUA_"))),
+    CUA_DRIVER_RS_TELEMETRY_ENABLED: "false",
+    CUA_DRIVER_RS_UPDATE_CHECK: "false",
+    CUA_DRIVER_PERMISSION_MODE: "standard",
+    CUA_DRIVER_DISABLE_UNRESTRICTED: "true"
+  };
+}
+async function digest(path, signal) {
+  let hash = createHash("sha256");
+  for await (let chunk of createReadStream(path, { signal }))
+    hash.update(chunk);
+  return hash.digest("hex");
+}
+async function assertOwnedPath(path) {
+  let current = resolve(path);
+  for (; ; ) {
+    try {
+      if ((await lstat(current)).isSymbolicLink() || resolve(await realpath(current)).toLowerCase() !== current.toLowerCase())
+        throw new Error(`Computer runtime path redirects elsewhere: ${current}`);
+    } catch (error) {
+      if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
+        throw error;
+    }
+    let parent = dirname(current);
+    if (parent === current)
+      return;
+    current = parent;
+  }
+}
+async function runtimeInventory(root, signal) {
+  let inventory = {};
+  async function walk(path) {
+    for (let item of await readdir(path, { withFileTypes: !0 })) {
+      let entry = join(path, item.name), key = relative(root, entry);
+      if (item.isSymbolicLink()) {
+        let target = await readlink(entry), resolved = relative(root, resolve(dirname(entry), target));
+        if (isAbsolute(target) || resolved === ".." || resolved.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) || isAbsolute(resolved))
+          throw new Error("Runtime symlink escapes its bundle.");
+        inventory[key] = `link:${target}`;
+      } else if (item.isDirectory())
+        await assertOwnedPath(entry), inventory[key] = "directory", await walk(entry);
+      else if (item.isFile())
+        await assertOwnedPath(entry), inventory[key] = await digest(entry, signal);
+      else
+        throw new Error("Unexpected runtime filesystem entry.");
+    }
+  }
+  return await walk(root), Object.fromEntries(Object.entries(inventory).sort(([a], [b]) => a.localeCompare(b)));
+}
+async function installRuntime(signal) {
+  signal?.throwIfAborted();
+  let platform = `${process.platform}-${process.arch}`, { archive, sha256 } = await resolveRuntimeArchive();
+  if (process.platform === "win32" && process.env.SESSIONNAME === "Services")
+    throw new Error("Computer use requires a logged-in interactive desktop.");
+  if (await digest(archive, signal) !== sha256)
+    throw new Error("Bundled computer-use archive failed SHA-256 verification.");
+  let root = join(userInfo().homedir, ".lunr", "desktop");
+  await assertOwnedPath(root), await mkdir(root, { recursive: !0, mode: 448 });
+  let release = await import_proper_lockfile.default.lock(root, { retries: 0, stale: 12e4 }), temporary = join(root, `extract-${randomUUID()}`), destination = join(root, `runtime-${platform}`);
+  try {
+    await assertOwnedPath(destination), await mkdir(temporary, { mode: 448 }), await exec(process.platform === "win32" ? join(process.env.SystemRoot ?? "C:\\Windows", "System32", "tar.exe") : "/usr/bin/tar", ["-xf", archive, "-C", temporary], {
+      timeout: 3e4,
+      windowsHide: !0,
+      signal
+    });
+    let extracted = process.platform === "darwin" ? join(temporary, `cua-driver-rs-${CUA_VERSION}-darwin-arm64`) : temporary, expected = await runtimeInventory(extracted, signal);
+    try {
+      if (await lstat(destination), JSON.stringify(await runtimeInventory(destination, signal)) !== JSON.stringify(expected))
+        throw new Error("Cached computer runtime differs from the verified archive. Remove the inactive lunR runtime directory before reinstalling; it was not executed or overwritten.");
+    } catch (error) {
+      if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
+        throw error;
+      await rename(extracted, destination);
+    }
+    if (signal?.throwIfAborted(), process.platform === "darwin") {
+      let app = join(destination, "CuaDriver.app");
+      return await exec("/usr/bin/codesign", ["--verify", "--deep", "--strict", app], { timeout: 15e3, signal }), { app, command: join(app, "Contents", "MacOS", "cua-driver") };
+    }
+    return { command: join(destination, "cua-driver.exe") };
+  } finally {
+    await rm(temporary, { recursive: !0, force: !0 }), await release();
+  }
+}
+
+export {
+  CUA_VERSION,
+  resolveRuntimeArchive,
+  runtimeEnvironment,
+  assertOwnedPath,
+  runtimeInventory,
+  installRuntime
+};

package/dist/node-runtime/{chunk-AD6VXAO7.js → chunk-5Q4A37RB.js}

@@ -3,6 +3,12 @@ import {
   loadPhoton
 } from "./chunk-RQ2Q5IYR.js";
 
+// packages/coding-agent/dist/utils/image-resize.js
+import { Worker } from "node:worker_threads";
+
+// packages/coding-agent/dist/utils/image-resize-core.js
+import { createHash } from "node:crypto";
+
 // packages/coding-agent/dist/utils/exif-orientation.js
 function readOrientationFromTiff(bytes, tiffStart) {
   if (tiffStart + 8 > bytes.length)
@@ -99,42 +105,13 @@ function applyExifOrientation(photon, image, originalBytes) {
   }
 }
 
-// packages/coding-agent/dist/utils/image-convert.js
-async function convertImageBytesToPng(bytes) {
-  let photon = await loadPhoton();
-  if (!photon)
-    return null;
-  try {
-    let rawImage = photon.PhotonImage.new_from_byteslice(bytes), image = applyExifOrientation(photon, rawImage, bytes);
-    image !== rawImage && rawImage.free();
-    try {
-      return new Uint8Array(image.get_bytes());
-    } finally {
-      image.free();
-    }
-  } catch {
-    return null;
-  }
-}
-async function convertToPng(base64Data, mimeType) {
-  if (mimeType === "image/png")
-    return { data: base64Data, mimeType };
-  let bytes = new Uint8Array(Buffer.from(base64Data, "base64")), pngBytes = await convertImageBytesToPng(bytes);
-  return pngBytes ? {
-    data: Buffer.from(pngBytes).toString("base64"),
-    mimeType: "image/png"
-  } : null;
-}
-
-// packages/coding-agent/dist/utils/image-resize.js
-import { Worker } from "node:worker_threads";
-
 // packages/coding-agent/dist/utils/image-resize-core.js
 var DEFAULT_MAX_BYTES = 4.5 * 1024 * 1024, DEFAULT_OPTIONS = {
   maxWidth: 2e3,
   maxHeight: 2e3,
   maxBytes: DEFAULT_MAX_BYTES,
-  jpegQuality: 80
+  jpegQuality: 80,
+  includePixelFingerprint: !1
 };
 function encodeCandidate(buffer, mimeType) {
   let data = Buffer.from(buffer).toString("base64");
@@ -162,7 +139,7 @@ async function resizeImageInProcess(inputBytes, mimeType, options) {
       }
     }, rawImage = photon.PhotonImage.new_from_byteslice(inputBytes);
     image = applyExifOrientation(photon, rawImage, inputBytes), image !== rawImage && rawImage.free();
-    let originalWidth = image.get_width(), originalHeight = image.get_height(), format = mimeType.split("/")[1] ?? "png";
+    let originalWidth = image.get_width(), originalHeight = image.get_height(), format = mimeType.split("/")[1] ?? "png", fingerprint = opts.includePixelFingerprint ? createHash("sha256").update(`${originalWidth}x${originalHeight}:`).update(image.get_raw_pixels()).digest("hex") : void 0;
     if (originalWidth <= opts.maxWidth && originalHeight <= opts.maxHeight && inputBase64Size < opts.maxBytes)
       return {
         data: Buffer.from(inputBytes).toString("base64"),
@@ -171,7 +148,8 @@ async function resizeImageInProcess(inputBytes, mimeType, options) {
         originalHeight,
         width: originalWidth,
         height: originalHeight,
-        wasResized: !1
+        wasResized: !1,
+        ...fingerprint ? { fingerprint } : {}
       };
     let targetWidth = originalWidth, targetHeight = originalHeight;
     targetWidth > opts.maxWidth && (targetHeight = Math.round(targetHeight * opts.maxWidth / targetWidth), targetWidth = opts.maxWidth), targetHeight > opts.maxHeight && (targetWidth = Math.round(targetWidth * opts.maxHeight / targetHeight), targetHeight = opts.maxHeight);
@@ -187,7 +165,8 @@ async function resizeImageInProcess(inputBytes, mimeType, options) {
             originalHeight,
             width: currentWidth,
             height: currentHeight,
-            wasResized: !0
+            wasResized: !0,
+            ...fingerprint ? { fingerprint } : {}
           };
       if (currentWidth === 1 && currentHeight === 1)
         break;
@@ -267,76 +246,8 @@ function formatDimensionNote(result) {
   return `[Image: original ${result.originalWidth}x${result.originalHeight}, displayed at ${result.width}x${result.height}. Multiply coordinates by ${scale.toFixed(2)} to map to original image.]`;
 }
 
-// packages/coding-agent/dist/utils/image-process.js
-function baseMimeType(mimeType) {
-  return mimeType.split(";")[0]?.trim().toLowerCase() ?? mimeType.toLowerCase();
-}
-function normalizeSupportedImageMimeType(mimeType) {
-  switch (baseMimeType(mimeType)) {
-    case "image/png":
-      return "image/png";
-    case "image/jpeg":
-    case "image/jpg":
-      return "image/jpeg";
-    case "image/gif":
-      return "image/gif";
-    case "image/webp":
-      return "image/webp";
-    default:
-      return null;
-  }
-}
-async function normalizeImage(bytes, mimeType) {
-  let normalizedMimeType = normalizeSupportedImageMimeType(mimeType);
-  if (normalizedMimeType)
-    return { bytes, mimeType: normalizedMimeType };
-  let pngBytes = await convertImageBytesToPng(bytes);
-  return pngBytes ? {
-    bytes: pngBytes,
-    mimeType: "image/png",
-    convertedFrom: baseMimeType(mimeType)
-  } : null;
-}
-function conversionHint(from, to) {
-  if (!(!from || from === to))
-    return `[Image converted from ${from} to ${to}.]`;
-}
-async function processImage(bytes, mimeType, options) {
-  let autoResizeImages = options?.autoResizeImages ?? !0, normalized = await normalizeImage(bytes, mimeType);
-  if (!normalized)
-    return {
-      ok: !1,
-      message: "[Image omitted: could not be converted to a supported inline image format.]"
-    };
-  if (autoResizeImages) {
-    let resized = await resizeImage(normalized.bytes, normalized.mimeType, options?.resizeOptions);
-    if (!resized)
-      return {
-        ok: !1,
-        message: "[Image omitted: could not be resized below the inline image size limit.]"
-      };
-    let hints2 = [], convertedHint2 = conversionHint(normalized.convertedFrom, resized.mimeType);
-    convertedHint2 && hints2.push(convertedHint2);
-    let dimensionNote = formatDimensionNote(resized);
-    return dimensionNote && hints2.push(dimensionNote), {
-      ok: !0,
-      data: resized.data,
-      mimeType: resized.mimeType,
-      hints: hints2
-    };
-  }
-  let hints = [], convertedHint = conversionHint(normalized.convertedFrom, normalized.mimeType);
-  return convertedHint && hints.push(convertedHint), {
-    ok: !0,
-    data: Buffer.from(normalized.bytes).toString("base64"),
-    mimeType: normalized.mimeType,
-    hints
-  };
-}
-
 export {
-  convertToPng,
+  applyExifOrientation,
   resizeImage,
-  formatDimensionNote,
-  processImage
+  formatDimensionNote
 };