prompteryx 0.1.0

package/README.md

@@ -0,0 +1,54 @@
+# prompteryx
+
+The [Prompteryx](https://www.prompteryx.ai) command line. Run AI browser agents, cloud browsers, Visual Studio workflows and Connect Hub actions from a terminal or a CI job.
+
+```bash
+npm install -g prompteryx      # or: npx prompteryx <command>
+prompteryx login               # opens the browser; approve once, tokens refresh automatically
+prompteryx agent "Find the cheapest direct flight from London to Lisbon next Tuesday"
+```
+
+## Sign in
+
+| Command | Use when |
+|---|---|
+| `prompteryx login` | You are at a keyboard. Opens `https://www.prompteryx.ai/oauth/authorize`; no key is pasted. |
+| `prompteryx login --key px_live_…` | Servers and CI. Create the key in Settings → API Keys. |
+| `prompteryx login --cloud-browser-key pcb_live_…` | Needed only for `prompteryx browser …`. Create it in Cloud Platform → API Keys. |
+
+`PROMPTERYX_API_KEY` and `PROMPTERYX_API_URL` environment variables override the saved config (`~/.prompteryx/config.json`). Add `--json` to any command for machine-readable output.
+
+## Commands
+
+```text
+agent "goal" [--start-url URL] [--max-steps N] [--max-credits N] [--save-as-workflow] [--local]
+workflows list [--search q] | get <id> | run <id> [--input key=value …] [--wait] [--visible]
+runs get <id> | wait <id> | logs <id>
+browser create [--record] [--local] | list | close <id>
+schedules list [--workflow <id>]
+apps list [--search q] | actions <app> | accounts | run <app> <action> --params '{"to":"…"}' [--account <id>]
+mcp <claude-code|cursor|vscode|claude-desktop|http>
+whoami | logout | help | version
+```
+
+### Examples
+
+```bash
+# Run a workflow with variables and wait for the result
+prompteryx workflows run fHX8NlpAJxoWuAOll7zr --input postcode="SW1A 1AA" --wait
+
+# Start a cloud browser and drive it from Playwright
+prompteryx browser create --record
+#   Connect with Playwright: chromium.connectOverCDP("wss://…")
+
+# Send an email through a connected Gmail account
+prompteryx apps actions gmail
+prompteryx apps run gmail gmail-send-email --params '{"to":"hello@example.com","subject":"Hi","body":"From the CLI"}'
+
+# Print the one-line setup for Claude Code
+prompteryx mcp claude-code
+```
+
+Access follows your account's balance of cloud browser minutes and AI credits, whatever plan you are on. When a limit is hit the command explains what to top up.
+
+Docs: https://www.prompteryx.ai/docs/developers/cli

package/dist/config.js

@@ -0,0 +1,36 @@
+/**
+ * Credential + settings store for the CLI: ~/.prompteryx/config.json
+ *
+ * Holds either an API key (px_live_…) or an OAuth token pair from
+ * `prompteryx login`, plus the optional cloud-browser key (pcb_live_…) and a
+ * base URL override for staging. File is written with mode 0600.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+export const DEFAULT_BASE_URL = 'https://www.prompteryx.ai';
+const dir = path.join(os.homedir(), '.prompteryx');
+const file = path.join(dir, 'config.json');
+export function configPath() {
+    return file;
+}
+export function readConfig() {
+    try {
+        return JSON.parse(fs.readFileSync(file, 'utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+export function writeConfig(cfg) {
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    fs.writeFileSync(file, JSON.stringify(cfg, null, 2) + '\n', { mode: 0o600 });
+}
+export function updateConfig(patch) {
+    const next = { ...readConfig(), ...patch };
+    writeConfig(next);
+    return next;
+}
+export function baseUrl(cfg = readConfig()) {
+    return (process.env.PROMPTERYX_API_URL || cfg.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, '');
+}

package/dist/index.js

@@ -0,0 +1,426 @@
+#!/usr/bin/env node
+/**
+ * prompteryx — the Prompteryx command line.
+ *
+ *   prompteryx login [--key px_live_…] [--cloud-browser-key pcb_live_…]
+ *   prompteryx whoami | logout
+ *   prompteryx agent "goal" [--start-url URL] [--max-steps N] [--save-as-workflow] [--local]
+ *   prompteryx workflows list | get <id> | run <id> [--input k=v …] [--wait] [--visible] [--json]
+ *   prompteryx runs get <id> | wait <id> | logs <id>
+ *   prompteryx browser create [--record] [--local] | list | close <id>
+ *   prompteryx schedules list
+ *   prompteryx apps list [--search q] | actions <app> | accounts | run <app> <action> --params '{…}'
+ *   prompteryx mcp <claude-code|cursor|vscode|claude-desktop|http>
+ *
+ * Thin wrapper over @prompteryx/sdk; credentials live in ~/.prompteryx/config.json.
+ */
+import { Prompteryx } from '@prompteryx/sdk';
+import { baseUrl, configPath, readConfig, updateConfig, writeConfig } from './config.js';
+import { ensureFreshOAuth, oauthLogin, revokeOAuth } from './login.js';
+const VERSION = '0.1.0';
+function parseArgs(argv) {
+    const positional = [];
+    const flags = {};
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a.startsWith('--')) {
+            const eq = a.indexOf('=');
+            const key = eq > 0 ? a.slice(2, eq) : a.slice(2);
+            let value;
+            if (eq > 0)
+                value = a.slice(eq + 1);
+            else if (i + 1 < argv.length && !argv[i + 1].startsWith('--'))
+                value = argv[++i];
+            else
+                value = true;
+            if (key === 'input' || key === 'header') {
+                const arr = flags[key] ?? [];
+                arr.push(String(value));
+                flags[key] = arr;
+            }
+            else {
+                flags[key] = value;
+            }
+        }
+        else {
+            positional.push(a);
+        }
+    }
+    return { positional, flags };
+}
+const str = (v) => typeof v === 'string' ? v : undefined;
+const num = (v) => typeof v === 'string' && v.trim() !== '' && !Number.isNaN(Number(v)) ? Number(v) : undefined;
+const bool = (v) => v === true || v === 'true';
+function parseKeyValues(items) {
+    const out = {};
+    for (const item of items ?? []) {
+        const i = item.indexOf('=');
+        if (i <= 0)
+            throw new UsageError(`--input expects key=value, got "${item}"`);
+        const key = item.slice(0, i);
+        const raw = item.slice(i + 1);
+        try {
+            out[key] = JSON.parse(raw);
+        }
+        catch {
+            out[key] = raw;
+        }
+    }
+    return out;
+}
+class UsageError extends Error {
+}
+// ── output helpers ───────────────────────────────────────────────────────────
+let JSON_MODE = false;
+function print(value, human) {
+    if (JSON_MODE || !human)
+        console.log(JSON.stringify(value, null, 2));
+    else
+        human();
+}
+function table(rows, columns) {
+    if (rows.length === 0) {
+        console.log('(none)');
+        return;
+    }
+    const widths = columns.map((c) => Math.max(c.length, ...rows.map((r) => String(r[c] ?? '').length)));
+    const line = (cells) => cells.map((c, i) => c.padEnd(widths[i])).join('  ');
+    console.log(line(columns));
+    console.log(line(widths.map((w) => '-'.repeat(w))));
+    for (const r of rows)
+        console.log(line(columns.map((c) => String(r[c] ?? ''))));
+}
+// ── client ───────────────────────────────────────────────────────────────────
+async function client(opts = {}) {
+    const cfg = readConfig();
+    let apiKey = process.env.PROMPTERYX_API_KEY || cfg.apiKey;
+    if (!apiKey && cfg.oauth) {
+        const fresh = await ensureFreshOAuth(cfg.oauth);
+        apiKey = fresh.accessToken;
+    }
+    if (!apiKey) {
+        throw new UsageError('Not signed in. Run `prompteryx login` (browser) or `prompteryx login --key px_live_…`.');
+    }
+    const cloudBrowserKey = process.env.PROMPTERYX_CLOUD_BROWSER_KEY || cfg.cloudBrowserKey;
+    if (opts.needCloudBrowser && !cloudBrowserKey) {
+        throw new UsageError('Cloud browser commands need a cloud-browser key (pcb_live_…) from Cloud Platform → API Keys.\nSave it with: prompteryx login --cloud-browser-key pcb_live_…');
+    }
+    return new Prompteryx({ apiKey, cloudBrowserKey, baseUrl: baseUrl(cfg) });
+}
+// ── commands ─────────────────────────────────────────────────────────────────
+async function cmdLogin(args) {
+    const key = str(args.flags.key);
+    const cbKey = str(args.flags['cloud-browser-key']);
+    const base = str(args.flags['base-url']);
+    if (base)
+        updateConfig({ baseUrl: base });
+    if (cbKey) {
+        updateConfig({ cloudBrowserKey: cbKey });
+        console.log('Cloud-browser key saved.');
+    }
+    if (key) {
+        updateConfig({ apiKey: key, oauth: undefined });
+        const px = await client();
+        const me = await px.subscription.get().catch(() => null);
+        console.log(`API key saved to ${configPath()}${me?.tier ? ` (plan: ${me.tier})` : ''}.`);
+        return;
+    }
+    if (cbKey && !key)
+        return;
+    const oauth = await oauthLogin();
+    const px = await client();
+    const me = await px.subscription.get().catch(() => null);
+    console.log(`Signed in${me?.tier ? ` (plan: ${me.tier})` : ''}. Tokens saved to ${configPath()}; they refresh automatically.`);
+    void oauth;
+}
+async function cmdLogout() {
+    const cfg = readConfig();
+    if (cfg.oauth)
+        await revokeOAuth(cfg.oauth);
+    writeConfig({ baseUrl: cfg.baseUrl });
+    console.log('Signed out. Credentials removed from ' + configPath());
+}
+async function cmdWhoami() {
+    const cfg = readConfig();
+    const px = await client();
+    const sub = await px.subscription.get();
+    print({ auth: cfg.oauth ? 'oauth' : 'api-key', baseUrl: baseUrl(cfg), cloudBrowserKey: !!cfg.cloudBrowserKey, subscription: sub }, () => {
+        console.log(`Signed in via ${cfg.oauth ? 'OAuth (browser sign-in)' : 'API key'} to ${baseUrl(cfg)}`);
+        if (sub?.tier)
+            console.log(`Plan: ${sub.tier}`);
+        const u = sub?.usage ?? sub;
+        if (u?.aiCredits !== undefined || u?.aiCreditsUsed !== undefined) {
+            console.log(`AI credits used: ${u.aiCreditsUsed ?? '?'} / ${u.aiCredits ?? u.aiCreditsIncluded ?? '?'}`);
+        }
+        if (u?.cloudBrowserMinutes !== undefined)
+            console.log(`Cloud browser minutes used: ${u.cloudBrowserMinutes}`);
+        console.log(`Cloud-browser key: ${cfg.cloudBrowserKey ? 'saved' : 'not set (needed for `prompteryx browser`)'}`);
+    });
+}
+async function cmdAgent(args) {
+    const goal = args.positional.slice(1).join(' ').trim();
+    if (!goal)
+        throw new UsageError('Usage: prompteryx agent "what you want done" [--start-url URL] [--max-steps N] [--save-as-workflow] [--local]');
+    const px = await client();
+    console.error(`Running the AI browser agent${bool(args.flags.local) ? ' on your local Chrome' : ' in a cloud browser'}…`);
+    const result = await px.autopilot.run({
+        goal,
+        startUrl: str(args.flags['start-url']),
+        maxSteps: num(args.flags['max-steps']),
+        maxCredits: num(args.flags['max-credits']),
+        saveAsWorkflow: bool(args.flags['save-as-workflow']),
+        ...(bool(args.flags.local) ? { target: 'local' } : {}),
+    });
+    print(result, () => {
+        console.log(result.success ? 'Done.' : 'The agent did not complete the goal.');
+        if (result.finalAnswer)
+            console.log('\n' + result.finalAnswer);
+        if (result.savedWorkflowId)
+            console.log(`\nSaved as workflow ${result.savedWorkflowId}. Run it again with: prompteryx workflows run ${result.savedWorkflowId}`);
+        if (result.usage)
+            console.log(`\nAI credits: ${result.usage.aiCredits ?? '?'}  steps: ${result.steps?.length ?? result.usage.turns ?? '?'}${result.usage.costUSD != null ? `  cost: $${result.usage.costUSD}` : ''}`);
+    });
+}
+async function cmdWorkflows(args) {
+    const [, sub, id] = args.positional;
+    const px = await client();
+    switch (sub) {
+        case 'list': {
+            const rows = await px.workflows.list({ limit: num(args.flags.limit) ?? 50, search: str(args.flags.search) });
+            print(rows, () => table(rows.map((w) => ({ id: w.id, name: w.name, nodes: w.nodeCount ?? '', updated: (w.updatedAt || '').slice(0, 10) })), ['id', 'name', 'nodes', 'updated']));
+            return;
+        }
+        case 'get': {
+            if (!id)
+                throw new UsageError('Usage: prompteryx workflows get <id>');
+            print(await px.workflows.get(id));
+            return;
+        }
+        case 'run': {
+            if (!id)
+                throw new UsageError('Usage: prompteryx workflows run <id> [--input key=value …] [--wait] [--visible]');
+            const input = parseKeyValues(args.flags.input);
+            const execution = bool(args.flags.visible) ? { runMode: 'visible' } : undefined;
+            if (bool(args.flags.wait)) {
+                console.error('Running and waiting for the result…');
+                const rec = await px.workflows.runAndWait(id, { input, execution, timeoutMs: (num(args.flags.timeout) ?? 300) * 1000 });
+                print(rec, () => {
+                    console.log(`${rec.status}  (${rec.durationMs != null ? `${Math.round(rec.durationMs / 1000)}s` : ''}) run ${rec.id}`);
+                    if (rec.error)
+                        console.log(`Error: ${rec.error.message}${rec.error.nodeLabel ? ` at ${rec.error.nodeLabel}` : ''}`);
+                    if (rec.outputs)
+                        console.log(JSON.stringify(rec.outputs, null, 2));
+                });
+                return;
+            }
+            const started = await px.workflows.run(id, { input, execution });
+            print(started, () => console.log(`Started run ${started.executionId} (${started.status}). Follow it with: prompteryx runs wait ${started.executionId}`));
+            return;
+        }
+        default:
+            throw new UsageError('Usage: prompteryx workflows <list|get|run>');
+    }
+}
+async function cmdRuns(args) {
+    const [, sub, id] = args.positional;
+    if (!id)
+        throw new UsageError('Usage: prompteryx runs <get|wait|logs> <executionId>');
+    const px = await client();
+    switch (sub) {
+        case 'get':
+            print(await px.executions.get(id));
+            return;
+        case 'wait': {
+            const rec = await px.executions.wait(id, { timeoutMs: (num(args.flags.timeout) ?? 300) * 1000 });
+            print(rec, () => console.log(`${rec.status} run ${rec.id}${rec.error ? `\nError: ${rec.error.message}` : ''}`));
+            return;
+        }
+        case 'logs': {
+            const logs = await px.executions.logs(id);
+            print(logs, () => logs.forEach((l) => console.log(`${l.timestamp ?? l.time ?? ''} ${l.level ?? ''} ${l.nodeLabel ?? l.nodeId ?? ''} ${l.message ?? JSON.stringify(l)}`.trim())));
+            return;
+        }
+        default:
+            throw new UsageError('Usage: prompteryx runs <get|wait|logs> <executionId>');
+    }
+}
+async function cmdBrowser(args) {
+    const [, sub, id] = args.positional;
+    const local = bool(args.flags.local);
+    const px = await client({ needCloudBrowser: !local });
+    switch (sub) {
+        case 'create': {
+            const s = await px.cloudBrowser.sessions.create({
+                target: local ? 'local' : 'cloud',
+                recordSession: bool(args.flags.record),
+                captureDownloads: true,
+            });
+            print(s, () => {
+                console.log(`Session ${s.id} (${s.status})`);
+                console.log(`Connect with Playwright: chromium.connectOverCDP("${s.connectUrl}")`);
+                if (s.liveURL)
+                    console.log(`Watch it live: ${s.liveURL}`);
+                console.log(`Close it when done: prompteryx browser close ${s.id}`);
+            });
+            return;
+        }
+        case 'list': {
+            const rows = await px.cloudBrowser.sessions.list({ limit: num(args.flags.limit) ?? 20 });
+            print(rows, () => table(rows.map((r) => ({ id: r.id, status: r.status, started: (r.startedAt || r.createdAt || '').slice(0, 19) })), ['id', 'status', 'started']));
+            return;
+        }
+        case 'close': {
+            if (!id)
+                throw new UsageError('Usage: prompteryx browser close <sessionId>');
+            print(await px.cloudBrowser.sessions.close(id), () => console.log(`Closed ${id}`));
+            return;
+        }
+        default:
+            throw new UsageError('Usage: prompteryx browser <create|list|close> [--record] [--local]');
+    }
+}
+async function cmdSchedules(args) {
+    const [, sub] = args.positional;
+    const px = await client();
+    if (sub !== 'list')
+        throw new UsageError('Usage: prompteryx schedules list [--workflow <id>]');
+    const rows = await px.schedules.list({ workflowId: str(args.flags.workflow) });
+    print(rows, () => table(rows.map((s) => ({ id: s.id, workflow: s.workflowId, cron: s.cronExpression, tz: s.timezone ?? '', active: s.active ? 'yes' : 'no' })), ['id', 'workflow', 'cron', 'tz', 'active']));
+}
+async function cmdApps(args) {
+    const [, sub, app, action] = args.positional;
+    const px = await client();
+    const hub = px.connectHub;
+    if (!hub)
+        throw new UsageError('This SDK build has no Connect Hub support; upgrade @prompteryx/sdk to 0.4.2 or later.');
+    switch (sub) {
+        case 'list': {
+            const rows = await hub.listApps({ search: str(args.flags.search), limit: num(args.flags.limit) ?? 25 });
+            print(rows, () => table(rows.map((a) => ({ slug: a.slug, name: a.name, auth: a.authType ?? '' })), ['slug', 'name', 'auth']));
+            return;
+        }
+        case 'actions': {
+            if (!app)
+                throw new UsageError('Usage: prompteryx apps actions <app-slug>');
+            const rows = await hub.listActions(app);
+            print(rows, () => table(rows.map((a) => ({ action: a.action, name: a.name })), ['action', 'name']));
+            return;
+        }
+        case 'accounts': {
+            const rows = await hub.listAccounts();
+            print(rows, () => {
+                if (rows.length === 0)
+                    console.log('No connected accounts. Connect one at https://www.prompteryx.ai/connections');
+                else
+                    table(rows.map((a) => ({ id: a.id, app: a.app, label: a.label })), ['id', 'app', 'label']);
+            });
+            return;
+        }
+        case 'run': {
+            if (!app || !action)
+                throw new UsageError('Usage: prompteryx apps run <app> <action> --params \'{"to":"…"}\' [--account <id>]');
+            let params = {};
+            const raw = str(args.flags.params);
+            if (raw) {
+                try {
+                    params = JSON.parse(raw);
+                }
+                catch {
+                    throw new UsageError('--params must be valid JSON');
+                }
+            }
+            const res = await hub.run({ app, action, params, credentialId: str(args.flags.account) });
+            print(res);
+            return;
+        }
+        default:
+            throw new UsageError('Usage: prompteryx apps <list|actions|accounts|run>');
+    }
+}
+function cmdMcp(args) {
+    const [, target] = args.positional;
+    const cfg = readConfig();
+    const key = process.env.PROMPTERYX_API_KEY || cfg.apiKey || 'px_live_YOUR_KEY';
+    const base = baseUrl(cfg);
+    const stdio = { command: 'npx', args: ['-y', '@prompteryx/mcp-server'], env: { PROMPTERYX_API_KEY: key } };
+    switch (target) {
+        case 'claude-code':
+            console.log(`claude mcp add prompteryx -e PROMPTERYX_API_KEY=${key} -- npx -y @prompteryx/mcp-server`);
+            console.log(`# or the hosted endpoint (OAuth sign-in, no key):\nclaude mcp add --transport http prompteryx ${base}/api/mcp`);
+            return;
+        case 'cursor':
+            console.log(`cursor://anysphere.cursor-deeplink/mcp/install?name=prompteryx&config=${Buffer.from(JSON.stringify(stdio)).toString('base64')}`);
+            console.log('\n# or paste into .cursor/mcp.json:');
+            console.log(JSON.stringify({ mcpServers: { prompteryx: stdio } }, null, 2));
+            return;
+        case 'vscode':
+            console.log(`vscode:mcp/install?${encodeURIComponent(JSON.stringify({ name: 'prompteryx', ...stdio }))}`);
+            return;
+        case 'claude-desktop':
+            console.log('# Add to claude_desktop_config.json:');
+            console.log(JSON.stringify({ mcpServers: { prompteryx: stdio } }, null, 2));
+            return;
+        case 'http':
+            console.log(`${base}/api/mcp\n# Choose OAuth when your client asks how to sign in, or send X-API-Key: ${key}`);
+            return;
+        default:
+            throw new UsageError('Usage: prompteryx mcp <claude-code|cursor|vscode|claude-desktop|http>');
+    }
+}
+function help() {
+    console.log(`prompteryx ${VERSION} — Prompteryx from your terminal
+
+  login [--key px_live_…] [--cloud-browser-key pcb_live_…]   sign in (browser) or save keys
+  whoami | logout
+  agent "goal" [--start-url URL] [--max-steps N] [--save-as-workflow] [--local]
+  workflows list | get <id> | run <id> [--input k=v …] [--wait] [--visible]
+  runs get <id> | wait <id> | logs <id>
+  browser create [--record] [--local] | list | close <id>
+  schedules list [--workflow <id>]
+  apps list [--search q] | actions <app> | accounts | run <app> <action> --params '{…}'
+  mcp <claude-code|cursor|vscode|claude-desktop|http>        print the config for an AI client
+
+  --json on any command prints raw JSON.  PROMPTERYX_API_KEY / PROMPTERYX_API_URL override the saved config.
+  Docs: https://www.prompteryx.ai/docs/developers/cli`);
+}
+// ── main ─────────────────────────────────────────────────────────────────────
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    JSON_MODE = bool(args.flags.json);
+    const cmd = args.positional[0];
+    if (!cmd || cmd === 'help' || bool(args.flags.help))
+        return help();
+    if (cmd === 'version' || bool(args.flags.version))
+        return console.log(VERSION);
+    switch (cmd) {
+        case 'login': return cmdLogin(args);
+        case 'logout': return cmdLogout();
+        case 'whoami': return cmdWhoami();
+        case 'agent': return cmdAgent(args);
+        case 'workflows':
+        case 'workflow':
+        case 'wf': return cmdWorkflows(args);
+        case 'runs':
+        case 'run':
+        case 'executions': return cmdRuns(args);
+        case 'browser': return cmdBrowser(args);
+        case 'schedules': return cmdSchedules(args);
+        case 'apps':
+        case 'connect-hub': return cmdApps(args);
+        case 'mcp': return cmdMcp(args);
+        default:
+            throw new UsageError(`Unknown command "${cmd}". Run \`prompteryx help\`.`);
+    }
+}
+main().catch((err) => {
+    const name = err?.constructor?.name ?? '';
+    if (err instanceof UsageError)
+        console.error(err.message);
+    else if (name === 'AuthError')
+        console.error(`Not authorised: ${err.message}\nRun \`prompteryx login\` again.`);
+    else if (name === 'QuotaError')
+        console.error(`Plan limit: ${err.message}`);
+    else
+        console.error(err?.message || err);
+    process.exit(1);
+});

