@vercel/next-browser 0.1.0 → 0.1.1

package/src/client.ts

@@ -1,80 +0,0 @@
-import { connect as netConnect, type Socket } from "node:net";
-import { readFileSync, existsSync, rmSync } from "node:fs";
-import { spawn } from "node:child_process";
-import { setTimeout as sleep } from "node:timers/promises";
-import { fileURLToPath } from "node:url";
-import { socketPath, pidFile } from "./paths.ts";
-
-export type Response = { ok: true; data?: unknown } | { ok: false; error: string };
-
-export async function send(
-  action: string,
-  payload: Record<string, unknown> = {},
-): Promise<Response> {
-  await ensureDaemon();
-  const socket = await connect();
-  const id = String(Date.now());
-  socket.write(JSON.stringify({ id, action, ...payload }) + "\n");
-  const line = await readLine(socket);
-  socket.end();
-  return JSON.parse(line);
-}
-
-async function ensureDaemon() {
-  if (daemonAlive() && (await connect().then(ok, no))) return;
-
-  const daemon = fileURLToPath(new URL("./daemon.ts", import.meta.url));
-  const child = spawn(process.execPath, [daemon], {
-    detached: true,
-    stdio: "ignore",
-  });
-  child.unref();
-
-  for (let i = 0; i < 50; i++) {
-    if (await connect().then(ok, no)) return;
-    await sleep(100);
-  }
-  throw new Error(`daemon failed to start (${socketPath})`);
-}
-
-function daemonAlive() {
-  if (!existsSync(pidFile)) return false;
-  const pid = Number(readFileSync(pidFile, "utf-8"));
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    rmSync(pidFile, { force: true });
-    rmSync(socketPath, { force: true });
-    return false;
-  }
-}
-
-function connect(): Promise<Socket> {
-  return new Promise((resolve, reject) => {
-    const socket = netConnect(socketPath);
-    socket.once("connect", () => resolve(socket));
-    socket.once("error", reject);
-  });
-}
-
-function readLine(socket: Socket): Promise<string> {
-  return new Promise((resolve, reject) => {
-    let buffer = "";
-    socket.on("data", (chunk) => {
-      buffer += chunk;
-      const newline = buffer.indexOf("\n");
-      if (newline >= 0) resolve(buffer.slice(0, newline));
-    });
-    socket.on("error", reject);
-  });
-}
-
-function ok(s: Socket) {
-  s.destroy();
-  return true;
-}
-
-function no() {
-  return false;
-}

package/src/daemon.ts

@@ -1,140 +0,0 @@
-import { createServer } from "node:net";
-import { mkdirSync, writeFileSync, rmSync } from "node:fs";
-import type { Socket } from "node:net";
-import * as browser from "./browser.ts";
-import { socketDir, socketPath, pidFile } from "./paths.ts";
-
-mkdirSync(socketDir, { recursive: true, mode: 0o700 });
-rmSync(socketPath, { force: true });
-rmSync(pidFile, { force: true });
-
-writeFileSync(pidFile, String(process.pid));
-
-const server = createServer((socket) => {
-  let buffer = "";
-  socket.on("data", (chunk) => {
-    buffer += chunk;
-    let newline: number;
-    while ((newline = buffer.indexOf("\n")) >= 0) {
-      const line = buffer.slice(0, newline);
-      buffer = buffer.slice(newline + 1);
-      if (line) dispatch(line, socket);
-    }
-  });
-  socket.on("error", () => {});
-});
-
-server.listen(socketPath);
-
-process.on("SIGINT", shutdown);
-process.on("SIGTERM", shutdown);
-process.on("exit", cleanup);
-
-async function dispatch(line: string, socket: Socket) {
-  const cmd = JSON.parse(line);
-  const result = await run(cmd).catch((err) => ({ ok: false, error: cleanError(err) }));
-  socket.write(JSON.stringify({ id: cmd.id, ...result }) + "\n");
-  if (cmd.action === "close") setImmediate(shutdown);
-}
-
-function cleanError(err: Error) {
-  const msg = err.message;
-  const m = msg.match(/^page\.\w+: (?:Error: )?(.+?)(?:\n|$)/);
-  return m ? m[1] : msg;
-}
-
-type Cmd = {
-  action: string;
-  url?: string;
-  nodeId?: number;
-  tool?: string;
-  args?: Record<string, unknown>;
-  script?: string;
-  idx?: number;
-  cookies?: { name: string; value: string }[];
-  domain?: string;
-};
-
-async function run(cmd: Cmd) {
-  if (cmd.action === "open") {
-    await browser.open(cmd.url);
-    return { ok: true };
-  }
-  if (cmd.action === "cookies") {
-    const data = await browser.cookies(cmd.cookies!, cmd.domain!);
-    return { ok: true, data };
-  }
-  if (cmd.action === "lock") {
-    await browser.lock();
-    return { ok: true };
-  }
-  if (cmd.action === "unlock") {
-    const data = await browser.unlock();
-    return { ok: true, data };
-  }
-  if (cmd.action === "reload") {
-    const data = await browser.reload();
-    return { ok: true, data };
-  }
-  if (cmd.action === "restart") {
-    const data = await browser.restart();
-    return { ok: true, data };
-  }
-  if (cmd.action === "screenshot") {
-    const data = await browser.screenshot();
-    return { ok: true, data };
-  }
-  if (cmd.action === "links") {
-    const data = await browser.links();
-    return { ok: true, data };
-  }
-  if (cmd.action === "push") {
-    const data = await browser.push(cmd.url!);
-    return { ok: true, data };
-  }
-  if (cmd.action === "goto") {
-    const data = await browser.goto(cmd.url!);
-    return { ok: true, data };
-  }
-  if (cmd.action === "back") {
-    await browser.back();
-    return { ok: true };
-  }
-  if (cmd.action === "tree") {
-    const data = await browser.tree();
-    return { ok: true, data };
-  }
-  if (cmd.action === "node") {
-    const data = await browser.node(cmd.nodeId!);
-    return { ok: true, data };
-  }
-  if (cmd.action === "eval") {
-    const data = await browser.evaluate(cmd.script!);
-    return { ok: true, data };
-  }
-  if (cmd.action === "mcp") {
-    const data = await browser.mcp(cmd.tool!, cmd.args);
-    return { ok: true, data };
-  }
-  if (cmd.action === "network") {
-    const data = await browser.network(cmd.idx);
-    return { ok: true, data };
-  }
-  if (cmd.action === "close") {
-    await browser.close();
-    return { ok: true };
-  }
-  return { ok: false, error: `unknown action: ${cmd.action}` };
-}
-
-async function shutdown() {
-  await browser.close();
-  server.close();
-  cleanup();
-  process.exit(0);
-}
-
-function cleanup() {
-  rmSync(socketPath, { force: true });
-  rmSync(pidFile, { force: true });
-}

