ai-remote 0.4.13 → 0.4.15

package/dist/cli-chunk-7UHHVT7Q.mjs

@@ -0,0 +1,483 @@
+import {
+  ROOT,
+  isTitlebarDragPoint,
+  logicalDisplaySize
+} from "./cli-chunk-K2DYJXC5.mjs";
+
+// src/cli/window.ts
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+
+// src/cli/bundle.ts
+import { existsSync, mkdirSync, readdirSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+// src/cli/png.ts
+import { deflateSync } from "node:zlib";
+var CRC_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    table[n] = c >>> 0;
+  }
+  return table;
+})();
+function crc32(bytes) {
+  let c = 4294967295;
+  for (let i = 0; i < bytes.length; i++) c = CRC_TABLE[(c ^ bytes[i]) & 255] ^ c >>> 8;
+  return (c ^ 4294967295) >>> 0;
+}
+function chunk(type, body) {
+  const out = new Uint8Array(12 + body.length);
+  const view = new DataView(out.buffer);
+  view.setUint32(0, body.length);
+  for (let i = 0; i < 4; i++) out[4 + i] = type.charCodeAt(i);
+  out.set(body, 8);
+  view.setUint32(8 + body.length, crc32(out.subarray(4, 8 + body.length)));
+  return out;
+}
+function encodePng(rgba, width, height) {
+  const stride = width * 4;
+  const raw = new Uint8Array((stride + 1) * height);
+  for (let y = 0; y < height; y++) {
+    raw[y * (stride + 1)] = 0;
+    raw.set(rgba.subarray(y * stride, y * stride + stride), y * (stride + 1) + 1);
+  }
+  const ihdr = new Uint8Array(13);
+  const view = new DataView(ihdr.buffer);
+  view.setUint32(0, width);
+  view.setUint32(4, height);
+  ihdr[8] = 8;
+  ihdr[9] = 6;
+  ihdr[10] = 0;
+  ihdr[11] = 0;
+  ihdr[12] = 0;
+  const parts = [
+    new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]),
+    chunk("IHDR", ihdr),
+    chunk("IDAT", new Uint8Array(deflateSync(raw, { level: 6 }))),
+    chunk("IEND", new Uint8Array(0))
+  ];
+  const total = parts.reduce((sum, part) => sum + part.length, 0);
+  const png = new Uint8Array(total);
+  let offset = 0;
+  for (const part of parts) {
+    png.set(part, offset);
+    offset += part.length;
+  }
+  return png;
+}
+function downscale(rgba, width, height, maxEdge) {
+  const scale = Math.min(1, maxEdge / Math.max(width, height));
+  if (scale >= 1) return { rgba, width, height };
+  const outWidth = Math.max(1, Math.round(width * scale));
+  const outHeight = Math.max(1, Math.round(height * scale));
+  const out = new Uint8Array(outWidth * outHeight * 4);
+  for (let y = 0; y < outHeight; y++) {
+    const sourceY = Math.min(height - 1, Math.floor(y / scale));
+    for (let x = 0; x < outWidth; x++) {
+      const sourceX = Math.min(width - 1, Math.floor(x / scale));
+      const from = (sourceY * width + sourceX) * 4;
+      const to = (y * outWidth + x) * 4;
+      out[to] = rgba[from];
+      out[to + 1] = rgba[from + 1];
+      out[to + 2] = rgba[from + 2];
+      out[to + 3] = rgba[from + 3];
+    }
+  }
+  return { rgba: out, width: outWidth, height: outHeight };
+}
+
+// src/cli/icon.ts
+var ICON_VERSION = 2;
+var SCREEN_TOP = [91, 149, 243];
+var SCREEN_BOTTOM = [47, 103, 214];
+var CURSOR = [255, 255, 255];
+var ARROW = [
+  [0, 0],
+  [0, 12.7],
+  [3.1, 9.9],
+  [5.1, 14.4],
+  [7.3, 13.4],
+  [5.3, 9],
+  [9.2, 8.6]
+];
+var ARROW_H = 14.4;
+function inSquircle(x, y, cx, cy, radius) {
+  const dx = Math.abs(x - cx) / radius;
+  const dy = Math.abs(y - cy) / radius;
+  return dx ** 5 + dy ** 5 <= 1;
+}
+function centroid(points) {
+  let twiceArea = 0;
+  let x = 0;
+  let y = 0;
+  for (let i = 0, j = points.length - 1; i < points.length; j = i++) {
+    const [xi, yi] = points[i];
+    const [xj, yj] = points[j];
+    const cross = xj * yi - xi * yj;
+    twiceArea += cross;
+    x += (xi + xj) * cross;
+    y += (yi + yj) * cross;
+  }
+  return [x / (3 * twiceArea), y / (3 * twiceArea)];
+}
+function inPolygon(x, y, points) {
+  let inside = false;
+  for (let i = 0, j = points.length - 1; i < points.length; j = i++) {
+    const [xi, yi] = points[i];
+    const [xj, yj] = points[j];
+    if (yi > y !== yj > y && x < (xj - xi) * (y - yi) / (yj - yi) + xi) inside = !inside;
+  }
+  return inside;
+}
+function iconRgba(size, { margin = 0.08 } = {}) {
+  const rgba = new Uint8Array(size * size * 4);
+  const side = size * (1 - margin * 2);
+  const centre = size / 2;
+  const radius = side / 2;
+  const arrowScale = side * 0.56 / ARROW_H;
+  const scaled = ARROW.map(([x, y]) => [x * arrowScale, y * arrowScale]);
+  const [gx, gy] = centroid(scaled);
+  const arrow = scaled.map(([x, y]) => [x + centre - gx, y + centre - gy]);
+  const SAMPLES = 4;
+  const step = 1 / SAMPLES;
+  const per = 1 / (SAMPLES * SAMPLES);
+  for (let py = 0; py < size; py++) {
+    for (let px = 0; px < size; px++) {
+      let screen = 0;
+      let cursor = 0;
+      for (let sy = 0; sy < SAMPLES; sy++) {
+        for (let sx = 0; sx < SAMPLES; sx++) {
+          const x = px + (sx + 0.5) * step;
+          const y = py + (sy + 0.5) * step;
+          if (!inSquircle(x, y, centre, centre, radius)) continue;
+          screen += per;
+          if (inPolygon(x, y, arrow)) cursor += per;
+        }
+      }
+      if (screen === 0) continue;
+      const t = (py / size - margin) / (1 - margin * 2);
+      const lit = Math.min(1, Math.max(0, t));
+      const cursorShare = cursor / screen;
+      const at = (py * size + px) * 4;
+      for (let channel = 0; channel < 3; channel++) {
+        const screenTone = SCREEN_TOP[channel] + (SCREEN_BOTTOM[channel] - SCREEN_TOP[channel]) * lit;
+        rgba[at + channel] = Math.round(screenTone + (CURSOR[channel] - screenTone) * cursorShare);
+      }
+      rgba[at + 3] = Math.round(screen * 255);
+    }
+  }
+  return rgba;
+}
+var iconPng = (size, options) => encodePng(iconRgba(size, options), size, size);
+function iconIcns() {
+  const entries = [
+    ["ic11", 32],
+    ["ic12", 64],
+    ["ic07", 128],
+    ["ic13", 256],
+    ["ic08", 256],
+    ["ic14", 512],
+    ["ic09", 512]
+  ];
+  const rendered = /* @__PURE__ */ new Map();
+  const chunks = entries.map(([type, edge]) => {
+    if (!rendered.has(edge)) rendered.set(edge, iconPng(edge));
+    const png = rendered.get(edge);
+    const chunk2 = new Uint8Array(8 + png.length);
+    for (let i = 0; i < 4; i++) chunk2[i] = type.charCodeAt(i);
+    new DataView(chunk2.buffer).setUint32(4, chunk2.length);
+    chunk2.set(png, 8);
+    return chunk2;
+  });
+  const total = 8 + chunks.reduce((sum, chunk2) => sum + chunk2.length, 0);
+  const out = new Uint8Array(total);
+  out.set([105, 99, 110, 115]);
+  new DataView(out.buffer).setUint32(4, total);
+  let at = 8;
+  for (const chunk2 of chunks) {
+    out.set(chunk2, at);
+    at += chunk2.length;
+  }
+  return out;
+}
+var ICON_SVG = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32"><defs><linearGradient id="s" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stop-color="#5b95f3"/><stop offset="1" stop-color="#336cdb"/></linearGradient></defs><rect x="1.5" y="1.5" width="29" height="29" rx="6.5" fill="url(#s)"/><path d="M12.28 7.46 12.28 21.78 15.77 18.63 18.03 23.70 20.51 22.57 18.26 17.61 22.65 17.16 Z" fill="#ffffff"/></svg>`;
+
+// src/cli/bundle.ts
+var APP_NAME = "ai-remote";
+var windowsDir = () => join(ROOT, "window");
+var bundleDir = () => join(windowsDir(), `v${ICON_VERSION}`, `${APP_NAME}.app`);
+var PLIST = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleName</key><string>${APP_NAME}</string>
+  <key>CFBundleDisplayName</key><string>${APP_NAME}</string>
+  <key>CFBundleIdentifier</key><string>dev.ai-remote.window</string>
+  <key>CFBundleExecutable</key><string>${APP_NAME}</string>
+  <key>CFBundleIconFile</key><string>${APP_NAME}</string>
+  <key>CFBundlePackageType</key><string>APPL</string>
+  <key>CFBundleInfoDictionaryVersion</key><string>6.0</string>
+  <key>CFBundleShortVersionString</key><string>1.0</string>
+  <key>CFBundleVersion</key><string>${ICON_VERSION}</string>
+  <key>NSHighResolutionCapable</key><true/>
+  <key>LSApplicationCategoryType</key><string>public.app-category.utilities</string>
+</dict>
+</plist>
+`;
+function windowExecutable() {
+  if (process.platform !== "darwin") return null;
+  const app = bundleDir();
+  const executable = join(app, "Contents", "MacOS", APP_NAME);
+  try {
+    if (!existsSync(executable)) build(app, executable);
+    return executable;
+  } catch {
+    return null;
+  }
+}
+function build(app, executable) {
+  const contents = join(app, "Contents");
+  rmSync(app, { recursive: true, force: true });
+  mkdirSync(join(contents, "MacOS"), { recursive: true });
+  mkdirSync(join(contents, "Resources"), { recursive: true });
+  writeFileSync(join(contents, "Info.plist"), PLIST);
+  writeFileSync(join(contents, "PkgInfo"), "APPL????");
+  writeFileSync(join(contents, "Resources", `${APP_NAME}.icns`), iconIcns());
+  symlinkSync(process.execPath, executable);
+  for (const old of readdirSync(windowsDir())) {
+    if (old !== `v${ICON_VERSION}`) rmSync(join(windowsDir(), old), { recursive: true, force: true });
+  }
+}
+
+// src/cli/window.ts
+function nativeWindowAvailable() {
+  try {
+    createRequire(import.meta.url).resolve("@webviewjs/webview");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function detectCurrentDisplaySize(timeoutMs = 3e3) {
+  if (!nativeWindowAvailable() || !process.argv[1]) return Promise.resolve(null);
+  return new Promise((resolve) => {
+    const child = spawn(process.execPath, [process.argv[1], "__display-size"], {
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    let output = "";
+    let settled = false;
+    const finish = (size) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(size);
+    };
+    const timer = setTimeout(() => {
+      try {
+        child.kill();
+      } catch {
+      }
+      finish(null);
+    }, timeoutMs);
+    child.stdout?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk2) => {
+      if (output.length < 4096) output += chunk2;
+    });
+    child.once("error", () => finish(null));
+    child.once("close", (code) => {
+      if (code !== 0) {
+        finish(null);
+        return;
+      }
+      const match = /^\s*\{"width":(\d+),"height":(\d+)\}\s*$/.exec(output);
+      const width = Number(match?.[1]);
+      const height = Number(match?.[2]);
+      finish(width > 0 && height > 0 ? { width, height } : null);
+    });
+  });
+}
+async function readCurrentDisplaySize() {
+  if (!nativeWindowAvailable()) return null;
+  const { Application } = await import("@webviewjs/webview");
+  const application = new Application();
+  const probe = application.createBrowserWindow({
+    title: "ai-remote display probe",
+    width: 1,
+    height: 1,
+    logical: true,
+    visible: false,
+    focused: false
+  });
+  try {
+    application.pumpEvents();
+    probe.center();
+    application.pumpEvents();
+    const monitor = probe.getCurrentMonitor() ?? probe.getPrimaryMonitor();
+    return monitor ? logicalDisplaySize(monitor.size, monitor.scaleFactor) : null;
+  } finally {
+    try {
+      probe.dispose();
+    } catch {
+    }
+    try {
+      application.exit();
+    } catch {
+    }
+  }
+}
+function openWindow(options) {
+  if (!options.tab && nativeWindowAvailable()) {
+    const args2 = [
+      process.argv[1],
+      "__window",
+      options.url,
+      "--title",
+      options.title,
+      "--width",
+      String(options.width),
+      "--height",
+      String(options.height)
+    ];
+    if (options.fullscreen) args2.push("--fullscreen");
+    const executable = windowExecutable() ?? process.execPath;
+    try {
+      const child = spawn(executable, args2, { stdio: "ignore", detached: true });
+      child.unref();
+      return { kind: "window", pid: child.pid, detail: "native window" };
+    } catch (error) {
+      return { kind: "none", detail: error instanceof Error ? error.message : String(error) };
+    }
+  }
+  const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+  const args = process.platform === "win32" ? ["/c", "start", "", options.url] : [options.url];
+  try {
+    spawn(command, args, { stdio: "ignore", detached: true }).unref();
+    return {
+      kind: "tab",
+      detail: options.tab ? "asked for a browser tab" : "the native window layer is not installed"
+    };
+  } catch (error) {
+    return { kind: "none", detail: error instanceof Error ? error.message : String(error) };
+  }
+}
+async function runWindow(argv) {
+  const positional = [];
+  const flags = {};
+  for (let i = 0; i < argv.length; i++) {
+    const token = argv[i];
+    if (!token.startsWith("--")) {
+      positional.push(token);
+      continue;
+    }
+    const name = token.slice(2);
+    if (name === "fullscreen") flags[name] = true;
+    else flags[name] = argv[++i] ?? "";
+  }
+  const url = positional[0];
+  if (!url) throw new Error("__window needs a URL");
+  const { Application, FullscreenType } = await import("@webviewjs/webview");
+  const application = new Application();
+  const window = application.createBrowserWindow({
+    title: String(flags.title || "ai-remote"),
+    width: Number(flags.width) || 1280,
+    height: Number(flags.height) || 800,
+    logical: true,
+    resizable: true,
+    maximizable: true,
+    minimizable: true,
+    focused: true,
+    // One bar, not two. The page draws the title and the controls, and the
+    // system titlebar becomes a transparent strip that the content runs
+    // underneath -- so the traffic lights sit on the page's own toolbar.
+    //
+    // Transparent rather than hidden on purpose: the drag below moves the
+    // window from the page, but a window with no titlebar at all also loses the
+    // traffic lights the page's toolbar is laid out around.
+    macosTitlebarTransparent: true,
+    macosFullsizeContentView: true,
+    macosTitleHidden: true,
+    // Keep AppKit background dragging disabled. The page-to-native bridge below
+    // moves the window only after a gesture begins in the HTML title bar;
+    // enabling this would also steal canvas and terminal pointer drags.
+    macosMovableByWindowBackground: false
+  });
+  try {
+    const edge = 64;
+    window.setWindowIcon(Buffer.from(iconRgba(edge, { margin: 0 })), edge, edge);
+  } catch {
+  }
+  const webview = window.createWebview({ url, enableDevtools: false });
+  const debugDrag = process.env.AI_REMOTE_DEBUG_DRAG === "1";
+  let pageDrag = null;
+  let dragPointer = null;
+  webview.onIpcMessage((message) => {
+    let note;
+    try {
+      note = JSON.parse(message.body.toString("utf8"));
+    } catch {
+      return;
+    }
+    if (debugDrag) console.error("[page-ipc]", note);
+    if (note.t === "drag-end") {
+      pageDrag = null;
+      return;
+    }
+    if (typeof note.x !== "number" || typeof note.y !== "number") return;
+    if (note.t === "drag-start") {
+      if (window.fullscreen !== null) return;
+      const at = window.getPosition(true);
+      pageDrag = { pointer: { x: note.x, y: note.y }, origin: { x: at.x, y: at.y } };
+      dragPointer = null;
+      return;
+    }
+    if (note.t !== "drag-move" || !pageDrag || window.fullscreen !== null) return;
+    window.setPosition(
+      pageDrag.origin.x + (note.x - pageDrag.pointer.x),
+      pageDrag.origin.y + (note.y - pageDrag.pointer.y),
+      true
+    );
+  });
+  window.on("mouse-down", (event) => {
+    if (debugDrag) console.error("[native-mouse-down]", event);
+    if (process.platform !== "darwin" || event.button !== 0 || window.fullscreen !== null) return;
+    if (pageDrag) return;
+    const point = { x: event.x, y: event.y };
+    if (!isTitlebarDragPoint(point, window.getInnerSize(false).width, window.scaleFactor())) return;
+    dragPointer = point;
+  });
+  window.on("mouse-move", (event) => {
+    if (!dragPointer || pageDrag || window.fullscreen !== null) return;
+    if (debugDrag) console.error("[native-mouse-move]", event);
+    const dx = event.x - dragPointer.x;
+    const dy = event.y - dragPointer.y;
+    if (dx === 0 && dy === 0) return;
+    const position = window.getPosition(false);
+    window.setPosition(position.x + dx, position.y + dy, false);
+  });
+  window.on("mouse-up", (event) => {
+    if (event.button === 0) dragPointer = null;
+  });
+  if (flags.fullscreen) {
+    setTimeout(() => {
+      try {
+        window.setFullscreen(FullscreenType.Borderless);
+      } catch {
+      }
+    }, 400);
+  }
+  await application.whenReady({ interval: 33 });
+}
+
+export {
+  encodePng,
+  downscale,
+  ICON_SVG,
+  nativeWindowAvailable,
+  detectCurrentDisplaySize,
+  readCurrentDisplaySize,
+  openWindow,
+  runWindow
+};