@proagentstore/cli 0.1.0

package/dist/browser-runner/index.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { startRunnerServer } from "./server.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);
+}
+function configFromArgs() {
+    const dataDir = arg("--data-dir") ||
+        process.env.PAGS_RUNNER_DATA_DIR ||
+        join(homedir(), ".config", "proagentstore", "browser-runner");
+    return {
+        host: arg("--host", process.env.PAGS_RUNNER_HOST || "127.0.0.1") || "127.0.0.1",
+        port: Number(arg("--port", process.env.PAGS_RUNNER_PORT || "49171")),
+        dataDir,
+        token: arg("--token", process.env.PAGS_RUNNER_TOKEN),
+        instanceId: arg("--instance-id", process.env.PAGS_INSTANCE_ID),
+        headless: flag("--headless") || process.env.PAGS_RUNNER_HEADLESS === "1",
+    };
+}
+if (flag("--help") || flag("-h")) {
+    process.stdout.write(`ProAgentStore browser runner
+
+Usage:
+  pags-browser-runner [--host 127.0.0.1] [--port 49171] [--data-dir path] [--token token] [--instance-id id] [--headless]
+
+Endpoints:
+  GET  /health
+  GET  /capabilities
+  POST /tasks
+  GET  /tasks/:id
+  POST /tasks/:id/approve
+  POST /tasks/:id/cancel
+  GET  /events
+`);
+    process.exit(0);
+}
+const config = configFromArgs();
+const started = await startRunnerServer(config);
+process.stdout.write(`PAGS browser runner listening at ${started.url}\n`);
+process.stdout.write(`Data dir: ${config.dataDir}\n`);
+process.stdout.write(`Brain placement: PAGS; runner role: tool-executor\n`);
+if (config.token)
+    process.stdout.write("Auth: bearer token required\n");
+if (config.instanceId)
+    process.stdout.write(`Instance binding: ${config.instanceId}\n`);
+const shutdown = async () => {
+    await started.close();
+    process.exit(0);
+};
+process.on("SIGINT", () => void shutdown());
+process.on("SIGTERM", () => void shutdown());

package/dist/browser-runner/runner.js

