@ashx-j/lunr-dev 0.2.13-dev.8.1 → 0.2.16-dev.9.1

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-OR4L3IB2.js

@@ -0,0 +1,42 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+
+// packages/coding-agent/dist/core/extensions/types.js
+function defineTool(tool) {
+  return tool;
+}
+function isBashToolResult(e) {
+  return e.toolName === "bash";
+}
+function isReadToolResult(e) {
+  return e.toolName === "read";
+}
+function isEditToolResult(e) {
+  return e.toolName === "edit";
+}
+function isWriteToolResult(e) {
+  return e.toolName === "write";
+}
+function isGrepToolResult(e) {
+  return e.toolName === "grep";
+}
+function isFindToolResult(e) {
+  return e.toolName === "find";
+}
+function isLsToolResult(e) {
+  return e.toolName === "ls";
+}
+function isToolCallEventType(toolName, event) {
+  return event.toolName === toolName;
+}
+
+export {
+  defineTool,
+  isBashToolResult,
+  isReadToolResult,
+  isEditToolResult,
+  isWriteToolResult,
+  isGrepToolResult,
+  isFindToolResult,
+  isLsToolResult,
+  isToolCallEventType
+};