abelworkflow 0.2.0 → 0.6.1

package/skills/dev-browser/src/startup.test.ts

@@ -0,0 +1,95 @@
+import { describe, expect, it, vi } from "vitest";
+
+import {
+  DEFAULT_HOST,
+  formatHttpUrl,
+  formatReadinessLines,
+  parseEntrypointArgs,
+  resolveHostForProbe,
+} from "./entrypoint.js";
+import { preflightStandaloneStartup } from "./startup.js";
+
+describe("entrypoint host handling", () => {
+  it("defaults standalone host to localhost", () => {
+    const args = parseEntrypointArgs([], {});
+
+    expect(args.host).toBe(DEFAULT_HOST);
+    expect(args.host).toBe("localhost");
+  });
+
+  it("formats IPv6 hosts in readiness output", () => {
+    expect(formatHttpUrl("::1", 9222)).toBe("http://[::1]:9222");
+
+    expect(
+      formatReadinessLines({
+        mode: "standalone",
+        host: "::1",
+        port: 9222,
+        wsEndpoint: "ws://127.0.0.1:9223/devtools/browser/test",
+        tmpDir: "/tmp/dev-browser",
+        profileDir: "/tmp/dev-browser/profile",
+      })
+    ).toContain("  HTTP: http://[::1]:9222");
+  });
+
+  it("normalizes wildcard hosts to a reachable probe target", () => {
+    expect(resolveHostForProbe("0.0.0.0")).toBe("127.0.0.1");
+    expect(resolveHostForProbe("::")).toBe("::1");
+    expect(resolveHostForProbe("[::1]")).toBe("::1");
+    expect(resolveHostForProbe("localhost")).toBe("localhost");
+  });
+});
+
+describe("preflightStandaloneStartup", () => {
+  it("checks the configured host before starting", async () => {
+    const checkServer = vi.fn().mockResolvedValue({ ok: false });
+    const isPortInUse = vi.fn().mockResolvedValue(false);
+    const log = vi.fn();
+
+    await expect(
+      preflightStandaloneStartup(
+        {
+          mode: "standalone",
+          host: "::1",
+          port: 9222,
+          cdpPort: 9223,
+          headless: false,
+        },
+        {
+          checkServer,
+          isPortInUse,
+          log,
+        }
+      )
+    ).resolves.toBe(true);
+
+    expect(checkServer).toHaveBeenCalledWith("::1", 9222);
+  });
+
+  it("short-circuits when the configured host already has a server", async () => {
+    const checkServer = vi.fn().mockResolvedValue({ ok: true, info: { wsEndpoint: "ws://test" } });
+    const isPortInUse = vi.fn();
+    const log = vi.fn();
+
+    await expect(
+      preflightStandaloneStartup(
+        {
+          mode: "standalone",
+          host: "localhost",
+          port: 9222,
+          cdpPort: 9223,
+          headless: false,
+        },
+        {
+          checkServer,
+          isPortInUse,
+          log,
+        }
+      )
+    ).resolves.toBe(false);
+
+    expect(checkServer).toHaveBeenCalledWith("localhost", 9222);
+    expect(isPortInUse).not.toHaveBeenCalled();
+    expect(log).toHaveBeenCalledWith("Server already running on port 9222");
+  });
+});

package/skills/dev-browser/src/startup.ts

