@ashx-j/lunr 0.2.17 → 0.2.19

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

@@ -0,0 +1,209 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  loadPhoton
+} from "./chunk-RQ2Q5IYR.js";
+
+// packages/coding-agent/dist/utils/clipboard-image.js
+import { spawnSync } from "child_process";
+import { randomUUID } from "crypto";
+import { readFileSync, statSync, unlinkSync } from "fs";
+import { tmpdir } from "os";
+import { extname, join as join2 } from "path";
+
+// packages/coding-agent/dist/utils/clipboard-native.js
+import { createRequire } from "module";
+import { dirname, join } from "path";
+import { pathToFileURL } from "url";
+var moduleRequire = createRequire(new URL("../utils/clipboard-native.js", import.meta.url).href), executableDirRequire = createRequire(pathToFileURL(join(dirname(process.execPath), "package.json")).href), hasDisplay = process.platform !== "linux" || !!(process.env.DISPLAY || process.env.WAYLAND_DISPLAY);
+function loadClipboardNative(requires = [moduleRequire, executableDirRequire]) {
+  for (let requireClipboard of requires)
+    try {
+      return requireClipboard("@mariozechner/clipboard");
+    } catch {
+    }
+  return null;
+}
+var clipboard = !process.env.TERMUX_VERSION && hasDisplay ? loadClipboardNative() : null;
+
+// packages/coding-agent/dist/utils/clipboard-image.js
+var SUPPORTED_IMAGE_MIME_TYPES = ["image/png", "image/jpeg", "image/webp", "image/gif"], DEFAULT_LIST_TIMEOUT_MS = 1e3, DEFAULT_READ_TIMEOUT_MS = 3e3, DEFAULT_POWERSHELL_TIMEOUT_MS = 5e3, DEFAULT_MAX_BUFFER_BYTES = 50 * 1024 * 1024;
+function isWaylandSession(env = process.env) {
+  return !!env.WAYLAND_DISPLAY || env.XDG_SESSION_TYPE === "wayland";
+}
+function baseMimeType(mimeType) {
+  return mimeType.split(";")[0]?.trim().toLowerCase() ?? mimeType.toLowerCase();
+}
+function extensionForImageMimeType(mimeType) {
+  switch (baseMimeType(mimeType)) {
+    case "image/png":
+      return "png";
+    case "image/jpeg":
+      return "jpg";
+    case "image/webp":
+      return "webp";
+    case "image/gif":
+      return "gif";
+    default:
+      return null;
+  }
+}
+function selectPreferredImageMimeType(mimeTypes) {
+  let normalized = mimeTypes.map((t) => t.trim()).filter(Boolean).map((t) => ({ raw: t, base: baseMimeType(t) }));
+  for (let preferred of SUPPORTED_IMAGE_MIME_TYPES) {
+    let match = normalized.find((t) => t.base === preferred);
+    if (match)
+      return match.raw;
+  }
+  return normalized.find((t) => t.base.startsWith("image/"))?.raw ?? null;
+}
+function isSupportedImageMimeType(mimeType) {
+  let base = baseMimeType(mimeType);
+  return SUPPORTED_IMAGE_MIME_TYPES.some((t) => t === base);
+}
+async function convertToPng(bytes) {
+  let photon = await loadPhoton();
+  if (!photon)
+    return null;
+  try {
+    let image = photon.PhotonImage.new_from_byteslice(bytes);
+    try {
+      return image.get_bytes();
+    } finally {
+      image.free();
+    }
+  } catch {
+    return null;
+  }
+}
+function runCommand(command, args, options) {
+  let timeoutMs = options?.timeoutMs ?? DEFAULT_READ_TIMEOUT_MS, maxBufferBytes = options?.maxBufferBytes ?? DEFAULT_MAX_BUFFER_BYTES, result = spawnSync(command, args, {
+    timeout: timeoutMs,
+    maxBuffer: maxBufferBytes,
+    env: options?.env
+  });
+  return result.error ? { ok: !1, stdout: Buffer.alloc(0) } : result.status !== 0 ? { ok: !1, stdout: Buffer.alloc(0) } : { ok: !0, stdout: Buffer.isBuffer(result.stdout) ? result.stdout : Buffer.from(result.stdout ?? "", typeof result.stdout == "string" ? "utf-8" : void 0) };
+}
+function readClipboardImageViaWlPaste() {
+  let list = runCommand("wl-paste", ["--list-types"], { timeoutMs: DEFAULT_LIST_TIMEOUT_MS });
+  if (!list.ok)
+    return null;
+  let types = list.stdout.toString("utf-8").split(/\r?\n/).map((t) => t.trim()).filter(Boolean), selectedType = selectPreferredImageMimeType(types);
+  if (!selectedType)
+    return null;
+  let data = runCommand("wl-paste", ["--type", selectedType, "--no-newline"]);
+  return !data.ok || data.stdout.length === 0 ? null : { bytes: data.stdout, mimeType: baseMimeType(selectedType) };
+}
+function isWSL(env = process.env) {
+  if (env.WSL_DISTRO_NAME || env.WSLENV)
+    return !0;
+  try {
+    let release = readFileSync("/proc/version", "utf-8");
+    return /microsoft|wsl/i.test(release);
+  } catch {
+    return !1;
+  }
+}
+function readClipboardImageViaPowerShell(useWslpath) {
+  let tmpFile = join2(tmpdir(), `pi-clip-${randomUUID()}.png`);
+  try {
+    let winPath = tmpFile;
+    if (useWslpath) {
+      let winPathResult = runCommand("wslpath", ["-w", tmpFile], { timeoutMs: DEFAULT_LIST_TIMEOUT_MS });
+      if (!winPathResult.ok || (winPath = winPathResult.stdout.toString("utf-8").trim(), !winPath))
+        return null;
+    }
+    let psScript = [
+      "Add-Type -AssemblyName System.Windows.Forms",
+      "Add-Type -AssemblyName System.Drawing",
+      `$path = '${winPath.replaceAll("'", "''")}'`,
+      "$img = $null",
+      "try { $img = Get-Clipboard -Format Image } catch {}",
+      "if (-not $img) { $img = [System.Windows.Forms.Clipboard]::GetImage() }",
+      "if ($img) { $img.Save($path, [System.Drawing.Imaging.ImageFormat]::Png); Write-Output 'ok' } else { Write-Output 'empty' }"
+    ].join("; "), result = runCommand("powershell.exe", ["-NoProfile", "-STA", "-Command", psScript], {
+      timeoutMs: DEFAULT_POWERSHELL_TIMEOUT_MS
+    });
+    if (!result.ok || result.stdout.toString("utf-8").trim() !== "ok")
+      return null;
+    let bytes = readFileSync(tmpFile);
+    return bytes.length === 0 ? null : { bytes: new Uint8Array(bytes), mimeType: "image/png" };
+  } catch {
+    return null;
+  } finally {
+    try {
+      unlinkSync(tmpFile);
+    } catch {
+    }
+  }
+}
+var FILE_DROP_IMAGE_MIME_TYPES = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".gif": "image/gif",
+  ".bmp": "image/bmp"
+};
+function readClipboardImageFileDropViaPowerShell() {
+  let result = runCommand("powershell.exe", ["-NoProfile", "-STA", "-Command", "Get-Clipboard -Format FileDropList"], {
+    timeoutMs: DEFAULT_POWERSHELL_TIMEOUT_MS
+  });
+  if (!result.ok || result.stdout.length === 0)
+    return null;
+  let candidates = result.stdout.toString("utf-8").split(/\r?\n/).map((p) => p.trim()).filter(Boolean);
+  for (let filePath of candidates) {
+    let mimeType = FILE_DROP_IMAGE_MIME_TYPES[extname(filePath).toLowerCase()];
+    if (mimeType)
+      try {
+        let stat = statSync(filePath);
+        if (!stat.isFile() || stat.size === 0 || stat.size > DEFAULT_MAX_BUFFER_BYTES)
+          continue;
+        return { bytes: new Uint8Array(readFileSync(filePath)), mimeType };
+      } catch {
+      }
+  }
+  return null;
+}
+function readClipboardImageViaXclip() {
+  let targets = runCommand("xclip", ["-selection", "clipboard", "-t", "TARGETS", "-o"], {
+    timeoutMs: DEFAULT_LIST_TIMEOUT_MS
+  }), candidateTypes = [];
+  targets.ok && (candidateTypes = targets.stdout.toString("utf-8").split(/\r?\n/).map((t) => t.trim()).filter(Boolean));
+  let preferred = candidateTypes.length > 0 ? selectPreferredImageMimeType(candidateTypes) : null, tryTypes = preferred ? [preferred, ...SUPPORTED_IMAGE_MIME_TYPES] : [...SUPPORTED_IMAGE_MIME_TYPES];
+  for (let mimeType of tryTypes) {
+    let data = runCommand("xclip", ["-selection", "clipboard", "-t", mimeType, "-o"]);
+    if (data.ok && data.stdout.length > 0)
+      return { bytes: data.stdout, mimeType: baseMimeType(mimeType) };
+  }
+  return null;
+}
+async function readClipboardImageViaNativeClipboard() {
+  if (!clipboard || !clipboard.hasImage())
+    return null;
+  let imageData = await clipboard.getImageBinary();
+  return !imageData || imageData.length === 0 ? null : { bytes: imageData instanceof Uint8Array ? imageData : Uint8Array.from(imageData), mimeType: "image/png" };
+}
+async function readClipboardImage(options) {
+  let env = options?.env ?? process.env, platform = options?.platform ?? process.platform;
+  if (env.TERMUX_VERSION)
+    return null;
+  let image = null;
+  if (platform === "linux") {
+    let wsl = isWSL(env), wayland = isWaylandSession(env);
+    (wayland || wsl) && (image = readClipboardImageViaWlPaste() ?? readClipboardImageViaXclip()), !image && wsl && (image = readClipboardImageViaPowerShell(!0)), !image && !wayland && (image = await readClipboardImageViaNativeClipboard() ?? readClipboardImageViaXclip());
+  } else platform === "win32" ? image = await readClipboardImageViaNativeClipboard() ?? readClipboardImageViaPowerShell(!1) ?? readClipboardImageFileDropViaPowerShell() : image = await readClipboardImageViaNativeClipboard();
+  if (!image)
+    return null;
+  if (!isSupportedImageMimeType(image.mimeType)) {
+    let pngBytes = await convertToPng(image.bytes);
+    return pngBytes ? { bytes: pngBytes, mimeType: "image/png" } : null;
+  }
+  return image;
+}
+
+export {
+  clipboard,
+  isWaylandSession,
+  extensionForImageMimeType,
+  readClipboardImage
+};

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

