@proagentstore/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,722 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command5 } from "commander";
+
+// src/commands/check.ts
+import { existsSync, readFileSync } from "fs";
+import { join, resolve } from "path";
+import { Command } from "commander";
+
+// src/output.ts
+function writeLine(message = "") {
+  process.stdout.write(`${message}
+`);
+}
+function writeError(message = "") {
+  process.stderr.write(`${message}
+`);
+}
+
+// src/commands/check.ts
+var checkCommand = new Command("check").description("Run compliance checks on an agent").option("-d, --dir <path>", "Agent directory", ".").action((opts) => {
+  const dir = resolve(opts.dir);
+  const results = [];
+  const manifestPath = join(dir, "agent.json");
+  const hasManifest = existsSync(manifestPath);
+  results.push({
+    name: "agent.json",
+    pass: hasManifest,
+    message: hasManifest ? "Found" : "Missing agent.json manifest"
+  });
+  let manifest = {};
+  if (hasManifest) {
+    try {
+      manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+    } catch {
+      results.push({
+        name: "agent.json parse",
+        pass: false,
+        message: "Invalid JSON"
+      });
+    }
+  }
+  for (const field of ["id", "name", "storeType", "category"]) {
+    const has = !!manifest[field];
+    results.push({
+      name: `manifest.${field}`,
+      pass: has,
+      message: has ? String(manifest[field]) : `Missing ${field}`
+    });
+  }
+  const hasWrangler = existsSync(join(dir, "wrangler.toml"));
+  results.push({
+    name: "wrangler.toml",
+    pass: hasWrangler,
+    message: hasWrangler ? "Found" : "Missing"
+  });
+  const hasEntry = existsSync(join(dir, "src", "index.ts"));
+  results.push({
+    name: "src/index.ts",
+    pass: hasEntry,
+    message: hasEntry ? "Found" : "Missing entry point"
+  });
+  const hasPkg = existsSync(join(dir, "package.json"));
+  results.push({
+    name: "package.json",
+    pass: hasPkg,
+    message: hasPkg ? "Found" : "Missing"
+  });
+  const hasWorkflow = existsSync(
+    join(dir, ".github", "workflows", "deploy.yml")
+  );
+  results.push({
+    name: "deploy.yml",
+    pass: hasWorkflow,
+    message: hasWorkflow ? "Found" : "Missing deploy workflow"
+  });
+  const hasReadme = existsSync(join(dir, "README.md"));
+  results.push({
+    name: "README.md",
+    pass: hasReadme,
+    message: hasReadme ? "Found" : "Missing"
+  });
+  const wranglerContent = hasWrangler ? readFileSync(join(dir, "wrangler.toml"), "utf-8") : "";
+  const hasSecretInWrangler = /secret|password|token/i.test(wranglerContent) && /sk-|gsk_|sk-ant-/.test(wranglerContent);
+  results.push({
+    name: "no secrets",
+    pass: !hasSecretInWrangler,
+    message: hasSecretInWrangler ? "Possible secret in wrangler.toml!" : "Clean"
+  });
+  const passed = results.filter((r) => r.pass).length;
+  const total = results.length;
+  writeLine(
+    `
+  ProAgentStore compliance check: ${passed}/${total} passed
+`
+  );
+  for (const r of results) {
+    writeLine(
+      `  ${r.pass ? "\x1B[32m\u2713\x1B[0m" : "\x1B[31m\u2717\x1B[0m"} ${r.name} \u2014 ${r.message}`
+    );
+  }
+  writeLine();
+  if (passed < total) process.exit(1);
+});
+
+// src/commands/init.ts
+import { cpSync, existsSync as existsSync2, mkdirSync, writeFileSync } from "fs";
+import { dirname, join as join2, resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+import { Command as Command2 } from "commander";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var TEMPLATES = ["worker", "cron", "api"];
+var TEMPLATE_DESC = {
+  worker: "Durable Object agent with memory, conversation, and tools",
+  cron: "Scheduled worker for daily digests, monitoring, batch processing",
+  api: "Stateless API endpoint for transform, generate, or analyze"
+};
+var initCommand = new Command2("init").description("Scaffold a new ProAgentStore agent").argument("<name>", "Agent name (lowercase, hyphens)").option(
+  "-t, --template <type>",
+  `Template: ${TEMPLATES.join(", ")}`,
+  "worker"
+).action((name, opts) => {
+  const slug = name.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+  const template = opts.template;
+  if (!TEMPLATES.includes(template)) {
+    writeError(
+      `Unknown template: ${template}. Choose: ${TEMPLATES.join(", ")}`
+    );
+    process.exit(1);
+  }
+  const dir = resolve2(slug);
+  if (existsSync2(dir)) {
+    writeError(`Directory ${slug} already exists`);
+    process.exit(1);
+  }
+  const templateDir = resolve2(
+    __dirname,
+    "..",
+    "..",
+    "..",
+    "..",
+    "templates",
+    `template-agent-${template}`
+  );
+  const templateHasFiles = existsSync2(join2(templateDir, "agent.json"));
+  if (templateHasFiles) {
+    cpSync(templateDir, dir, { recursive: true });
+    writeLine(`Copied template: template-agent-${template}`);
+  } else {
+    mkdirSync(dir, { recursive: true });
+    mkdirSync(join2(dir, "src"));
+    mkdirSync(join2(dir, "migrations"));
+    mkdirSync(join2(dir, ".github", "workflows"), { recursive: true });
+    writeFileSync(
+      join2(dir, "agent.json"),
+      `${JSON.stringify(
+        {
+          id: slug,
+          name,
+          description: "",
+          storeType: template === "api" ? "tool" : template === "cron" ? "worker" : "agent",
+          category: "general",
+          model: "@cf/meta/llama-3.2-3b-instruct",
+          template,
+          serverConfig: {
+            durableObject: template === "worker",
+            cron: template === "cron" ? "0 8 * * *" : void 0,
+            routes: [`${slug}.proagentstore.online/*`],
+            aiBilling: "caller-provided"
+          }
+        },
+        null,
+        2
+      )}
+`
+    );
+    writeFileSync(
+      join2(dir, "package.json"),
+      `${JSON.stringify(
+        {
+          name: `@proagentstore/${slug}`,
+          version: "0.0.1",
+          private: true,
+          type: "module",
+          scripts: {
+            dev: "wrangler dev",
+            deploy: "wrangler deploy",
+            typecheck: "tsc --noEmit"
+          },
+          dependencies: { hono: "^4.7.0" },
+          devDependencies: {
+            "@cloudflare/workers-types": "^4.20250530.0",
+            typescript: "^5.7.0",
+            wrangler: "^4.0.0"
+          }
+        },
+        null,
+        2
+      )}
+`
+    );
+    const wranglerLines = [
+      `name = "proagentstore-${slug}"`,
+      'main = "src/index.ts"',
+      'compatibility_date = "2026-01-01"',
+      'compatibility_flags = ["nodejs_compat"]',
+      "",
+      "[[routes]]",
+      `pattern = "${slug}.proagentstore.online/*"`,
+      'zone_name = "proagentstore.online"'
+    ];
+    if (template === "worker") {
+      wranglerLines.push(
+        "",
+        "[[durable_objects.bindings]]",
+        'name = "AGENT"',
+        'class_name = "AgentDO"'
+      );
+      wranglerLines.push(
+        "",
+        "[[migrations]]",
+        'tag = "v1"',
+        'new_classes = ["AgentDO"]'
+      );
+    }
+    if (template === "cron") {
+      wranglerLines.push("", "[triggers]", 'crons = ["0 8 * * *"]');
+    }
+    writeFileSync(
+      join2(dir, "wrangler.toml"),
+      `${wranglerLines.join("\n")}
+`
+    );
+    writeFileSync(
+      join2(dir, "tsconfig.json"),
+      `${JSON.stringify(
+        {
+          compilerOptions: {
+            target: "ESNext",
+            module: "ESNext",
+            moduleResolution: "bundler",
+            lib: ["ESNext"],
+            types: ["@cloudflare/workers-types"],
+            strict: true,
+            skipLibCheck: true,
+            outDir: "dist",
+            rootDir: "src"
+          },
+          include: ["src"],
+          exclude: ["src/**/*.test.ts"]
+        },
+        null,
+        2
+      )}
+`
+    );
+    if (template === "worker") {
+      writeFileSync(
+        join2(dir, "src", "index.ts"),
+        `import { Hono } from 'hono';
+
+const app = new Hono();
+
+app.get('/', (c) => c.json({ agent: '${slug}', status: 'ok' }));
+
+export default app;
+`
+      );
+    } else if (template === "cron") {
+      writeFileSync(
+        join2(dir, "src", "index.ts"),
+        `export default {
+  async scheduled(event: ScheduledEvent, env: unknown, ctx: ExecutionContext) {
+    // Your scheduled logic here. Access event.cron if you need the trigger expression.
+  },
+  async fetch() {
+    return new Response('${slug} cron worker', { status: 200 });
+  },
+};
+`
+      );
+    } else {
+      writeFileSync(
+        join2(dir, "src", "index.ts"),
+        `import { Hono } from 'hono';
+
+const app = new Hono();
+
+app.post('/run', async (c) => {
+  const { input } = await c.req.json();
+  // Your API logic here
+  return c.json({ result: input });
+});
+
+export default app;
+`
+      );
+    }
+    writeFileSync(
+      join2(dir, "README.md"),
+      `# ${name}
+
+A ProAgentStore ${template} agent.
+
+## AI billing
+
+This scaffold does not include a ProAgentStore Cloudflare Workers AI binding. AI calls must use caller-owned credentials or another explicit billing source.
+
+## Development
+
+\`\`\`bash
+pnpm install
+pnpm dev
+\`\`\`
+
+## Deploy
+
+\`\`\`bash
+pags publish
+\`\`\`
+`
+    );
+    writeFileSync(
+      join2(dir, ".github", "workflows", "deploy.yml"),
+      `name: Deploy
+on:
+  push:
+    branches: [main]
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: pnpm
+      - run: pnpm install --frozen-lockfile
+      - uses: cloudflare/wrangler-action@v3
+        with:
+          apiToken: \${{ secrets.CLOUDFLARE_API_TOKEN }}
+          accountId: \${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
+          command: deploy
+`
+    );
+    writeFileSync(
+      join2(dir, ".gitignore"),
+      "node_modules/\ndist/\n.wrangler/\n"
+    );
+    writeFileSync(join2(dir, "LICENSE"), "MIT License\n");
+  }
+  writeLine(`
+  Created ${slug}/`);
+  writeLine(`  Template: ${template} \u2014 ${TEMPLATE_DESC[template]}`);
+  writeLine(`
+  cd ${slug}`);
+  writeLine("  pnpm install");
+  writeLine("  pnpm dev");
+  writeLine();
+});
+
+// src/commands/publish.ts
+import { execFileSync } from "child_process";
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { join as join3, resolve as resolve3 } from "path";
+import { Command as Command3 } from "commander";
+var publishCommand = new Command3("publish").description("Publish an agent to ProAgentStore").option("-d, --dir <path>", "Agent directory", ".").action(async (opts) => {
+  const dir = resolve3(opts.dir);
+  const manifestPath = join3(dir, "agent.json");
+  if (!existsSync3(manifestPath)) {
+    writeError("No agent.json found. Run `pags init` first.");
+    process.exit(1);
+  }
+  const manifest = JSON.parse(readFileSync2(manifestPath, "utf-8"));
+  const slug = manifest.id;
+  if (!slug) {
+    writeError("agent.json missing id");
+    process.exit(1);
+  }
+  writeLine(`
+  Publishing ${manifest.name} (${slug})...
+`);
+  writeLine("  Running compliance checks...");
+  try {
+    execFileSync("pags", ["check"], { cwd: dir, stdio: "inherit" });
+  } catch {
+    writeError("\n  Compliance checks failed. Fix issues and retry.\n");
+    process.exit(1);
+  }
+  const org = "ProAgentStore";
+  const repoName = slug;
+  writeLine(`
+  Checking GitHub repo: ${org}/${repoName}`);
+  let repoExists = false;
+  try {
+    execFileSync("gh", ["api", `repos/${org}/${repoName}`, "--jq", ".name"], {
+      stdio: "pipe"
+    });
+    repoExists = true;
+    writeLine("  Repo exists, pushing...");
+  } catch {
+    writeLine("  Creating repo...");
+    try {
+      execFileSync(
+        "gh",
+        ["repo", "create", `${org}/${repoName}`, "--public", `--source=${dir}`, "--push"],
+        { stdio: "inherit" }
+      );
+      repoExists = true;
+    } catch (e) {
+      writeError(`  Failed to create repo: ${e}`);
+      process.exit(1);
+    }
+  }
+  if (repoExists) {
+    try {
+      execFileSync("git", ["remote", "get-url", "origin"], {
+        cwd: dir,
+        stdio: "pipe"
+      });
+    } catch {
+      execFileSync(
+        "git",
+        ["remote", "add", "origin", `https://github.com/${org}/${repoName}.git`],
+        { cwd: dir }
+      );
+    }
+    try {
+      execFileSync("git", ["push", "-u", "origin", "main"], {
+        cwd: dir,
+        stdio: "inherit"
+      });
+    } catch {
+      writeLine("  Push skipped (up to date or no commits)");
+    }
+  }
+  writeLine("\n  Registering agent in store...");
+  writeLine(`
+  Published! ${slug}.proagentstore.online`);
+  writeLine(`  Store: https://proagentstore.online/agents/${slug}/`);
+  writeLine(`  Repo:  https://github.com/${org}/${repoName}`);
+  writeLine();
+});
+
+// src/commands/runner.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync4 } from "fs";
+import { resolve as resolve4 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { Command as Command4 } from "commander";
+var runnerCommand = createRunnerCommand();
+function runnerBaseUrl(url) {
+  return (clean(url) || clean(process.env.PAGS_RUNNER_URL) || "http://127.0.0.1:49171").replace(/\/$/, "");
+}
+function pagsApiBase(url) {
+  return (clean(url) || clean(process.env.PAGS_API_BASE) || "https://api.proagentstore.online").replace(/\/$/, "");
+}
+function pagsHeaders(token) {
+  const resolved = clean(token) || clean(process.env.PAGS_TOKEN);
+  return resolved ? { Authorization: `Bearer ${resolved}` } : {};
+}
+function runnerRequestHeaders(opts) {
+  const resolved = clean(opts.token) || clean(process.env.PAGS_RUNNER_TOKEN);
+  const headers = resolved ? { Authorization: `Bearer ${resolved}` } : {};
+  const instanceId = clean(opts.instanceId) || clean(process.env.PAGS_INSTANCE_ID);
+  if (instanceId) headers["X-PAGS-Instance-Id"] = instanceId;
+  return headers;
+}
+function apiPathSegment(value) {
+  return encodeURIComponent(value);
+}
+function buildRunnerArgs(opts) {
+  const args = [];
+  if (clean(opts.host)) args.push("--host", clean(opts.host));
+  if (clean(opts.port)) args.push("--port", clean(opts.port));
+  if (clean(opts.dataDir)) args.push("--data-dir", clean(opts.dataDir));
+  if (clean(opts.token)) args.push("--token", clean(opts.token));
+  if (clean(opts.instanceId)) args.push("--instance-id", clean(opts.instanceId));
+  if (opts.headless) args.push("--headless");
+  return args;
+}
+function buildRuntimeRegistrationBody(opts, capabilities = []) {
+  return {
+    endpointUrl: clean(opts.endpointUrl) || opts.endpointUrl,
+    token: clean(opts.runnerToken) || clean(opts.token) || clean(process.env.PAGS_RUNNER_TOKEN),
+    placement: opts.placement === "managed" ? "managed" : "local",
+    capabilities,
+    runnerVersion: clean(opts.runnerVersion) || ""
+  };
+}
+function clean(value) {
+  const trimmed = value?.trim();
+  return trimmed || void 0;
+}
+function findWorkspaceRoot() {
+  let dir = process.cwd();
+  for (let i = 0; i < 8; i++) {
+    if (existsSync4(resolve4(dir, "pnpm-workspace.yaml"))) return dir;
+    const parent = resolve4(dir, "..");
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return process.cwd();
+}
+function bundledRunnerPath() {
+  return fileURLToPath2(new URL("./browser-runner/index.js", import.meta.url));
+}
+function startRunnerForeground(opts) {
+  const root = findWorkspaceRoot();
+  const localPackage = resolve4(root, "packages", "browser-runner", "src", "index.ts");
+  const bundledPackage = bundledRunnerPath();
+  const runnerArgs = buildRunnerArgs(opts);
+  let cwd = root;
+  let command = "pags-browser-runner";
+  let args = runnerArgs;
+  if (existsSync4(localPackage)) {
+    command = "pnpm";
+    args = ["--filter", "@proagentstore/browser-runner", "dev", "--", ...runnerArgs];
+  } else if (existsSync4(bundledPackage)) {
+    cwd = process.cwd();
+    command = process.execPath;
+    args = [bundledPackage, ...runnerArgs];
+  }
+  return new Promise((resolvePromise, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      stdio: "inherit",
+      shell: process.platform === "win32"
+    });
+    child.on("error", reject);
+    child.on("exit", (code) => {
+      if (code && code !== 0) reject(new Error(`runner exited with code ${code}`));
+      else resolvePromise();
+    });
+  });
+}
+async function requestRunner(method, path, opts, body) {
+  const headers = {
+    ...runnerRequestHeaders(opts)
+  };
+  if (body !== void 0) headers["Content-Type"] = "application/json";
+  const res = await fetch(`${runnerBaseUrl(opts.url)}${path}`, {
+    method,
+    headers,
+    body: body === void 0 ? void 0 : JSON.stringify(body)
+  });
+  const { text, data } = await readResponse(res);
+  if (!res.ok) {
+    const message = responseErrorMessage(data, text, res.statusText);
+    throw new Error(`${res.status} ${message}`);
+  }
+  return data;
+}
+async function requestPags(method, path, opts, body) {
+  const headers = {
+    ...pagsHeaders(opts.pagsToken)
+  };
+  if (!headers.Authorization) {
+    throw new Error("PAGS token required. Set PAGS_TOKEN or pass --pags-token.");
+  }
+  if (body !== void 0) headers["Content-Type"] = "application/json";
+  const res = await fetch(`${pagsApiBase(opts.apiBase)}${path}`, {
+    method,
+    headers,
+    body: body === void 0 ? void 0 : JSON.stringify(body)
+  });
+  const { text, data } = await readResponse(res);
+  if (!res.ok) {
+    const message = responseErrorMessage(data, text, res.statusText);
+    throw new Error(`${res.status} ${message}`);
+  }
+  return data;
+}
+async function readResponse(res) {
+  const text = await res.text();
+  if (!text) return { text, data: {} };
+  try {
+    return { text, data: JSON.parse(text) };
+  } catch {
+    return { text, data: {} };
+  }
+}
+function responseErrorMessage(data, text, statusText) {
+  return typeof data.error === "string" ? data.error : text || statusText;
+}
+function collectCapability(value, previous = []) {
+  return [...previous, value];
+}
+function createRunnerCommand() {
+  const command = new Command4("runner").description(
+    "Manage a local ProAgentStore browser runner"
+  );
+  command.command("start").description("Start the local browser runner in the foreground").option("--host <host>", "Host to bind", "127.0.0.1").option("--port <port>", "Port to bind", "49171").option("--data-dir <path>", "Runner data directory").option("--token <token>", "Require this bearer token").option("--instance-id <id>", "Bind runner requests to a PAGS instance id").option("--headless", "Run Playwright headless").action(async (opts) => {
+    await startRunnerForeground(opts);
+  });
+  command.command("status").description("Check local runner health and capabilities").option("--url <url>", "Runner URL").option("--token <token>", "Runner bearer token").option("--instance-id <id>", "PAGS instance id header").action(async (opts) => {
+    const health = await requestRunner("GET", "/health", opts);
+    const capabilities = await requestRunner("GET", "/capabilities", opts);
+    writeLine(JSON.stringify({ health, capabilities }, null, 2));
+  });
+  command.command("task").description("Create a runner task").requiredOption("--type <type>", "Task type, e.g. echo or browser.open").option("--url <url>", "Runner URL").option("--token <token>", "Runner bearer token").option("--instance-id <id>", "PAGS instance id header").option("--input <json>", "Task input JSON").option("--job-url <url>", "Shortcut input for browser.open").option("--approve", "Create task in needs_approval state").option("--approval-prompt <text>", "Approval prompt").action(
+    async (opts) => {
+      let input = {};
+      if (opts.input) {
+        try {
+          input = JSON.parse(opts.input);
+        } catch {
+          writeError("--input must be valid JSON");
+          process.exit(1);
+        }
+      }
+      if (opts.jobUrl) input.url = opts.jobUrl;
+      const task = await requestRunner("POST", "/tasks", opts, {
+        type: opts.type,
+        input,
+        requiresApproval: Boolean(opts.approve),
+        approvalPrompt: opts.approvalPrompt
+      });
+      writeLine(JSON.stringify(task, null, 2));
+    }
+  );
+  command.command("register <instanceId>").description("Register a local or managed runner endpoint with a PAGS instance").requiredOption("--endpoint-url <url>", "Runner endpoint URL to store in PAGS").option("--api-base <url>", "PAGS API base URL").option("--pags-token <token>", "PAGS session token. Defaults to PAGS_TOKEN").option("--runner-token <token>", "Runner bearer token to store in PAGS").option("--url <url>", "Local runner URL to probe for capabilities").option("--token <token>", "Local runner bearer token for capability probe").option("--instance-id <id>", "PAGS instance id header for capability probe").option("--placement <placement>", "Runtime placement: local or managed", "local").option("--runner-version <version>", "Runner version").option("--capability <name>", "Runtime capability; repeatable", collectCapability, []).option("--probe", "Read capabilities from the runner before registering").action(async (instanceId, opts) => {
+    let capabilities = opts.capability || [];
+    if (opts.probe) {
+      const data = await requestRunner("GET", "/capabilities", {
+        url: opts.url || opts.endpointUrl,
+        token: opts.token || opts.runnerToken,
+        instanceId: opts.instanceId || instanceId
+      });
+      capabilities = Array.isArray(data.capabilities) ? data.capabilities.filter((item) => typeof item === "string") : capabilities;
+    }
+    const body = buildRuntimeRegistrationBody(opts, capabilities);
+    const result = await requestPags("POST", `/v1/instances/${apiPathSegment(instanceId)}/runtime`, opts, body);
+    writeLine(JSON.stringify(result, null, 2));
+  });
+  command.command("runtime <instanceId>").description("Read the PAGS runtime registration for an instance").option("--api-base <url>", "PAGS API base URL").option("--pags-token <token>", "PAGS session token. Defaults to PAGS_TOKEN").option("--probe", "Ask PAGS to probe /health and /capabilities on the runner").action(async (instanceId, opts) => {
+    const path = opts.probe ? `/v1/instances/${apiPathSegment(instanceId)}/runtime/status` : `/v1/instances/${apiPathSegment(instanceId)}/runtime`;
+    const result = await requestPags("GET", path, opts);
+    writeLine(JSON.stringify(result, null, 2));
+  });
+  command.command("unregister <instanceId>").description("Remove the PAGS runtime registration for an instance").option("--api-base <url>", "PAGS API base URL").option("--pags-token <token>", "PAGS session token. Defaults to PAGS_TOKEN").action(async (instanceId, opts) => {
+    const result = await requestPags("DELETE", `/v1/instances/${apiPathSegment(instanceId)}/runtime`, opts);
+    writeLine(JSON.stringify(result, null, 2));
+  });
+  command.command("run <instanceId>").description("Create a task through PAGS on an instance's registered runner").requiredOption("--type <type>", "Task type, e.g. echo or browser.open").option("--api-base <url>", "PAGS API base URL").option("--pags-token <token>", "PAGS session token. Defaults to PAGS_TOKEN").option("--input <json>", "Task input JSON").option("--job-url <url>", "Shortcut input for browser.open").option("--approve", "Create task in needs_approval state").option("--approval-prompt <text>", "Approval prompt").action(
+    async (instanceId, opts) => {
+      let input = {};
+      if (opts.input) {
+        try {
+          input = JSON.parse(opts.input);
+        } catch {
+          writeError("--input must be valid JSON");
+          process.exit(1);
+        }
+      }
+      if (opts.jobUrl) input.url = opts.jobUrl;
+      const result = await requestPags("POST", `/v1/instances/${apiPathSegment(instanceId)}/tasks`, opts, {
+        type: opts.type,
+        input,
+        requiresApproval: Boolean(opts.approve),
+        approvalPrompt: opts.approvalPrompt
+      });
+      writeLine(JSON.stringify(result, null, 2));
+    }
+  );
+  command.command("approve-task <instanceId> <taskId>").description("Approve a registered-runner task through PAGS").option("--api-base <url>", "PAGS API base URL").option("--pags-token <token>", "PAGS session token. Defaults to PAGS_TOKEN").action(async (instanceId, taskId, opts) => {
+    const result = await requestPags(
+      "POST",
+      `/v1/instances/${apiPathSegment(instanceId)}/tasks/${apiPathSegment(taskId)}/approve`,
+      opts
+    );
+    writeLine(JSON.stringify(result, null, 2));
+  });
+  command.command("cancel-task <instanceId> <taskId>").description("Cancel a registered-runner task through PAGS").option("--api-base <url>", "PAGS API base URL").option("--pags-token <token>", "PAGS session token. Defaults to PAGS_TOKEN").action(async (instanceId, taskId, opts) => {
+    const result = await requestPags(
+      "POST",
+      `/v1/instances/${apiPathSegment(instanceId)}/tasks/${apiPathSegment(taskId)}/cancel`,
+      opts
+    );
+    writeLine(JSON.stringify(result, null, 2));
+  });
+  command.command("task-events <instanceId>").description("Read registered-runner task events through PAGS").option("--api-base <url>", "PAGS API base URL").option("--pags-token <token>", "PAGS session token. Defaults to PAGS_TOKEN").option("--limit <n>", "Number of events", "50").action(async (instanceId, opts) => {
+    const result = await requestPags(
+      "GET",
+      `/v1/instances/${apiPathSegment(instanceId)}/task-events?limit=${Number(opts.limit) || 50}`,
+      opts
+    );
+    writeLine(JSON.stringify(result, null, 2));
+  });
+  command.command("approve <taskId>").description("Approve a task waiting on human approval").option("--url <url>", "Runner URL").option("--token <token>", "Runner bearer token").option("--instance-id <id>", "PAGS instance id header").action(async (taskId, opts) => {
+    const task = await requestRunner("POST", `/tasks/${apiPathSegment(taskId)}/approve`, opts);
+    writeLine(JSON.stringify(task, null, 2));
+  });
+  command.command("cancel <taskId>").description("Cancel a local runner task").option("--url <url>", "Runner URL").option("--token <token>", "Runner bearer token").option("--instance-id <id>", "PAGS instance id header").action(async (taskId, opts) => {
+    const task = await requestRunner("POST", `/tasks/${apiPathSegment(taskId)}/cancel`, opts);
+    writeLine(JSON.stringify(task, null, 2));
+  });
+  command.command("events").description("List recent runner events").option("--url <url>", "Runner URL").option("--token <token>", "Runner bearer token").option("--instance-id <id>", "PAGS instance id header").option("--limit <n>", "Number of events", "50").action(async (opts) => {
+    const events = await requestRunner("GET", `/events?limit=${Number(opts.limit) || 50}`, opts);
+    writeLine(JSON.stringify(events, null, 2));
+  });
+  return command;
+}
+
+// src/index.ts
+var program = new Command5();
+program.name("pags").description(
+  "ProAgentStore CLI \u2014 create and publish server-powered AI agents"
+).version("0.1.0");
+program.addCommand(initCommand);
+program.addCommand(checkCommand);
+program.addCommand(publishCommand);
+program.addCommand(runnerCommand);
+try {
+  await program.parseAsync();
+} catch (error) {
+  writeError(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+}