@@ -0,0 +1,203 @@
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { RunnerStore } from "./store.js";
+const CAPABILITIES = [
+    "browser.playwright",
+    "browser.screenshot",
+    "downloads",
+    "file.upload",
+    "human.approval",
+];
+const APPROVAL_REQUIRED_TASKS = new Set(["browser.open"]);
+export class RunnerInputError extends Error {
+    status = 400;
+}
+export class LocalRunner {
+    config;
+    browserContext = null;
+    store;
+    constructor(config) {
+        this.config = config;
+        mkdirSync(config.dataDir, { recursive: true });
+        this.store = new RunnerStore(config.dataDir);
+    }
+    capabilities() {
+        return {
+            runtime: "local-browser-runner",
+            brainPlacement: "pags",
+            runnerRole: "tool-executor",
+            capabilities: CAPABILITIES,
+            taskTypes: ["echo", "browser.open"],
+            approvalRequiredFor: ["browser.open"],
+        };
+    }
+    createTask(request) {
+        const normalized = normalizeCreateTaskRequest(request);
+        const now = new Date().toISOString();
+        const requiresApproval = normalized.requiresApproval || APPROVAL_REQUIRED_TASKS.has(normalized.type);
+        const task = {
+            id: `task_${crypto.randomUUID()}`,
+            type: normalized.type,
+            status: requiresApproval ? "needs_approval" : "queued",
+            input: normalized.input,
+            requiresApproval,
+            approval: requiresApproval
+                ? {
+                    prompt: normalized.approvalPrompt || `Approve task ${normalized.type}`,
+                }
+                : undefined,
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.store.putTask(task);
+        this.store.addEvent({
+            taskId: task.id,
+            type: "task.created",
+            message: `Task created: ${task.type}`,
+            data: { status: task.status },
+        });
+        if (task.status === "queued")
+            void this.runTask(task.id);
+        return task;
+    }
+    async approveTask(id) {
+        const task = this.requireTask(id);
+        if (task.status !== "needs_approval") {
+            throw new Error(`Task is not waiting for approval: ${task.status}`);
+        }
+        task.status = "queued";
+        task.updatedAt = new Date().toISOString();
+        task.approval = {
+            prompt: task.approval?.prompt || `Approve task ${task.type}`,
+            approvedAt: task.updatedAt,
+        };
+        this.store.putTask(task);
+        this.store.addEvent({
+            taskId: task.id,
+            type: "task.approved",
+            message: `Task approved: ${task.type}`,
+        });
+        await this.runTask(task.id);
+        return this.requireTask(id);
+    }
+    cancelTask(id) {
+        const task = this.requireTask(id);
+        if (task.status === "completed" || task.status === "failed")
+            return task;
+        task.status = "cancelled";
+        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}`,
+        });
+        return task;
+    }
+    async close() {
+        await this.browserContext?.close();
+        this.browserContext = null;
+    }
+    async runTask(id) {
+        const task = this.requireTask(id);
+        if (task.status !== "queued")
+            return;
+        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}`,
+        });
+        try {
+            const output = await this.execute(task);
+            task.status = "completed";
+            task.output = output;
+            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,
+            });
+        }
+        catch (error) {
+            task.status = "failed";
+            task.error = error instanceof Error ? error.message : String(error);
+            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,
+            });
+        }
+    }
+    async execute(task) {
+        if (task.type === "echo") {
+            return task.input;
+        }
+        if (task.type === "browser.open") {
+            const url = String(task.input.url || "");
+            if (!url || !/^https?:\/\//.test(url)) {
+                throw new Error("browser.open requires an http(s) url");
+            }
+            const context = await this.getBrowserContext();
+            const page = context.pages()[0] || (await context.newPage());
+            await page.goto(url, { waitUntil: "domcontentloaded", timeout: 30_000 });
+            return {
+                url: page.url(),
+                title: await page.title(),
+            };
+        }
+        throw new Error(`Unknown task type: ${task.type}`);
+    }
+    requireTask(id) {
+        const task = this.store.getTask(id);
+        if (!task)
+            throw new Error(`Task not found: ${id}`);
+        return task;
+    }
+    async getBrowserContext() {
+        if (this.browserContext)
+            return this.browserContext;
+        const profileDir = join(this.config.dataDir, "browser-profile");
+        const downloadsPath = join(this.config.dataDir, "downloads");
+        mkdirSync(profileDir, { recursive: true });
+        mkdirSync(downloadsPath, { recursive: true });
+        const playwright = await import("playwright").catch((error) => {
+            throw new Error(`Playwright is not installed. Run pnpm install in the PAGS platform repo. ${error instanceof Error ? error.message : String(error)}`);
+        });
+        this.browserContext = await playwright.chromium.launchPersistentContext(profileDir, {
+            headless: this.config.headless,
+            acceptDownloads: true,
+            downloadsPath,
+        });
+        return this.browserContext;
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeCreateTaskRequest(request) {
+    if (!isRecord(request) || typeof request.type !== "string" || !request.type.trim()) {
+        throw new RunnerInputError("task type required");
+    }
+    return {
+        type: request.type.trim().slice(0, 120),
+        input: isRecord(request.input) ? request.input : {},
+        requiresApproval: request.requiresApproval === true,
+        approvalPrompt: typeof request.approvalPrompt === "string"
+            ? request.approvalPrompt.trim().slice(0, 500)
+            : "",
+    };
+}
+export function fileUrl(path) {
+    return pathToFileURL(path).toString();
+}

package/dist/browser-runner/server.js

@@ -0,0 +1,124 @@
+import { createServer, } from "node:http";
+import { URL } from "node:url";
+import { LocalRunner, RunnerInputError } from "./runner.js";
+export function createRunnerServer(runner) {
+    return createServer(async (req, res) => {
+        try {
+            if (!authorize(req, runner.config)) {
+                return json(res, 401, { error: "Unauthorized" });
+            }
+            await route(runner, req, res);
+        }
+        catch (error) {
+            const status = error instanceof RunnerInputError ? error.status : 500;
+            json(res, status, {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    });
+}
+export async function startRunnerServer(config) {
+    const runner = new LocalRunner(config);
+    const server = createRunnerServer(runner);
+    await new Promise((resolve) => {
+        server.listen(config.port, config.host, resolve);
+    });
+    const address = server.address();
+    const actualPort = address.port;
+    return {
+        runner,
+        url: `http://${config.host}:${actualPort}`,
+        async close() {
+            await runner.close();
+            await new Promise((resolve, reject) => {
+                server.close((error) => (error ? reject(error) : resolve()));
+            });
+        },
+    };
+}
+async function route(runner, req, res) {
+    const url = new URL(req.url || "/", `http://${req.headers.host || "127.0.0.1"}`);
+    const path = url.pathname.replace(/\/$/, "") || "/";
+    if (req.method === "GET" && path === "/health") {
+        return json(res, 200, {
+            ok: true,
+            service: "proagentstore-browser-runner",
+            brainPlacement: "pags",
+            instanceId: runner.config.instanceId,
+        });
+    }
+    if (req.method === "GET" && path === "/capabilities") {
+        return json(res, 200, runner.capabilities());
+    }
+    if (req.method === "GET" && path === "/sessions") {
+        return json(res, 200, { sessions: runner.store.listSessions() });
+    }
+    if (req.method === "POST" && path === "/sessions") {
+        return json(res, 201, runner.store.createSession());
+    }
+    if (req.method === "GET" && path === "/tasks") {
+        return json(res, 200, { tasks: runner.store.listTasks() });
+    }
+    if (req.method === "POST" && path === "/tasks") {
+        const body = await readJson(req);
+        return json(res, 202, runner.createTask(body));
+    }
+    const taskMatch = path.match(/^\/tasks\/([^/]+)$/);
+    if (req.method === "GET" && taskMatch) {
+        const task = runner.store.getTask(taskMatch[1]);
+        if (!task)
+            return json(res, 404, { error: "Task not found" });
+        return json(res, 200, task);
+    }
+    const approveMatch = path.match(/^\/tasks\/([^/]+)\/approve$/);
+    if (req.method === "POST" && approveMatch) {
+        return json(res, 200, await runner.approveTask(approveMatch[1]));
+    }
+    const cancelMatch = path.match(/^\/tasks\/([^/]+)\/cancel$/);
+    if (req.method === "POST" && cancelMatch) {
+        return json(res, 200, runner.cancelTask(cancelMatch[1]));
+    }
+    if (req.method === "GET" && path === "/events") {
+        const limit = clampLimit(url.searchParams.get("limit"), 100, 500);
+        return json(res, 200, { events: runner.store.listEvents(limit) });
+    }
+    return json(res, 404, { error: "Not found" });
+}
+function authorize(req, config) {
+    const token = config.token;
+    if (config.instanceId && req.headers["x-pags-instance-id"] !== config.instanceId) {
+        return false;
+    }
+    if (!token)
+        return true;
+    const auth = req.headers.authorization || "";
+    const headerToken = req.headers["x-pags-runner-token"];
+    return auth === `Bearer ${token}` || headerToken === token;
+}
+async function readJson(req) {
+    const chunks = [];
+    for await (const chunk of req)
+        chunks.push(Buffer.from(chunk));
+    const raw = Buffer.concat(chunks).toString("utf-8");
+    if (!raw)
+        return {};
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        throw new RunnerInputError("Request body must be valid JSON");
+    }
+}
+function clampLimit(value, fallback, max) {
+    const parsed = Number(value || fallback);
+    if (!Number.isFinite(parsed))
+        return fallback;
+    return Math.max(1, Math.min(max, Math.trunc(parsed)));
+}
+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));
+}

