@proagentstore/cli 0.1.4 → 0.1.6

package/dist/browser-runner/index.js

@@ -33,6 +33,7 @@ Usage:
 Endpoints:
   GET  /health
   GET  /capabilities
+  GET  /tasks
   POST /tasks
   GET  /tasks/:id
   POST /tasks/:id/approve

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/package.json

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