@pxlarified/browser 0.1.0

package/src/cli.js

@@ -0,0 +1,155 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { resolveBrowser, supportedBrowsers } from "./browsers/registry.js";
+import { BridgeUnavailableError, sendBridgeCommandWithRetry } from "./bridge/client.js";
+import { screenshotsDir } from "./util/paths.js";
+
+export async function runCli(argv) {
+  if (argv.length === 0 || argv.includes("--help") || argv.includes("-h")) {
+    printHelp();
+    return;
+  }
+
+  const parsed = parseGlobalOptions(argv);
+  const [command, ...positionals] = parsed.positionals;
+  const adapter = resolveBrowser(parsed.browser);
+
+  if (command === "install") {
+    const browserName = positionals[0] || parsed.browser;
+    if (!browserName) throw new Error(`Usage: OpenBrowser install <browser>`);
+    const installAdapter = resolveBrowser(browserName);
+    const result = await installAdapter.install();
+    console.error(result.note);
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+
+  const request = toBridgeRequest(command, positionals, parsed.flags);
+  if (!request) throw new Error(`Unknown command: ${command}`);
+
+  const result = await sendCommandEnsuringBridge(adapter, request.command, request.args, request.timeoutMs);
+  await printResult(request, result);
+}
+
+async function sendCommandEnsuringBridge(adapter, command, args, timeoutMs) {
+  try {
+    return await sendBridgeCommandWithRetry(adapter.name, command, args, { timeoutMs });
+  } catch (error) {
+    if (!(error instanceof BridgeUnavailableError)) throw error;
+    await adapter.launch();
+    return sendBridgeCommandWithRetry(adapter.name, command, args, {
+      timeoutMs,
+      attempts: 12,
+      delayMs: 500,
+    });
+  }
+}
+
+function parseGlobalOptions(argv) {
+  const flags = new Map();
+  const positionals = [];
+  let browser;
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (token === "--browser") {
+      browser = requireValue(argv, ++i, "--browser");
+      continue;
+    }
+    if (token.startsWith("--browser=")) {
+      browser = token.slice("--browser=".length);
+      continue;
+    }
+    if (token.startsWith("--")) {
+      const [name, inlineValue] = token.slice(2).split("=", 2);
+      if (inlineValue !== undefined) flags.set(name, inlineValue);
+      else if (isValueFlag(name)) flags.set(name, requireValue(argv, ++i, `--${name}`));
+      else flags.set(name, true);
+      continue;
+    }
+    positionals.push(token);
+  }
+
+  return { browser, flags, positionals };
+}
+
+function isValueFlag(name) {
+  return new Set(["ref", "to"]).has(name);
+}
+
+function requireValue(argv, index, flag) {
+  const value = argv[index];
+  if (!value || value.startsWith("--")) throw new Error(`Missing value for ${flag}.`);
+  return value;
+}
+
+function toBridgeRequest(command, args, flags) {
+  switch (command) {
+    case "open":
+      return requireArgs(command, args, 1, { command, args: { url: args[0] } });
+    case "close":
+    case "status":
+    case "reload":
+    case "back":
+    case "forward":
+    case "state":
+      return { command, args: {} };
+    case "navigate":
+      return requireArgs(command, args, 1, { command, args: { url: args[0] } });
+    case "screenshot":
+      return { command, args: { base64: Boolean(flags.get("base64")) }, timeoutMs: 45_000 };
+    case "click":
+      return requireArgs(command, args, 1, { command, args: { ref: args[0] } });
+    case "keys":
+      return requireArgs(command, args, 1, { command, args: { text: args.join(" ") } });
+    case "press":
+      return requireArgs(command, args, 1, { command, args: { key: args[0] } });
+    case "select":
+      return requireArgs(command, args, 2, { command, args: { ref: args[0], option: args[1] } });
+    case "get":
+      if (!flags.get("html")) throw new Error("Only get --html is currently supported.");
+      return { command: "getHtml", args: { ref: flags.get("ref") || null } };
+    case "scroll":
+      if (flags.get("to")) return { command, args: { to: flags.get("to") } };
+      if (!["up", "down"].includes(args[0])) {
+        throw new Error("Usage: OpenBrowser scroll up|down [pixels] or OpenBrowser scroll --to <ref>");
+      }
+      return { command, args: { direction: args[0], pixels: Number(args[1] || 600) } };
+    default:
+      return null;
+  }
+}
+
+function requireArgs(name, args, count, request) {
+  if (args.length < count) throw new Error(`Missing argument for ${name}.`);
+  return request;
+}
+
+async function printResult(request, result) {
+  if (request.command === "screenshot") {
+    const base64 = normalizeBase64(result.dataUrl || result.base64 || "");
+    if (request.args.base64) {
+      process.stdout.write(`${base64}\n`);
+      return;
+    }
+
+    const dir = screenshotsDir();
+    fs.mkdirSync(dir, { recursive: true });
+    const file = path.join(dir, `${crypto.randomBytes(4).toString("hex")}.png`);
+    fs.writeFileSync(file, Buffer.from(base64, "base64"));
+    process.stdout.write(`${file}\n`);
+    return;
+  }
+
+  console.log(JSON.stringify(result, null, 2));
+}
+
+function normalizeBase64(value) {
+  const comma = value.indexOf(",");
+  return comma === -1 ? value : value.slice(comma + 1);
+}
+
+function printHelp() {
+  console.log(`OpenBrowser\n\nUsage:\n  OpenBrowser install <browser>\n  OpenBrowser open <url> [--browser zen]\n  OpenBrowser close [--browser zen]\n  OpenBrowser status [--browser zen]\n  OpenBrowser navigate <url> [--browser zen]\n  OpenBrowser reload|back|forward [--browser zen]\n  OpenBrowser state [--browser zen]\n  OpenBrowser screenshot [--base64] [--browser zen]\n  OpenBrowser click <ref> [--browser zen]\n  OpenBrowser keys <text> [--browser zen]\n  OpenBrowser press <key> [--browser zen]\n  OpenBrowser select <ref> <option> [--browser zen]\n  OpenBrowser get --html [--ref <ref>] [--browser zen]\n  OpenBrowser scroll up|down [pixels] [--browser zen]\n  OpenBrowser scroll --to <ref> [--browser zen]\n\nSupported browsers: ${supportedBrowsers().join(", ")}`);
+}