package/dist/browser-runner/store.js

@@ -0,0 +1,82 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+function emptyStore() {
+    return {
+        sessions: [],
+        tasks: [],
+        events: [],
+    };
+}
+export class RunnerStore {
+    filePath;
+    constructor(dataDir) {
+        this.filePath = join(dataDir, "runner-store.json");
+    }
+    listSessions() {
+        return this.read().sessions;
+    }
+    createSession() {
+        const data = this.read();
+        const now = new Date().toISOString();
+        const session = {
+            id: `session_${crypto.randomUUID()}`,
+            createdAt: now,
+            status: "active",
+        };
+        data.sessions.unshift(session);
+        this.write(data);
+        return session;
+    }
+    listTasks() {
+        return this.read().tasks;
+    }
+    getTask(id) {
+        return this.read().tasks.find((task) => task.id === id) || null;
+    }
+    putTask(task) {
+        const data = this.read();
+        const index = data.tasks.findIndex((row) => row.id === task.id);
+        if (index === -1)
+            data.tasks.unshift(task);
+        else
+            data.tasks[index] = task;
+        this.write(data);
+        return task;
+    }
+    addEvent(event) {
+        const data = this.read();
+        const row = {
+            ...event,
+            id: `event_${crypto.randomUUID()}`,
+            createdAt: new Date().toISOString(),
+        };
+        data.events.unshift(row);
+        data.events = data.events.slice(0, 500);
+        this.write(data);
+        return row;
+    }
+    listEvents(limit = 100) {
+        return this.read().events.slice(0, limit);
+    }
+    read() {
+        if (!existsSync(this.filePath))
+            return emptyStore();
+        try {
+            const parsed = JSON.parse(readFileSync(this.filePath, "utf-8"));
+            return {
+                sessions: Array.isArray(parsed.sessions) ? parsed.sessions : [],
+                tasks: Array.isArray(parsed.tasks) ? parsed.tasks : [],
+                events: Array.isArray(parsed.events) ? parsed.events : [],
+            };
+        }
+        catch {
+            return emptyStore();
+        }
+    }
+    write(data) {
+        mkdirSync(dirname(this.filePath), { recursive: true });
+        writeFileSync(this.filePath, `${JSON.stringify(data, null, 2)}\n`, {
+            mode: 0o600,
+        });
+    }
+}

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

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+import { startTestJobServer } from "./test-job-server.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
+
+Usage:
+  pags-test-job-server [--port 49210]
+
+Routes:
+  GET  /jobs/software-engineer
+  POST /apply
+  GET  /success/:id
+  GET  /submissions
+`);
+    process.exit(0);
+}
+const port = Number(arg("--port", process.env.PAGS_TEST_JOB_PORT || "49210"));
+const server = await startTestJobServer(port);
+process.stdout.write(`PAGS test job server listening at ${server.url}\n`);
+process.stdout.write(`Job URL: ${server.jobUrl}\n`);
+const shutdown = async () => {
+    await server.close();
+    process.exit(0);
+};
+process.on("SIGINT", () => void shutdown());
+process.on("SIGTERM", () => void shutdown());