@rigkit/provider-freestyle 0.2.3 → 0.2.5

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,17 +19,30 @@ 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("light red");
-      expect(html).toContain("Finished");
+      expect(html).toContain("freestyle.sh");
+      expect(html).toContain("Complete task");
       expect(html).toContain("document.addEventListener(\"keydown\"");
       expect(html).toContain("{ capture: true }");
       expect(html).toContain("terminalEl.contains(target)");
       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");
 
@@ -102,6 +115,46 @@ describe("Freestyle terminal session", () => {
     }
   });
 
+  test("can allow finishing while the terminal process is still running", async () => {
+    const session = createFreestyleTerminalSession({
+      nodePath: "login",
+      title: "Keep-open command",
+      command: "sleep 5",
+      displayCommand: "sleep 5",
+      canFinishWhileRunning: true,
+    });
+
+    let resolved = false;
+    session.completed.then(() => {
+      resolved = true;
+    });
+
+    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, "status") && Boolean(message.canFinish)
+        ),
+      );
+      await new Promise((resolve) => setTimeout(resolve, 25));
+      expect(resolved).toBe(false);
+
+      socket.send(JSON.stringify({ type: "finish" }));
+      await expect(session.completed).resolves.toEqual({ finished: true });
+      socket.close();
+    } finally {
+      session.stop();
+    }
+  });
+
   test("answers cursor position reports for terminal UI prompts", async () => {
     const session = createFreestyleTerminalSession({
       nodePath: "prompt",
@@ -133,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);
@@ -173,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));
   }
 }