@proagentstore/cli 0.1.8 → 0.1.10

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;
@@ -34,7 +34,7 @@ export class LocalRunner {
             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],
         };
     }
@@ -57,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);
@@ -79,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);
     }
@@ -95,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() {
@@ -113,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";
@@ -125,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";
@@ -138,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;
@@ -156,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,
@@ -191,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);
@@ -406,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/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());

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

@@ -0,0 +1,450 @@
+import { createServer, } from "node:http";
+export async function startTestJobServerAuth(port = 0) {
+    const submissions = [];
+    const users = [];
+    const sessions = new Map();
+    const server = createServer(async (req, res) => {
+        try {
+            await route(req, res, { submissions, users, sessions });
+        }
+        catch (error) {
+            html(res, 500, page("Error", `<main><h1>Server Error</h1><pre>${escapeHtml(String(error))}</pre></main>`));
+        }
+    });
+    await new Promise((resolve) => {
+        server.listen(port, "127.0.0.1", resolve);
+    });
+    const address = server.address();
+    const url = `http://127.0.0.1:${address.port}`;
+    return {
+        url,
+        jobUrl: `${url}/jobs/software-engineer`,
+        loginUrl: `${url}/login`,
+        registerUrl: `${url}/register`,
+        submissions,
+        users,
+        sessions,
+        async close() {
+            await new Promise((resolve, reject) => {
+                server.close((error) => (error ? reject(error) : resolve()));
+            });
+        },
+    };
+}
+async function route(req, res, state) {
+    const url = new URL(req.url || "/", "http://127.0.0.1");
+    const sessionId = parseCookie(req.headers.cookie || "", "session");
+    const userId = sessionId ? state.sessions.get(sessionId) : undefined;
+    const user = userId ? state.users.find((u) => u.id === userId) : undefined;
+    if (req.method === "GET" && url.pathname === "/") {
+        redirect(res, "/jobs/software-engineer");
+        return;
+    }
+    if (req.method === "GET" && url.pathname === "/register") {
+        const error = url.searchParams.get("error") || "";
+        html(res, 200, registerPage(error));
+        return;
+    }
+    if (req.method === "POST" && url.pathname === "/register") {
+        const body = await parseFormBody(req);
+        const email = body.email?.trim().toLowerCase();
+        const password = body.password?.trim();
+        const fullName = body.fullName?.trim();
+        if (!email || !password || !fullName) {
+            redirect(res, "/register?error=All+fields+are+required");
+            return;
+        }
+        if (password.length < 6) {
+            redirect(res, "/register?error=Password+must+be+at+least+6+characters");
+            return;
+        }
+        if (state.users.some((u) => u.email === email)) {
+            redirect(res, "/register?error=Email+already+registered");
+            return;
+        }
+        const newUser = {
+            id: `user_${crypto.randomUUID()}`,
+            email,
+            password,
+            fullName,
+            createdAt: new Date().toISOString(),
+        };
+        state.users.push(newUser);
+        const newSessionId = `sess_${crypto.randomUUID()}`;
+        state.sessions.set(newSessionId, newUser.id);
+        setSessionCookie(res, newSessionId);
+        redirect(res, "/dashboard");
+        return;
+    }
+    if (req.method === "GET" && url.pathname === "/login") {
+        if (user) {
+            redirect(res, "/dashboard");
+            return;
+        }
+        const error = url.searchParams.get("error") || "";
+        const next = url.searchParams.get("next") || "";
+        html(res, 200, loginPage(error, next));
+        return;
+    }
+    if (req.method === "POST" && url.pathname === "/login") {
+        const body = await parseFormBody(req);
+        const email = body.email?.trim().toLowerCase();
+        const password = body.password?.trim();
+        const next = body.next?.trim() || "/dashboard";
+        if (!email || !password) {
+            redirect(res, `/login?error=Email+and+password+required&next=${encodeURIComponent(next)}`);
+            return;
+        }
+        const found = state.users.find((u) => u.email === email && u.password === password);
+        if (!found) {
+            redirect(res, `/login?error=Invalid+email+or+password&next=${encodeURIComponent(next)}`);
+            return;
+        }
+        const newSessionId = `sess_${crypto.randomUUID()}`;
+        state.sessions.set(newSessionId, found.id);
+        setSessionCookie(res, newSessionId);
+        redirect(res, next);
+        return;
+    }
+    if (req.method === "POST" && url.pathname === "/logout") {
+        if (sessionId)
+            state.sessions.delete(sessionId);
+        clearSessionCookie(res);
+        redirect(res, "/login");
+        return;
+    }
+    if (req.method === "GET" && url.pathname === "/jobs/software-engineer") {
+        html(res, 200, jobPage(user));
+        return;
+    }
+    if (req.method === "GET" && url.pathname === "/apply") {
+        if (!user) {
+            redirect(res, "/login?next=/apply");
+            return;
+        }
+        html(res, 200, applyPage(user));
+        return;
+    }
+    if (req.method === "POST" && url.pathname === "/apply") {
+        if (!user) {
+            redirect(res, "/login?next=/apply");
+            return;
+        }
+        const submission = await parseApplication(req, user.id);
+        state.submissions.unshift(submission);
+        redirect(res, `/success/${submission.id}`);
+        return;
+    }
+    if (req.method === "GET" && url.pathname === "/dashboard") {
+        if (!user) {
+            redirect(res, "/login?next=/dashboard");
+            return;
+        }
+        const userSubmissions = state.submissions.filter((s) => s.userId === user.id);
+        html(res, 200, dashboardPage(user, userSubmissions));
+        return;
+    }
+    if (req.method === "GET" && url.pathname.startsWith("/success/")) {
+        if (!user) {
+            redirect(res, "/login");
+            return;
+        }
+        const id = url.pathname.split("/").pop() || "";
+        const submission = state.submissions.find((row) => row.id === id && row.userId === user.id);
+        if (!submission) {
+            html(res, 404, page("Not Found", "<main><h1>Application not found</h1></main>"));
+            return;
+        }
+        html(res, 200, successPage(submission));
+        return;
+    }
+    if (req.method === "GET" && url.pathname === "/submissions") {
+        json(res, 200, { submissions: state.submissions });
+        return;
+    }
+    html(res, 404, page("Not Found", "<main><h1>Not found</h1></main>"));
+}
+function registerPage(error) {
+    return page("Create Account", `
+    <main>
+      <section class="auth-card">
+        <h1>Create Account</h1>
+        <p class="subtitle">Join Fixture Labs to apply for positions</p>
+        ${error ? `<p class="error">${escapeHtml(error)}</p>` : ""}
+        <form action="/register" method="post" class="auth-form">
+          <label>Full name <input name="fullName" autocomplete="name" required /></label>
+          <label>Email <input name="email" type="email" autocomplete="email" required /></label>
+          <label>Password <input name="password" type="password" autocomplete="new-password" minlength="6" required /></label>
+          <button type="submit">Create account</button>
+        </form>
+        <p class="switch">Already have an account? <a href="/login">Sign in</a></p>
+      </section>
+    </main>
+  `);
+}
+function loginPage(error, next) {
+    return page("Sign In", `
+    <main>
+      <section class="auth-card">
+        <h1>Sign In</h1>
+        <p class="subtitle">Sign in to continue your application</p>
+        ${error ? `<p class="error">${escapeHtml(error)}</p>` : ""}
+        <form action="/login" method="post" class="auth-form">
+          <input type="hidden" name="next" value="${escapeHtml(next || "/dashboard")}" />
+          <label>Email <input name="email" type="email" autocomplete="email" required /></label>
+          <label>Password <input name="password" type="password" autocomplete="current-password" required /></label>
+          <button type="submit">Sign in</button>
+        </form>
+        <p class="switch">Don't have an account? <a href="/register">Create one</a></p>
+      </section>
+    </main>
+  `);
+}
+function jobPage(user) {
+    const nav = user
+        ? `<nav><span>Signed in as ${escapeHtml(user.fullName)}</span> <a href="/dashboard">Dashboard</a></nav>`
+        : `<nav><a href="/login">Sign in</a> <a href="/register">Create account</a></nav>`;
+    return page("Senior Software Engineer", `
+    ${nav}
+    <main>
+      <section class="job">
+        <p class="eyebrow">PAGS Test Fixture</p>
+        <h1>Senior Software Engineer</h1>
+        <p class="company">Fixture Labs</p>
+        <p>Build workflow tools for safe browser agents. This role values TypeScript, automation, product judgment, and careful user approval flows.</p>
+        <h2>Requirements</h2>
+        <ul>
+          <li>5+ years TypeScript/JavaScript experience</li>
+          <li>Experience with browser automation (Playwright, Puppeteer)</li>
+          <li>Strong product sense and attention to UX details</li>
+          <li>Comfortable with distributed systems and Workers</li>
+        </ul>
+        <h2>Benefits</h2>
+        <ul>
+          <li>Fully remote</li>
+          <li>Competitive compensation</li>
+          <li>Health, dental, vision</li>
+        </ul>
+        <a href="/apply" class="apply-button">Apply for this position</a>
+      </section>
+    </main>
+  `);
+}
+function applyPage(user) {
+    return page("Apply - Senior Software Engineer", `
+    <nav><span>Signed in as ${escapeHtml(user.fullName)}</span> <a href="/dashboard">Dashboard</a></nav>
+    <main>
+      <section class="job-header">
+        <p class="eyebrow">Applying for</p>
+        <h1>Senior Software Engineer</h1>
+        <p class="company">Fixture Labs</p>
+      </section>
+      <form action="/apply" method="post" enctype="multipart/form-data" class="application-form">
+        <label>Full name <input name="fullName" autocomplete="name" value="${escapeHtml(user.fullName)}" required /></label>
+        <label>Email <input name="email" type="email" autocomplete="email" value="${escapeHtml(user.email)}" required /></label>
+        <label>Phone <input name="phone" autocomplete="tel" /></label>
+        <label>Location <input name="location" autocomplete="address-level2" /></label>
+        <label>LinkedIn <input name="linkedin" type="url" /></label>
+        <label>Portfolio <input name="portfolio" type="url" /></label>
+        <label>Work authorization
+          <select name="workAuthorization" required>
+            <option value="">Select one</option>
+            <option>Authorized to work in the United States</option>
+            <option>Require sponsorship</option>
+          </select>
+        </label>
+        <label>Resume <input name="resume" type="file" accept=".pdf,.txt,.doc,.docx" required /></label>
+        <label>Cover note <textarea name="coverNote" rows="5" required></textarea></label>
+        <button type="submit">Submit application</button>
+      </form>
+    </main>
+  `);
+}
+function dashboardPage(user, submissions) {
+    const rows = submissions.length
+        ? submissions.map((s) => `
+        <tr>
+          <td>${escapeHtml(s.id)}</td>
+          <td>Senior Software Engineer</td>
+          <td>${escapeHtml(s.createdAt.split("T")[0])}</td>
+          <td><a href="/success/${escapeHtml(s.id)}">View</a></td>
+        </tr>
+      `).join("")
+        : `<tr><td colspan="4" class="empty">No applications yet. <a href="/jobs/software-engineer">Browse jobs</a></td></tr>`;
+    return page("Dashboard", `
+    <nav><span>Signed in as ${escapeHtml(user.fullName)}</span>
+      <form action="/logout" method="post" style="display:inline"><button type="submit" class="link-button">Sign out</button></form>
+    </nav>
+    <main>
+      <section class="dashboard">
+        <h1>My Applications</h1>
+        <table>
+          <thead><tr><th>ID</th><th>Position</th><th>Date</th><th></th></tr></thead>
+          <tbody>${rows}</tbody>
+        </table>
+      </section>
+    </main>
+  `);
+}
+function successPage(submission) {
+    return page("Application Received", `
+    <main>
+      <section class="success">
+        <p class="eyebrow">Success</p>
+        <h1>Application received</h1>
+        <p id="application-id">${escapeHtml(submission.id)}</p>
+        <p>Thank you, ${escapeHtml(submission.fields.fullName || "candidate")}.</p>
+        <p>Resume: ${escapeHtml(submission.resume?.filename || "missing")} (${submission.resume?.size || 0} bytes)</p>
+        <a href="/dashboard">Back to dashboard</a>
+      </section>
+    </main>
+  `);
+}
+function page(title, body) {
+    return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>${escapeHtml(title)}</title>
+  <style>
+    body { margin: 0; font-family: system-ui, sans-serif; background: #f6f8fb; color: #16202a; }
+    main { width: min(880px, calc(100% - 32px)); margin: 40px auto; }
+    nav { display: flex; align-items: center; gap: 16px; padding: 12px 24px; background: white; border-bottom: 1px solid #d7dee8; }
+    nav span { font-weight: 600; margin-right: auto; }
+    nav a, .switch a { color: #4f46e5; text-decoration: none; font-weight: 600; }
+    .job, .success, .auth-card, .dashboard, .job-header, form.application-form { background: white; border: 1px solid #d7dee8; border-radius: 8px; padding: 24px; margin-bottom: 16px; }
+    .auth-card { max-width: 400px; margin: 60px auto; }
+    .auth-form, .application-form { display: grid; gap: 16px; margin-top: 16px; }
+    label { display: grid; gap: 6px; font-weight: 650; }
+    input, select, textarea { box-sizing: border-box; width: 100%; padding: 10px 12px; border: 1px solid #aab6c4; border-radius: 6px; font: inherit; }
+    button[type="submit"] { width: fit-content; padding: 10px 16px; border: 0; border-radius: 6px; background: #166534; color: white; font-weight: 700; cursor: pointer; }
+    .link-button { background: none; border: none; color: #4f46e5; font-weight: 600; cursor: pointer; font: inherit; padding: 0; }
+    .apply-button { display: inline-block; margin-top: 20px; padding: 12px 20px; background: #166534; color: white; border-radius: 6px; text-decoration: none; font-weight: 700; }
+    .eyebrow { color: #4f46e5; font-weight: 800; text-transform: uppercase; letter-spacing: .06em; }
+    .company { font-weight: 700; }
+    .subtitle { color: #566778; }
+    .switch { text-align: center; color: #566778; margin-top: 16px; }
+    .error { color: #dc2626; background: #fef2f2; border: 1px solid #fecaca; border-radius: 6px; padding: 10px 14px; font-weight: 600; }
+    table { width: 100%; border-collapse: collapse; margin-top: 16px; }
+    th, td { text-align: left; padding: 10px 12px; border-bottom: 1px solid #e5e9f0; }
+    th { font-weight: 700; color: #566778; text-transform: uppercase; font-size: 0.8em; letter-spacing: .04em; }
+    .empty { text-align: center; color: #566778; padding: 32px; }
+    ul { padding-left: 20px; line-height: 1.8; }
+  </style>
+</head>
+<body>${body}</body>
+</html>`;
+}
+async function parseApplication(req, userId) {
+    const contentType = req.headers["content-type"] || "";
+    if (!contentType.includes("multipart/form-data")) {
+        throw new Error("Expected multipart/form-data");
+    }
+    const boundary = contentType.match(/boundary=([^;]+)/)?.[1];
+    if (!boundary)
+        throw new Error("Missing multipart boundary");
+    const raw = await readBody(req);
+    const parsed = parseMultipart(raw, boundary);
+    return {
+        id: `fixture_app_${crypto.randomUUID()}`,
+        userId,
+        fields: parsed.fields,
+        resume: parsed.files.resume,
+        createdAt: new Date().toISOString(),
+    };
+}
+function parseMultipart(raw, boundary) {
+    const fields = {};
+    const files = {};
+    const delimiter = Buffer.from(`--${boundary}`);
+    let offset = 0;
+    while (offset < raw.length) {
+        const start = raw.indexOf(delimiter, offset);
+        if (start === -1)
+            break;
+        const partStart = start + delimiter.length;
+        if (raw.subarray(partStart, partStart + 2).toString() === "--")
+            break;
+        const headerStart = raw.subarray(partStart, partStart + 2).toString() === "\r\n"
+            ? partStart + 2
+            : partStart;
+        const headerEnd = raw.indexOf(Buffer.from("\r\n\r\n"), headerStart);
+        if (headerEnd === -1)
+            break;
+        const next = raw.indexOf(delimiter, headerEnd + 4);
+        if (next === -1)
+            break;
+        const headers = raw.subarray(headerStart, headerEnd).toString("utf-8");
+        const body = trimPartBody(raw.subarray(headerEnd + 4, next));
+        const name = headers.match(/name="([^"]+)"/)?.[1];
+        const filename = headers.match(/filename="([^"]*)"/)?.[1];
+        const ct = headers.match(/Content-Type:\s*([^\r\n]+)/i)?.[1] || "application/octet-stream";
+        if (name && filename) {
+            files[name] = { filename, contentType: ct, size: body.length };
+        }
+        else if (name) {
+            fields[name] = body.toString("utf-8");
+        }
+        offset = next;
+    }
+    return { fields, files };
+}
+function trimPartBody(value) {
+    if (value.subarray(-2).toString() === "\r\n")
+        return value.subarray(0, -2);
+    return value;
+}
+async function parseFormBody(req) {
+    const raw = await readBody(req);
+    const params = new URLSearchParams(raw.toString("utf-8"));
+    const result = {};
+    for (const [key, value] of params.entries())
+        result[key] = value;
+    return result;
+}
+async function readBody(req) {
+    const chunks = [];
+    for await (const chunk of req)
+        chunks.push(Buffer.from(chunk));
+    return Buffer.concat(chunks);
+}
+function parseCookie(header, name) {
+    const match = header.match(new RegExp(`(?:^|;\\s*)${name}=([^;]+)`));
+    return match ? match[1] : undefined;
+}
+function setSessionCookie(res, sessionId) {
+    res.setHeader("Set-Cookie", `session=${sessionId}; Path=/; HttpOnly; SameSite=Lax`);
+}
+function clearSessionCookie(res) {
+    res.setHeader("Set-Cookie", "session=; Path=/; HttpOnly; SameSite=Lax; Max-Age=0");
+}
+function redirect(res, location) {
+    res.writeHead(303, { Location: location });
+    res.end();
+}
+function html(res, status, body) {
+    res.writeHead(status, {
+        "Content-Type": "text/html; charset=utf-8",
+        "X-Content-Type-Options": "nosniff",
+    });
+    res.end(body);
+}
+function json(res, status, body) {
+    res.writeHead(status, {
+        "Content-Type": "application/json; charset=utf-8",
+        "X-Content-Type-Options": "nosniff",
+    });
+    res.end(JSON.stringify(body));
+}
+function escapeHtml(value) {
+    return value.replace(/[&<>"']/g, (char) => {
+        switch (char) {
+            case "&": return "&amp;";
+            case "<": return "&lt;";
+            case ">": return "&gt;";
+            case '"': return "&quot;";
+            default: return "&#39;";
+        }
+    });
+}

package/dist/index.js

@@ -1,8 +1,14 @@
 #!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 
 // src/index.ts
 import { createRequire } from "module";
-import { Command as Command6 } from "commander";
+import { Command as Command8 } from "commander";
 
 // src/commands/check.ts
 import { existsSync, readFileSync } from "fs";
@@ -363,9 +369,143 @@ jobs:
   writeLine();
 });
 
+// src/commands/login.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { createServer } from "http";
+import { homedir } from "os";
+import { join as join3 } from "path";
+import { Command as Command3 } from "commander";
+var CONFIG_DIR = join3(homedir(), ".config", "proagentstore");
+var TOKEN_FILE = join3(CONFIG_DIR, "session.json");
+var API_BASE = "https://api.proagentstore.online";
+var FAS_API = "https://api.freeappstore.online";
+function loadSession() {
+  try {
+    if (!existsSync3(TOKEN_FILE)) return null;
+    const data = JSON.parse(readFileSync2(TOKEN_FILE, "utf-8"));
+    if (data.expiresAt < Date.now()) {
+      writeLine("Session expired. Run: pags login");
+      return null;
+    }
+    return data;
+  } catch {
+    return null;
+  }
+}
+function saveSession(session) {
+  mkdirSync2(CONFIG_DIR, { recursive: true });
+  writeFileSync2(TOKEN_FILE, JSON.stringify(session, null, 2));
+}
+function requireSession() {
+  const session = loadSession();
+  if (!session) {
+    writeError("Not logged in. Run: pags login");
+    process.exit(1);
+  }
+  return session;
+}
+var loginCommand = new Command3("login").description("Sign in with Google or GitHub (opens browser)").option("--github", "Use GitHub instead of Google").action(async (opts) => {
+  const provider = opts.github ? "github" : "google";
+  writeLine(`Opening browser for ${provider} sign-in...`);
+  const port = await findFreePort();
+  const callbackUrl = `http://127.0.0.1:${port}/callback`;
+  const tokenPromise = new Promise((resolve5, reject) => {
+    const timeout = setTimeout(() => {
+      server.close();
+      reject(new Error("Login timed out (60s)"));
+    }, 6e4);
+    const server = createServer(async (req, res) => {
+      const url = new URL(req.url || "/", `http://127.0.0.1:${port}`);
+      if (url.pathname !== "/callback") {
+        res.writeHead(404);
+        res.end();
+        return;
+      }
+      const fasSession = url.searchParams.get("fas_session");
+      if (!fasSession) {
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end("<h1>Sign-in failed</h1><p>No session received.</p>");
+        clearTimeout(timeout);
+        server.close();
+        reject(new Error("No fas_session in callback"));
+        return;
+      }
+      try {
+        const exchangeRes = await fetch(`${API_BASE}/v1/auth/exchange`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ fas_session: fasSession })
+        });
+        const data = await exchangeRes.json();
+        if (!data.token) throw new Error(data.error || "Exchange failed");
+        saveSession({
+          token: data.token,
+          user: data.user,
+          expiresAt: Date.now() + 29 * 24 * 60 * 60 * 1e3
+          // ~29 days
+        });
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(`<h1>Signed in as ${data.user?.login}</h1><p>You can close this tab and return to the terminal.</p><script>window.close()</script>`);
+        clearTimeout(timeout);
+        server.close();
+        resolve5(data.token);
+      } catch (err) {
+        res.writeHead(500, { "Content-Type": "text/html" });
+        res.end(`<h1>Sign-in failed</h1><p>${err instanceof Error ? err.message : String(err)}</p>`);
+        clearTimeout(timeout);
+        server.close();
+        reject(err);
+      }
+    });
+    server.listen(port, "127.0.0.1");
+  });
+  const oauthBase = provider === "google" ? `${FAS_API}/v1/auth/google/start` : `${FAS_API}/v1/auth/github/start`;
+  const oauthUrl = `${oauthBase}?app_id=pags-cli&response_mode=query&return_to=${encodeURIComponent(callbackUrl)}`;
+  const open = (await import("child_process")).exec;
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  open(`${cmd} "${oauthUrl}"`);
+  try {
+    await tokenPromise;
+    const session = loadSession();
+    writeLine(`Signed in as ${session?.user.login}. Token stored at ${TOKEN_FILE}`);
+  } catch (err) {
+    writeError(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+var logoutCommand = new Command3("logout").description("Sign out and remove stored session").action(() => {
+  try {
+    if (existsSync3(TOKEN_FILE)) {
+      const { unlinkSync } = __require("fs");
+      unlinkSync(TOKEN_FILE);
+    }
+    writeLine("Signed out.");
+  } catch {
+    writeLine("Already signed out.");
+  }
+});
+var whoamiCommand = new Command3("whoami").description("Show current signed-in user").action(() => {
+  const session = loadSession();
+  if (session) {
+    writeLine(`${session.user.login} (${session.user.id})`);
+  } else {
+    writeLine("Not logged in. Run: pags login");
+  }
+});
+async function findFreePort() {
+  return new Promise((resolve5) => {
+    const server = createServer();
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      const port = typeof addr === "object" && addr ? addr.port : 0;
+      server.close(() => resolve5(port));
+    });
+  });
+}
+
 // src/commands/mcp.ts
 import { spawn } from "child_process";
-import { Command as Command3 } from "commander";
+import { Command as Command4 } 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];
@@ -383,23 +523,23 @@ async function runMcpProxy(opts, extraArgs = []) {
     });
   });
 }
-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) => {
+var mcpCommand = new Command4("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 Command4 } from "commander";
-var publishCommand = new Command4("publish").description("Publish an agent to ProAgentStore").option("-d, --dir <path>", "Agent directory", ".").action(async (opts) => {
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { join as join4, resolve as resolve3 } from "path";
+import { Command as Command5 } from "commander";
+var publishCommand = new Command5("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)) {
+  const manifestPath = join4(dir, "agent.json");
+  if (!existsSync4(manifestPath)) {
     writeError("No agent.json found. Run `pags init` first.");
     process.exit(1);
   }
-  const manifest = JSON.parse(readFileSync2(manifestPath, "utf-8"));
+  const manifest = JSON.parse(readFileSync3(manifestPath, "utf-8"));
   const slug = manifest.id;
   if (!slug) {
     writeError("agent.json missing id");
@@ -473,10 +613,10 @@ 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 { existsSync as existsSync5 } from "fs";
 import { resolve as resolve4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { Command as Command5 } from "commander";
+import { Command as Command6 } from "commander";
 var runnerCommand = createRunnerCommand();
 function runnerBaseUrl(url) {
   return (clean(url) || clean(process.env.PAGS_RUNNER_URL) || "http://127.0.0.1:49171").replace(/\/$/, "");
@@ -530,7 +670,7 @@ function clean(value) {
 function findWorkspaceRoot() {
   let dir = process.cwd();
   for (let i = 0; i < 8; i++) {
-    if (existsSync4(resolve4(dir, "pnpm-workspace.yaml"))) return dir;
+    if (existsSync5(resolve4(dir, "pnpm-workspace.yaml"))) return dir;
     const parent = resolve4(dir, "..");
     if (parent === dir) break;
     dir = parent;
@@ -548,10 +688,10 @@ function runnerSpawnSpec(opts) {
   let cwd = root;
   let command = "pags-browser-runner";
   let args = runnerArgs;
-  if (existsSync4(localPackage)) {
+  if (existsSync5(localPackage)) {
     command = "pnpm";
     args = ["--filter", "@proagentstore/browser-runner", "dev", "--", ...runnerArgs];
-  } else if (existsSync4(bundledPackage)) {
+  } else if (existsSync5(bundledPackage)) {
     cwd = process.cwd();
     command = process.execPath;
     args = [bundledPackage, ...runnerArgs];
@@ -640,7 +780,7 @@ function collectCapability(value, previous = []) {
   return [...previous, value];
 }
 function createRunnerCommand() {
-  const command = new Command5("runner").description(
+  const command = new Command6("runner").description(
     "Manage the local FAGS browser runtime for ProAgentStore agents"
   );
   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) => {
@@ -850,13 +990,67 @@ function createRunnerCommand() {
   return command;
 }
 
+// src/commands/up.ts
+import { Command as Command7 } from "commander";
+var API_BASE2 = "https://api.proagentstore.online";
+var upCommand = new Command7("up").description("Start the browser runner for all your agent instances").option("--headless", "Run browser in headless mode").option("--instance <id>", "Connect to a specific instance only").action(async (opts) => {
+  const session = requireSession();
+  writeLine(`Signed in as ${session.user.login}`);
+  writeLine("Fetching your instances...");
+  const res = await fetch(`${API_BASE2}/v1/instances/my/instances`, {
+    headers: { Authorization: `Bearer ${session.token}` }
+  });
+  if (!res.ok) {
+    writeError(`Failed to fetch instances: ${res.status}`);
+    process.exit(1);
+  }
+  const data = await res.json();
+  let instances = (data.instances || []).filter((i) => i.status === "active");
+  if (opts.instance) {
+    instances = instances.filter((i) => i.id === opts.instance || i.slug === opts.instance);
+  }
+  if (instances.length === 0) {
+    writeError("No active instances found. Subscribe to an agent first at https://proagentstore.online");
+    process.exit(1);
+  }
+  writeLine(`Found ${instances.length} instance${instances.length === 1 ? "" : "s"}:`);
+  for (const inst of instances) {
+    writeLine(`  ${inst.name || inst.slug || inst.id.slice(0, 8)} (${inst.id.slice(0, 8)}...)`);
+  }
+  const target = instances[0];
+  writeLine(`
+Connecting runner to: ${target.name || target.id.slice(0, 8)}...`);
+  const { spawn: spawn3 } = await import("child_process");
+  const cliPath = process.argv[1];
+  const args = [
+    cliPath,
+    "runner",
+    "connect",
+    target.id,
+    "--pags-token",
+    session.token
+  ];
+  if (opts.headless) args.push("--headless");
+  const child = spawn3(process.execPath, args, {
+    stdio: "inherit",
+    env: process.env
+  });
+  child.on("exit", (code) => {
+    process.exit(code || 0);
+  });
+});
+
 // src/index.ts
 var require2 = createRequire(import.meta.url);
 var { version } = require2("../package.json");
-var program = new Command6();
+var program = new Command8();
 program.name("pags").description(
   "ProAgentStore CLI \u2014 create and publish server-powered AI agents"
 ).version(version);
+program.addCommand(loginCommand);
+program.addCommand(logoutCommand);
+program.addCommand(whoamiCommand);
+program.addCommand(upCommand);
 program.addCommand(initCommand);
 program.addCommand(checkCommand);
 program.addCommand(publishCommand);

package/package.json

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