package/src/mcp.ts

@@ -1,37 +0,0 @@
-/**
- * Next.js dev-server MCP client. POSTs JSON-RPC to /_next/mcp
- * (StreamableHTTP transport, SSE response).
- */
-
-export async function call(
-  origin: string,
-  tool: string,
-  args: Record<string, unknown> = {},
-): Promise<unknown> {
-  const res = await fetch(`${origin}/_next/mcp`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Accept: "application/json, text/event-stream",
-    },
-    body: JSON.stringify({
-      jsonrpc: "2.0",
-      id: 1,
-      method: "tools/call",
-      params: { name: tool, arguments: args },
-    }),
-    signal: AbortSignal.timeout(10_000),
-  });
-
-  if (!res.ok) throw new Error(`MCP ${res.status} ${res.statusText}`);
-
-  const body = await res.text();
-  const data = body.match(/^data: (.+)$/m)?.[1];
-  if (!data) throw new Error("no data frame in MCP response");
-
-  const parsed = JSON.parse(data);
-  if (parsed.error) throw new Error(parsed.error.message);
-
-  const text = parsed.result?.content?.[0]?.text;
-  return text ? JSON.parse(text) : parsed.result;
-}

package/src/network.ts

@@ -1,124 +0,0 @@
-import { writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import type { Page, Request, Response } from "playwright";
-
-const BODY_INLINE_LIMIT = 4000;
-
-type Entry = {
-  req: Request;
-  res: Response | null;
-  ms: number | null;
-};
-
-let entries: Entry[] = [];
-let startTime = new Map<Request, number>();
-
-export function attach(page: Page) {
-  page.on("request", (req) => {
-    if (req.resourceType() === "document" && req.frame() === page.mainFrame()) {
-      clear();
-    }
-    startTime.set(req, Date.now());
-  });
-
-  page.on("response", (res) => {
-    const req = res.request();
-    const t0 = startTime.get(req);
-    if (t0 == null) return;
-    entries.push({ req, res, ms: Date.now() - t0 });
-  });
-
-  page.on("requestfailed", (req) => {
-    if (!startTime.has(req)) return;
-    entries.push({ req, res: null, ms: null });
-  });
-}
-
-export function clear() {
-  entries = [];
-  startTime = new Map();
-}
-
-export async function detail(idx: number): Promise<string> {
-  const e = entries[idx];
-  if (!e) throw new Error(`no request at index ${idx}`);
-
-  const { req, res, ms } = e;
-  const lines: string[] = [
-    `${req.method()} ${req.url()}`,
-    `type: ${req.resourceType()}${ms != null ? `  ${ms}ms` : ""}`,
-    "",
-    "request headers:",
-    ...indent(await req.allHeaders()),
-  ];
-
-  const postData = req.postData();
-  if (postData) {
-    lines.push("", "request body:", truncate(postData, 2000));
-  }
-
-  if (!res) {
-    lines.push("", `FAILED: ${req.failure()?.errorText ?? "unknown"}`);
-    return lines.join("\n");
-  }
-
-  lines.push(
-    "",
-    `response: ${res.status()} ${res.statusText()}`,
-    "response headers:",
-    ...indent(await res.allHeaders()),
-  );
-
-  const body = await res.text().catch((err) => `(body unavailable: ${err.message})`);
-  lines.push("", "response body:", spillIfLong(body, idx, res));
-
-  return lines.join("\n");
-}
-
-function indent(headers: Record<string, string>): string[] {
-  return Object.entries(headers).map(([k, v]) => `  ${k}: ${v}`);
-}
-
-function truncate(s: string, max: number): string {
-  return s.length > max ? s.slice(0, max) + `\n… (${s.length - max} more bytes)` : s;
-}
-
-function spillIfLong(body: string, idx: number, res: Response): string {
-  if (body.length <= BODY_INLINE_LIMIT) return body;
-  const ext = extFor(res.headers()["content-type"]);
-  const path = join(tmpdir(), `next-browser-${process.pid}-${idx}${ext}`);
-  writeFileSync(path, body);
-  return `(${body.length} bytes written to ${path})`;
-}
-
-function extFor(contentType: string | undefined): string {
-  if (!contentType) return ".txt";
-  if (contentType.includes("json")) return ".json";
-  if (contentType.includes("html")) return ".html";
-  if (contentType.includes("javascript")) return ".js";
-  if (contentType.includes("x-component")) return ".rsc";
-  return ".txt";
-}
-
-export function format(): string {
-  if (entries.length === 0) return "(no requests)";
-
-  const lines = [
-    "# Network requests since last navigation",
-    "# Columns: idx status method type ms url [next-action=...]",
-    "# Use `network <idx>` for headers and body.",
-    "",
-  ];
-
-  entries.forEach((e, i) => {
-    const { req, res, ms } = e;
-    const status = res?.status() ?? "FAIL";
-    const time = ms != null ? `${ms}ms` : "-";
-    const action = req.headers()["next-action"];
-    const suffix = action ? ` next-action=${action}` : "";
-    lines.push(`${i} ${status} ${req.method()} ${req.resourceType()} ${time} ${req.url()}${suffix}`);
-  });
-
-  return lines.join("\n");
-}

package/src/sourcemap.ts

@@ -1,84 +0,0 @@
-/**
- * Resolve a bundle location to its original source file via Next.js's
- * dev-server endpoint. Returns null if it didn't resolve (Next internals,
- * prod build, non-Next app).
- */
-export async function resolve(
-  origin: string,
-  file: string,
-  line: number,
-  column: number,
-): Promise<{ file: string; line: number; column: number } | null> {
-  const { path, isServer } = normalize(file, origin);
-
-  const res = await fetch(`${origin}/__nextjs_original-stack-frames`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({
-      frames: [{ file: path, methodName: "", arguments: [], line1: line, column1: column }],
-      isServer,
-      isEdgeServer: false,
-      isAppDirectory: true,
-    }),
-    signal: AbortSignal.timeout(5000),
-  }).catch(() => null);
-
-  if (!res?.ok) return null;
-
-  const [result] = await res.json();
-  const frame = result?.status === "fulfilled" ? result.value.originalStackFrame : null;
-  if (!frame || frame.file === path) return null;
-
-  return { file: frame.file, line: frame.line1, column: frame.column1 };
-}
-
-function normalize(file: string, origin: string): { path: string; isServer: boolean } {
-  const stripped = file.replace(/^about:\/\/React\/[^/]+\//, "");
-  const isServer = file !== stripped;
-
-  if (stripped.startsWith("file://")) return { path: stripped, isServer };
-  if (stripped.startsWith(origin)) return { path: stripped.slice(origin.length), isServer };
-  if (stripped.startsWith("http")) return { path: new URL(stripped).pathname, isServer };
-  return { path: stripped, isServer };
-}
-
-import { SourceMapConsumer } from "source-map-js";
-
-const consumers = new Map<string, SourceMapConsumer | null>();
-
-/**
- * Fallback for locations the Next API won't resolve (node_modules).
- * Fetches the .map directly and decodes the mappings.
- */
-export async function resolveViaMap(
-  origin: string,
-  file: string,
-  line: number,
-  column: number,
-): Promise<{ file: string; line: number; column: number } | null> {
-  const consumer = await load(origin, normalize(file, origin).path);
-  if (!consumer) return null;
-
-  const pos = consumer.originalPositionFor({ line, column });
-  if (!pos.source) return null;
-
-  return { file: cleanPath(pos.source), line: pos.line, column: pos.column };
-}
-
-async function load(origin: string, path: string) {
-  if (consumers.has(path)) return consumers.get(path)!;
-
-  const res = await fetch(`${origin}${path}.map`, {
-    signal: AbortSignal.timeout(5000),
-  }).catch(() => null);
-
-  const consumer = res?.ok ? new SourceMapConsumer(await res.json()) : null;
-  consumers.set(path, consumer);
-  return consumer;
-}
-
-function cleanPath(src: string): string {
-  const path = decodeURIComponent(src.replace(/^file:\/\//, ""));
-  const nm = path.lastIndexOf("/node_modules/");
-  return nm >= 0 ? path.slice(nm + 1) : path;
-}