abelworkflow 0.2.0 → 0.6.1

package/skills/dev-browser/package.json

@@ -6,8 +6,8 @@
     "@/*": "./src/*"
   },
   "scripts": {
-    "start-server": "npx tsx scripts/start-server.ts",
-    "start-extension": "npx tsx scripts/start-relay.ts",
+    "start-server": "npx tsx scripts/start.ts standalone",
+    "start-extension": "npx tsx scripts/start.ts extension",
     "dev": "npx tsx --watch src/index.ts",
     "test": "vitest run",
     "test:watch": "vitest"

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

@@ -0,0 +1,279 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync } from "node:fs";
+import { spawn, spawnSync } from "node:child_process";
+import { join } from "node:path";
+
+import { formatHttpUrl, parseEntrypointArgs, resolveHostForProbe } from "@/entrypoint.js";
+import {
+  commandExists,
+  findAvailablePackageManager,
+  getMissingPackageDependencies,
+  isPlaywrightChromiumInstalled,
+  resolveSkillDirFromEntrypoint,
+  resolveRuntimePaths,
+  shouldUseShellForPackageCommands,
+} from "@/runtime.js";
+import {
+  ensurePlaywrightChromium,
+  preflightStandaloneStartup,
+  runEntrypoint,
+} from "@/startup.js";
+
+const runtimePaths = resolveRuntimePaths(resolveSkillDirFromEntrypoint(import.meta.url));
+const useShell = shouldUseShellForPackageCommands(process.platform);
+
+async function main() {
+  const args = parseEntrypointArgs(process.argv.slice(2));
+  await ensureSkillDependencies();
+
+  await runEntrypoint(args, {
+    runtimePaths,
+    mkdir: mkdirSync,
+    serveStandalone: async (options) => {
+      const { serve } = await import("@/index.js");
+      return serve(options);
+    },
+    serveExtension: async (options) => {
+      const { serveRelay } = await import("@/relay.js");
+      return serveRelay(options);
+    },
+    registerShutdown,
+    keepAlive: () => new Promise(() => {}),
+    log: (line) => console.log(line),
+    ensureBrowser: () =>
+      ensurePlaywrightChromium({
+        isInstalled: () =>
+          isPlaywrightChromiumInstalled({
+            platform: process.platform,
+            env: process.env,
+            exists: existsSync,
+            readDir: readdirSync,
+          }),
+        findPackageManager: () =>
+          findAvailablePackageManager((command) =>
+            commandExists(command, (candidate) =>
+              spawnSync(candidate, ["--version"], {
+                stdio: "ignore",
+                shell: useShell,
+                windowsHide: useShell,
+              })
+            )
+          ),
+        runCommand,
+        log: (line) => console.log(line),
+      }),
+    preflightStandalone: () =>
+      preflightStandaloneStartup(args, {
+        checkServer: async (host, port) => {
+          try {
+            const response = await fetch(formatHttpUrl(resolveHostForProbe(host), port), {
+              signal: AbortSignal.timeout(1000),
+            });
+            if (!response.ok) {
+              return { ok: false };
+            }
+            const info = (await response.json()) as { wsEndpoint?: string };
+            return { ok: true, info };
+          } catch {
+            return { ok: false };
+          }
+        },
+        isPortInUse,
+        browserDataDir: runtimePaths.browserDataDir,
+        recoverStaleBrowser: ({ cdpPort, browserDataDir }) =>
+          recoverStaleDevBrowserChromium({
+            cdpPort,
+            browserDataDir,
+            isPortInUse,
+            log: (line) => console.log(line),
+          }),
+        log: (line) => console.log(line),
+      }),
+  });
+}
+
+async function ensureSkillDependencies() {
+  const packageJson = JSON.parse(readFileSync(join(runtimePaths.skillDir, "package.json"), "utf8")) as {
+    dependencies?: Record<string, string>;
+  };
+  const missingDependencies = getMissingPackageDependencies({
+    skillDir: runtimePaths.skillDir,
+    dependencies: Object.keys(packageJson.dependencies ?? {}),
+    exists: existsSync,
+  });
+
+  if (missingDependencies.length === 0) {
+    return;
+  }
+
+  console.log("dev-browser dependencies not found. Installing local packages...");
+  await runCommand("npm", ["install"]);
+  console.log("dev-browser dependencies installed.");
+}
+
+async function runCommand(command: string, args: string[]) {
+  await new Promise<void>((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: runtimePaths.skillDir,
+      stdio: "inherit",
+      shell: useShell,
+      windowsHide: useShell,
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(new Error(`${command} ${args.join(" ")} exited with code ${code}`));
+    });
+  });
+}
+
+async function isPortInUse(port: number) {
+  const socket = await import("node:net");
+  return await new Promise<boolean>((resolve) => {
+    const server = socket.createServer();
+    server.once("error", () => resolve(true));
+    server.once("listening", () => {
+      server.close(() => resolve(false));
+    });
+    server.listen(port, "127.0.0.1");
+  });
+}
+
+async function recoverStaleDevBrowserChromium({
+  cdpPort,
+  browserDataDir,
+  isPortInUse,
+  log,
+}: {
+  cdpPort: number;
+  browserDataDir: string;
+  isPortInUse: (port: number) => Promise<boolean>;
+  log: (line: string) => void;
+}) {
+  const pid = findListeningPid(cdpPort);
+  if (!pid) {
+    return false;
+  }
+
+  const commandLine = readProcessCommandLine(pid);
+  if (!commandLine || !isOwnedDevBrowserProcess(commandLine, browserDataDir, cdpPort)) {
+    return false;
+  }
+
+  log(`Cleaning up stale dev-browser Chromium on CDP port ${cdpPort} (PID: ${pid})`);
+  if (!terminateProcess(pid)) {
+    return false;
+  }
+
+  const deadline = Date.now() + 3000;
+  while (Date.now() < deadline) {
+    if (!(await isPortInUse(cdpPort))) {
+      return true;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+
+  return !(await isPortInUse(cdpPort));
+}
+
+function findListeningPid(port: number): number | null {
+  if (process.platform === "win32") {
+    const result = runCapture("powershell.exe", [
+      "-NoProfile",
+      "-Command",
+      `Get-NetTCPConnection -LocalPort ${port} -State Listen -ErrorAction SilentlyContinue | Select-Object -ExpandProperty OwningProcess -First 1`,
+    ]);
+    return parsePid(result.stdout);
+  }
+
+  const result = runCapture("lsof", ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN", "-t"]);
+  return parsePid(result.stdout);
+}
+
+function readProcessCommandLine(pid: number): string | null {
+  if (process.platform === "win32") {
+    const result = runCapture("powershell.exe", [
+      "-NoProfile",
+      "-Command",
+      `(Get-CimInstance Win32_Process -Filter "ProcessId = ${pid}").CommandLine`,
+    ]);
+    return normalizeOutput(result.stdout);
+  }
+
+  const result = runCapture("ps", ["-p", String(pid), "-o", "args="]);
+  return normalizeOutput(result.stdout);
+}
+
+function isOwnedDevBrowserProcess(commandLine: string, browserDataDir: string, cdpPort: number): boolean {
+  const normalizedCommandLine = normalizePathLike(commandLine);
+  const normalizedBrowserDataDir = normalizePathLike(browserDataDir);
+
+  return (
+    normalizedCommandLine.includes(`--remote-debugging-port=${cdpPort}`) &&
+    normalizedCommandLine.includes("--user-data-dir=") &&
+    normalizedCommandLine.includes(normalizedBrowserDataDir)
+  );
+}
+
+function terminateProcess(pid: number): boolean {
+  if (process.platform === "win32") {
+    return runCapture("taskkill", ["/PID", String(pid), "/T", "/F"]).status === 0;
+  }
+
+  try {
+    process.kill(pid, "SIGKILL");
+    return true;
+  } catch (error) {
+    return error instanceof Error && "code" in error && error.code === "ESRCH";
+  }
+}
+
+function runCapture(command: string, args: string[]) {
+  const result = spawnSync(command, args, {
+    cwd: runtimePaths.skillDir,
+    encoding: "utf8",
+    shell: false,
+    windowsHide: true,
+  });
+
+  return {
+    status: result.status,
+    stdout: typeof result.stdout === "string" ? result.stdout : "",
+  };
+}
+
+function parsePid(stdout: string): number | null {
+  const value = normalizeOutput(stdout);
+  if (!value) {
+    return null;
+  }
+
+  const pid = Number.parseInt(value.split(/\s+/)[0] ?? "", 10);
+  return Number.isInteger(pid) && pid > 0 ? pid : null;
+}
+
+function normalizeOutput(stdout: string): string | null {
+  const value = stdout.trim();
+  return value.length > 0 ? value : null;
+}
+
+function normalizePathLike(value: string): string {
+  return value.replaceAll("\\", "/").toLowerCase();
+}
+
+function registerShutdown(stop: () => Promise<void>) {
+  const shutdown = async () => {
+    await stop();
+    process.exit(0);
+  };
+
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+
+main().catch((error) => {
+  console.error("Failed to start dev-browser:", error);
+  process.exit(1);
+});

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

@@ -0,0 +1,157 @@
+export type EntrypointMode = "standalone" | "extension";
+
+export interface EntrypointArgs {
+  mode: EntrypointMode;
+  host: string;
+  port: number;
+  cdpPort: number;
+  headless: boolean;
+}
+
+export interface StandaloneReadinessInfo {
+  mode: "standalone";
+  host: string;
+  port: number;
+  wsEndpoint: string;
+  tmpDir: string;
+  profileDir: string;
+}
+
+export interface ExtensionReadinessInfo {
+  mode: "extension";
+  host: string;
+  port: number;
+  wsEndpoint: string;
+}
+
+export type ReadinessInfo = StandaloneReadinessInfo | ExtensionReadinessInfo;
+
+export const DEFAULT_HOST = "localhost";
+const DEFAULT_PORT = 9222;
+const DEFAULT_CDP_PORT = 9223;
+
+export function formatHostForUrl(host: string): string {
+  const normalizedHost =
+    host.startsWith("[") && host.endsWith("]") ? host.slice(1, -1) : host;
+  return normalizedHost.includes(":") ? `[${normalizedHost}]` : normalizedHost;
+}
+
+export function formatHttpUrl(host: string, port: number): string {
+  return `http://${formatHostForUrl(host)}:${port}`;
+}
+
+export function formatWsUrl(host: string, port: number, path = ""): string {
+  return `ws://${formatHostForUrl(host)}:${port}${path}`;
+}
+
+export function resolveHostForProbe(host: string): string {
+  const normalizedHost =
+    host.startsWith("[") && host.endsWith("]") ? host.slice(1, -1) : host;
+
+  if (normalizedHost === "0.0.0.0") {
+    return "127.0.0.1";
+  }
+
+  if (normalizedHost === "::") {
+    return "::1";
+  }
+
+  return normalizedHost;
+}
+
+export function parseEntrypointArgs(
+  argv: string[],
+  env: Record<string, string | undefined> = process.env
+): EntrypointArgs {
+  let index = 0;
+  let mode: EntrypointMode = "standalone";
+
+  const first = argv[0];
+  if (first && !first.startsWith("--")) {
+    if (first !== "standalone" && first !== "extension") {
+      throw new Error(`Unknown mode: ${first}`);
+    }
+    mode = first;
+    index = 1;
+  }
+
+  const args: EntrypointArgs = {
+    mode,
+    host: env.HOST?.trim() || DEFAULT_HOST,
+    port: readEnvPort(env.PORT, "PORT") ?? DEFAULT_PORT,
+    cdpPort: DEFAULT_CDP_PORT,
+    headless: env.HEADLESS?.trim().toLowerCase() === "true",
+  };
+
+  while (index < argv.length) {
+    const token = argv[index++];
+    switch (token) {
+      case "--headless":
+        args.headless = true;
+        break;
+      case "--host":
+        args.host = readValue(argv, index - 1);
+        index += 1;
+        break;
+      case "--port":
+        args.port = parsePort(readValue(argv, index - 1), "port");
+        index += 1;
+        break;
+      case "--cdp-port":
+        args.cdpPort = parsePort(readValue(argv, index - 1), "cdpPort");
+        index += 1;
+        break;
+      default:
+        throw new Error(`Unknown argument: ${token}`);
+    }
+  }
+
+  return args;
+}
+
+export function formatReadinessLines(info: ReadinessInfo): string[] {
+  if (info.mode === "standalone") {
+    return [
+      "Dev browser server started",
+      `  HTTP: ${formatHttpUrl(info.host, info.port)}`,
+      `  WebSocket: ${info.wsEndpoint}`,
+      `  Tmp directory: ${info.tmpDir}`,
+      `  Profile directory: ${info.profileDir}`,
+      "",
+      "Ready",
+    ];
+  }
+
+  return [
+    "CDP relay server started",
+    `  HTTP: ${formatHttpUrl(info.host, info.port)}`,
+    `  CDP endpoint: ${info.wsEndpoint}`,
+    `  Extension endpoint: ${formatWsUrl(info.host, info.port, "/extension")}`,
+    "",
+    "Waiting for extension to connect...",
+  ];
+}
+
+function readValue(argv: string[], optionIndex: number): string {
+  const value = argv[optionIndex + 1];
+  if (!value || value.startsWith("--")) {
+    throw new Error(`Missing value for ${argv[optionIndex]}`);
+  }
+  return value;
+}
+
+function parsePort(value: string, label: string): number {
+  const port = Number.parseInt(value, 10);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error(`Invalid ${label}: ${value}`);
+  }
+  return port;
+}
+
+function readEnvPort(value: string | undefined, label: string): number | undefined {
+  const normalized = value?.trim();
+  if (!normalized) {
+    return undefined;
+  }
+  return parsePort(normalized, label);
+}

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

@@ -3,6 +3,7 @@ import { chromium, type BrowserContext, type Page } from "playwright";
 import { mkdirSync } from "fs";
 import { join } from "path";
 import type { Socket } from "net";
+import { formatHttpUrl } from "./entrypoint";
 import type {
   ServeOptions,
   GetPageRequest,
@@ -53,6 +54,7 @@ function withTimeout<T>(promise: Promise<T>, ms: number, message: string): Promi
 
 export async function serve(options: ServeOptions = {}): Promise<DevBrowserServer> {
   const port = options.port ?? 9222;
+  const host = options.host ?? "localhost";
   const headless = options.headless ?? false;
   const cdpPort = options.cdpPort ?? 9223;
   const profileDir = options.profileDir;
@@ -191,8 +193,8 @@ export async function serve(options: ServeOptions = {}): Promise<DevBrowserServe
   });
 
   // Start the server
-  const server = app.listen(port, () => {
-    console.log(`HTTP API server running on port ${port}`);
+  const server = app.listen(port, host, () => {
+    console.log(`HTTP API server running on ${formatHttpUrl(host, port)}`);
   });
 
   // Track active connections for clean shutdown

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

@@ -0,0 +1,147 @@
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+export interface CommandStatusResult {
+  status: number | null;
+}
+
+export interface PackageManager {
+  name: "bun" | "pnpm" | "npm";
+  command: string;
+  args: string[];
+}
+
+export interface ChromiumInstallCheckOptions {
+  platform: NodeJS.Platform;
+  env: NodeJS.ProcessEnv;
+  exists: (path: string) => boolean;
+  readDir: (path: string) => string[];
+}
+
+export interface MissingPackageDependenciesOptions {
+  skillDir: string;
+  dependencies: string[];
+  exists: (path: string) => boolean;
+}
+
+export function commandExists(
+  command: string,
+  runCheck: (command: string) => CommandStatusResult
+): boolean {
+  return runCheck(command).status === 0;
+}
+
+export function findAvailablePackageManager(
+  hasCommand: (command: string) => boolean
+): PackageManager | null {
+  const candidates: PackageManager[] = [
+    {
+      name: "bun",
+      command: "bunx",
+      args: ["playwright", "install", "chromium"],
+    },
+    {
+      name: "pnpm",
+      command: "pnpm",
+      args: ["exec", "playwright", "install", "chromium"],
+    },
+    {
+      name: "npm",
+      command: "npx",
+      args: ["playwright", "install", "chromium"],
+    },
+  ];
+
+  for (const candidate of candidates) {
+    const probe = candidate.name === "npm" ? "npm" : candidate.name;
+    if (hasCommand(probe)) {
+      return candidate;
+    }
+  }
+
+  return null;
+}
+
+export function getPlaywrightInstallCommand(manager: PackageManager): string {
+  return [manager.command, ...manager.args].join(" ");
+}
+
+export function getPlaywrightBrowserRoots({
+  platform,
+  env,
+}: {
+  platform: NodeJS.Platform;
+  env: NodeJS.ProcessEnv;
+}): string[] {
+  const explicitPath = env.PLAYWRIGHT_BROWSERS_PATH?.trim();
+  if (explicitPath) {
+    return [explicitPath];
+  }
+
+  if (platform === "win32") {
+    const userProfile = env.USERPROFILE ?? env.HOME;
+    return userProfile ? [join(userProfile, "AppData", "Local", "ms-playwright")] : [];
+  }
+
+  const home = env.HOME ?? env.USERPROFILE;
+  return home ? [join(home, ".cache", "ms-playwright")] : [];
+}
+
+export function isPlaywrightChromiumInstalled({
+  platform,
+  env,
+  exists,
+  readDir,
+}: ChromiumInstallCheckOptions): boolean {
+  for (const root of getPlaywrightBrowserRoots({ platform, env })) {
+    if (!exists(root)) {
+      continue;
+    }
+
+    try {
+      const entries = readDir(root);
+      if (entries.some((entry) => entry.startsWith("chromium"))) {
+        return true;
+      }
+    } catch {
+      // Ignore unreadable directories and continue probing.
+    }
+  }
+
+  return false;
+}
+
+export function getMissingPackageDependencies({
+  skillDir,
+  dependencies,
+  exists,
+}: MissingPackageDependenciesOptions): string[] {
+  return dependencies.filter(
+    (dependency) =>
+      !exists(join(skillDir, "node_modules", ...dependency.split("/"), "package.json"))
+  );
+}
+
+export function resolveRuntimePaths(skillDir: string) {
+  const tmpDir = join(skillDir, "tmp");
+  const profileDir = join(skillDir, "profiles");
+
+  return {
+    skillDir,
+    tmpDir,
+    profileDir,
+    browserDataDir: join(profileDir, "browser-data"),
+  };
+}
+
+export function resolveImportMetaDir(moduleUrl: string): string {
+  return dirname(fileURLToPath(moduleUrl));
+}
+
+export function resolveSkillDirFromEntrypoint(moduleUrl: string): string {
+  return dirname(resolveImportMetaDir(moduleUrl));
+}
+
+export function shouldUseShellForPackageCommands(platform: NodeJS.Platform): boolean {
+  return platform === "win32";
+}

package/skills/dev-browser/src/snapshot/browser-script.ts

@@ -11,6 +11,7 @@
 
 import * as fs from "fs";
 import * as path from "path";
+import { fileURLToPath } from "node:url";
 
 // Cache the bundled script
 let cachedScript: string | null = null;
@@ -26,7 +27,7 @@ export function getSnapshotScript(): string {
   if (cachedScript) return cachedScript;
 
   // Read the compiled JavaScript files
-  const snapshotDir = path.dirname(new URL(import.meta.url).pathname);
+  const snapshotDir = path.dirname(fileURLToPath(import.meta.url));
 
   // For now, we'll inline the functions directly
   // In production, we could use a bundler like esbuild to create a single file