@rigkit/provider-freestyle 0.2.4 → 0.2.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigkit/provider-freestyle",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "type": "module",
   "repository": {
     "type": "git",
@@ -17,9 +17,9 @@
   ],
   "dependencies": {
     "zod": "^4",
-    "@rigkit/sdk": "0.2.4",
-    "@rigkit/engine": "0.2.4",
-    "@rigkit/provider-cmux": "0.2.4"
+    "@rigkit/sdk": "0.2.6",
+    "@rigkit/provider-cmux": "0.2.6",
+    "@rigkit/engine": "0.2.6"
   },
   "peerDependencies": {
     "freestyle": "^0.1.51"

package/src/provider.test.ts

@@ -160,6 +160,23 @@ describe("Freestyle provider host adapters", () => {
     expect(html).toContain("const canFinishWhileRunning = false;");
   });
 
+  test("sets remote browser open fallbacks for SSH terminal commands", () => {
+    const command = buildInteractiveSshCommand(
+      {
+        kind: "ssh",
+        host: "vm-ssh.freestyle.sh",
+        username: "vm-stream+root",
+        auth: { type: "token", token: "token" },
+        command: "ssh vm-stream+root:token@vm-ssh.freestyle.sh",
+      },
+      "gh auth login --hostname github.com --web",
+    );
+
+    expect(command).toContain('export BROWSER="${BROWSER:-true}"');
+    expect(command).toContain('export GH_BROWSER="${GH_BROWSER:-$BROWSER}"');
+    expect(command).toContain("gh auth login --hostname github.com --web");
+  });
+
   test("can keep an SSH terminal open after a successful remote command", () => {
     const command = buildInteractiveSshCommand(
       {

package/src/provider.ts

@@ -88,6 +88,7 @@ export function createFreestyleTerminalController(): WorkflowProviderController<
             canFinishWhileRunning: options.keepOpenAfterCommand,
             instructions: options.instructions,
             nodePath: context.nodePath,
+            openExternalTarget: (target) => context.local.open(target),
           });
           return await context.interaction.present(session);
         },
@@ -234,10 +235,18 @@ export function buildInteractiveSshCommand(
   if (command) args.push("-tt", "-q");
   if (connection.port !== undefined) args.push("-p", String(connection.port));
   args.push(destination);
-  if (command) args.push(command);
+  if (command) args.push(withBrowserOpenFallback(command));
   return args.map((arg) => arg === "ssh" || arg.startsWith("-") ? arg : shellQuote(arg)).join(" ");
 }
 
+function withBrowserOpenFallback(command: string): string {
+  return [
+    'export BROWSER="${BROWSER:-true}"',
+    'export GH_BROWSER="${GH_BROWSER:-$BROWSER}"',
+    command,
+  ].join("\n");
+}
+
 function keepOpenAfterCommand(command: string): string {
   return [
     command,

package/src/terminal-session.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, test } from "bun:test";
 import { createFreestyleTerminalSession } from "./terminal-session.ts";
 
 describe("Freestyle terminal session", () => {
-  test("serves a wterm page and resolves after the user finishes", async () => {
+  test("serves an xterm page and resolves after the user finishes", async () => {
     const session = createFreestyleTerminalSession({
       nodePath: "login",
       title: "GitHub auth",
@@ -19,8 +19,9 @@ describe("Freestyle terminal session", () => {
       expect(html).toContain("GitHub auth");
       expect(html).toContain("Authenticate GitHub inside the VM.");
       expect(html).toContain("printf interactive-ready");
-      expect(html).toContain("@wterm/dom");
-      expect(html).toContain("@wterm/ghostty");
+      expect(html).toContain("@xterm/xterm");
+      expect(html).toContain("@xterm/addon-fit");
+      expect(html).toContain("@xterm/addon-web-links");
       expect(html).toContain("terminal-window");
       expect(html).toContain("freestyle.sh");
       expect(html).toContain("Complete task");
@@ -30,6 +31,18 @@ describe("Freestyle terminal session", () => {
       expect(html).toContain("user-select: text");
       expect(html).toContain("keyEventToTerminalInput");
       expect(html).toContain("sendTerminalInput(data)");
+      expect(html).toContain("terminalUrlFromEvent");
+      expect(html).toContain("expandKnownTerminalUrl");
+      expect(html).toContain("openPendingBrowserPrompt");
+      expect(html).toContain("window.open(normalized");
+      expect(html).toContain("document.addEventListener(\"paste\"");
+      expect(html).toContain("term-input-proxy");
+      expect(html).toContain("onPointerDownCapture");
+      expect(html).toContain("onBeforeInput");
+      expect(html).toContain("sendTextInputEventToTerminal");
+      expect(html).toContain("sendPasteEventToTerminal");
+      expect(html).not.toContain("term-send-form");
+      expect(html).not.toContain("Send to terminal");
       const startupInput = readStartupInput(html);
       expect(startupInput).toBe("printf interactive-ready\n");
 
@@ -173,16 +186,195 @@ describe("Freestyle terminal session", () => {
       session.stop();
     }
   });
+
+  test("forwards browser terminal input to process stdin", async () => {
+    const session = createFreestyleTerminalSession({
+      nodePath: "prompt",
+      title: "Input prompt",
+      command: stdinEchoProbe,
+    });
+
+    try {
+      const messages: unknown[] = [];
+      const socketUrl = new URL(session.url.replace("/?", "/terminal?"));
+      socketUrl.protocol = "ws:";
+      const socket = new WebSocket(socketUrl);
+      socket.addEventListener("message", (event) => {
+        messages.push(JSON.parse(String(event.data)));
+      });
+
+      await waitForSocketOpen(socket);
+      socket.send(JSON.stringify({ type: "input", data: "abc123\n" }));
+
+      await waitFor(() =>
+        messages.some((message) =>
+          isMessage(message, "output") && message.data.includes("STDIN:abc123")
+        ),
+      );
+
+      socket.send(JSON.stringify({ type: "finish" }));
+      await expect(session.completed).resolves.toEqual({ finished: true });
+      socket.close();
+    } finally {
+      session.stop();
+    }
+  });
+
+  test("drops terminal-generated string control responses from browser input", async () => {
+    const session = createFreestyleTerminalSession({
+      nodePath: "prompt",
+      title: "Input prompt",
+      command: stdinHexProbe,
+    });
+
+    try {
+      const messages: unknown[] = [];
+      const socketUrl = new URL(session.url.replace("/?", "/terminal?"));
+      socketUrl.protocol = "ws:";
+      const socket = new WebSocket(socketUrl);
+      socket.addEventListener("message", (event) => {
+        messages.push(JSON.parse(String(event.data)));
+      });
+
+      await waitForSocketOpen(socket);
+      socket.send(JSON.stringify({ type: "input", data: "\x1b]10;rgb:ffff/ffff/ffff\x07" }));
+      socket.send(JSON.stringify({ type: "input", data: "y\n" }));
+
+      await waitFor(() =>
+        messages.some((message) =>
+          isMessage(message, "output") && message.data.includes("STDINHEX:790a")
+        ),
+      );
+
+      socket.send(JSON.stringify({ type: "finish" }));
+      await expect(session.completed).resolves.toEqual({ finished: true });
+      socket.close();
+    } finally {
+      session.stop();
+    }
+  });
+
+  test("runs interactive commands with a TTY stdin", async () => {
+    const session = createFreestyleTerminalSession({
+      nodePath: "prompt",
+      title: "TTY probe",
+      command: ttyProbe,
+    });
+
+    try {
+      const messages: unknown[] = [];
+      const socketUrl = new URL(session.url.replace("/?", "/terminal?"));
+      socketUrl.protocol = "ws:";
+      const socket = new WebSocket(socketUrl);
+      socket.addEventListener("message", (event) => {
+        messages.push(JSON.parse(String(event.data)));
+      });
+
+      await waitForSocketOpen(socket);
+
+      await waitFor(() =>
+        messages.some((message) =>
+          isMessage(message, "output") && message.data.includes("TTY:true")
+        ),
+      );
+
+      socket.send(JSON.stringify({ type: "finish" }));
+      await expect(session.completed).resolves.toEqual({ finished: true });
+      socket.close();
+    } finally {
+      session.stop();
+    }
+  });
+
+  test("asks the host to open complete browser auth URLs printed by the terminal", async () => {
+    const opened: string[] = [];
+    const authUrl = "https://claude.com/cai/oauth/authorize?code=true&state=abc";
+    const session = createFreestyleTerminalSession({
+      nodePath: "login",
+      title: "Claude auth",
+      command: "printf %s " + JSON.stringify(`Opening browser to sign in...\nIf the browser didn't open, visit: ${authUrl}\nPaste code here if prompted > `),
+      openExternalTarget: (target) => opened.push(target),
+    });
+
+    try {
+      const socketUrl = new URL(session.url.replace("/?", "/terminal?"));
+      socketUrl.protocol = "ws:";
+      const socket = new WebSocket(socketUrl);
+      await waitForSocketOpen(socket);
+
+      await waitFor(() => opened.includes(authUrl));
+      socket.send(JSON.stringify({ type: "finish" }));
+      await expect(session.completed).resolves.toEqual({ finished: true });
+      socket.close();
+    } finally {
+      session.stop();
+    }
+  });
+
+  test("does not open partial browser auth URLs while output is still streaming", async () => {
+    const opened: string[] = [];
+    const authUrl = "https://claude.com/cai/oauth/authorize?code=true&state=abc";
+    const session = createFreestyleTerminalSession({
+      nodePath: "login",
+      title: "Claude auth",
+      command: streamedAuthUrlProbe,
+      openExternalTarget: (target) => opened.push(target),
+    });
+
+    try {
+      const socketUrl = new URL(session.url.replace("/?", "/terminal?"));
+      socketUrl.protocol = "ws:";
+      const socket = new WebSocket(socketUrl);
+      await waitForSocketOpen(socket);
+
+      await new Promise((resolve) => setTimeout(resolve, 750));
+      expect(opened).toEqual([]);
+      await waitFor(() => opened.includes(authUrl), 2_500);
+      socket.send(JSON.stringify({ type: "finish" }));
+      await expect(session.completed).resolves.toEqual({ finished: true });
+      socket.close();
+    } finally {
+      session.stop();
+    }
+  });
 });
 
 const localInteractiveShell = "bash --noprofile --norc -i";
 const cursorPositionProbe = "node -e " + JSON.stringify([
+  "process.stdin.setRawMode?.(true);",
   "process.stdout.write('\\x1b[6n');",
   "process.stdin.once('data', (chunk) => {",
   "  process.stdout.write('CPR:' + Buffer.from(chunk).toString('hex') + '\\n');",
   "  process.exit(0);",
   "});",
 ].join(""));
+const stdinEchoProbe = "node -e " + JSON.stringify([
+  "process.stdin.once('data', (chunk) => {",
+  "  process.stdout.write('STDIN:' + chunk.toString('utf8').trim() + '\\n');",
+  "  process.exit(0);",
+  "});",
+].join(""));
+const stdinHexProbe = "node -e " + JSON.stringify([
+  "process.stdin.setRawMode?.(true);",
+  "let data = Buffer.alloc(0);",
+  "process.stdin.on('data', (chunk) => {",
+  "  data = Buffer.concat([data, chunk]);",
+  "  if (data.includes(10)) {",
+  "    process.stdout.write('STDINHEX:' + data.toString('hex') + '\\n');",
+  "    process.exit(0);",
+  "  }",
+  "});",
+].join(""));
+const ttyProbe = "node -e " + JSON.stringify([
+  "process.stdout.write('TTY:' + Boolean(process.stdin.isTTY) + '\\n');",
+  "process.exit(0);",
+].join(""));
+const streamedAuthUrlProbe = "node -e " + JSON.stringify([
+  "process.stdout.write(\"Opening browser to sign in...\\nIf the browser didn't open, visit: https://claude.com/cai/oauth/authorize?code=true\");",
+  "setTimeout(() => {",
+  "  process.stdout.write('&state=abc\\nPaste code here if prompted > ');",
+  "}, 1000);",
+].join(""));
 
 function readStartupInput(html: string): string {
   const match = /const startupInput = (.*);/.exec(html);
@@ -213,10 +405,10 @@ function isMessage(
   return Boolean(value && typeof value === "object" && (value as { type?: unknown }).type === type);
 }
 
-async function waitFor(assertion: () => boolean): Promise<void> {
+async function waitFor(assertion: () => boolean, timeoutMs = 1_000): Promise<void> {
   const started = Date.now();
   while (!assertion()) {
-    if (Date.now() - started > 1_000) throw new Error("Timed out waiting for terminal event");
+    if (Date.now() - started > timeoutMs) throw new Error("Timed out waiting for terminal event");
     await new Promise((resolve) => setTimeout(resolve, 10));
   }
 }

package/src/terminal-session.ts

@@ -10,6 +10,7 @@ export type FreestyleTerminalSessionRequest = {
   canFinishWhileRunning?: boolean;
   instructions?: string;
   nodePath?: string;
+  openExternalTarget?: (target: string) => unknown;
 };
 
 export type FreestyleTerminalSessionResult = {
@@ -41,12 +42,15 @@ export function createFreestyleTerminalSession(
   let terminalCols = 100;
   let terminalRows = 28;
   let terminalQueryBuffer = "";
+  let browserPromptOutputTail = "";
+  let browserPromptOpenTimer: ReturnType<typeof setTimeout> | undefined;
   let proc: Subprocess<"pipe", "pipe", "pipe"> | undefined;
   let stdin: { write(data: Uint8Array): unknown; flush?(): unknown } | undefined;
   let complete!: (result: FreestyleTerminalSessionResult) => void;
   let fail!: (error: Error) => void;
   const sockets = new Set<ServerWebSocket<SocketData>>();
   const outputBuffer: string[] = [];
+  const openedExternalTargets = new Set<string>();
   const startupCommand = request.startupInput ?? request.remoteCommand;
   const startupInput = startupCommand ? ensureTrailingNewline(startupCommand) : undefined;
   const displayCommand = request.displayCommand ?? request.remoteCommand ?? request.command;
@@ -122,6 +126,7 @@ export function createFreestyleTerminalSession(
     stop: () => {
       if (stopped) return;
       stopped = true;
+      clearTimeout(browserPromptOpenTimer);
       proc?.kill();
       server.stop(true);
     },
@@ -136,10 +141,11 @@ export function createFreestyleTerminalSession(
       canFinish: canFinishWhileRunning,
     });
 
-    proc = Bun.spawn(["sh", "-lc", `exec ${request.command}`], {
+    proc = Bun.spawn(["sh", "-lc", terminalProcessShellCommand(request.command)], {
       stdin: "pipe",
       stdout: "pipe",
       stderr: "pipe",
+      env: terminalProcessEnv(terminalCols, terminalRows),
     });
     stdin = proc.stdin;
 
@@ -184,6 +190,7 @@ export function createFreestyleTerminalSession(
   function handleProcessOutput(data: string): void {
     appendOutput(data);
     respondToTerminalQueries(data);
+    openBrowserUrlsFromOutput(data);
   }
 
   function appendOutput(data: string): void {
@@ -193,9 +200,10 @@ export function createFreestyleTerminalSession(
   }
 
   function writeInput(data: string): void {
-    if (isCursorPositionReport(data)) return;
+    const input = sanitizeBrowserTerminalInput(data);
+    if (!input) return;
 
-    if (startupInput && data === startupInput) {
+    if (startupInput && input === startupInput) {
       if (remoteCommandStarted) return;
       remoteCommandStarted = true;
       broadcast({
@@ -205,7 +213,7 @@ export function createFreestyleTerminalSession(
       });
     }
 
-    writeProcessInput(data);
+    writeProcessInput(input);
   }
 
   function writeProcessInput(data: string): void {
@@ -234,6 +242,26 @@ export function createFreestyleTerminalSession(
     }
   }
 
+  function openBrowserUrlsFromOutput(data: string): void {
+    if (!request.openExternalTarget) return;
+    browserPromptOutputTail = (browserPromptOutputTail + data).slice(-12_000);
+    clearTimeout(browserPromptOpenTimer);
+    browserPromptOpenTimer = setTimeout(openBufferedBrowserPromptUrls, 600);
+  }
+
+  function openBufferedBrowserPromptUrls(): void {
+    browserPromptOpenTimer = undefined;
+    const openExternalTarget = request.openExternalTarget;
+    if (!openExternalTarget) return;
+    for (const url of browserPromptUrlsInText(browserPromptOutputTail)) {
+      if (openedExternalTargets.has(url)) continue;
+      openedExternalTargets.add(url);
+      Promise.resolve(openExternalTarget(url)).catch(() => {
+        // The URL remains visible/clickable in the terminal if the host cannot open it.
+      });
+    }
+  }
+
   function requestFinish(): void {
     if (settled) return;
     settled = true;
@@ -267,6 +295,192 @@ export function createFreestyleTerminalSession(
   }
 }
 
+function browserPromptUrlsInText(text: string): string[] {
+  const cleaned = stripAnsi(text).replace(/\r(?!\n)/g, "\n");
+  const urls: string[] = [];
+  const matcher = /https?:\/\/[^\s<>"'\\]+/ig;
+  let match: RegExpExecArray | null;
+  while ((match = matcher.exec(cleaned)) !== null) {
+    const url = normalizeHttpUrl(match[0]);
+    if (!url) continue;
+    const context = cleaned.slice(Math.max(0, match.index - 260), match.index);
+    const trailing = cleaned.slice(match.index + match[0].length, match.index + match[0].length + 260);
+    if (looksLikeBrowserAuthPrompt(context) && looksLikeCompleteBrowserPrompt(trailing)) urls.push(url);
+  }
+  return urls;
+}
+
+function looksLikeBrowserAuthPrompt(context: string): boolean {
+  const lower = context.toLowerCase();
+  return Boolean(
+    lower.includes("browser") ||
+      lower.includes("sign in") ||
+      lower.includes("login") ||
+      lower.includes("oauth") ||
+      lower.includes("authorize") ||
+      lower.includes("visit:"),
+  );
+}
+
+function looksLikeCompleteBrowserPrompt(trailing: string): boolean {
+  const lower = trailing.toLowerCase();
+  return Boolean(
+    lower.includes("paste code here") ||
+      lower.includes("in your browser"),
+  );
+}
+
+function normalizeHttpUrl(value: string): string | undefined {
+  let url = value.trim();
+  while (/[),.;:!?\]}]+$/.test(url)) url = url.slice(0, -1);
+  try {
+    const parsed = new URL(url);
+    if (parsed.protocol === "http:" || parsed.protocol === "https:") return parsed.href;
+  } catch {
+    return undefined;
+  }
+  return undefined;
+}
+
+function stripAnsi(text: string): string {
+  return text.replace(/[\u001b\u009b][[\]()#;?]*(?:(?:(?:[a-zA-Z\d]*(?:;[a-zA-Z\d]*)*)?\u0007)|(?:(?:\d{1,4}(?:;\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]))/g, "");
+}
+
+function terminalProcessShellCommand(command: string): string {
+  return [
+    "if command -v python3 >/dev/null 2>&1; then",
+    `  exec python3 -c ${shellQuote(ptyBridgePythonScript)} ${shellQuote(command)}`,
+    "fi",
+    `exec ${command}`,
+  ].join("\n");
+}
+
+function terminalProcessEnv(cols: number, rows: number): Record<string, string> {
+  const env: Record<string, string> = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (typeof value === "string") env[key] = value;
+  }
+  env.TERM = env.TERM || "xterm-256color";
+  env.COLORTERM = env.COLORTERM || "truecolor";
+  env.COLUMNS = String(cols);
+  env.LINES = String(rows);
+  return env;
+}
+
+const ptyBridgePythonScript = String.raw`
+import errno
+import fcntl
+import os
+import pty
+import select
+import signal
+import struct
+import sys
+import termios
+
+command = sys.argv[1]
+rows = int(os.environ.get("LINES") or "28")
+cols = int(os.environ.get("COLUMNS") or "100")
+
+pid, fd = pty.fork()
+if pid == 0:
+    os.environ.setdefault("TERM", "xterm-256color")
+    os.environ.setdefault("COLORTERM", "truecolor")
+    os.execlp("sh", "sh", "-lc", "exec " + command)
+
+def forward_signal(signum, _frame):
+    try:
+        os.kill(pid, signum)
+    finally:
+        sys.exit(128 + signum)
+
+signal.signal(signal.SIGTERM, forward_signal)
+signal.signal(signal.SIGINT, forward_signal)
+
+try:
+    fcntl.ioctl(fd, termios.TIOCSWINSZ, struct.pack("HHHH", rows, cols, 0, 0))
+except Exception:
+    pass
+
+for target in (fd, sys.stdin.fileno()):
+    try:
+        os.set_blocking(target, False)
+    except Exception:
+        pass
+
+stdout_fd = sys.stdout.fileno()
+stdin_open = True
+child_exited = False
+exit_code = 0
+
+while True:
+    reads = [fd]
+    if stdin_open:
+        reads.append(sys.stdin.fileno())
+    try:
+        ready, _, _ = select.select(reads, [], [], 0.1)
+    except InterruptedError:
+        continue
+
+    if fd in ready:
+        try:
+            data = os.read(fd, 65536)
+        except OSError as exc:
+            if exc.errno not in (errno.EIO, errno.EBADF):
+                raise
+            data = b""
+        if data:
+            os.write(stdout_fd, data)
+        else:
+            child_exited = True
+
+    if stdin_open and sys.stdin.fileno() in ready:
+        try:
+            data = os.read(sys.stdin.fileno(), 65536)
+        except BlockingIOError:
+            data = None
+        if data:
+            os.write(fd, data)
+        elif data == b"":
+            stdin_open = False
+
+    try:
+        done_pid, status = os.waitpid(pid, os.WNOHANG)
+    except ChildProcessError:
+        done_pid = pid
+        status = 0
+
+    if done_pid == pid:
+        child_exited = True
+        if os.WIFEXITED(status):
+            exit_code = os.WEXITSTATUS(status)
+        elif os.WIFSIGNALED(status):
+            exit_code = 128 + os.WTERMSIG(status)
+        else:
+            exit_code = 1
+
+    if child_exited:
+        while True:
+            try:
+                data = os.read(fd, 65536)
+            except OSError:
+                break
+            if not data:
+                break
+            os.write(stdout_fd, data)
+        break
+
+try:
+    os.close(fd)
+except Exception:
+    pass
+sys.exit(exit_code)
+`;
+
+function shellQuote(value: string): string {
+  return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+
 function parseClientMessage(raw: string | Buffer): ClientMessage | undefined {
   if (typeof raw !== "string") return undefined;
   try {
@@ -292,6 +506,30 @@ function isCursorPositionReport(data: string): boolean {
   return /^\x1b\[\??\d+;\d+R$/.test(data);
 }
 
+function isDeviceAttributesReport(data: string): boolean {
+  return /^\x1b\[(?:[>?]\d+)?(?:;\d+)*c$/.test(data);
+}
+
+function isDeviceStatusReport(data: string): boolean {
+  return /^\x1b\[\??\d+n$/.test(data);
+}
+
+function isStringControlResponse(data: string): boolean {
+  return /^(?:\x1b[\]\^_P]|[\x90\x9d\x9e\x9f])/.test(data);
+}
+
+function sanitizeBrowserTerminalInput(data: string): string {
+  if (
+    isCursorPositionReport(data) ||
+    isDeviceAttributesReport(data) ||
+    isDeviceStatusReport(data) ||
+    isStringControlResponse(data)
+  ) {
+    return "";
+  }
+  return data;
+}
+
 function send(ws: ServerWebSocket<SocketData>, message: ServerMessage): void {
   ws.send(JSON.stringify(message));
 }
@@ -305,11 +543,11 @@ function htmlResponse(body: string): Response {
     headers: {
       "content-type": "text/html; charset=utf-8",
       "content-security-policy": [
-        "default-src 'none'",
-        "script-src 'unsafe-inline' 'unsafe-eval' 'wasm-unsafe-eval' https://esm.sh",
-        "style-src 'unsafe-inline'",
-        "connect-src 'self' ws: wss: https://esm.sh",
-        "form-action 'self'",
+      "default-src 'none'",
+      "script-src 'unsafe-inline' 'unsafe-eval' 'wasm-unsafe-eval' https://esm.sh",
+      "style-src 'unsafe-inline' https://esm.sh",
+      "connect-src 'self' ws: wss: https://esm.sh",
+      "form-action 'self'",
       ].join("; "),
     },
   });
@@ -342,6 +580,7 @@ function renderInteractionPage(
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width, initial-scale=1">
   <title>${escapedDocTitle}</title>
+  <link rel="stylesheet" href="https://esm.sh/@xterm/xterm@6.0.0/css/xterm.css">
   <style>
     :root {
       color-scheme: light;
@@ -590,10 +829,13 @@ function renderInteractionPage(
       background: var(--term-bg);
       overflow: hidden;
       user-select: text;
+      outline: none;
     }
     .term-host {
       position: absolute;
       inset: 0;
+      padding: 14px 16px;
+      box-sizing: border-box;
       user-select: text;
       --term-bg: #faf8f2;
       --term-fg: #1a1a1a;
@@ -618,7 +860,22 @@ function renderInteractionPage(
       --term-color-14: #06606a;
       --term-color-15: #0a0a0a;
     }
+    .term-host .xterm {
+      width: 100%;
+      height: 100%;
+      padding: 0;
+    }
+    .term-host .xterm-viewport {
+      background: transparent !important;
+    }
+    .term-host .xterm-screen {
+      user-select: text;
+    }
     .term-host:not(.ready) { visibility: hidden; }
+    .term-host.link-hover,
+    .term-fallback.link-hover {
+      cursor: pointer;
+    }
     .term-fallback {
       position: absolute;
       inset: 0;
@@ -636,34 +893,18 @@ function renderInteractionPage(
       line-height: 1.4;
     }
     .term-fallback.hidden { display: none; }
-    .wterm {
-      position: relative;
-      background: var(--term-bg);
-      color: var(--term-fg);
-      font-family: var(--term-font-family);
-      font-size: var(--term-font-size);
-      line-height: 1.2;
-      padding: 14px 16px;
-      outline: none;
-      overflow: auto;
-      user-select: text;
-    }
-    .term-grid { display: block; white-space: pre; contain: layout paint style; user-select: text; }
-    .term-row {
-      display: block;
-      height: var(--term-row-height);
-      line-height: var(--term-row-height);
-      user-select: text;
-    }
-    .term-row > span {
-      display: inline-block;
-      height: var(--term-row-height);
-      vertical-align: top;
-      user-select: text;
+    .term-input-proxy {
+      position: absolute;
+      left: 0;
+      top: 0;
+      width: 1px;
+      height: 1px;
+      padding: 0;
+      border: 0;
+      opacity: 0;
+      pointer-events: none;
+      resize: none;
     }
-    .term-block { width: 1ch; overflow: hidden; }
-    .term-cursor { outline: 1px solid var(--term-cursor); outline-offset: -1px; }
-    .wterm.focused .term-cursor { background: var(--term-cursor); color: #ffffff; outline: none; }
     .success-pane {
       position: absolute;
       inset: 0;
@@ -765,6 +1006,8 @@ function renderInteractionPage(
     let startupSent = false;
     let startupIdleTimer;
     let startupMaxTimer;
+    let terminalOutputTail = "";
+    let pendingBrowserPromptUrl = null;
     const outputBacklog = [];
     const listeners = {
       onStatus: null,
@@ -792,9 +1035,88 @@ function renderInteractionPage(
       startupMaxTimer = startupMaxTimer || setTimeout(sendStartupInput, 1500);
     }
 
+    const URL_MATCH_PATTERN = "https?:\\\\/\\\\/[^\\\\s<>\\\"'\\\\\\\\]+";
+
+    function stripAnsi(text) {
+      return text.replace(/[\\u001b\\u009b][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[a-zA-Z\\d]*)*)?\\u0007)|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))/g, "");
+    }
+
+    function normalizeHttpUrlLiteral(value) {
+      let url = String(value || "").trim();
+      while (/[),.;:!?\\]}]+$/.test(url)) url = url.slice(0, -1);
+      try {
+        const parsed = new URL(url);
+        if (parsed.protocol === "http:" || parsed.protocol === "https:") return parsed.href;
+      } catch {
+        return null;
+      }
+      return null;
+    }
+
+    function normalizeHttpUrl(value) {
+      const normalized = normalizeHttpUrlLiteral(value);
+      return normalized ? expandKnownTerminalUrl(normalized) : null;
+    }
+
+    function expandKnownTerminalUrl(url) {
+      const cleaned = stripAnsi(terminalOutputTail).replace(/\\r(?!\\n)/g, "\\n");
+      let best = url;
+      for (const candidate of urlsInText(cleaned)) {
+        if (candidate.url.startsWith(url) && candidate.url.length > best.length) {
+          best = candidate.url;
+        }
+      }
+      return best;
+    }
+
+    function urlsInText(text) {
+      const urls = [];
+      const matcher = new RegExp(URL_MATCH_PATTERN, "ig");
+      let match;
+      while ((match = matcher.exec(text)) !== null) {
+        const raw = match[0];
+        const url = normalizeHttpUrlLiteral(raw);
+        if (url) urls.push({ url, start: match.index, end: match.index + raw.length });
+      }
+      return urls;
+    }
+
+    function urlAtTextIndex(text, index) {
+      for (const candidate of urlsInText(text)) {
+        if (index >= candidate.start - 1 && index <= candidate.end) return candidate.url;
+      }
+      return null;
+    }
+
+    function findPendingBrowserPromptUrl(text) {
+      const cleaned = stripAnsi(text).replace(/\\r(?!\\n)/g, "\\n");
+      const currentLine = cleaned.split(/\\n/).pop() || "";
+      const match = /Press\\s+Enter\\s+to\\s+open\\s+(https?:\\/\\/\\S+)\\s+in\\s+your\\s+browser/i.exec(currentLine);
+      return match ? normalizeHttpUrl(match[1]) : null;
+    }
+
+    function trackBrowserPrompt(data) {
+      terminalOutputTail = (terminalOutputTail + data).slice(-8000);
+      pendingBrowserPromptUrl = findPendingBrowserPromptUrl(terminalOutputTail);
+    }
+
+    function openExternalUrl(url) {
+      const normalized = normalizeHttpUrl(url);
+      if (!normalized) return false;
+      const opened = window.open(normalized, "_blank", "noopener,noreferrer");
+      return Boolean(opened);
+    }
+
+    function openPendingBrowserPrompt() {
+      if (!pendingBrowserPromptUrl) return false;
+      const url = pendingBrowserPromptUrl;
+      pendingBrowserPromptUrl = null;
+      return openExternalUrl(url);
+    }
+
     function isTextEditingTarget(target) {
       if (!(target instanceof Element)) return false;
-      if (terminalEl && terminalEl.contains(target)) return false;
+      if (terminalEl && terminalEl.contains(target)) return true;
       return Boolean(target.closest("textarea, input, select, button, [contenteditable=''], [contenteditable='true']"));
     }
 
@@ -869,9 +1191,20 @@ function renderInteractionPage(
       event.preventDefault();
       event.stopImmediatePropagation();
       term?.focus();
+      if (data === "\\r") openPendingBrowserPrompt();
       sendTerminalInput(data);
     }, { capture: true });
 
+    document.addEventListener("paste", (event) => {
+      if (event.defaultPrevented || isTextEditingTarget(event.target)) return;
+      const text = event.clipboardData && event.clipboardData.getData("text/plain");
+      if (!text) return;
+      event.preventDefault();
+      event.stopImmediatePropagation();
+      term?.focus();
+      sendTerminalInput(text);
+    }, { capture: true });
+
     function setupSocket() {
       const terminalUrl = new URL("/terminal", location.href);
       terminalUrl.protocol = location.protocol === "https:" ? "wss:" : "ws:";
@@ -884,6 +1217,7 @@ function renderInteractionPage(
       socket.addEventListener("message", (event) => {
         const message = JSON.parse(event.data);
         if (message.type === "output") {
+          trackBrowserPrompt(message.data);
           outputBacklog.push(message.data);
           if (termReady) {
             term.write(message.data);
@@ -987,14 +1321,18 @@ function renderInteractionPage(
     }
 
     function TerminalChrome() {
+      const shellRef = useRef(null);
       const hostRef = useRef(null);
       const fallbackRef = useRef(null);
+      const inputProxyRef = useRef(null);
 
       useEffect(() => {
-        terminalEl = hostRef.current;
-        if (fallbackRef.current) {
+        const host = hostRef.current;
+        const fallback = fallbackRef.current;
+        terminalEl = host;
+        if (fallback) {
           for (const chunk of outputBacklog) {
-            fallbackRef.current.textContent += chunk;
+            fallback.textContent += chunk;
           }
         }
         listeners.onOutput = (data) => {
@@ -1003,46 +1341,182 @@ function renderInteractionPage(
           fallbackRef.current.scrollTop = fallbackRef.current.scrollHeight;
         };
 
+        const handleTerminalClick = (event) => {
+          if (event.defaultPrevented || event.button !== 0) return;
+          const selection = window.getSelection();
+          if (selection && selection.toString()) return;
+          const url = terminalUrlFromEvent(event);
+          if (!url) {
+            focusTerminalInput();
+            return;
+          }
+          event.preventDefault();
+          event.stopPropagation();
+          openExternalUrl(url);
+        };
+        const handleTerminalPointerMove = (event) => {
+          const target = event.currentTarget;
+          if (!(target instanceof HTMLElement)) return;
+          target.classList.toggle("link-hover", Boolean(terminalUrlFromEvent(event)));
+        };
+        const handleTerminalPointerLeave = (event) => {
+          const target = event.currentTarget;
+          if (target instanceof HTMLElement) target.classList.remove("link-hover");
+        };
+
+        host?.addEventListener("click", handleTerminalClick);
+        host?.addEventListener("pointermove", handleTerminalPointerMove);
+        host?.addEventListener("pointerleave", handleTerminalPointerLeave);
+        fallback?.addEventListener("click", handleTerminalClick);
+        fallback?.addEventListener("pointermove", handleTerminalPointerMove);
+        fallback?.addEventListener("pointerleave", handleTerminalPointerLeave);
+
         let cancelled = false;
+        let resizeObserver = null;
+        let currentTerm = null;
         (async () => {
           try {
-            const [{ WTerm }, { GhosttyCore }] = await Promise.all([
-              import("https://esm.sh/@wterm/dom@0.3.0?bundle"),
-              import("https://esm.sh/@wterm/ghostty@0.3.0?bundle"),
+            const [{ Terminal }, { FitAddon }, { WebLinksAddon }] = await Promise.all([
+              import("https://esm.sh/@xterm/xterm@6.0.0?bundle"),
+              import("https://esm.sh/@xterm/addon-fit@0.11.0?bundle"),
+              import("https://esm.sh/@xterm/addon-web-links@0.12.0?bundle"),
             ]);
             if (cancelled || !hostRef.current) return;
-            const core = await GhosttyCore.load({
-              wasmPath: "https://esm.sh/@wterm/ghostty@0.3.0/wasm/ghostty-vt.wasm",
-            });
-            if (cancelled || !hostRef.current) return;
-            term = new WTerm(hostRef.current, {
-              core,
+            const xterm = new Terminal({
               cols: 100,
               rows: 28,
-              autoResize: true,
               cursorBlink: true,
-              onData(data) { sendTerminalInput(data); },
-              onResize(cols, rows) {
-                if (socket && socket.readyState === WebSocket.OPEN) {
-                  socket.send(JSON.stringify({ type: "resize", cols, rows }));
-                }
+              convertEol: true,
+              scrollback: 10000,
+              fontFamily: 'ui-monospace, "SF Mono", SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", monospace',
+              fontSize: 13,
+              lineHeight: 1.3,
+              theme: {
+                background: "#faf8f2",
+                foreground: "#1a1a1a",
+                cursor: "#2d4df5",
+                selectionBackground: "#d8d2c5",
+                black: "#0a0a0a",
+                red: "#c93250",
+                green: "#1f8b4c",
+                yellow: "#a17500",
+                blue: "#2d4df5",
+                magenta: "#8e3eff",
+                cyan: "#0a7783",
+                white: "#5a5a5a",
+                brightBlack: "#6a6a6a",
+                brightRed: "#b81e3a",
+                brightGreen: "#176a3a",
+                brightYellow: "#7a5800",
+                brightBlue: "#1a3ad9",
+                brightMagenta: "#7128df",
+                brightCyan: "#06606a",
+                brightWhite: "#0a0a0a",
               },
             });
-            await term.init();
+            const fitAddon = new FitAddon();
+            xterm.loadAddon(fitAddon);
+            xterm.loadAddon(new WebLinksAddon((event, url) => {
+              event.preventDefault();
+              openExternalUrl(url);
+            }));
+            xterm.onData((data) => {
+              if (data === "\\r") openPendingBrowserPrompt();
+              sendTerminalInput(data);
+            });
+            xterm.onResize(({ cols, rows }) => {
+              if (socket && socket.readyState === WebSocket.OPEN) {
+                socket.send(JSON.stringify({ type: "resize", cols, rows }));
+              }
+            });
+            xterm.open(hostRef.current);
+            const fitTerminal = () => {
+              try {
+                fitAddon.fit();
+                if (socket && socket.readyState === WebSocket.OPEN) {
+                  socket.send(JSON.stringify({ type: "resize", cols: xterm.cols, rows: xterm.rows }));
+                }
+              } catch {
+                // The fit addon can throw while the element is detached during teardown.
+              }
+            };
+            fitTerminal();
+            resizeObserver = new ResizeObserver(fitTerminal);
+            resizeObserver.observe(hostRef.current);
+            currentTerm = xterm;
+            term = xterm;
             for (const chunk of outputBacklog) term.write(chunk);
             termReady = true;
             hostRef.current.classList.add("ready");
             fallbackRef.current && fallbackRef.current.classList.add("hidden");
             term.focus();
+            focusTerminalInput();
           } catch (error) {
             console.error(error);
             if (fallbackRef.current) {
-              fallbackRef.current.textContent += "\\nUnable to load the libghostty renderer. Output will continue here.\\n";
+              fallbackRef.current.textContent += "\\nUnable to load the xterm renderer. Output will continue here.\\n";
             }
           }
         })();
 
-        return () => { cancelled = true; };
+        return () => {
+          cancelled = true;
+          resizeObserver?.disconnect();
+          currentTerm?.dispose();
+          if (term === currentTerm) term = null;
+          terminalEl = null;
+          host?.removeEventListener("click", handleTerminalClick);
+          host?.removeEventListener("pointermove", handleTerminalPointerMove);
+          host?.removeEventListener("pointerleave", handleTerminalPointerLeave);
+          fallback?.removeEventListener("click", handleTerminalClick);
+          fallback?.removeEventListener("pointermove", handleTerminalPointerMove);
+          fallback?.removeEventListener("pointerleave", handleTerminalPointerLeave);
+        };
+      }, []);
+
+      const focusTerminalInput = useCallback(() => {
+        shellRef.current?.focus({ preventScroll: true });
+        if (term?.focus) {
+          term.focus();
+        } else {
+          inputProxyRef.current?.focus({ preventScroll: true });
+        }
+      }, []);
+
+      const sendKeyboardEventToTerminal = useCallback((event) => {
+        const data = keyEventToTerminalInput(event);
+        if (!data) return;
+        event.preventDefault();
+        event.stopPropagation();
+        if (inputProxyRef.current) inputProxyRef.current.value = "";
+        if (data === "\\r") openPendingBrowserPrompt();
+        sendTerminalInput(data);
+      }, []);
+
+      const sendTextInputEventToTerminal = useCallback((event) => {
+        const data = event.data || "";
+        if (!data) return;
+        event.preventDefault();
+        event.stopPropagation();
+        if (inputProxyRef.current) inputProxyRef.current.value = "";
+        sendTerminalInput(data);
+      }, []);
+
+      const sendPasteEventToTerminal = useCallback((event) => {
+        const text = event.clipboardData && event.clipboardData.getData("text/plain");
+        if (!text) return;
+        event.preventDefault();
+        event.stopPropagation();
+        if (inputProxyRef.current) inputProxyRef.current.value = "";
+        sendTerminalInput(text);
+      }, []);
+
+      const sendInputValueToTerminal = useCallback((event) => {
+        const target = event.currentTarget;
+        const value = target.value || "";
+        if (!value) return;
+        target.value = "";
+        sendTerminalInput(value);
       }, []);
 
       return h(F, null,
@@ -1050,9 +1524,29 @@ function renderInteractionPage(
           h("span", { className: "term-titlebar-icon", "aria-hidden": "true" }, h(TerminalIcon, null)),
           h("span", { className: "term-titlebar-label" }, NODE_PATH + " · terminal"),
         ),
-        h("div", { className: "terminal-shell" },
+        h("div", {
+          ref: shellRef,
+          className: "terminal-shell",
+          tabIndex: 0,
+          onPointerDownCapture: focusTerminalInput,
+          onKeyDown: sendKeyboardEventToTerminal,
+          onPaste: sendPasteEventToTerminal,
+        },
           h("pre", { ref: fallbackRef, className: "term-fallback" }, "Starting terminal...\\n"),
           h("div", { ref: hostRef, className: "term-host" }),
+          h("textarea", {
+            ref: inputProxyRef,
+            className: "term-input-proxy",
+            tabIndex: 0,
+            autoCapitalize: "off",
+            autoComplete: "off",
+            autoCorrect: "off",
+            spellCheck: false,
+            onKeyDown: sendKeyboardEventToTerminal,
+            onBeforeInput: sendTextInputEventToTerminal,
+            onInput: sendInputValueToTerminal,
+            onPaste: sendPasteEventToTerminal,
+          }),
         ),
       );
     }
@@ -1069,6 +1563,36 @@ function renderInteractionPage(
       );
     }
 
+    function terminalUrlFromEvent(event) {
+      const target = event.target;
+      if (!(target instanceof Element)) return null;
+
+      const fallback = target.closest(".term-fallback");
+      if (fallback) {
+        return terminalUrlFromPreEvent(fallback, event);
+      }
+
+      return null;
+    }
+
+    function terminalUrlFromPreEvent(pre, event) {
+      const text = pre.textContent || "";
+      const rect = pre.getBoundingClientRect();
+      const style = window.getComputedStyle(pre);
+      const lineHeight = parseFloat(style.lineHeight) || 18;
+      const fontSize = parseFloat(style.fontSize) || 13;
+      const charWidth = fontSize * 0.62;
+      const paddingTop = parseFloat(style.paddingTop) || 0;
+      const paddingLeft = parseFloat(style.paddingLeft) || 0;
+      const lineIndex = Math.floor((event.clientY - rect.top + pre.scrollTop - paddingTop) / lineHeight);
+      const colIndex = Math.floor((event.clientX - rect.left + pre.scrollLeft - paddingLeft) / charWidth);
+      const line = text.split("\\n")[lineIndex] || "";
+      const exactUrl = urlAtTextIndex(line, Math.max(0, colIndex));
+      if (exactUrl) return exactUrl;
+      const urls = urlsInText(line);
+      return urls.length === 1 ? urls[0].url : null;
+    }
+
     function App() {
       const [canFinish, setCanFinish] = useState(false);
       const [done, setDone] = useState(INITIAL_COMPLETED);

package/src/version.ts

@@ -1 +1 @@
-export const RIGKIT_PROVIDER_FREESTYLE_VERSION = "0.2.4";
+export const RIGKIT_PROVIDER_FREESTYLE_VERSION = "0.2.6";