package/src/constants.js

@@ -0,0 +1,7 @@
+export const APP_NAME = "OpenBrowser";
+export const PACKAGE_NAME = "@pxlarified/browser";
+export const NATIVE_HOST_NAME = "openbrowser";
+export const EXTENSION_ID = "openbrowser@mizius.com";
+export const DEFAULT_BROWSER = "zen";
+export const FIREFOX_DEV_ARTIFACT = "dist/extensions/firefox/openbrowser-dev.xpi";
+export const FIREFOX_SIGNED_ARTIFACT = "dist/extensions/firefox/openbrowser.xpi";

package/src/native-host.cjs

@@ -0,0 +1,162 @@
+#!/usr/bin/env node
+/* eslint-disable no-console */
+const fs = require("node:fs");
+const net = require("node:net");
+const os = require("node:os");
+const path = require("node:path");
+
+const browser = process.env.OPENBROWSER_BROWSER || "zen";
+const appHome = process.env.OPENBROWSER_HOME || path.join(os.homedir(), "OpenBrowser");
+const socketPath = process.platform === "win32"
+  ? `\\\\.\\pipe\\openbrowser-${browser}`
+  : path.join(appHome, "bridge", `${browser}.sock`);
+
+const pending = new Map();
+let nextId = 1;
+let server;
+
+function log(message) {
+  console.error(`[OpenBrowser native host] ${message}`);
+}
+
+function nativeWrite(message) {
+  const json = Buffer.from(JSON.stringify(message), "utf8");
+  const header = Buffer.alloc(4);
+  header.writeUInt32LE(json.length, 0);
+  process.stdout.write(Buffer.concat([header, json]));
+}
+
+function respond(socket, response) {
+  socket.end(`${JSON.stringify(response)}\n`);
+}
+
+function forwardToExtension(payload) {
+  return new Promise((resolve, reject) => {
+    const id = `n_${Date.now()}_${nextId++}`;
+    const timer = setTimeout(() => {
+      pending.delete(id);
+      reject(new Error("Timed out waiting for the OpenBrowser extension."));
+    }, 30_000);
+
+    pending.set(id, { resolve, reject, timer });
+    nativeWrite({ id, ...payload });
+  });
+}
+
+function handleNativeMessage(message) {
+  if (!message || typeof message !== "object") return;
+  if (!message.replyTo) return;
+
+  const request = pending.get(message.replyTo);
+  if (!request) return;
+  pending.delete(message.replyTo);
+  clearTimeout(request.timer);
+
+  if (message.ok) request.resolve(message.result);
+  else {
+    const error = new Error(message.error?.message || "OpenBrowser extension command failed.");
+    error.code = message.error?.code;
+    request.reject(error);
+  }
+}
+
+let stdinBuffer = Buffer.alloc(0);
+process.stdin.on("data", (chunk) => {
+  stdinBuffer = Buffer.concat([stdinBuffer, chunk]);
+
+  while (stdinBuffer.length >= 4) {
+    const length = stdinBuffer.readUInt32LE(0);
+    if (stdinBuffer.length < 4 + length) break;
+
+    const body = stdinBuffer.slice(4, 4 + length);
+    stdinBuffer = stdinBuffer.slice(4 + length);
+
+    try {
+      handleNativeMessage(JSON.parse(body.toString("utf8")));
+    } catch (error) {
+      log(`failed to parse extension message: ${error.message}`);
+    }
+  }
+});
+
+process.stdin.on("end", () => {
+  shutdown(0);
+});
+
+function ensureSocketDirectory() {
+  if (process.platform === "win32") return;
+  const dir = path.dirname(socketPath);
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  try {
+    fs.chmodSync(appHome, 0o700);
+  } catch {}
+  try {
+    fs.unlinkSync(socketPath);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+}
+
+function startServer() {
+  ensureSocketDirectory();
+
+  server = net.createServer((socket) => {
+    let buffer = "";
+    socket.on("data", async (chunk) => {
+      buffer += chunk.toString("utf8");
+      const newline = buffer.indexOf("\n");
+      if (newline === -1) return;
+      const line = buffer.slice(0, newline);
+      buffer = buffer.slice(newline + 1);
+
+      let request;
+      try {
+        request = JSON.parse(line);
+      } catch {
+        respond(socket, { ok: false, error: { code: "BAD_REQUEST", message: "Invalid OpenBrowser request." } });
+        return;
+      }
+
+      try {
+        const result = await forwardToExtension(request);
+        respond(socket, { ok: true, result });
+      } catch (error) {
+        respond(socket, {
+          ok: false,
+          error: { code: error.code || "COMMAND_FAILED", message: error.message || String(error) },
+        });
+      }
+    });
+  });
+
+  server.listen(socketPath, () => {
+    if (process.platform !== "win32") {
+      try { fs.chmodSync(socketPath, 0o600); } catch {}
+    }
+    log(`listening on ${socketPath}`);
+  });
+
+  server.on("error", (error) => {
+    log(error.message);
+    shutdown(1);
+  });
+}
+
+function shutdown(code) {
+  for (const [id, request] of pending) {
+    clearTimeout(request.timer);
+    request.reject(new Error("OpenBrowser native host stopped."));
+    pending.delete(id);
+  }
+
+  if (server) server.close();
+  if (process.platform !== "win32") {
+    try { fs.unlinkSync(socketPath); } catch {}
+  }
+  process.exit(code);
+}
+
+process.on("SIGINT", () => shutdown(0));
+process.on("SIGTERM", () => shutdown(0));
+
+startServer();

package/src/util/paths.js

@@ -0,0 +1,24 @@
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { APP_NAME } from "../constants.js";
+
+export function packageRoot() {
+  return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+}
+
+export function openBrowserHome() {
+  return process.env.OPENBROWSER_HOME || path.join(os.homedir(), APP_NAME);
+}
+
+export function screenshotsDir() {
+  return path.join(openBrowserHome(), "screenshots");
+}
+
+export function bridgeSocketPath(browser) {
+  if (process.platform === "win32") {
+    return `\\\\.\\pipe\\openbrowser-${browser}`;
+  }
+
+  return path.join(openBrowserHome(), "bridge", `${browser}.sock`);
+}