@@ -0,0 +1,153 @@
+import { formatReadinessLines, type EntrypointArgs } from "./entrypoint.js";
+import type { PackageManager } from "./runtime.js";
+
+export interface RuntimePaths {
+  skillDir: string;
+  tmpDir: string;
+  profileDir: string;
+  browserDataDir: string;
+}
+
+interface StandaloneServer {
+  port: number;
+  wsEndpoint: string;
+  stop: () => Promise<void>;
+}
+
+interface ExtensionServer {
+  port: number;
+  wsEndpoint: string;
+  stop: () => Promise<void>;
+}
+
+export interface RunEntrypointDeps {
+  runtimePaths: RuntimePaths;
+  mkdir: (path: string, options: { recursive: true }) => void;
+  serveStandalone: (options: {
+    port: number;
+    host: string;
+    headless: boolean;
+    cdpPort: number;
+    profileDir: string;
+  }) => Promise<StandaloneServer>;
+  serveExtension: (options: { port: number; host: string }) => Promise<ExtensionServer>;
+  registerShutdown: (stop: () => Promise<void>) => void;
+  keepAlive: () => Promise<void>;
+  log: (line: string) => void;
+  ensureBrowser?: () => Promise<void>;
+  preflightStandalone?: () => Promise<boolean>;
+}
+
+export interface EnsurePlaywrightChromiumDeps {
+  isInstalled: () => boolean;
+  findPackageManager: () => PackageManager | null;
+  runCommand: (command: string, args: string[]) => Promise<void>;
+  log: (line: string) => void;
+}
+
+export interface PreflightStandaloneStartupDeps {
+  checkServer: (host: string, port: number) => Promise<{ ok: boolean; info?: { wsEndpoint?: string } }>;
+  isPortInUse: (port: number) => Promise<boolean>;
+  browserDataDir?: string;
+  recoverStaleBrowser?: (options: { cdpPort: number; browserDataDir: string }) => Promise<boolean>;
+  log: (line: string) => void;
+}
+
+export async function preflightStandaloneStartup(
+  args: EntrypointArgs,
+  deps: PreflightStandaloneStartupDeps
+): Promise<boolean> {
+  const serverCheck = await deps.checkServer(args.host, args.port);
+  if (serverCheck.ok) {
+    deps.log(`Server already running on port ${args.port}`);
+    return false;
+  }
+
+  if (await deps.isPortInUse(args.cdpPort)) {
+    const recovered =
+      deps.browserDataDir && deps.recoverStaleBrowser
+        ? await deps.recoverStaleBrowser({
+            cdpPort: args.cdpPort,
+            browserDataDir: deps.browserDataDir,
+          })
+        : false;
+
+    if (!recovered && (await deps.isPortInUse(args.cdpPort))) {
+      throw new Error(`CDP port ${args.cdpPort} is already in use by another process`);
+    }
+  }
+
+  return true;
+}
+
+export async function ensurePlaywrightChromium(deps: EnsurePlaywrightChromiumDeps) {
+  if (deps.isInstalled()) {
+    deps.log("Playwright Chromium already installed.");
+    return;
+  }
+
+  deps.log("Playwright Chromium not found. Installing (this may take a minute)...");
+  const manager = deps.findPackageManager();
+  if (!manager) {
+    throw new Error("No package manager found (tried bun, pnpm, npm)");
+  }
+
+  deps.log(`Using ${manager.name} to install Playwright...`);
+  await deps.runCommand(manager.command, manager.args);
+  deps.log("Chromium installed successfully.");
+}
+
+export async function runEntrypoint(args: EntrypointArgs, deps: RunEntrypointDeps) {
+  deps.mkdir(deps.runtimePaths.tmpDir, { recursive: true });
+
+  if (args.mode === "extension") {
+    const server = await deps.serveExtension({
+      port: args.port,
+      host: args.host,
+    });
+
+    for (const line of formatReadinessLines({
+      mode: "extension",
+      host: args.host,
+      port: args.port,
+      wsEndpoint: server.wsEndpoint,
+    })) {
+      deps.log(line);
+    }
+
+    deps.registerShutdown(() => server.stop());
+    await deps.keepAlive();
+    return;
+  }
+
+  deps.mkdir(deps.runtimePaths.profileDir, { recursive: true });
+
+  const shouldStart = await deps.preflightStandalone?.();
+  if (shouldStart === false) {
+    return;
+  }
+
+  await deps.ensureBrowser?.();
+
+  const server = await deps.serveStandalone({
+    port: args.port,
+    host: args.host,
+    headless: args.headless,
+    cdpPort: args.cdpPort,
+    profileDir: deps.runtimePaths.profileDir,
+  });
+
+  for (const line of formatReadinessLines({
+    mode: "standalone",
+    host: args.host,
+    port: args.port,
+    wsEndpoint: server.wsEndpoint,
+    tmpDir: deps.runtimePaths.tmpDir,
+    profileDir: deps.runtimePaths.profileDir,
+  })) {
+    deps.log(line);
+  }
+
+  deps.registerShutdown(() => server.stop());
+  await deps.keepAlive();
+}

package/skills/dev-browser/src/types.ts

