@proagentstore/cli 0.1.3 → 0.1.5

package/dist/browser-runner/runner.js

@@ -1,7 +1,7 @@
 import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync } from "node:fs";
 import { createRequire } from "node:module";
-import { mkdirSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { basename, dirname, join, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import { RunnerStore } from "./store.js";
 const CAPABILITIES = [
@@ -11,7 +11,7 @@ const CAPABILITIES = [
     "file.upload",
     "human.approval",
 ];
-const APPROVAL_REQUIRED_TASKS = new Set(["browser.open"]);
+const APPROVAL_REQUIRED_TASKS = new Set(["browser.open", "job.apply_basic"]);
 const require = createRequire(import.meta.url);
 export class RunnerInputError extends Error {
     status = 400;
@@ -32,8 +32,8 @@ export class LocalRunner {
             brainPlacement: "pags",
             runnerRole: "tool-executor",
             capabilities: CAPABILITIES,
-            taskTypes: ["echo", "browser.open"],
-            approvalRequiredFor: ["browser.open"],
+            taskTypes: ["echo", "browser.open", "job.apply_basic"],
+            approvalRequiredFor: [...APPROVAL_REQUIRED_TASKS],
         };
     }
     createTask(request) {
@@ -160,8 +160,36 @@ export class LocalRunner {
                 title: await page.title(),
             };
         }
+        if (task.type === "job.apply_basic") {
+            return this.applyToBasicJob(task.input);
+        }
         throw new Error(`Unknown task type: ${task.type}`);
     }
+    async applyToBasicJob(input) {
+        const job = normalizeJobApplicationInput(input);
+        const context = await this.getBrowserContext();
+        const page = context.pages()[0] || (await context.newPage());
+        await page.goto(job.url, { waitUntil: "domcontentloaded", timeout: 30_000 });
+        const filledFields = await fillBasicApplicationForm(page, job);
+        const beforeSubmitUrl = page.url();
+        const navigation = page.waitForNavigation({
+            waitUntil: "domcontentloaded",
+            timeout: 15_000,
+        }).catch(() => null);
+        await submitApplicationForm(page);
+        await navigation;
+        await page.waitForLoadState("domcontentloaded", { timeout: 5_000 }).catch(() => undefined);
+        return {
+            taskType: "job.apply_basic",
+            submitted: true,
+            beforeSubmitUrl,
+            finalUrl: page.url(),
+            title: await page.title(),
+            fieldsFilled: filledFields,
+            resumeFile: basename(job.resumePath),
+            visibleText: (await page.locator("body").innerText({ timeout: 5_000 }).catch(() => "")).slice(0, 2_000),
+        };
+    }
     requireTask(id) {
         const task = this.store.getTask(id);
         if (!task)
@@ -202,9 +230,164 @@ 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");
+    }
+    const resumePath = resolve(stringValue(input.resumePath));
+    if (!resumePath || !existsSync(resumePath)) {
+        throw new RunnerInputError("job.apply_basic requires an existing resumePath");
+    }
+    const candidate = isRecord(input.candidate) ? input.candidate : {};
+    const fullName = stringValue(candidate.fullName);
+    const email = stringValue(candidate.email);
+    if (!fullName)
+        throw new RunnerInputError("candidate.fullName is required");
+    if (!email || !/^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(email)) {
+        throw new RunnerInputError("candidate.email must be a valid email address");
+    }
+    return {
+        url,
+        resumePath,
+        candidate: {
+            fullName,
+            email,
+            phone: optionalString(candidate.phone),
+            location: optionalString(candidate.location),
+            linkedin: optionalString(candidate.linkedin),
+            portfolio: optionalString(candidate.portfolio),
+            workAuthorization: optionalString(candidate.workAuthorization),
+        },
+        coverNote: optionalString(input.coverNote),
+    };
+}
+async function fillBasicApplicationForm(page, job) {
+    const filled = [];
+    const candidate = job.candidate;
+    const fillSpecs = [
+        ["fullName", candidate.fullName, [
+                'input[name="fullName"]',
+                'input[name="full_name"]',
+                'input[name="name"]',
+                'input[autocomplete="name"]',
+            ]],
+        ["email", candidate.email, [
+                'input[name="email"]',
+                'input[type="email"]',
+                'input[autocomplete="email"]',
+            ]],
+        ["phone", candidate.phone, [
+                'input[name="phone"]',
+                'input[name="mobile"]',
+                'input[autocomplete="tel"]',
+            ]],
+        ["location", candidate.location, [
+                'input[name="location"]',
+                'input[autocomplete="address-level2"]',
+                'input[autocomplete="address-level1"]',
+            ]],
+        ["linkedin", candidate.linkedin, [
+                'input[name="linkedin"]',
+                'input[name="linkedIn"]',
+                'input[placeholder*="LinkedIn" i]',
+            ]],
+        ["portfolio", candidate.portfolio, [
+                'input[name="portfolio"]',
+                'input[name="website"]',
+                'input[placeholder*="Portfolio" i]',
+                'input[placeholder*="Website" i]',
+            ]],
+        ["coverNote", job.coverNote, [
+                'textarea[name="coverNote"]',
+                'textarea[name="cover_letter"]',
+                'textarea[name="coverLetter"]',
+                'textarea[placeholder*="cover" i]',
+                'textarea[placeholder*="message" i]',
+            ]],
+    ];
+    for (const [name, value, selectors] of fillSpecs) {
+        if (value && await fillFirst(page, selectors, value))
+            filled.push(name);
+    }
+    if (candidate.workAuthorization && await selectOrFillFirst(page, [
+        'select[name="workAuthorization"]',
+        'select[name="work_authorization"]',
+        'select[name*="authorization" i]',
+    ], candidate.workAuthorization)) {
+        filled.push("workAuthorization");
+    }
+    const resumeInput = page.locator('input[type="file"][name*="resume" i], input[type="file"][name*="cv" i], input[type="file"]').first();
+    if (await resumeInput.count() === 0) {
+        throw new Error("No resume upload field found on the application form");
+    }
+    await resumeInput.setInputFiles(job.resumePath);
+    filled.push("resume");
+    return filled;
+}
+async function fillFirst(page, selectors, value) {
+    for (const selector of selectors) {
+        const locator = page.locator(selector).first();
+        if (await locator.count() === 0)
+            continue;
+        try {
+            await locator.fill(value, { timeout: 5_000 });
+            return true;
+        }
+        catch {
+            /* try next selector */
+        }
+    }
+    return false;
+}
+async function selectOrFillFirst(page, selectors, value) {
+    for (const selector of selectors) {
+        const locator = page.locator(selector).first();
+        if (await locator.count() === 0)
+            continue;
+        try {
+            await locator.selectOption({ label: value }, { timeout: 5_000 });
+            return true;
+        }
+        catch {
+            try {
+                await locator.fill(value, { timeout: 5_000 });
+                return true;
+            }
+            catch {
+                /* try next selector */
+            }
+        }
+    }
+    return false;
+}
+async function submitApplicationForm(page) {
+    const submit = page.locator('form button[type="submit"], form input[type="submit"], button:has-text("Submit"), input[type="submit"]').first();
+    if (await submit.count() > 0) {
+        await submit.click({ timeout: 10_000 });
+        return;
+    }
+    const form = page.locator("form").first();
+    if (await form.count() === 0)
+        throw new Error("No application form found to submit");
+    await form.evaluate((node) => {
+        const htmlForm = node;
+        if (typeof htmlForm.requestSubmit === "function")
+            htmlForm.requestSubmit();
+        else
+            htmlForm.submit();
+    });
+}
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function stringValue(value) {
+    return String(value || "").trim();
+}
+function optionalString(value) {
+    const text = stringValue(value);
+    return text || undefined;
+}
 function normalizeCreateTaskRequest(request) {
     if (!isRecord(request) || typeof request.type !== "string" || !request.type.trim()) {
         throw new RunnerInputError("task type required");

package/dist/index.js

@@ -2,7 +2,7 @@
 
 // src/index.ts
 import { createRequire } from "module";
-import { Command as Command5 } from "commander";
+import { Command as Command6 } from "commander";
 
 // src/commands/check.ts
 import { existsSync, readFileSync } from "fs";
@@ -363,12 +363,36 @@ jobs:
   writeLine();
 });
 
+// src/commands/mcp.ts
+import { spawn } from "child_process";
+import { Command as Command3 } from "commander";
+var DEFAULT_MCP_URL = "https://mcp.proagentstore.online/mcp";
+function buildMcpRemoteArgs(opts, extraArgs = []) {
+  return ["-y", "mcp-remote", opts.url || DEFAULT_MCP_URL, ...extraArgs];
+}
+async function runMcpProxy(opts, extraArgs = []) {
+  const child = spawn("npx", buildMcpRemoteArgs(opts, extraArgs), {
+    stdio: "inherit",
+    env: process.env
+  });
+  await new Promise((resolve5, reject) => {
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code && code !== 0) reject(new Error(`mcp proxy exited with code ${code}`));
+      else resolve5();
+    });
+  });
+}
+var mcpCommand = new Command3("mcp").description("Run a local stdio proxy for the official ProAgentStore MCP server").option("--url <url>", "Remote MCP endpoint", DEFAULT_MCP_URL).argument("[args...]", "Extra arguments passed to mcp-remote").action(async (args, opts) => {
+  await runMcpProxy(opts, args);
+});
+
 // src/commands/publish.ts
 import { execFileSync } from "child_process";
 import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
 import { join as join3, resolve as resolve3 } from "path";