@@ -0,0 +1,68 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+
+// packages/coding-agent/dist/core/output-guard.js
+var stdoutTakeoverState;
+var rawStdoutWriteTail = Promise.resolve();
+function getRawStdoutWrite() {
+  return stdoutTakeoverState ? stdoutTakeoverState.rawStdoutWrite : process.stdout.write.bind(process.stdout);
+}
+async function writeRawStdoutChunk(text) {
+  for (; ; )
+    try {
+      await new Promise((resolve, reject) => {
+        try {
+          getRawStdoutWrite()(text, (error) => {
+            error ? reject(error) : resolve();
+          });
+        } catch (error) {
+          reject(error instanceof Error ? error : new Error(String(error)));
+        }
+      });
+      return;
+    } catch (error) {
+      let writeError = error instanceof Error ? error : new Error(String(error)), code = writeError.code;
+      if (code !== "ENOBUFS" && code !== "EAGAIN" && code !== "EWOULDBLOCK")
+        throw writeError;
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+}
+function takeOverStdout() {
+  if (stdoutTakeoverState)
+    return;
+  let rawStdoutWrite = process.stdout.write.bind(process.stdout), rawStderrWrite = process.stderr.write.bind(process.stderr), originalStdoutWrite = process.stdout.write;
+  process.stdout.write = ((chunk, encodingOrCallback, callback) => typeof encodingOrCallback == "function" ? rawStderrWrite(String(chunk), encodingOrCallback) : rawStderrWrite(String(chunk), callback)), stdoutTakeoverState = {
+    rawStdoutWrite,
+    rawStderrWrite,
+    originalStdoutWrite
+  };
+}
+function restoreStdout() {
+  stdoutTakeoverState && (process.stdout.write = stdoutTakeoverState.originalStdoutWrite, stdoutTakeoverState = void 0);
+}
+function isStdoutTakenOver() {
+  return stdoutTakeoverState !== void 0;
+}
+function writeRawStdout(text) {
+  text.length !== 0 && (rawStdoutWriteTail = rawStdoutWriteTail.then(() => writeRawStdoutChunk(text)), rawStdoutWriteTail.catch(() => {
+    process.exit(1);
+  }));
+}
+async function waitForRawStdoutBackpressure() {
+  for (; ; ) {
+    let tail = rawStdoutWriteTail;
+    if (await tail, tail === rawStdoutWriteTail)
+      return;
+  }
+}
+async function flushRawStdout() {
+  await waitForRawStdoutBackpressure(), await writeRawStdoutChunk("");
+}
+
+export {
+  takeOverStdout,
+  restoreStdout,
+  isStdoutTakenOver,
+  writeRawStdout,
+  waitForRawStdoutBackpressure,
+  flushRawStdout
+};

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

@@ -0,0 +1,88 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  flushRawStdout,
+  writeRawStdout
+} from "./chunk-OBMWP3I5.js";
+import {
+  killTrackedDetachedChildren
+} from "./chunk-CSFI6YXL.js";
+
+// packages/coding-agent/dist/modes/print-mode.js
+async function runPrintMode(runtimeHost, options) {
+  let { mode, messages = [], initialMessage, initialImages } = options, exitCode = 0, session = runtimeHost.session, unsubscribe, disposed = !1, signalCleanupHandlers = [], disposeRuntime = async () => {
+    disposed || (disposed = !0, unsubscribe?.(), await runtimeHost.dispose());
+  };
+  (() => {
+    let signals = ["SIGTERM"];
+    process.platform !== "win32" && signals.push("SIGHUP");
+    for (let signal of signals) {
+      let handler = () => {
+        killTrackedDetachedChildren(), disposeRuntime().finally(() => {
+          process.exit(signal === "SIGHUP" ? 129 : 143);
+        });
+      };
+      process.on(signal, handler), signalCleanupHandlers.push(() => process.off(signal, handler));
+    }
+  })(), runtimeHost.setRebindSession(async () => {
+    await rebindSession();
+  });
+  let rebindSession = async () => {
+    session = runtimeHost.session, await session.bindExtensions({
+      mode: mode === "json" ? "json" : "print",
+      commandContextActions: {
+        waitForIdle: () => session.waitForIdle(),
+        newSession: async (newSessionOptions) => runtimeHost.newSession(newSessionOptions),
+        fork: async (entryId, forkOptions) => ({ cancelled: (await runtimeHost.fork(entryId, forkOptions)).cancelled }),
+        navigateTree: async (targetId, navigateOptions) => ({ cancelled: (await session.navigateTree(targetId, {
+          summarize: navigateOptions?.summarize,
+          customInstructions: navigateOptions?.customInstructions,
+          replaceInstructions: navigateOptions?.replaceInstructions,
+          label: navigateOptions?.label
+        })).cancelled }),
+        switchSession: async (sessionPath, switchOptions) => runtimeHost.switchSession(sessionPath, switchOptions),
+        reload: async () => {
+          await session.reload();
+        }
+      },
+      onError: (err) => {
+        console.error(`Extension error (${err.extensionPath}): ${err.error}`);
+      }
+    }), unsubscribe?.(), unsubscribe = session.subscribe((event) => {
+      mode === "json" && writeRawStdout(`${JSON.stringify(event)}
+`);
+    });
+  };
+  try {
+    if (mode === "json") {
+      let header = session.sessionManager.getHeader();
+      header && writeRawStdout(`${JSON.stringify(header)}
+`);
+    }
+    await rebindSession(), initialMessage && await session.prompt(initialMessage, { images: initialImages });
+    for (let message of messages)
+      await session.prompt(message);
+    if (mode === "text") {
+      let state = session.state, lastMessage = state.messages[state.messages.length - 1];
+      if (lastMessage?.role === "assistant") {
+        let assistantMsg = lastMessage;
+        if (assistantMsg.stopReason === "error" || assistantMsg.stopReason === "aborted")
+          console.error(assistantMsg.errorMessage || `Request ${assistantMsg.stopReason}`), exitCode = 1;
+        else
+          for (let content of assistantMsg.content)
+            content.type === "text" && writeRawStdout(`${content.text}
+`);
+      }
+    }
+    return exitCode;
+  } catch (error) {
+    return console.error(error instanceof Error ? error.message : String(error)), 1;
+  } finally {
+    for (let cleanup of signalCleanupHandlers)
+      cleanup();
+    await disposeRuntime(), await flushRawStdout();
+  }
+}
+
+export {
+  runPrintMode
+};