@@ -2,6 +2,7 @@
 
 export interface ServeOptions {
   port?: number;
+  host?: string;
   headless?: boolean;
   cdpPort?: number;
   /** Directory to store persistent browser profiles (cookies, localStorage, etc.) */

package/skills/dev-browser/scripts/start-relay.ts

@@ -1,32 +0,0 @@
-/**
- * Start the CDP relay server for Chrome extension mode
- *
- * Usage: npm run start-extension
- */
-
-import { serveRelay } from "@/relay.js";
-
-const PORT = parseInt(process.env.PORT || "9222", 10);
-const HOST = process.env.HOST || "127.0.0.1";
-
-async function main() {
-  const server = await serveRelay({
-    port: PORT,
-    host: HOST,
-  });
-
-  // Handle shutdown
-  const shutdown = async () => {
-    console.log("\nShutting down relay server...");
-    await server.stop();
-    process.exit(0);
-  };
-
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
-}
-
-main().catch((err) => {
-  console.error("Failed to start relay server:", err);
-  process.exit(1);
-});

package/skills/dev-browser/scripts/start-server.ts

@@ -1,117 +0,0 @@
-import { serve } from "@/index.js";
-import { execSync } from "child_process";
-import { mkdirSync, existsSync, readdirSync } from "fs";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const tmpDir = join(__dirname, "..", "tmp");
-const profileDir = join(__dirname, "..", "profiles");
-
-// Create tmp and profile directories if they don't exist
-console.log("Creating tmp directory...");
-mkdirSync(tmpDir, { recursive: true });
-console.log("Creating profiles directory...");
-mkdirSync(profileDir, { recursive: true });
-
-// Install Playwright browsers if not already installed
-console.log("Checking Playwright browser installation...");
-
-function findPackageManager(): { name: string; command: string } | null {
-  const managers = [
-    { name: "bun", command: "bunx playwright install chromium" },
-    { name: "pnpm", command: "pnpm exec playwright install chromium" },
-    { name: "npm", command: "npx playwright install chromium" },
-  ];
-
-  for (const manager of managers) {
-    try {
-      execSync(`which ${manager.name}`, { stdio: "ignore" });
-      return manager;
-    } catch {
-      // Package manager not found, try next
-    }
-  }
-  return null;
-}
-
-function isChromiumInstalled(): boolean {
-  const homeDir = process.env.HOME || process.env.USERPROFILE || "";
-  const playwrightCacheDir = join(homeDir, ".cache", "ms-playwright");
-
-  if (!existsSync(playwrightCacheDir)) {
-    return false;
-  }
-
-  // Check for chromium directories (e.g., chromium-1148, chromium_headless_shell-1148)
-  try {
-    const entries = readdirSync(playwrightCacheDir);
-    return entries.some((entry) => entry.startsWith("chromium"));
-  } catch {
-    return false;
-  }
-}
-
-try {
-  if (!isChromiumInstalled()) {
-    console.log("Playwright Chromium not found. Installing (this may take a minute)...");
-
-    const pm = findPackageManager();
-    if (!pm) {
-      throw new Error("No package manager found (tried bun, pnpm, npm)");
-    }
-
-    console.log(`Using ${pm.name} to install Playwright...`);
-    execSync(pm.command, { stdio: "inherit" });
-    console.log("Chromium installed successfully.");
-  } else {
-    console.log("Playwright Chromium already installed.");
-  }
-} catch (error) {
-  console.error("Failed to install Playwright browsers:", error);
-  console.log("You may need to run: npx playwright install chromium");
-}
-
-// Check if server is already running
-console.log("Checking for existing servers...");
-try {
-  const res = await fetch("http://localhost:9222", {
-    signal: AbortSignal.timeout(1000),
-  });
-  if (res.ok) {
-    console.log("Server already running on port 9222");
-    process.exit(0);
-  }
-} catch {
-  // Server not running, continue to start
-}
-
-// Clean up stale CDP port if HTTP server isn't running (crash recovery)
-// This handles the case where Node crashed but Chrome is still running on 9223
-try {
-  const pid = execSync("lsof -ti:9223", { encoding: "utf-8" }).trim();
-  if (pid) {
-    console.log(`Cleaning up stale Chrome process on CDP port 9223 (PID: ${pid})`);
-    execSync(`kill -9 ${pid}`);
-  }
-} catch {
-  // No process on CDP port, which is expected
-}
-
-console.log("Starting dev browser server...");
-const headless = process.env.HEADLESS === "true";
-const server = await serve({
-  port: 9222,
-  headless,
-  profileDir,
-});
-
-console.log(`Dev browser server started`);
-console.log(`  WebSocket: ${server.wsEndpoint}`);
-console.log(`  Tmp directory: ${tmpDir}`);
-console.log(`  Profile directory: ${profileDir}`);
-console.log(`\nReady`);
-console.log(`\nPress Ctrl+C to stop`);
-
-// Keep the process running
-await new Promise(() => {});

package/skills/dev-browser/server.sh

@@ -1,24 +0,0 @@
-#!/bin/bash
-
-# Get the directory where this script is located
-SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-
-# Change to the script directory
-cd "$SCRIPT_DIR"
-
-# Parse command line arguments
-HEADLESS=false
-while [[ "$#" -gt 0 ]]; do
-    case $1 in
-        --headless) HEADLESS=true ;;
-        *) echo "Unknown parameter: $1"; exit 1 ;;
-    esac
-    shift
-done
-
-echo "Installing dependencies..."
-npm install
-
-echo "Starting dev-browser server..."
-export HEADLESS=$HEADLESS
-npx tsx scripts/start-server.ts