@proagentstore/cli 0.1.6 → 0.1.7

package/dist/index.js

@@ -472,6 +472,7 @@ var publishCommand = new Command4("publish").description("Publish an agent to Pr
 
 // src/commands/runner.ts
 import { spawn as spawn2 } from "child_process";
+import { randomUUID } from "crypto";
 import { existsSync as existsSync4 } from "fs";
 import { resolve as resolve4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
@@ -507,6 +508,12 @@ function buildRunnerArgs(opts) {
   if (opts.headless) args.push("--headless");
   return args;
 }
+function buildCloudflaredArgs(localUrl) {
+  return ["tunnel", "--url", localUrl];
+}
+function parseCloudflaredTunnelUrl(text) {
+  return text.match(/https:\/\/[a-z0-9-]+\.trycloudflare\.com/i)?.[0] || null;
+}
 function buildRuntimeRegistrationBody(opts, capabilities = []) {
   return {
     endpointUrl: clean(opts.endpointUrl) || opts.endpointUrl,
@@ -533,7 +540,7 @@ function findWorkspaceRoot() {
 function bundledRunnerPath() {
   return fileURLToPath2(new URL("./browser-runner/index.js", import.meta.url));
 }
-function startRunnerForeground(opts) {
+function runnerSpawnSpec(opts) {
   const root = findWorkspaceRoot();
   const localPackage = resolve4(root, "packages", "browser-runner", "src", "index.ts");
   const bundledPackage = bundledRunnerPath();
@@ -549,9 +556,13 @@ function startRunnerForeground(opts) {
     command = process.execPath;
     args = [bundledPackage, ...runnerArgs];
   }
+  return { command, args, cwd };
+}
+function startRunnerForeground(opts) {
+  const spec = runnerSpawnSpec(opts);
   return new Promise((resolvePromise, reject) => {
-    const child = spawn2(command, args, {
-      cwd,
+    const child = spawn2(spec.command, spec.args, {
+      cwd: spec.cwd,
       stdio: "inherit",
       shell: process.platform === "win32"
     });
@@ -562,6 +573,20 @@ function startRunnerForeground(opts) {
     });
   });
 }
+async function waitForLocalRunner(opts, timeoutMs = 15e3) {
+  const started = Date.now();
+  let lastError;
+  while (Date.now() - started < timeoutMs) {
+    try {
+      await requestRunner("GET", "/health", opts);
+      return;
+    } catch (error) {
+      lastError = error;
+      await new Promise((resolvePromise) => setTimeout(resolvePromise, 500));
+    }
+  }
+  throw new Error(`runner did not become healthy: ${lastError instanceof Error ? lastError.message : String(lastError)}`);
+}
 async function requestRunner(method, path, opts, body) {
   const headers = {
     ...runnerRequestHeaders(opts)
@@ -621,6 +646,101 @@ function createRunnerCommand() {
   command.command("start").description("Start the local browser runner in the foreground").option("--host <host>", "Host to bind", "127.0.0.1").option("--port <port>", "Port to bind", "49171").option("--data-dir <path>", "Runner data directory").option("--token <token>", "Require this bearer token").option("--instance-id <id>", "Bind runner requests to a PAGS instance id").option("--headless", "Run Playwright headless").action(async (opts) => {
     await startRunnerForeground(opts);
   });
+  command.command("connect <instanceId>").description("Start a local runner, open a Cloudflare quick tunnel, and register it with PAGS").option("--host <host>", "Host to bind", "127.0.0.1").option("--port <port>", "Port to bind", "49171").option("--data-dir <path>", "Runner data directory").option("--token <token>", "Runner bearer token. Defaults to PAGS_RUNNER_TOKEN or a generated token").option("--headless", "Run Playwright headless").option("--api-base <url>", "PAGS API base URL").option("--pags-token <token>", "PAGS session token. Defaults to PAGS_TOKEN").option("--cloudflared <path>", "cloudflared executable", "cloudflared").option("--runner-version <version>", "Runner version").option("--skip-probe", "Skip PAGS runtime probe after registration").action(async (instanceId, opts) => {
+    const runnerToken = clean(opts.token) || clean(process.env.PAGS_RUNNER_TOKEN) || `pags_runner_${randomUUID()}`;
+    const host = clean(opts.host) || "127.0.0.1";
+    const port = clean(opts.port) || "49171";
+    const localUrl = `http://${host}:${port}`;
+    const runnerOpts = {
+      ...opts,
+      host,
+      port,
+      token: runnerToken,
+      instanceId
+    };
+    const spec = runnerSpawnSpec(runnerOpts);
+    const runner = spawn2(spec.command, spec.args, {
+      cwd: spec.cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: process.platform === "win32"
+    });
+    runner.stdout?.on("data", (data) => process.stdout.write(data));
+    runner.stderr?.on("data", (data) => process.stderr.write(data));
+    runner.on("exit", (code) => {
+      if (code && code !== 0) writeError(`runner exited with code ${code}`);
+    });
+    let tunnel = null;
+    const shutdown = () => {
+      if (tunnel && !tunnel.killed) tunnel.kill("SIGTERM");
+      if (!runner.killed) runner.kill("SIGTERM");
+    };
+    process.once("SIGINT", () => {
+      shutdown();
+      process.exit(0);
+    });
+    process.once("SIGTERM", () => {
+      shutdown();
+      process.exit(0);
+    });
+    try {
+      await waitForLocalRunner({ url: localUrl, token: runnerToken, instanceId });
+      writeLine(`Local runner healthy at ${localUrl}`);
+      const tunnelUrl = await new Promise((resolveTunnel, reject) => {
+        let output = "";
+        const cloudflared = clean(opts.cloudflared) || "cloudflared";
+        tunnel = spawn2(cloudflared, buildCloudflaredArgs(localUrl), {
+          stdio: ["ignore", "pipe", "pipe"],
+          shell: process.platform === "win32"
+        });
+        const onData = (data) => {
+          const text = data.toString("utf-8");
+          output += text;
+          process.stderr.write(text);
+          const parsed = parseCloudflaredTunnelUrl(output);
+          if (parsed) resolveTunnel(parsed);
+        };
+        tunnel.stdout?.on("data", onData);
+        tunnel.stderr?.on("data", onData);
+        tunnel.on("error", reject);
+        tunnel.on("exit", (code) => {
+          if (code && code !== 0) reject(new Error(`cloudflared exited with code ${code}`));
+        });
+        setTimeout(() => reject(new Error("timed out waiting for cloudflared tunnel URL")), 45e3).unref();
+      });
+      writeLine(`Tunnel ready: ${tunnelUrl}`);
+      await waitForLocalRunner({ url: tunnelUrl, token: runnerToken, instanceId }, 3e4);
+      writeLine("Tunnel health check passed");
+      const capabilities = await requestRunner("GET", "/capabilities", {
+        url: tunnelUrl,
+        token: runnerToken,
+        instanceId
+      });
+      const result = await requestPags("POST", `/v1/instances/${apiPathSegment(instanceId)}/runtime`, opts, {
+        endpointUrl: tunnelUrl,
+        token: runnerToken,
+        placement: "local",
+        capabilities: Array.isArray(capabilities.capabilities) ? capabilities.capabilities.filter((item) => typeof item === "string") : [],
+        runnerVersion: clean(opts.runnerVersion) || ""
+      });
+      writeLine(JSON.stringify(result, null, 2));
+      if (!opts.skipProbe) {
+        const status = await requestPags(
+          "GET",
+          `/v1/instances/${apiPathSegment(instanceId)}/runtime/status`,
+          opts
+        );
+        writeLine(JSON.stringify(status, null, 2));
+      }
+      writeLine("Connected. Keep this process running while the agent uses your local browser.");
+      await new Promise((resolvePromise) => {
+        runner.on("exit", () => resolvePromise());
+        tunnel?.on("exit", () => resolvePromise());
+      });
+    } catch (error) {
+      shutdown();
+      throw error;
+    }
+  });
   command.command("status").description("Check local runner health and capabilities").option("--url <url>", "Runner URL").option("--token <token>", "Runner bearer token").option("--instance-id <id>", "PAGS instance id header").action(async (opts) => {
     const health = await requestRunner("GET", "/health", opts);
     const capabilities = await requestRunner("GET", "/capabilities", opts);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@proagentstore/cli",
-	"version": "0.1.6",
+	"version": "0.1.7",
 	"description": "CLI for creating, publishing, and running ProAgentStore agents",
 	"license": "MIT",
 	"type": "module",