-import { Command as Command3 } from "commander";
-var publishCommand = new Command3("publish").description("Publish an agent to ProAgentStore").option("-d, --dir <path>", "Agent directory", ".").action(async (opts) => {
+import { Command as Command4 } from "commander";
+var publishCommand = new Command4("publish").description("Publish an agent to ProAgentStore").option("-d, --dir <path>", "Agent directory", ".").action(async (opts) => {
   const dir = resolve3(opts.dir);
   const manifestPath = join3(dir, "agent.json");
   if (!existsSync3(manifestPath)) {
@@ -447,11 +471,11 @@ var publishCommand = new Command3("publish").description("Publish an agent to Pr
 });
 
 // src/commands/runner.ts
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 import { existsSync as existsSync4 } from "fs";
 import { resolve as resolve4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { Command as Command4 } from "commander";
+import { Command as Command5 } from "commander";
 var runnerCommand = createRunnerCommand();
 function runnerBaseUrl(url) {
   return (clean(url) || clean(process.env.PAGS_RUNNER_URL) || "http://127.0.0.1:49171").replace(/\/$/, "");
@@ -526,7 +550,7 @@ function startRunnerForeground(opts) {
     args = [bundledPackage, ...runnerArgs];
   }
   return new Promise((resolvePromise, reject) => {
-    const child = spawn(command, args, {
+    const child = spawn2(command, args, {
       cwd,
       stdio: "inherit",
       shell: process.platform === "win32"
@@ -591,7 +615,7 @@ function collectCapability(value, previous = []) {
   return [...previous, value];
 }
 function createRunnerCommand() {
-  const command = new Command4("runner").description(
+  const command = new Command5("runner").description(
     "Manage a local ProAgentStore browser runner"
   );
   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) => {
@@ -709,7 +733,7 @@ function createRunnerCommand() {
 // src/index.ts
 var require2 = createRequire(import.meta.url);
 var { version } = require2("../package.json");
-var program = new Command5();
+var program = new Command6();
 program.name("pags").description(
   "ProAgentStore CLI \u2014 create and publish server-powered AI agents"
 ).version(version);
@@ -717,6 +741,7 @@ program.addCommand(initCommand);
 program.addCommand(checkCommand);
 program.addCommand(publishCommand);
 program.addCommand(runnerCommand);
+program.addCommand(mcpCommand);
 try {
   await program.parseAsync();
 } catch (error) {

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@proagentstore/cli",
-	"version": "0.1.3",
-	"description": "CLI for creating and publishing ProAgentStore agents",
+	"version": "0.1.5",
+	"description": "CLI for creating, publishing, and running ProAgentStore agents",
 	"license": "MIT",
 	"type": "module",
 	"bin": {
@@ -18,6 +18,7 @@
 		"pags",
 		"cli",
 		"agents",
+		"mcp",
 		"browser-runner"
 	],
 	"publishConfig": {