ai-remote 0.3.0 → 0.4.0

package/src/cli/window.ts

@@ -0,0 +1,140 @@
+/**
+ * A native window for the session — no browser, no bundled engine.
+ *
+ * The window and the webview inside it come from the operating system: WebView2
+ * on Windows, WebKit on macOS, WebKitGTK on Linux, reached through tao/wry. So
+ * the session gets a real application window with the platform's own title bar,
+ * its own dock or taskbar entry, and the green button on macOS meaning
+ * fullscreen — for about 4 MB rather than the 150 MB a second browser costs.
+ *
+ * It runs in a process of its own rather than inside the session, for the same
+ * reason the viewer is an attachment: a window has an event loop that wants the
+ * main thread, and closing one must not take a session with it.
+ */
+
+import { spawn } from 'node:child_process';
+import { createRequire } from 'node:module';
+
+/** Whether the native window layer is installed for this platform. */
+export function nativeWindowAvailable(): boolean {
+  try {
+    createRequire(import.meta.url).resolve('@webviewjs/webview');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export interface WindowOptions {
+  url: string;
+  title: string;
+  /** The remote desktop's size; the window is sized to show it at 100%. */
+  width: number;
+  height: number;
+  fullscreen?: boolean;
+  /** Open in the default browser instead of a window of its own. */
+  tab?: boolean;
+}
+
+export interface WindowHandle {
+  kind: 'window' | 'tab' | 'none';
+  pid?: number;
+  detail: string;
+}
+
+/**
+ * Open the viewer, and say what actually happened rather than throwing. A
+ * window that will not open is a worse session, not a failed one, and the URL
+ * has been printed either way.
+ */
+export function openWindow(options: WindowOptions): WindowHandle {
+  if (!options.tab && nativeWindowAvailable()) {
+    const args = [
+      process.argv[1],
+      '__window',
+      options.url,
+      '--title', options.title,
+      '--width', String(options.width),
+      '--height', String(options.height),
+    ];
+    if (options.fullscreen) args.push('--fullscreen');
+
+    try {
+      const child = spawn(process.execPath, args, { 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) };
+  }
+}
+
+/** Run the window. This is the `__window` process, and it does not return. */
+export async function runWindow(argv: string[]): Promise<void> {
+  const positional: string[] = [];
+  const flags: Record<string, string | boolean> = {};
+  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 } = await import('@webviewjs/webview');
+  const application = new Application();
+
+  // `logical: true` matters: without it these are device pixels, so a window
+  // asked for at 1280 opens at 640 on any Retina display.
+  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: this binding exposes no way to
+    // start a window drag from the page, so removing the titlebar outright
+    // would leave a window nothing could move.
+    macosTitlebarTransparent: true,
+    macosFullsizeContentView: true,
+    macosTitleHidden: true,
+    // The page handles clicks in the bar, so this is what leaves the window
+    // draggable by the parts of it that are not a button.
+    macosMovableByWindowBackground: true,
+  });
+
+  window.createWebview({ url, enableDevtools: false });
+
+  if (flags.fullscreen) {
+    // After the window has a screen to fill.
+    setTimeout(() => { try { window.setFullscreen(); } catch { /* not fatal */ } }, 400);
+  }
+
+  await application.whenReady();
+}