autokap 1.0.6 → 1.0.8

package/dist/cli.js

@@ -3,32 +3,129 @@ import { Command } from 'commander';
 import { createRequire } from 'node:module';
 import path from 'node:path';
 import fs from 'node:fs/promises';
-import WebSocket from 'ws';
 const require = createRequire(import.meta.url);
 const { version } = require('../package.json');
-import { Browser } from './browser.js';
 import { logger } from './logger.js';
-import { writeConfig, requireConfig, DEFAULT_API_BASE_URL, DEFAULT_WS_URL, } from './cli-config.js';
-import { replaceSkillPlaceholders } from './cli-utils.js';
+import { writeConfig, deleteConfig, requireConfig, getConfigPath, DEFAULT_API_BASE_URL, getDefaultApiBaseUrl, getDefaultWsUrl, LOCAL_API_BASE_URL, LOCAL_WS_URL, API_BASE_URL_ENV_VAR, WS_URL_ENV_VAR, } from './cli-config.js';
+import { renderSkillSingleFile, writeSkillExport } from './skill-packaging.js';
 // ── Program definition ──────────────────────────────────────────────
 export const program = new Command();
 program
     .name('autokap')
     .version(version)
     .description('AI-powered screenshot capture — local Playwright proxy');
+function fatal(message) {
+    logger.error(message);
+    process.exit(1);
+}
+function authHeaders(config, extra = {}) {
+    return {
+        Authorization: `Bearer ${config.apiKey}`,
+        ...extra,
+    };
+}
+function buildApiUrl(config, pathname, searchParams) {
+    const suffix = searchParams && Array.from(searchParams.keys()).length > 0
+        ? `?${searchParams.toString()}`
+        : '';
+    return `${config.apiBaseUrl}${pathname}${suffix}`;
+}
+async function readApiError(response) {
+    const body = await response.json().catch(() => ({ error: response.statusText }));
+    return body.error || response.statusText;
+}
+async function requestJson(config, pathname, init, errorPrefix, searchParams) {
+    try {
+        const response = await fetch(buildApiUrl(config, pathname, searchParams), init);
+        if (!response.ok) {
+            fatal(`${errorPrefix}: ${await readApiError(response)}`);
+        }
+        return await response.json();
+    }
+    catch (error) {
+        fatal(`${errorPrefix}: ${error.message}`);
+    }
+}
+async function requestText(config, pathname, init, errorPrefix, searchParams) {
+    try {
+        const response = await fetch(buildApiUrl(config, pathname, searchParams), init);
+        if (!response.ok) {
+            fatal(`${errorPrefix}: ${await readApiError(response)}`);
+        }
+        return await response.text();
+    }
+    catch (error) {
+        fatal(`${errorPrefix}: ${error.message}`);
+    }
+}
+function ensureListFormat(format) {
+    if (format !== 'json' && format !== 'table') {
+        fatal('Invalid --format. Use "json" or "table".');
+    }
+    return format;
+}
+function ensureExportFormat(format) {
+    if (format !== 'json' && format !== 'csv') {
+        fatal('Invalid --format. Use "json" or "csv".');
+    }
+    return format;
+}
+function printJson(value) {
+    console.log(JSON.stringify(value, null, 2));
+}
+function buildEndpointAssetUrl(config, endpointId) {
+    return `${config.apiBaseUrl}/api/v1/assets/${endpointId}`;
+}
+function toEndpointOutputRow(config, endpoint) {
+    return {
+        ...endpoint,
+        url: buildEndpointAssetUrl(config, endpoint.id),
+    };
+}
+function toCsv(rows, columns) {
+    const escape = (value) => {
+        const text = value === null || value === undefined ? '' : String(value);
+        return /[",\n]/.test(text) ? `"${text.replace(/"/g, '""')}"` : text;
+    };
+    const header = columns.join(',');
+    const body = rows.map((row) => columns.map((column) => escape(row[column])).join(','));
+    return [header, ...body].join('\n');
+}
+async function loadProject(config, projectId) {
+    const data = await requestJson(config, `/api/v1/projects/${projectId}`, { headers: authHeaders(config) }, 'Failed to get project');
+    return data.project;
+}
+async function listProjectAccounts(config, projectId) {
+    const data = await requestJson(config, `/api/cli/projects/${projectId}/credentials`, { headers: authHeaders(config) }, 'Failed to list accounts');
+    return data.accounts;
+}
+async function resolveProjectAccount(config, projectId, accountNameOrId) {
+    const accounts = await listProjectAccounts(config, projectId);
+    const needle = accountNameOrId.toLowerCase();
+    const account = accounts.find((candidate) => candidate.id === accountNameOrId ||
+        candidate.name.toLowerCase() === needle);
+    if (!account) {
+        const available = accounts.map((candidate) => candidate.name).join(', ');
+        fatal(available
+            ? `Account "${accountNameOrId}" not found. Available accounts: ${available}`
+            : `Account "${accountNameOrId}" not found. This project has no accounts.`);
+    }
+    return account;
+}
 // ── login command ───────────────────────────────────────────────────
 program
     .command('login <key>')
-    .description('Authenticate with the AutoKap API')
-    .option('--api-base-url <url>', 'API base URL', DEFAULT_API_BASE_URL)
-    .option('--ws-url <url>', 'WebSocket server URL', DEFAULT_WS_URL)
+    .description('Authenticate the AutoKap CLI with your CLI key')
+    .option('--api-base-url <url>', `API base URL (env: ${API_BASE_URL_ENV_VAR})`, getDefaultApiBaseUrl())
+    .option('--ws-url <url>', `WebSocket server URL (env: ${WS_URL_ENV_VAR})`)
     .action(async (key, opts) => {
+    const wsUrl = opts.wsUrl?.trim() || getDefaultWsUrl(opts.apiBaseUrl);
     try {
         const res = await fetch(`${opts.apiBaseUrl}/api/cli/validate`, {
             headers: { Authorization: `Bearer ${key}` },
         });
         if (!res.ok) {
-            logger.error('Invalid API key. Generate one in the AutoKap dashboard.');
+            logger.error('Invalid CLI key. Generate one in the AutoKap dashboard.');
             process.exit(1);
         }
     }
@@ -39,291 +136,947 @@ program
     await writeConfig({
         apiKey: key,
         apiBaseUrl: opts.apiBaseUrl,
-        wsUrl: opts.wsUrl,
+        wsUrl,
     });
-    logger.success('Authenticated. Key stored in ~/.autokap/config.json');
+    logger.success(`Authenticated. Key stored in ${getConfigPath()}`);
     process.exit(0);
 });
-// ── run command ─────────────────────────────────────────────────────
+// ── ping command ───────────────────────────────────────────────────
+program
+    .command('ping')
+    .description('Verify CLI connection with the AutoKap server')
+    .action(async () => {
+    const config = await requireConfig();
+    try {
+        const res = await fetch(`${config.apiBaseUrl}/api/cli/validate`, {
+            headers: { Authorization: `Bearer ${config.apiKey}` },
+        });
+        if (!res.ok) {
+            logger.error('CLI key is no longer valid. Run `npx autokap@latest init --cli-key <key>` to re-authenticate.');
+            process.exit(1);
+        }
+    }
+    catch (err) {
+        logger.error(`Cannot reach API: ${err.message}`);
+        process.exit(1);
+    }
+    logger.success('Connection verified. Stored CLI key is active.');
+    process.exit(0);
+});
+// ── logout command ─────────────────────────────────────────────────
+program
+    .command('logout')
+    .description('Remove stored credentials')
+    .action(async () => {
+    await deleteConfig();
+    logger.success(`Logged out. Credentials removed from ${getConfigPath()}`);
+    process.exit(0);
+});
+// ── whoami command ─────────────────────────────────────────────────
+program
+    .command('whoami')
+    .description('Show the account linked to the current CLI key')
+    .action(async () => {
+    const config = await requireConfig();
+    try {
+        const res = await fetch(`${config.apiBaseUrl}/api/cli/validate`, {
+            headers: { Authorization: `Bearer ${config.apiKey}` },
+        });
+        if (!res.ok) {
+            logger.error('CLI key is no longer valid. Run `npx autokap@latest init --cli-key <key>` to re-authenticate.');
+            process.exit(1);
+        }
+        const data = await res.json();
+        const display = data.name
+            ? `${data.name} (${data.email})`
+            : data.email ?? 'Unknown';
+        logger.info(`Logged in as: ${display}`);
+        logger.info(`Server: ${config.apiBaseUrl}`);
+    }
+    catch (err) {
+        logger.error(`Cannot reach API: ${err.message}`);
+        process.exit(1);
+    }
+    process.exit(0);
+});
+// ── run command (deterministic capture engine) ───────────────────────
 program
     .command('run <preset-id>')
-    .description('Run a preset capture using local Playwright')
+    .description('Run a capture using the deterministic opcode engine (local Playwright)')
     .option('--headed', 'Show browser window for debugging', false)
+    .option('--local', `Use the local AutoKap dev server (${LOCAL_API_BASE_URL})`, false)
+    .option('--output <dir>', 'Optional output directory for local artifact copies')
+    .option('--program <file>', 'Path to a program JSON file')
+    .option('--debug', 'Verbose logging: per-substep timing, opcode dumps, recovery strategy traces', false)
     .action(async (presetId, opts) => {
+    if (opts.debug) {
+        const { setDebugEnabled } = await import('./logger.js');
+        setDebugEnabled(true);
+        logger.info('[capture] Debug mode enabled — verbose logging on');
+    }
+    if (opts.local) {
+        process.env[API_BASE_URL_ENV_VAR] = LOCAL_API_BASE_URL;
+        process.env[WS_URL_ENV_VAR] = LOCAL_WS_URL;
+        logger.info(`Using local AutoKap dev server: ${LOCAL_API_BASE_URL}`);
+    }
+    const { runLocal } = await import('./cli-runner-local.js');
+    await runLocal(presetId, opts);
+});
+// ── project commands ───────────────────────────────────────────────
+const projectCmd = program
+    .command('project')
+    .description('Manage projects');
+projectCmd
+    .command('list')
+    .description('List accessible projects')
+    .action(async () => {
     const config = await requireConfig();
-    logger.info(`Connecting to ${config.wsUrl}...`);
-    const browser = new Browser({
-        headed: opts.headed,
-        viewport: { width: 1440, height: 900 },
+    const data = await requestJson(config, '/api/v1/projects', { headers: authHeaders(config) }, 'Failed to list projects');
+    printJson(data.projects);
+    process.exit(0);
+});
+projectCmd
+    .command('get <project-id>')
+    .description('Get project details')
+    .action(async (projectId) => {
+    const config = await requireConfig();
+    const project = await loadProject(config, projectId);
+    printJson(project);
+    process.exit(0);
+});
+projectCmd
+    .command('create')
+    .description('Create a project')
+    .requiredOption('--name <name>', 'Project name')
+    .requiredOption('--url <url>', 'Project URL')
+    .option('--description <text>', 'Project description')
+    .action(async (opts) => {
+    const config = await requireConfig();
+    const data = await requestJson(config, '/api/v1/projects', {
+        method: 'POST',
+        headers: authHeaders(config, { 'Content-Type': 'application/json' }),
+        body: JSON.stringify({
+            name: opts.name,
+            url: opts.url,
+            description: opts.description,
+        }),
+    }, 'Failed to create project');
+    console.log(data.project.id);
+    process.exit(0);
+});
+// ── capture commands ───────────────────────────────────────────────
+const captureCmd = program
+    .command('capture')
+    .description('Query captured outputs');
+captureCmd
+    .command('list')
+    .description('List captures')
+    .option('--project <id>', 'Filter by project ID')
+    .option('--preset <id>', 'Filter by preset ID')
+    .option('--limit <n>', 'Limit results', '50')
+    .option('--offset <n>', 'Offset results', '0')
+    .action(async (opts) => {
+    const config = await requireConfig();
+    const searchParams = new URLSearchParams();
+    if (opts.project)
+        searchParams.set('project_id', opts.project);
+    if (opts.preset)
+        searchParams.set('preset_id', opts.preset);
+    searchParams.set('limit', String(Math.max(1, Number.parseInt(opts.limit, 10) || 50)));
+    searchParams.set('offset', String(Math.max(0, Number.parseInt(opts.offset, 10) || 0)));
+    const data = await requestJson(config, '/api/v1/captures', { headers: authHeaders(config) }, 'Failed to list captures', searchParams);
+    printJson(data);
+    process.exit(0);
+});
+program
+    .command('usage')
+    .description('Show usage for the current billing period')
+    .action(async () => {
+    const config = await requireConfig();
+    const data = await requestJson(config, '/api/v1/usage', { headers: authHeaders(config) }, 'Failed to get usage');
+    printJson(data);
+    process.exit(0);
+});
+// ── preset commands ────────────────────────────────────────────────
+async function readJsonInput(filePath) {
+    if (filePath === '-') {
+        const chunks = [];
+        for await (const chunk of process.stdin)
+            chunks.push(chunk);
+        return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    }
+    const raw = await fs.readFile(filePath, 'utf8');
+    return JSON.parse(raw);
+}
+const presetCmd = program
+    .command('preset')
+    .description('Manage capture presets');
+presetCmd
+    .command('create')
+    .description('Create a new preset from a JSON config file')
+    .requiredOption('--project <id>', 'Project ID')
+    .requiredOption('--name <name>', 'Preset name')
+    .option('--description <text>', 'Preset description', '')
+    .requiredOption('--config <file>', 'Path to config JSON file (use "-" for stdin)')
+    .action(async (opts) => {
+    const cfg = await requireConfig();
+    let configJson;
+    try {
+        configJson = await readJsonInput(opts.config);
+    }
+    catch (err) {
+        logger.error(`Failed to read config: ${err.message}`);
+        process.exit(1);
+    }
+    const res = await fetch(`${cfg.apiBaseUrl}/api/v1/presets`, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${cfg.apiKey}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            project_id: opts.project,
+            name: opts.name,
+            description: opts.description,
+            config: configJson,
+        }),
     });
-    await browser.launch();
-    logger.success('Browser launched');
-    const wsUrl = `${config.wsUrl}?key=${encodeURIComponent(config.apiKey)}&preset_id=${encodeURIComponent(presetId)}`;
-    const ws = new WebSocket(wsUrl);
-    const cleanup = async () => {
-        try {
-            await browser.close();
-        }
-        catch { /* ignore */ }
-        try {
-            ws.close();
-        }
-        catch { /* ignore */ }
-    };
-    ws.on('error', async (err) => {
-        logger.error(`WebSocket error: ${err.message}`);
-        await cleanup();
+    if (!res.ok) {
+        const body = await res.json().catch(() => ({ error: res.statusText }));
+        logger.error(`Failed to create preset: ${body.error || res.statusText}`);
         process.exit(1);
+    }
+    const data = await res.json();
+    // Output only the preset ID so callers can chain: autokap run $(autokap preset create ...)
+    console.log(data.preset.id);
+    process.exit(0);
+});
+presetCmd
+    .command('update <preset-id>')
+    .description('Update an existing preset config')
+    .option('--name <name>', 'New preset name')
+    .option('--description <text>', 'New description')
+    .requiredOption('--config <file>', 'Path to config JSON file (use "-" for stdin)')
+    .action(async (presetId, opts) => {
+    const cfg = await requireConfig();
+    let configJson;
+    try {
+        configJson = await readJsonInput(opts.config);
+    }
+    catch (err) {
+        logger.error(`Failed to read config: ${err.message}`);
+        process.exit(1);
+    }
+    const payload = { config: configJson };
+    if (opts.name !== undefined)
+        payload.name = opts.name;
+    if (opts.description !== undefined)
+        payload.description = opts.description;
+    const res = await fetch(`${cfg.apiBaseUrl}/api/v1/presets/${presetId}`, {
+        method: 'PATCH',
+        headers: {
+            Authorization: `Bearer ${cfg.apiKey}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(payload),
     });
-    ws.on('close', async () => {
-        await cleanup();
+    if (!res.ok) {
+        const body = await res.json().catch(() => ({ error: res.statusText }));
+        logger.error(`Failed to update preset: ${body.error || res.statusText}`);
+        process.exit(1);
+    }
+    const data = await res.json();
+    console.log(data.preset.id);
+    process.exit(0);
+});
+presetCmd
+    .command('delete <preset-id>')
+    .description('Delete a preset (soft-delete)')
+    .action(async (presetId) => {
+    const cfg = await requireConfig();
+    const res = await fetch(`${cfg.apiBaseUrl}/api/v1/presets/${presetId}`, {
+        method: 'DELETE',
+        headers: { Authorization: `Bearer ${cfg.apiKey}` },
     });
-    ws.on('open', () => {
-        logger.success('Connected to AutoKap server');
+    if (!res.ok) {
+        const body = await res.json().catch(() => ({ error: res.statusText }));
+        logger.error(`Failed to delete preset: ${body.error || res.statusText}`);
+        process.exit(1);
+    }
+    logger.success(`Preset ${presetId} deleted`);
+    process.exit(0);
+});
+presetCmd
+    .command('get <preset-id>')
+    .description('Get preset details')
+    .action(async (presetId) => {
+    const cfg = await requireConfig();
+    const res = await fetch(`${cfg.apiBaseUrl}/api/v1/presets/${presetId}`, {
+        headers: { Authorization: `Bearer ${cfg.apiKey}` },
     });
-    ws.on('message', async (data) => {
-        const raw = typeof data === 'string' ? data : data.toString('utf-8');
-        let msg;
-        try {
-            msg = JSON.parse(raw);
+    if (!res.ok) {
+        const body = await res.json().catch(() => ({ error: res.statusText }));
+        logger.error(`Failed to get preset: ${body.error || res.statusText}`);
+        process.exit(1);
+    }
+    const data = await res.json();
+    console.log(JSON.stringify(data.preset, null, 2));
+    process.exit(0);
+});
+presetCmd
+    .command('list')
+    .description('List presets for a project')
+    .requiredOption('--project <id>', 'Project ID')
+    .action(async (opts) => {
+    const cfg = await requireConfig();
+    const res = await fetch(`${cfg.apiBaseUrl}/api/v1/presets?project_id=${encodeURIComponent(opts.project)}`, { headers: { Authorization: `Bearer ${cfg.apiKey}` } });
+    if (!res.ok) {
+        const body = await res.json().catch(() => ({ error: res.statusText }));
+        logger.error(`Failed to list presets: ${body.error || res.statusText}`);
+        process.exit(1);
+    }
+    const data = await res.json();
+    const rows = data.presets.map((p) => ({
+        id: p.id,
+        name: p.name,
+        description: p.description ?? '',
+    }));
+    console.log(JSON.stringify(rows, null, 2));
+    process.exit(0);
+});
+presetCmd
+    .command('info <preset-id>')
+    .description('Get structured integration info for a preset (endpoints, variants, URL params)')
+    .action(async (presetId) => {
+    const cfg = await requireConfig();
+    // Fetch preset + endpoints in parallel
+    const [presetRes, endpointsRes] = await Promise.all([
+        fetch(`${cfg.apiBaseUrl}/api/v1/presets/${presetId}`, {
+            headers: { Authorization: `Bearer ${cfg.apiKey}` },
+        }),
+        fetch(`${cfg.apiBaseUrl}/api/v1/endpoints?preset_id=${encodeURIComponent(presetId)}`, {
+            headers: { Authorization: `Bearer ${cfg.apiKey}` },
+        }),
+    ]);
+    if (!presetRes.ok) {
+        const body = await presetRes.json().catch(() => ({ error: presetRes.statusText }));
+        logger.error(`Failed to get preset: ${body.error || presetRes.statusText}`);
+        process.exit(1);
+    }
+    if (!endpointsRes.ok) {
+        const body = await endpointsRes.json().catch(() => ({ error: endpointsRes.statusText }));
+        logger.error(`Failed to list endpoints: ${body.error || endpointsRes.statusText}`);
+        process.exit(1);
+    }
+    const { preset } = await presetRes.json();
+    const { endpoints } = await endpointsRes.json();
+    // Extract variants from config
+    const config = preset.config ?? {};
+    const langs = Array.isArray(config.langs) ? config.langs : [];
+    const themes = Array.isArray(config.themes) ? config.themes : [];
+    const targets = Array.isArray(config.targets)
+        ? config.targets
+            .map((t) => ({ id: t.id, label: t.label, viewport: t.viewport, deviceFrame: t.deviceFrame ?? null }))
+        : [];
+    const captureMode = config.captureMode ?? 'screenshot';
+    // Build per-endpoint info with type-specific URL params
+    const endpointEntries = endpoints.map((ep) => {
+        const assetType = ep.asset_type ?? 'screenshot';
+        const url = assetType === 'interactive_demo'
+            ? `${cfg.apiBaseUrl}/demo/${presetId}`
+            : `${cfg.apiBaseUrl}/api/v1/assets/${ep.id}`;
+        let urlParams;
+        if (assetType === 'interactive_demo') {
+            urlParams = {
+                embed: 'Set to "1" for iframe embedding',
+                lang: 'Language variant',
+                theme: 'Color theme ("light" or "dark")',
+                target: 'Device target ID',
+            };
         }
-        catch {
-            return;
+        else if (assetType === 'screenshot') {
+            urlParams = {
+                lang: 'Language variant',
+                theme: 'Color theme ("light" or "dark")',
+                target: 'Device target ID',
+                w: 'Max width in px (1-2560)',
+                quality: 'Image quality 1-100',
+                format: 'Output format: "webp", "png", "jpg"',
+                scale: 'Resolution multiplier (0.5-4)',
+                render: 'Set to "studio" for Studio render',
+                slot: 'Studio composition slot',
+            };
         }
-        // Handle server events (progress, done, error)
-        if ('type' in msg) {
-            const event = msg;
-            switch (event.type) {
-                case 'progress':
-                    logger.info(event.message ?? '');
-                    break;
-                case 'done':
-                    if (event.summary) {
-                        logger.success(`Done: ${event.summary.successes}/${event.summary.total} captures succeeded`);
-                    }
-                    await cleanup();
-                    process.exit(0);
-                    break;
-                case 'error':
-                    logger.error(event.message ?? 'Unknown error');
-                    await cleanup();
-                    process.exit(1);
-                    break;
-            }
-            return;
+        else if (assetType === 'clip') {
+            urlParams = {
+                lang: 'Language variant',
+                theme: 'Color theme ("light" or "dark")',
+                target: 'Device target ID',
+                format: 'Output format: "gif" (default), "mp4"',
+                render: 'Set to "studio" for Studio render',
+                slot: 'Studio composition slot',
+            };
         }
-        // Handle browser commands from server
-        const cmd = msg;
-        try {
-            const result = await executeBrowserCommand(browser, cmd.method, cmd.params);
-            ws.send(JSON.stringify({ id: cmd.id, result }));
+        else if (assetType === 'composition') {
+            urlParams = {
+                scale: 'Resolution multiplier (0.5-4)',
+                format: 'Output format: "png", "webp", "jpg"',
+            };
         }
-        catch (err) {
-            ws.send(JSON.stringify({ id: cmd.id, error: err.message }));
+        else {
+            urlParams = {};
         }
+        return {
+            id: ep.id,
+            label: ep.label ?? null,
+            capture_name: ep.capture_name ?? null,
+            asset_type: assetType,
+            url,
+            url_params: urlParams,
+        };
     });
-    // Handle SIGINT gracefully
-    process.on('SIGINT', async () => {
-        logger.info('Interrupted. Cleaning up...');
-        await cleanup();
-        process.exit(130);
+    const info = {
+        preset: {
+            id: preset.id,
+            name: preset.name,
+            description: preset.description ?? null,
+            capture_mode: captureMode,
+        },
+        variants: { langs, themes, targets },
+        endpoints: endpointEntries,
+    };
+    if (captureMode === 'interactive_demo') {
+        info.interactive_demo = {
+            url: `${cfg.apiBaseUrl}/demo/${presetId}`,
+            embed_url: `${cfg.apiBaseUrl}/demo/${presetId}?embed=1`,
+        };
+    }
+    console.log(JSON.stringify(info, null, 2));
+    process.exit(0);
+});
+// ── auth commands ──────────────────────────────────────────────────
+const authCmd = program
+    .command('auth')
+    .description('Manage authentication sessions for project credentials accounts');
+authCmd
+    .command('capture <project-id>')
+    .description('Open a browser, let you log in, and save the resulting session to a project credentials account')
+    .option('--account <name-or-id>', 'Account name or ID to attach the session to. If omitted, lists accounts to choose from.')
+    .option('--url <url>', 'URL to open in the browser. Defaults to the project URL.')
+    .action(async (projectId, opts) => {
+    const cfg = await requireConfig();
+    const allAccounts = await listProjectAccounts(cfg, projectId);
+    const accounts = allAccounts.filter((a) => a.type === 'session');
+    if (!accounts.length) {
+        if (allAccounts.length > 0) {
+            logger.error(`No session-type accounts in project ${projectId}. This project has ${allAccounts.length} credentials account(s), but none are session accounts. Create a new account with type "session" in Settings → Login accounts.`);
+        }
+        else {
+            logger.error(`No accounts found for project ${projectId}. Create a session account in Settings → Login accounts first.`);
+        }
+        process.exit(1);
+    }
+    let account;
+    if (opts.account) {
+        const needle = opts.account.toLowerCase();
+        account = accounts.find((a) => a.id === opts.account || a.name.toLowerCase() === needle);
+        if (!account) {
+            // If the account exists but is a credentials account, give a precise error.
+            const otherTypeMatch = allAccounts.find((a) => a.id === opts.account || a.name.toLowerCase() === needle);
+            if (otherTypeMatch) {
+                logger.error(`Account "${opts.account}" exists but is a credentials account (email/password). auth capture only works with session accounts.`);
+            }
+            else {
+                logger.error(`Account "${opts.account}" not found in project ${projectId}.`);
+                logger.info(`Available session accounts: ${accounts.map((a) => a.name).join(', ')}`);
+            }
+            process.exit(1);
+        }
+    }
+    else if (accounts.length === 1) {
+        account = accounts[0];
+        logger.info(`Using the only session account in this project: "${account.name}"`);
+    }
+    else {
+        logger.info('Multiple session accounts found. Re-run with --account <name>:');
+        for (const a of accounts) {
+            const status = a.storage_state_updated_at
+                ? `session updated ${a.storage_state_updated_at}`
+                : 'no session yet';
+            logger.info(`  • ${a.name}  (${status})`);
+        }
+        process.exit(0);
+    }
+    const startUrl = opts.url || (await loadProject(cfg, projectId)).url;
+    logger.info(`Opening ${startUrl}`);
+    const { captureAuthSession } = await import('./auth-capture.js');
+    await captureAuthSession({
+        apiBaseUrl: cfg.apiBaseUrl,
+        apiKey: cfg.apiKey,
+        projectId,
+        accountId: account.id,
+        startUrl,
     });
 });
-// ── skill command ───────────────────────────────────────────────────
-program
-    .command('skill')
-    .description('Output or install the AutoKap preset creation skill for AI coding agents')
-    .option('--output <path>', 'Write skill file to this path instead of stdout')
-    .option('--project-url <url>', 'Replace the project URL placeholder in the skill')
-    .option('--project-id <id>', 'Replace the project ID placeholder in the skill')
-    .option('--api-key <key>', 'Replace the API key placeholder in the skill')
-    .option('--api-base-url <url>', 'Replace the API base URL placeholder (default: https://app.autokap.com)')
+const authAccountCmd = authCmd
+    .command('account')
+    .description('Manage project credential accounts');
+authAccountCmd
+    .command('list <project-id>')
+    .description('List accounts for a project')
+    .action(async (projectId) => {
+    const config = await requireConfig();
+    const accounts = await listProjectAccounts(config, projectId);
+    printJson(accounts);
+    process.exit(0);
+});
+authAccountCmd
+    .command('create <project-id>')
+    .description('Create a project credential account')
+    .requiredOption('--name <name>', 'Account name')
+    .option('--type <type>', 'Account type: credentials or session', 'credentials')
+    .option('--email <email>', 'Email for credentials accounts')
+    .option('--password <password>', 'Password for credentials accounts')
+    .option('--login-url <url>', 'Login URL for credentials accounts')
+    .action(async (projectId, opts) => {
+    const type = opts.type === 'session' ? 'session' : opts.type === 'credentials' ? 'credentials' : null;
+    if (!type) {
+        fatal('Invalid --type. Use "credentials" or "session".');
+    }
+    if (type === 'session' && (opts.email || opts.password || opts.loginUrl)) {
+        fatal('Session accounts do not accept --email, --password, or --login-url.');
+    }
+    const config = await requireConfig();
+    const data = await requestJson(config, `/api/cli/projects/${projectId}/credentials`, {
+        method: 'POST',
+        headers: authHeaders(config, { 'Content-Type': 'application/json' }),
+        body: JSON.stringify({
+            name: opts.name,
+            type,
+            email: opts.email,
+            password: opts.password,
+            loginUrl: opts.loginUrl,
+        }),
+    }, 'Failed to create account');
+    console.log(data.account.id);
+    process.exit(0);
+});
+authAccountCmd
+    .command('update <project-id>')
+    .description('Update a project credential account')
+    .requiredOption('--account <name-or-id>', 'Account name or ID')
+    .option('--name <name>', 'New account name')
+    .option('--email <email>', 'Replace the email on a credentials account')
+    .option('--password <password>', 'Replace the password on a credentials account')
+    .option('--login-url <url>', 'Replace the login URL on a credentials account')
+    .option('--clear-email', 'Remove the stored email from a credentials account', false)
+    .option('--clear-password', 'Remove the stored password from a credentials account', false)
+    .option('--clear-login-url', 'Remove the stored login URL from a credentials account', false)
+    .action(async (projectId, opts) => {
+    if (opts.email && opts.clearEmail)
+        fatal('Cannot use --email and --clear-email together.');
+    if (opts.password && opts.clearPassword)
+        fatal('Cannot use --password and --clear-password together.');
+    if (opts.loginUrl && opts.clearLoginUrl)
+        fatal('Cannot use --login-url and --clear-login-url together.');
+    const config = await requireConfig();
+    const account = await resolveProjectAccount(config, projectId, opts.account);
+    const payload = {};
+    if (opts.name !== undefined)
+        payload.name = opts.name;
+    if (opts.email !== undefined)
+        payload.email = opts.email;
+    if (opts.password !== undefined)
+        payload.password = opts.password;
+    if (opts.loginUrl !== undefined)
+        payload.loginUrl = opts.loginUrl;
+    if (opts.clearEmail)
+        payload.email = null;
+    if (opts.clearPassword)
+        payload.password = null;
+    if (opts.clearLoginUrl)
+        payload.loginUrl = null;
+    if (Object.keys(payload).length === 0) {
+        fatal('No changes provided. Pass at least one update option.');
+    }
+    const data = await requestJson(config, `/api/cli/projects/${projectId}/credentials/${account.id}`, {
+        method: 'PATCH',
+        headers: authHeaders(config, { 'Content-Type': 'application/json' }),
+        body: JSON.stringify(payload),
+    }, 'Failed to update account');
+    console.log(data.account.id);
+    process.exit(0);
+});
+authAccountCmd
+    .command('delete <project-id>')
+    .description('Delete a project credential account')
+    .requiredOption('--account <name-or-id>', 'Account name or ID')
+    .action(async (projectId, opts) => {
+    const config = await requireConfig();
+    const account = await resolveProjectAccount(config, projectId, opts.account);
+    await requestJson(config, `/api/cli/projects/${projectId}/credentials/${account.id}`, {
+        method: 'DELETE',
+        headers: authHeaders(config),
+    }, 'Failed to delete account');
+    logger.success(`Account ${account.name} deleted`);
+    process.exit(0);
+});
+const authSessionCmd = authCmd
+    .command('session')
+    .description('Manage captured browser sessions');
+authSessionCmd
+    .command('clear <project-id>')
+    .description('Clear the stored browser session for a session account')
+    .requiredOption('--account <name-or-id>', 'Account name or ID')
+    .action(async (projectId, opts) => {
+    const config = await requireConfig();
+    const account = await resolveProjectAccount(config, projectId, opts.account);
+    if (account.type !== 'session') {
+        fatal(`Account "${account.name}" is a credentials account. Only session accounts can clear a stored browser session.`);
+    }
+    await requestJson(config, `/api/cli/projects/${projectId}/credentials/${account.id}/session`, {
+        method: 'DELETE',
+        headers: authHeaders(config),
+    }, 'Failed to clear session');
+    logger.success(`Cleared session for ${account.name}`);
+    process.exit(0);
+});
+// ── endpoints commands ─────────────────────────────────────────────
+const endpointsCmd = program
+    .command('endpoints')
+    .description('Manage screenshot endpoints (dev links)');
+endpointsCmd
+    .command('list')
+    .description('List endpoints for a preset or project')
+    .option('--preset <id>', 'Preset ID')
+    .option('--project <id>', 'Project ID')
+    .option('--format <fmt>', 'Output format: json or table', 'json')
     .action(async (opts) => {
-    const skillPath = path.resolve(path.dirname(new URL(import.meta.url).pathname), '..', 'assets', 'skill', 'SKILL.md');
-    let rawContent;
-    try {
-        rawContent = await fs.readFile(skillPath, 'utf-8');
+    if ((opts.preset ? 1 : 0) + (opts.project ? 1 : 0) !== 1) {
+        fatal('Pass exactly one of --preset or --project.');
     }
-    catch {
-        console.error('Error: Could not find SKILL.md. Make sure the autokap package is installed correctly.');
-        process.exit(1);
+    const format = ensureListFormat(opts.format);
+    const cfg = await requireConfig();
+    const searchParams = new URLSearchParams();
+    if (opts.preset)
+        searchParams.set('preset_id', opts.preset);
+    if (opts.project)
+        searchParams.set('project_id', opts.project);
+    const data = await requestJson(cfg, '/api/v1/endpoints', { headers: authHeaders(cfg) }, 'Failed to list endpoints', searchParams);
+    const rows = data.endpoints.map((endpoint) => toEndpointOutputRow(cfg, endpoint));
+    if (format === 'table') {
+        console.table(rows.map((row) => ({
+            id: row.id,
+            capture_name: row.capture_name ?? '(default)',
+            label: row.label,
+            asset_type: row.asset_type ?? 'screenshot',
+            url: row.url,
+        })));
     }
-    const content = replaceSkillPlaceholders(rawContent, opts);
-    if (opts.output) {
-        const outDir = path.dirname(opts.output);
-        await fs.mkdir(outDir, { recursive: true });
-        await fs.writeFile(opts.output, content, 'utf-8');
-        console.log(`Skill file written to: ${opts.output}`);
-        console.log('');
-        console.log('Next steps:');
-        console.log('  Claude Code:  Place the file in .claude/commands/autokap-preset.md');
-        console.log('  Cursor:       Place the file in .cursor/rules/autokap-preset.md');
-        console.log('  Other agents: Point your agent to the file when asking it to create presets');
+    else {
+        printJson(rows);
+    }
+    process.exit(0);
+});
+endpointsCmd
+    .command('get <endpoint-id>')
+    .description('Get endpoint details')
+    .action(async (endpointId) => {
+    const cfg = await requireConfig();
+    const data = await requestJson(cfg, `/api/v1/endpoints/${endpointId}`, { headers: authHeaders(cfg) }, 'Failed to get endpoint');
+    printJson(toEndpointOutputRow(cfg, data.endpoint));
+    process.exit(0);
+});
+endpointsCmd
+    .command('export')
+    .description('Export endpoints as JSON or CSV')
+    .option('--preset <id>', 'Preset ID')
+    .option('--project <id>', 'Project ID')
+    .option('--format <fmt>', 'Output format: json or csv', 'json')
+    .action(async (opts) => {
+    if ((opts.preset ? 1 : 0) + (opts.project ? 1 : 0) !== 1) {
+        fatal('Pass exactly one of --preset or --project.');
+    }
+    const format = ensureExportFormat(opts.format);
+    const cfg = await requireConfig();
+    if (opts.preset) {
+        const searchParams = new URLSearchParams({
+            preset_id: opts.preset,
+            format,
+        });
+        if (format === 'csv') {
+            const csv = await requestText(cfg, '/api/v1/endpoints/export', { headers: authHeaders(cfg) }, 'Failed to export endpoints', searchParams);
+            process.stdout.write(csv);
+        }
+        else {
+            const data = await requestJson(cfg, '/api/v1/endpoints/export', { headers: authHeaders(cfg) }, 'Failed to export endpoints', searchParams);
+            printJson(data);
+        }
+        process.exit(0);
+    }
+    const searchParams = new URLSearchParams({ project_id: opts.project });
+    const data = await requestJson(cfg, '/api/v1/endpoints', { headers: authHeaders(cfg) }, 'Failed to list endpoints', searchParams);
+    const rows = data.endpoints.map((endpoint) => toEndpointOutputRow(cfg, endpoint));
+    if (format === 'csv') {
+        process.stdout.write(`${toCsv(rows, ['id', 'label', 'url', 'capture_type', 'asset_type', 'capture_name'])}\n`);
     }
     else {
-        process.stdout.write(content);
+        printJson({ endpoints: rows });
     }
     process.exit(0);
 });
-// ── Browser command executor ────────────────────────────────────────
-async function executeBrowserCommand(browser, method, params) {
-    switch (method) {
-        // Lifecycle
-        case 'launch':
-            await browser.launch();
-            return null;
-        case 'close':
-            await browser.close();
-            return null;
-        case 'closeContext':
-            await browser.closeContext();
-            return null;
-        // Navigation
-        case 'navigateTo':
-            await browser.navigateTo(params.url);
-            return null;
-        case 'addCookies':
-            await browser.addCookies(params.cookies);
-            return null;
-        // Page info (used by RemoteBrowser.currentPage proxy)
-        case 'getPageInfo': return {
-            url: browser.currentPage.url(),
-            viewport: browser.currentPage.viewportSize(),
-        };
-        case 'getPageTitle': return await browser.currentPage.title();
-        // Screenshots — serialize buffers to base64
-        case 'takeScreenshot': {
-            const buf = await browser.takeScreenshot();
-            return { screenshot: buf.toString('base64') };
+// ── skill command ───────────────────────────────────────────────────
+// Agent output path mappings
+const AGENT_PATHS = {
+    claude: '.claude/commands/autokap-preset.md',
+    codex: '.agents/skills/autokap-preset/SKILL.md',
+    cursor: '.cursor/rules/autokap-preset.md',
+    windsurf: '.windsurf/rules/autokap-preset.md',
+    copilot: '.github/instructions/autokap-preset.instructions.md',
+};
+const STUDIO_AGENT_PATHS = {
+    claude: '.claude/commands/autokap-studio.md',
+    codex: '.agents/skills/autokap-studio/SKILL.md',
+    cursor: '.cursor/rules/autokap-studio.md',
+    windsurf: '.windsurf/rules/autokap-studio.md',
+    copilot: '.github/instructions/autokap-studio.instructions.md',
+};
+program
+    .command('skill')
+    .description('Output or install an AutoKap skill for AI coding agents')
+    .option('--output <path>', 'Write the generated skill output to this path instead of stdout')
+    .option('--agent <name>', 'Target AI coding agent: claude, codex, cursor, windsurf, copilot (auto-resolves output path and packaging mode)')
+    .option('--type <type>', 'Skill type: preset (default) or studio (composition designer)')
+    .option('--project-url <url>', 'Replace the project URL placeholder in the skill')
+    .option('--project-id <id>', 'Replace the project ID placeholder in the skill')
+    .option('--api-base-url <url>', 'Replace the API base URL placeholder (default: https://autokap.app)')
+    .action(async (opts) => {
+    const skillType = opts.type === 'studio' ? 'studio' : undefined;
+    const pathMap = skillType === 'studio' ? STUDIO_AGENT_PATHS : AGENT_PATHS;
+    // Resolve --agent to an output path
+    if (opts.agent) {
+        const agentKey = opts.agent.toLowerCase();
+        if (!pathMap[agentKey]) {
+            logger.error(`Unknown agent "${opts.agent}". Supported: ${Object.keys(pathMap).join(', ')}`);
+            process.exit(1);
         }
-        case 'takeScreenshotForAI': {
-            const buf = await browser.takeScreenshotForAI(params);
-            return { screenshot: buf.toString('base64') };
+        if (opts.output) {
+            logger.error('Cannot use both --agent and --output. Pick one.');
+            process.exit(1);
         }
-        case 'screenshotElement': {
-            const buf = await browser.screenshotElement(params.index, params.padding);
-            return { screenshot: buf.toString('base64') };
+        opts.output = pathMap[agentKey];
+    }
+    try {
+        if (opts.output) {
+            const result = await writeSkillExport({
+                type: skillType === 'studio' ? 'studio' : 'preset',
+                agent: opts.agent?.toLowerCase(),
+                outputPath: opts.output,
+                placeholders: opts,
+            });
+            if (result.mode === 'bundle') {
+                logger.success(`Skill bundle written to: ${path.dirname(opts.output)}`);
+            }
+            else {
+                logger.success(`Skill file written to: ${opts.output}`);
+            }
         }
-        case 'screenshotRegion': {
-            const buf = await browser.screenshotRegion(params.x, params.y, params.width, params.height, params.padding);
-            return { screenshot: buf.toString('base64') };
+        else {
+            const content = await renderSkillSingleFile({
+                type: skillType === 'studio' ? 'studio' : 'preset',
+                agent: opts.agent?.toLowerCase(),
+                placeholders: opts,
+            });
+            process.stdout.write(content);
         }
-        case 'screenshotBySelector': {
-            const r = await browser.screenshotBySelector(params.selector, params.outscale);
-            return { buffer: r.buffer.toString('base64'), validation: r.validation };
+    }
+    catch (error) {
+        logger.error(error.message);
+        process.exit(1);
+    }
+    process.exit(0);
+});
+// ── init command ───────────────────────────────────────────────────
+program
+    .command('init')
+    .description('Set up AutoKap: authenticate and install the AI skill in one step')
+    .option('--cli-key <key>', 'Your AutoKap CLI key')
+    .option('--project-id <id>', 'Your project ID (optional, can be set later)')
+    .option('--agent <name>', 'Target AI coding agent: claude, codex, cursor, windsurf, copilot (default: auto-detect)')
+    .option('--api-base-url <url>', `API base URL (env: ${API_BASE_URL_ENV_VAR})`, getDefaultApiBaseUrl())
+    .option('--ws-url <url>', `WebSocket server URL (env: ${WS_URL_ENV_VAR})`)
+    .action(async (opts) => {
+    const wsUrl = opts.wsUrl?.trim() || getDefaultWsUrl(opts.apiBaseUrl);
+    // If --cli-key not provided, prompt interactively
+    let cliKey = opts.cliKey;
+    if (!cliKey) {
+        const readline = await import('node:readline');
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        cliKey = await new Promise((resolve) => {
+            rl.question('Enter your AutoKap CLI key:', (answer) => {
+                rl.close();
+                resolve(answer.trim());
+            });
+        });
+        if (!cliKey) {
+            logger.error('CLI key is required. Get one at https://autokap.app/settings');
+            process.exit(1);
         }
-        case 'screenshotByRegion': {
-            const buf = await browser.screenshotByRegion(params.region, params.outscale);
-            return { screenshot: buf.toString('base64') };
+    }
+    // Validate the key
+    logger.info('Validating CLI key...');
+    try {
+        const res = await fetch(`${opts.apiBaseUrl}/api/cli/validate`, {
+            headers: { Authorization: `Bearer ${cliKey}` },
+        });
+        if (!res.ok) {
+            logger.error('Invalid CLI key. Generate one at https://autokap.app/settings');
+            process.exit(1);
         }
-        // Page state — serialize screenshots inside PageState
-        case 'getPageState': {
-            const state = await browser.getPageState(params);
-            return {
-                ...state,
-                cleanScreenshot: state.cleanScreenshot.toString('base64'),
-                screenshot: state.screenshot.toString('base64'),
-            };
+    }
+    catch (err) {
+        logger.error(`Cannot reach API: ${err.message}`);
+        process.exit(1);
+    }
+    // Store credentials
+    await writeConfig({
+        apiKey: cliKey,
+        apiBaseUrl: opts.apiBaseUrl,
+        wsUrl,
+    });
+    logger.success(`Authenticated. Key stored in ${getConfigPath()}`);
+    // Determine agent target
+    let agentKey = opts.agent?.toLowerCase();
+    if (!agentKey) {
+        // Auto-detect from directory structure
+        const detectors = [
+            ['.claude', 'claude'],
+            ['.agents', 'codex'],
+            ['.cursor', 'cursor'],
+            ['.windsurf', 'windsurf'],
+            ['.github/instructions', 'copilot'],
+        ];
+        for (const [dir, key] of detectors) {
+            try {
+                await fs.access(dir);
+                agentKey = key;
+                break;
+            }
+            catch { /* try next */ }
         }
-        case 'getPageStateLite':
-            return await browser.getPageStateLite();
-        case 'getAccessibilityTree':
-            return await browser.getAccessibilityTree(params);
-        case 'getInteractiveElements':
-            return await browser.getInteractiveElements(params);
-        case 'getSimplifiedDOM':
-            return await browser.getSimplifiedDOM();
-        case 'captureObservation':
-            return await browser.captureObservation();
-        case 'capturePageSignals':
-            return await browser.capturePageSignals(params);
-        case 'captureVerificationBundle': {
-            const bundle = await browser.captureVerificationBundle(params);
-            return { ...bundle, screenshot: bundle.screenshot.toString('base64') };
+        if (!agentKey)
+            agentKey = 'claude'; // Default
+        logger.info(`Detected agent: ${agentKey}`);
+    }
+    if (!AGENT_PATHS[agentKey]) {
+        logger.error(`Unknown agent "${agentKey}". Supported: ${Object.keys(AGENT_PATHS).join(', ')}`);
+        process.exit(1);
+    }
+    // Install skill file
+    const skillOutput = AGENT_PATHS[agentKey];
+    try {
+        const result = await writeSkillExport({
+            type: 'preset',
+            agent: agentKey,
+            outputPath: skillOutput,
+            placeholders: {
+                projectId: opts.projectId,
+                apiBaseUrl: opts.apiBaseUrl !== DEFAULT_API_BASE_URL ? opts.apiBaseUrl : undefined,
+            },
+        });
+        if (result.mode === 'bundle') {
+            logger.success(`Skill bundle installed to: ${path.dirname(skillOutput)}`);
         }
-        case 'captureVideoVerificationBundle': {
-            const bundle = await browser.captureVideoVerificationBundle(params);
-            return { ...bundle, screenshot: bundle.screenshot.toString('base64') };
+        else {
+            logger.success(`Skill installed to: ${skillOutput}`);
         }
-        // Interactions
-        case 'clickByIndex':
-            await browser.clickByIndex(params.index);
-            return null;
-        case 'clickBySelector':
-            await browser.clickBySelector(params.selector, params);
-            return null;
-        case 'clickByCoordinates':
-            await browser.clickByCoordinates(params.x, params.y);
-            return null;
-        case 'hoverByIndex':
-            await browser.hoverByIndex(params.index);
-            return null;
-        case 'hoverBySelector':
-            await browser.hoverBySelector(params.selector);
-            return null;
-        case 'hoverByCoordinates':
-            await browser.hoverByCoordinates(params.x, params.y);
-            return null;
-        case 'typeText':
-            await browser.typeText(params.text, params);
-            return null;
-        case 'selectOption':
-            await browser.selectOption(params);
-            return null;
-        case 'scroll':
-            await browser.scroll(params.direction, params.amount, params.selector);
-            return null;
-        case 'scrollElementIntoView':
-            await browser.scrollElementIntoView(params.index, params);
-            return null;
-        case 'safeExpand':
-            await browser.safeExpand(params);
-            return null;
-        case 'pressKey':
-            await browser.pressKey(params.key);
-            return null;
-        case 'searchText': return await browser.searchText(params.query);
-        // Reactions
-        case 'waitForPageReaction':
-            return await browser.waitForPageReaction(params.before, params);
-        // UI manipulation
-        case 'wait':
-            await browser.wait(params.ms);
-            return null;
-        case 'dismissOverlays': return await browser.dismissOverlays();
-        case 'setColorScheme':
-            await browser.setColorScheme(params.scheme);
-            return null;
-        case 'setLanguage':
-            await browser.setLanguage(params.lang);
-            return null;
-        case 'resizeViewport':
-            await browser.resizeViewport(params.width, params.height);
-            return null;
-        case 'forceLoadLazyImages':
-            await browser.forceLoadLazyImages(params);
-            return null;
-        // Storage
-        case 'exportStorageState': return await browser.exportStorageState();
-        case 'exportSessionStorage': return await browser.exportSessionStorage();
-        case 'prepareSessionStorage':
-            await browser.prepareSessionStorage(params.bundle, params);
-            return null;
-        // Network
-        case 'observeNetworkRequests': return await browser.observeNetworkRequests(params.url, params.waitMs);
-        case 'setupRouteInterception':
-            await browser.setupRouteInterception(params.mocks);
-            return null;
-        case 'clearRouteInterception':
-            await browser.clearRouteInterception();
-            return null;
-        default:
-            throw new Error(`Unknown browser command: ${method}`);
     }
-}
+    catch (error) {
+        logger.error(error.message);
+        process.exit(1);
+    }
+    console.log('');
+    console.log('Setup complete! You can now:');
+    console.log(`  - Ask your AI agent to create presets using the autokap-preset skill`);
+    console.log(`  - Run captures locally: autokap run <preset-id>`);
+    process.exit(0);
+});
+// ── proxy command ──────────────────────────────────────────────────
+const proxyCmd = program
+    .command('proxy')
+    .description('Manage capture proxy for edge caching');
+proxyCmd
+    .command('register')
+    .description('Register a user-side proxy for faster capture loading')
+    .requiredOption('--project <id>', 'Project ID')
+    .requiredOption('--proxy-url <url>', 'Proxy base URL (e.g. https://myapp.com/api/autokap/assets)')
+    .option('--webhook-url <url>', 'Webhook URL for cache invalidation (e.g. https://myapp.com/api/autokap/webhook)')
+    .option('--signing-secret <secret>', 'Webhook signing secret (auto-generated if omitted)')
+    .action(async (opts) => {
+    const cfg = await requireConfig();
+    const body = {
+        proxy_base_url: opts.proxyUrl,
+    };
+    if (opts.webhookUrl)
+        body.webhook_url = opts.webhookUrl;
+    if (opts.signingSecret)
+        body.signing_secret = opts.signingSecret;
+    const res = await fetch(`${cfg.apiBaseUrl}/api/v1/projects/${opts.project}/proxy`, {
+        method: 'PATCH',
+        headers: {
+            Authorization: `Bearer ${cfg.apiKey}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        const data = await res.json().catch(() => ({ error: res.statusText }));
+        logger.error(`Failed to register proxy: ${data.error || res.statusText}`);
+        process.exit(1);
+    }
+    const result = await res.json();
+    logger.info(`Proxy registered: ${result.proxy_base_url}`);
+    if (result.webhook_url) {
+        logger.info(`Webhook configured: ${result.webhook_url}`);
+    }
+    if (result.signing_secret) {
+        console.log('');
+        console.log('Add this to your environment variables:');
+        console.log(`  AUTOKAP_WEBHOOK_SECRET=${result.signing_secret}`);
+        console.log('');
+    }
+    process.exit(0);
+});
+proxyCmd
+    .command('verify')
+    .description('Verify the configured proxy for a project')
+    .requiredOption('--project <id>', 'Project ID')
+    .action(async (opts) => {
+    const config = await requireConfig();
+    const project = await loadProject(config, opts.project);
+    if (!project.proxy_base_url) {
+        fatal(`Project ${opts.project} has no proxy configured. Run "autokap proxy register" first.`);
+    }
+    const result = await requestJson(config, '/api/v1/proxy/verify', {
+        method: 'POST',
+        headers: authHeaders(config, { 'Content-Type': 'application/json' }),
+        body: JSON.stringify({
+            project_id: opts.project,
+            proxy_base_url: project.proxy_base_url,
+        }),
+    }, 'Failed to verify proxy');
+    printJson(result);
+    if (!result.success) {
+        process.exit(1);
+    }
+    process.exit(0);
+});
 // ── Entry point ─────────────────────────────────────────────────────
 const resolvedArgv = process.argv[1] && fs.realpath(process.argv[1]).catch(() => process.argv[1]);
-const isDirectExecution = resolvedArgv && await resolvedArgv.then(p => p.endsWith('/cli.js') || p.endsWith('/cli.ts'));
+const isDirectExecution = resolvedArgv && await resolvedArgv.then(p => {
+    const base = path.basename(p);
+    return base === 'cli.js' || base === 'cli.ts';
+});
 if (isDirectExecution) {
     program.parseAsync().catch(async (err) => {
         logger.error(err.message);