package/dist/login.js

@@ -0,0 +1,161 @@
+/**
+ * `prompteryx login` — OAuth 2.1 in the browser with a loopback redirect
+ * (RFC 8252), PKCE S256, dynamic client registration on first use, and
+ * refresh-token rotation on later runs. `login --key px_live_…` is the
+ * non-interactive alternative for servers and CI.
+ */
+import crypto from 'node:crypto';
+import http from 'node:http';
+import { spawn } from 'node:child_process';
+import { baseUrl, readConfig, updateConfig } from './config.js';
+const SCOPE = 'workflows executions browser integrations profile';
+const LOGIN_TIMEOUT_MS = 5 * 60_000;
+function openBrowser(url) {
+    if (process.env.BROWSER === 'none' || process.env.CI)
+        return; // print only (tests, headless servers)
+    try {
+        if (process.platform === 'win32')
+            spawn('cmd', ['/c', 'start', '', url], { stdio: 'ignore', detached: true }).unref();
+        else if (process.platform === 'darwin')
+            spawn('open', [url], { stdio: 'ignore', detached: true }).unref();
+        else
+            spawn('xdg-open', [url], { stdio: 'ignore', detached: true }).unref();
+    }
+    catch {
+        /* the URL is printed; the user can open it by hand */
+    }
+}
+async function tokenRequest(base, form) {
+    const res = await fetch(`${base}/api/oauth/token`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        body: new URLSearchParams(form),
+    });
+    const j = await res.json().catch(() => ({}));
+    if (!res.ok || !j.access_token) {
+        throw new Error(`Token request failed: ${j.error_description || j.error || `HTTP ${res.status}`}`);
+    }
+    return j;
+}
+function toState(clientId, tokens, email) {
+    return {
+        clientId,
+        accessToken: tokens.access_token,
+        refreshToken: tokens.refresh_token,
+        expiresAt: Date.now() + (Number(tokens.expires_in) || 3600) * 1000,
+        email,
+    };
+}
+async function registerClient(base) {
+    const res = await fetch(`${base}/api/oauth/register`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            client_name: 'Prompteryx CLI',
+            client_uri: 'https://www.prompteryx.ai/docs/developers/cli',
+            redirect_uris: ['http://127.0.0.1/callback', 'http://localhost/callback'],
+            token_endpoint_auth_method: 'none',
+        }),
+    });
+    const j = await res.json().catch(() => ({}));
+    if (!res.ok || !j.client_id) {
+        throw new Error(`Could not register the CLI with ${base}: ${j.error_description || j.error || `HTTP ${res.status}`}`);
+    }
+    return j.client_id;
+}
+/** Starts a loopback HTTP listener and resolves with its redirect URI. */
+function listenLoopback() {
+    return new Promise((resolve, reject) => {
+        const server = http.createServer();
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', () => {
+            const port = server.address().port;
+            resolve({ server, redirectUri: `http://127.0.0.1:${port}/callback` });
+        });
+    });
+}
+/** Waits for the browser to hit /callback with a code that matches `state`. */
+function waitForCode(server, state) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            server.close();
+            reject(new Error('Timed out waiting for the browser sign-in (5 minutes). Run `prompteryx login` again.'));
+        }, LOGIN_TIMEOUT_MS);
+        timer.unref();
+        server.on('request', (req, res) => {
+            const url = new URL(req.url || '/', 'http://127.0.0.1');
+            if (url.pathname !== '/callback') {
+                res.writeHead(404).end();
+                return;
+            }
+            const error = url.searchParams.get('error');
+            const code = url.searchParams.get('code');
+            const returnedState = url.searchParams.get('state');
+            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+            if (error || !code || returnedState !== state) {
+                res.end('<p style="font-family:sans-serif">Sign-in was cancelled or failed. You can close this tab.</p>');
+                clearTimeout(timer);
+                server.close();
+                reject(new Error(error ? `${error}: ${url.searchParams.get('error_description') || ''}`.trim() : 'Invalid sign-in callback'));
+                return;
+            }
+            res.end('<p style="font-family:sans-serif">Signed in to Prompteryx. You can close this tab and go back to the terminal.</p>');
+            clearTimeout(timer);
+            server.close();
+            resolve(code);
+        });
+    });
+}
+export async function oauthLogin() {
+    const base = baseUrl();
+    const clientId = readConfig().oauth?.clientId ?? (await registerClient(base));
+    const verifier = crypto.randomBytes(48).toString('base64url');
+    const challenge = crypto.createHash('sha256').update(verifier).digest('base64url');
+    const state = crypto.randomBytes(16).toString('base64url');
+    const { server, redirectUri } = await listenLoopback();
+    const pending = waitForCode(server, state);
+    const q = new URLSearchParams({
+        client_id: clientId,
+        redirect_uri: redirectUri,
+        response_type: 'code',
+        code_challenge: challenge,
+        code_challenge_method: 'S256',
+        scope: SCOPE,
+        state,
+        resource: `${base}/api/v1`,
+    });
+    const authorizeUrl = `${base}/oauth/authorize?${q}`;
+    console.log(`Opening your browser to sign in to Prompteryx.\nIf it does not open, visit:\n  ${authorizeUrl}\n`);
+    openBrowser(authorizeUrl);
+    const code = await pending;
+    const tokens = await tokenRequest(base, {
+        grant_type: 'authorization_code',
+        code,
+        client_id: clientId,
+        redirect_uri: redirectUri,
+        code_verifier: verifier,
+    });
+    const oauth = toState(clientId, tokens);
+    updateConfig({ oauth, apiKey: undefined });
+    return oauth;
+}
+/** Returns a valid access token, refreshing (and rotating) when within 60s of expiry. */
+export async function ensureFreshOAuth(oauth) {
+    if (oauth.expiresAt - Date.now() > 60_000)
+        return oauth;
+    const tokens = await tokenRequest(baseUrl(), {
+        grant_type: 'refresh_token',
+        refresh_token: oauth.refreshToken,
+        client_id: oauth.clientId,
+    });
+    const next = toState(oauth.clientId, tokens, oauth.email);
+    updateConfig({ oauth: next });
+    return next;
+}
+export async function revokeOAuth(oauth) {
+    await fetch(`${baseUrl()}/api/oauth/revoke`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        body: new URLSearchParams({ token: oauth.refreshToken }),
+    }).catch(() => { });
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "prompteryx",
+  "version": "0.1.0",
+  "description": "Prompteryx command line: run AI browser agents, cloud browsers, workflows and Connect Hub actions from your terminal.",
+  "author": "Prompteryx <support@prompteryx.ai>",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "prompteryx": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "prompteryx",
+    "cli",
+    "browser-automation",
+    "ai-agent",
+    "workflow",
+    "mcp"
+  ],
+  "dependencies": {
+    "@prompteryx/sdk": "^0.4.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "typescript": "^5.4.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}