@proagentstore/cli 0.1.16 → 0.1.18

package/dist/browser-runner/runner.js

@@ -40,6 +40,7 @@ export class LocalRunner {
     }
     createTask(request) {
         const normalized = normalizeCreateTaskRequest(request);
+        validateTaskInput(normalized.type, normalized.input);
         const now = new Date().toISOString();
         const requiresApproval = normalized.requiresApproval || APPROVAL_REQUIRED_TASKS.has(normalized.type);
         const task = {
@@ -354,11 +355,11 @@ export class LocalRunner {
 export function normalizeJobApplicationInput(input) {
     const url = stringValue(input.url);
     if (!url || !/^https?:\/\//.test(url)) {
-        throw new RunnerInputError("job.apply_basic requires an http(s) url");
+        throw new RunnerInputError("job application requires an http(s) url");
     }
     const resumePath = resolve(stringValue(input.resumePath));
     if (!resumePath || !existsSync(resumePath)) {
-        throw new RunnerInputError("job.apply_basic requires an existing resumePath");
+        throw new RunnerInputError("job application requires an existing local resumePath");
     }
     const candidate = isRecord(input.candidate) ? input.candidate : {};
     const fullName = stringValue(candidate.fullName);
@@ -522,6 +523,15 @@ function normalizeCreateTaskRequest(request) {
             : "",
     };
 }
+function validateTaskInput(type, input) {
+    if (type === "job.apply_basic") {
+        normalizeJobApplicationInput(input);
+        return;
+    }
+    if (type === "job.apply_authenticated") {
+        normalizeAuthenticatedJobInput(input);
+    }
+}
 export function fileUrl(path) {
     return pathToFileURL(path).toString();
 }

package/dist/index.js

@@ -614,6 +614,9 @@ var publishCommand = new Command5("publish").description("Publish an agent to Pr
 import { spawn as spawn2 } from "child_process";
 import { randomUUID } from "crypto";
 import { existsSync as existsSync5 } from "fs";
+import { chmod, mkdir, writeFile } from "fs/promises";
+import { gunzipSync } from "zlib";
+import { arch, homedir as homedir2, platform } from "os";
 import { resolve as resolve4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { Command as Command6 } from "commander";
@@ -651,6 +654,112 @@ function buildRunnerArgs(opts) {
 function buildCloudflaredArgs(localUrl) {
   return ["tunnel", "--url", localUrl];
 }
+function cloudflaredAssetForPlatform(os = platform(), cpu = arch()) {
+  if (os === "darwin") {
+    if (cpu === "arm64") {
+      return {
+        asset: "cloudflared-darwin-arm64.tgz",
+        executableName: "cloudflared",
+        archive: true
+      };
+    }
+    if (cpu === "x64") {
+      return {
+        asset: "cloudflared-darwin-amd64.tgz",
+        executableName: "cloudflared",
+        archive: true
+      };
+    }
+  }
+  if (os === "linux") {
+    if (cpu === "x64") {
+      return {
+        asset: "cloudflared-linux-amd64",
+        executableName: "cloudflared",
+        archive: false
+      };
+    }
+    if (cpu === "arm64") {
+      return {
+        asset: "cloudflared-linux-arm64",
+        executableName: "cloudflared",
+        archive: false
+      };
+    }
+  }
+  if (os === "win32" && cpu === "x64") {
+    return {
+      asset: "cloudflared-windows-amd64.exe",
+      executableName: "cloudflared.exe",
+      archive: false
+    };
+  }
+  throw new Error(
+    `Automatic cloudflared download is not supported on ${os}/${cpu}. Install cloudflared and pass --cloudflared <path>.`
+  );
+}
+function cloudflaredDownloadUrl(asset) {
+  return `https://github.com/cloudflare/cloudflared/releases/latest/download/${asset}`;
+}
+function extractCloudflaredBinary(asset, bytes) {
+  const buffer = Buffer.from(bytes);
+  if (!asset.archive) return buffer;
+  const tar = gunzipSync(buffer);
+  for (let offset = 0; offset + 512 <= tar.length; ) {
+    const header = tar.subarray(offset, offset + 512);
+    if (header.every((byte) => byte === 0)) break;
+    const rawName = header.subarray(0, 100).toString("utf8");
+    const name = rawName.slice(0, rawName.indexOf("\0") === -1 ? void 0 : rawName.indexOf("\0"));
+    const rawSize = header.subarray(124, 136).toString("utf8").replace(/\0.*$/, "").trim();
+    const size = Number.parseInt(rawSize || "0", 8);
+    const contentStart = offset + 512;
+    const contentEnd = contentStart + size;
+    if (name.split("/").pop() === asset.executableName) {
+      return tar.subarray(contentStart, contentEnd);
+    }
+    offset = contentStart + Math.ceil(size / 512) * 512;
+  }
+  throw new Error(`Downloaded ${asset.asset} did not contain ${asset.executableName}`);
+}
+function cloudflaredCacheDir() {
+  return resolve4(homedir2(), ".config", "proagentstore", "bin");
+}
+function cachedCloudflaredPath(asset) {
+  const suffix = asset.asset.replace(/[^a-zA-Z0-9._-]/g, "-");
+  return resolve4(cloudflaredCacheDir(), `${asset.executableName}-${suffix}`);
+}
+async function commandAvailable(command) {
+  return new Promise((resolvePromise) => {
+    const child = spawn2(command, ["--version"], {
+      stdio: "ignore",
+      shell: process.platform === "win32"
+    });
+    child.on("error", () => resolvePromise(false));
+    child.on("exit", (code) => resolvePromise(code === 0));
+  });
+}
+async function downloadCloudflared(asset) {
+  const target = cachedCloudflaredPath(asset);
+  if (existsSync5(target)) return target;
+  await mkdir(cloudflaredCacheDir(), { recursive: true });
+  const url = cloudflaredDownloadUrl(asset.asset);
+  writeLine(`cloudflared not found; downloading ${asset.asset}...`);
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new Error(`cloudflared download failed: ${res.status} ${res.statusText}`);
+  }
+  const binary = extractCloudflaredBinary(asset, new Uint8Array(await res.arrayBuffer()));
+  await writeFile(target, binary);
+  if (process.platform !== "win32") await chmod(target, 493);
+  writeLine(`cloudflared cached at ${target}`);
+  return target;
+}
+async function resolveCloudflaredCommand(requested) {
+  const explicit = clean(requested);
+  if (explicit && explicit !== "cloudflared") return explicit;
+  if (await commandAvailable("cloudflared")) return "cloudflared";
+  return downloadCloudflared(cloudflaredAssetForPlatform());
+}
 function parseCloudflaredTunnelUrl(text) {
   return text.match(/https:\/\/[a-z0-9-]+\.trycloudflare\.com/i)?.[0] || null;
 }
@@ -786,7 +895,7 @@ function createRunnerCommand() {
   command.command("start").description("Start the local FAGS browser runtime 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 the local FAGS runtime, 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 FAGS-runtime probe after registration").action(async (instanceId, opts) => {
+  command.command("connect <instanceId>").description("Start the local FAGS runtime, 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").option("--runner-version <version>", "Runner version").option("--skip-probe", "Skip PAGS FAGS-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";
@@ -827,24 +936,25 @@ function createRunnerCommand() {
       writeLine(`Local FAGS runtime 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}`));
-        });
+        resolveCloudflaredCommand(opts.cloudflared).then((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}`));
+          });
+        }).catch(reject);
         setTimeout(() => reject(new Error("timed out waiting for cloudflared tunnel URL")), 45e3).unref();
       });
       writeLine(`Tunnel ready: ${tunnelUrl}`);
@@ -853,7 +963,7 @@ function createRunnerCommand() {
         token: runnerToken,
         instanceId
       });
-      const result = await requestPags("POST", `/v1/instances/${apiPathSegment(instanceId)}/runtime`, opts, {
+      await requestPags("POST", `/v1/instances/${apiPathSegment(instanceId)}/runtime`, opts, {
         endpointUrl: tunnelUrl,
         token: runnerToken,
         placement: "local",

package/package.json

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