@proagentstore/cli 0.1.7 → 0.1.9

package/dist/browser-runner/index.js

@@ -25,7 +25,7 @@ function configFromArgs() {
     };
 }
 if (flag("--help") || flag("-h")) {
-    process.stdout.write(`ProAgentStore browser runner
+    process.stdout.write(`FreeAgentStore browser runtime for ProAgentStore
 
 Usage:
   pags-browser-runner [--host 127.0.0.1] [--port 49171] [--data-dir path] [--token token] [--instance-id id] [--headless]
@@ -44,9 +44,9 @@ Endpoints:
 }
 const config = configFromArgs();
 const started = await startRunnerServer(config);
-process.stdout.write(`PAGS browser runner listening at ${started.url}\n`);
+process.stdout.write(`FAGS browser runtime listening at ${started.url}\n`);
 process.stdout.write(`Data dir: ${config.dataDir}\n`);
-process.stdout.write(`Brain placement: PAGS; runner role: tool-executor\n`);
+process.stdout.write("Control plane: PAGS; runtime plane: FAGS; brain placement: PAGS; runner role: tool-executor\n");
 if (config.token)
     process.stdout.write("Auth: bearer token required\n");
 if (config.instanceId)

package/dist/browser-runner/runner.js

@@ -11,7 +11,7 @@ const CAPABILITIES = [
     "file.upload",
     "human.approval",
 ];
-const APPROVAL_REQUIRED_TASKS = new Set(["browser.open", "job.apply_basic"]);
+const APPROVAL_REQUIRED_TASKS = new Set(["browser.open", "job.apply_basic", "job.apply_authenticated"]);
 const require = createRequire(import.meta.url);
 export class RunnerInputError extends Error {
     status = 400;
@@ -28,11 +28,13 @@ export class LocalRunner {
     }
     capabilities() {
         return {
-            runtime: "local-browser-runner",
+            runtime: "fags-browser-runtime",
             brainPlacement: "pags",
+            controlPlane: "pags",
+            runtimePlane: "fags",
             runnerRole: "tool-executor",
             capabilities: CAPABILITIES,
-            taskTypes: ["echo", "browser.open", "job.apply_basic"],
+            taskTypes: ["echo", "browser.open", "job.apply_basic", "job.apply_authenticated"],
             approvalRequiredFor: [...APPROVAL_REQUIRED_TASKS],
         };
     }
@@ -55,11 +57,8 @@ export class LocalRunner {
             updatedAt: now,
         };
         this.store.putTask(task);
-        this.store.addEvent({
-            taskId: task.id,
-            type: "task.created",
-            message: `Task created: ${task.type}`,
-            data: { status: task.status },
+        this.addTaskEvent(task, "task.created", `Task created: ${task.type}`, {
+            status: task.status,
         });
         if (task.status === "queued")
             void this.runTask(task.id);
@@ -77,11 +76,7 @@ export class LocalRunner {
             approvedAt: task.updatedAt,
         };
         this.store.putTask(task);
-        this.store.addEvent({
-            taskId: task.id,
-            type: "task.approved",
-            message: `Task approved: ${task.type}`,
-        });
+        this.addTaskEvent(task, "task.approved", `Task approved: ${task.type}`);
         await this.runTask(task.id);
         return this.requireTask(id);
     }
@@ -93,11 +88,7 @@ export class LocalRunner {
         task.updatedAt = new Date().toISOString();
         task.completedAt = task.updatedAt;
         this.store.putTask(task);
-        this.store.addEvent({
-            taskId: task.id,
-            type: "task.cancelled",
-            message: `Task cancelled: ${task.type}`,
-        });
+        this.addTaskEvent(task, "task.cancelled", `Task cancelled: ${task.type}`);
         return task;
     }
     async close() {
@@ -111,11 +102,7 @@ export class LocalRunner {
         task.status = "running";
         task.updatedAt = new Date().toISOString();
         this.store.putTask(task);
-        this.store.addEvent({
-            taskId: task.id,
-            type: "task.running",
-            message: `Task running: ${task.type}`,
-        });
+        this.addTaskEvent(task, "task.running", `Task running: ${task.type}`);
         try {
             const output = await this.execute(task);
             task.status = "completed";
@@ -123,12 +110,7 @@ export class LocalRunner {
             task.updatedAt = new Date().toISOString();
             task.completedAt = task.updatedAt;
             this.store.putTask(task);
-            this.store.addEvent({
-                taskId: task.id,
-                type: "task.completed",
-                message: `Task completed: ${task.type}`,
-                data: output,
-            });
+            this.addTaskEvent(task, "task.completed", `Task completed: ${task.type}`, output);
         }
         catch (error) {
             task.status = "failed";
@@ -136,13 +118,17 @@ export class LocalRunner {
             task.updatedAt = new Date().toISOString();
             task.completedAt = task.updatedAt;
             this.store.putTask(task);
-            this.store.addEvent({
-                taskId: task.id,
-                type: "task.failed",
-                message: task.error,
-            });
+            this.addTaskEvent(task, "task.failed", task.error);
         }
     }
+    addTaskEvent(task, type, message, data) {
+        this.store.addEvent({
+            taskId: task.id,
+            type,
+            message,
+            data,
+        });
+    }
     async execute(task) {
         if (task.type === "echo") {
             return task.input;
@@ -154,32 +140,59 @@ export class LocalRunner {
             }
             const context = await this.getBrowserContext();
             const page = context.pages()[0] || (await context.newPage());
+            this.addTaskEvent(task, "browser.goto.started", "Opening browser page", { url });
             await page.goto(url, { waitUntil: "domcontentloaded", timeout: 30_000 });
-            return {
+            const output = {
                 url: page.url(),
                 title: await page.title(),
             };
+            this.addTaskEvent(task, "browser.goto.completed", "Browser page loaded", output);
+            return output;
         }
         if (task.type === "job.apply_basic") {
-            return this.applyToBasicJob(task.input);
+            return this.applyToBasicJob(task);
+        }
+        if (task.type === "job.apply_authenticated") {
+            return this.applyToAuthenticatedJob(task);
         }
         throw new Error(`Unknown task type: ${task.type}`);
     }
-    async applyToBasicJob(input) {
-        const job = normalizeJobApplicationInput(input);
+    async applyToBasicJob(task) {
+        const job = normalizeJobApplicationInput(task.input);
         const context = await this.getBrowserContext();
         const page = context.pages()[0] || (await context.newPage());
+        this.addTaskEvent(task, "browser.goto.started", "Opening job application page", {
+            url: job.url,
+        });
         await page.goto(job.url, { waitUntil: "domcontentloaded", timeout: 30_000 });
+        this.addTaskEvent(task, "browser.goto.completed", "Job application page loaded", {
+            url: page.url(),
+            title: await page.title(),
+        });
+        this.addTaskEvent(task, "job.form.fill.started", "Filling application form", {
+            candidate: {
+                fullName: job.candidate.fullName,
+                email: job.candidate.email,
+            },
+            resumeFile: basename(job.resumePath),
+        });
         const filledFields = await fillBasicApplicationForm(page, job);
+        this.addTaskEvent(task, "job.form.filled", "Application form fields completed", {
+            fieldsFilled: filledFields,
+            resumeFile: basename(job.resumePath),
+        });
         const beforeSubmitUrl = page.url();
         const navigation = page.waitForNavigation({
             waitUntil: "domcontentloaded",
             timeout: 15_000,
         }).catch(() => null);
+        this.addTaskEvent(task, "job.form.submit.started", "Submitting application form", {
+            url: beforeSubmitUrl,
+        });
         await submitApplicationForm(page);
         await navigation;
         await page.waitForLoadState("domcontentloaded", { timeout: 5_000 }).catch(() => undefined);
-        return {
+        const output = {
             taskType: "job.apply_basic",
             submitted: true,
             beforeSubmitUrl,
@@ -189,6 +202,114 @@ export class LocalRunner {
             resumeFile: basename(job.resumePath),
             visibleText: (await page.locator("body").innerText({ timeout: 5_000 }).catch(() => "")).slice(0, 2_000),
         };
+        this.addTaskEvent(task, "job.form.submit.completed", "Application submission completed", output);
+        return output;
+    }
+    /**
+     * Apply to a job that requires login/registration first.
+     * Flow: navigate → detect login requirement → register or login → fill form → submit
+     */
+    async applyToAuthenticatedJob(task) {
+        const input = normalizeAuthenticatedJobInput(task.input);
+        const context = await this.getBrowserContext();
+        const page = context.pages()[0] || (await context.newPage());
+        // Step 1: Navigate to job page
+        this.addTaskEvent(task, "browser.goto.started", "Opening job page", { url: input.url });
+        await page.goto(input.url, { waitUntil: "domcontentloaded", timeout: 30_000 });
+        this.addTaskEvent(task, "browser.goto.completed", "Job page loaded", {
+            url: page.url(),
+            title: await page.title(),
+        });
+        // Step 2: Check if we need to authenticate
+        const needsAuth = await detectAuthRequirement(page);
+        if (needsAuth) {
+            this.addTaskEvent(task, "job.auth.required", "Authentication required", {
+                loginDetected: true,
+            });
+            // Navigate to login page
+            const loginUrl = input.loginUrl || await findLoginUrl(page, input.url);
+            if (!loginUrl)
+                throw new Error("Login required but no login URL found");
+            await page.goto(loginUrl, { waitUntil: "domcontentloaded", timeout: 30_000 });
+            if (input.registration && !input.accountExists) {
+                // Register first
+                this.addTaskEvent(task, "job.auth.register.started", "Registering new account");
+                const registerUrl = await findRegisterUrl(page, loginUrl);
+                if (registerUrl && registerUrl !== loginUrl) {
+                    await page.goto(registerUrl, { waitUntil: "domcontentloaded", timeout: 30_000 });
+                }
+                await fillRegistrationForm(page, input.registration);
+                await submitForm(page);
+                await page.waitForLoadState("domcontentloaded", { timeout: 10_000 }).catch(() => undefined);
+                this.addTaskEvent(task, "job.auth.register.completed", "Registration submitted", {
+                    url: page.url(),
+                });
+            }
+            else if (input.credentials) {
+                // Login with existing credentials
+                this.addTaskEvent(task, "job.auth.login.started", "Logging in");
+                await fillLoginForm(page, input.credentials);
+                await submitForm(page);
+                await page.waitForLoadState("domcontentloaded", { timeout: 10_000 }).catch(() => undefined);
+                this.addTaskEvent(task, "job.auth.login.completed", "Login submitted", {
+                    url: page.url(),
+                });
+            }
+            else {
+                throw new Error("Login required but no credentials or registration details provided");
+            }
+            // Verify we're logged in (check for common indicators)
+            const stillNeedsAuth = await detectAuthRequirement(page);
+            if (stillNeedsAuth) {
+                // Try navigating back to the apply page — some sites redirect after login
+                const applyUrl = input.url.includes("/apply") ? input.url : `${input.url}`;
+                await page.goto(applyUrl, { waitUntil: "domcontentloaded", timeout: 30_000 });
+                const thirdCheck = await detectAuthRequirement(page);
+                if (thirdCheck) {
+                    throw new Error("Authentication failed — still seeing login/register prompts after login attempt");
+                }
+            }
+            // Navigate to apply page (may have been redirected after login)
+            if (!page.url().includes("apply")) {
+                await page.goto(input.url, { waitUntil: "domcontentloaded", timeout: 30_000 });
+            }
+        }
+        // Step 3: Look for the apply form (might be on current page or linked)
+        const applyLink = await page.locator('a[href*="apply"], a:has-text("Apply")').first();
+        if (await applyLink.count() > 0) {
+            await applyLink.click();
+            await page.waitForLoadState("domcontentloaded", { timeout: 10_000 }).catch(() => undefined);
+        }
+        // Step 4: Fill the application form
+        this.addTaskEvent(task, "job.form.fill.started", "Filling application form");
+        const filledFields = await fillBasicApplicationForm(page, input);
+        this.addTaskEvent(task, "job.form.filled", "Form fields completed", {
+            fieldsFilled: filledFields,
+            resumeFile: basename(input.resumePath),
+        });
+        // Step 5: Submit
+        const beforeSubmitUrl = page.url();
+        const navigation = page.waitForNavigation({
+            waitUntil: "domcontentloaded",
+            timeout: 15_000,
+        }).catch(() => null);
+        this.addTaskEvent(task, "job.form.submit.started", "Submitting application");
+        await submitApplicationForm(page);
+        await navigation;
+        await page.waitForLoadState("domcontentloaded", { timeout: 5_000 }).catch(() => undefined);
+        const output = {
+            taskType: "job.apply_authenticated",
+            submitted: true,
+            authenticated: needsAuth,
+            beforeSubmitUrl,
+            finalUrl: page.url(),
+            title: await page.title(),
+            fieldsFilled: filledFields,
+            resumeFile: basename(input.resumePath),
+            visibleText: (await page.locator("body").innerText({ timeout: 5_000 }).catch(() => "")).slice(0, 2_000),
+        };
+        this.addTaskEvent(task, "job.form.submit.completed", "Application submitted", output);
+        return output;
     }
     requireTask(id) {
         const task = this.store.getTask(id);
@@ -404,3 +525,99 @@ function normalizeCreateTaskRequest(request) {
 export function fileUrl(path) {
     return pathToFileURL(path).toString();
 }
+// ── Authenticated job application helpers ─────────────────────────────────
+export function normalizeAuthenticatedJobInput(input) {
+    const base = normalizeJobApplicationInput(input);
+    const credentials = isRecord(input.credentials) ? input.credentials : undefined;
+    const registration = isRecord(input.registration) ? input.registration : undefined;
+    return {
+        ...base,
+        credentials: credentials ? {
+            email: stringValue(credentials.email),
+            password: stringValue(credentials.password),
+        } : undefined,
+        loginUrl: optionalString(input.loginUrl),
+        accountExists: input.accountExists === true,
+        registration: registration ? {
+            fullName: stringValue(registration.fullName),
+            email: stringValue(registration.email),
+            password: stringValue(registration.password),
+        } : undefined,
+    };
+}
+async function detectAuthRequirement(page) {
+    const body = await page.locator("body").innerHTML({ timeout: 5_000 }).catch(() => "");
+    const lower = body.toLowerCase();
+    // Check for login/register prompts
+    const hasLoginForm = await page.locator('input[type="password"], form[action*="login"], form[action*="signin"]').count() > 0;
+    const hasLoginText = /sign\s*in|log\s*in|create\s*(an\s*)?account|register\s*to\s*apply/i.test(lower);
+    const hasLoginLink = await page.locator('a[href*="login"], a[href*="signin"], a[href*="register"]').count() > 0;
+    return hasLoginForm || (hasLoginText && hasLoginLink);
+}
+async function findLoginUrl(page, baseUrl) {
+    const loginLink = page.locator('a[href*="login"], a[href*="signin"], a:has-text("Sign in"), a:has-text("Log in")').first();
+    if (await loginLink.count() > 0) {
+        const href = await loginLink.getAttribute("href");
+        if (href)
+            return new URL(href, baseUrl).toString();
+    }
+    return null;
+}
+async function findRegisterUrl(page, baseUrl) {
+    const regLink = page.locator('a[href*="register"], a[href*="signup"], a:has-text("Create account"), a:has-text("Sign up")').first();
+    if (await regLink.count() > 0) {
+        const href = await regLink.getAttribute("href");
+        if (href)
+            return new URL(href, baseUrl).toString();
+    }
+    return null;
+}
+async function fillLoginForm(page, credentials) {
+    await fillFirst(page, [
+        'input[name="email"]',
+        'input[type="email"]',
+        'input[autocomplete="email"]',
+        'input[autocomplete="username"]',
+        'input[name="username"]',
+    ], credentials.email);
+    await fillFirst(page, [
+        'input[name="password"]',
+        'input[type="password"]',
+        'input[autocomplete="current-password"]',
+    ], credentials.password);
+}
+async function fillRegistrationForm(page, registration) {
+    await fillFirst(page, [
+        'input[name="fullName"]',
+        'input[name="full_name"]',
+        'input[name="name"]',
+        'input[autocomplete="name"]',
+    ], registration.fullName);
+    await fillFirst(page, [
+        'input[name="email"]',
+        'input[type="email"]',
+        'input[autocomplete="email"]',
+    ], registration.email);
+    await fillFirst(page, [
+        'input[name="password"]',
+        'input[type="password"]',
+        'input[autocomplete="new-password"]',
+    ], registration.password);
+}
+async function submitForm(page) {
+    const submit = page.locator('button[type="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) {
+        await form.evaluate((node) => {
+            const f = node;
+            if (typeof f.requestSubmit === "function")
+                f.requestSubmit();
+            else
+                f.submit();
+        });
+    }
+}

package/dist/browser-runner/server.js

@@ -42,8 +42,10 @@ async function route(runner, req, res) {
     if (req.method === "GET" && path === "/health") {
         return json(res, 200, {
             ok: true,
-            service: "proagentstore-browser-runner",
+            service: "freeagentstore-browser-runtime",
             brainPlacement: "pags",
+            controlPlane: "pags",
+            runtimePlane: "fags",
             instanceId: runner.config.instanceId,
         });
     }

package/dist/browser-runner/test-job-server-auth-cli.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+import { startTestJobServerAuth } from "./test-job-server-auth.js";
+function arg(name, fallback) {
+    const index = process.argv.indexOf(name);
+    if (index === -1)
+        return fallback;
+    return process.argv[index + 1] || fallback;
+}
+function flag(name) {
+    return process.argv.includes(name);
+}
+if (flag("--help") || flag("-h")) {
+    process.stdout.write(`ProAgentStore test job server (with auth)
+
+Usage:
+  pags-test-job-server-auth [--port 49211]
+
+Routes:
+  GET  /register              Registration form
+  POST /register              Create account
+  GET  /login                 Login form
+  POST /login                 Sign in
+  POST /logout                Sign out
+  GET  /jobs/software-engineer  Job posting (public)
+  GET  /apply                 Application form (requires auth)
+  POST /apply                 Submit application (requires auth)
+  GET  /dashboard             User's applications (requires auth)
+  GET  /success/:id           Submission confirmation (requires auth)
+  GET  /submissions           All submissions (JSON, no auth)
+`);
+    process.exit(0);
+}
+const port = Number(arg("--port", process.env.PAGS_TEST_JOB_AUTH_PORT || "49211"));
+const server = await startTestJobServerAuth(port);
+process.stdout.write(`PAGS test job server (auth) listening at ${server.url}\n`);
+process.stdout.write(`Job URL: ${server.jobUrl}\n`);
+process.stdout.write(`Register: ${server.registerUrl}\n`);
+process.stdout.write(`Login: ${server.loginUrl}\n`);
+const shutdown = async () => {
+    await server.close();
+    process.exit(0);
+};
+process.on("SIGINT", () => void shutdown());
+process.on("SIGTERM", () => void shutdown());