@formigio/fazemos-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1335 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { config, getEnv, getToken, getActiveOrgId, setActiveOrgId, addEnvironment, hasEnvironments } from './config.js';
+import { login, signup, confirmSignup, adminLogin } from './auth.js';
+import { api } from './api.js';
+import { execSync } from 'child_process';
+function parseNumber(val) {
+    const n = parseFloat(val);
+    if (isNaN(n))
+        throw new Error(`Invalid number: ${val}`);
+    return n;
+}
+const program = new Command();
+program
+    .name('fazemos')
+    .description('Fazemos CLI — Team Accomplishment Platform')
+    .version('0.1.0');
+// ── Init ────────────────────────────────────────────────────
+program
+    .command('init')
+    .description('Configure an environment (auto-discovers Cognito settings from the API)')
+    .argument('<name>', 'Environment name (e.g., dev, prod, local)')
+    .requiredOption('--api-url <url>', 'API base URL')
+    .option('--cognito-pool <id>', 'Cognito User Pool ID (auto-discovered if omitted)')
+    .option('--cognito-client <id>', 'Cognito Client ID (auto-discovered if omitted)')
+    .option('--cognito-region <region>', 'Cognito region (auto-discovered if omitted)')
+    .action(async (name, opts) => {
+    let poolId = opts.cognitoPool;
+    let clientId = opts.cognitoClient;
+    let region = opts.cognitoRegion;
+    // Auto-discover from API if not provided
+    if (!poolId || !clientId) {
+        try {
+            console.log(chalk.cyan('Discovering auth config...'));
+            const res = await fetch(`${opts.apiUrl}/auth/config`);
+            if (res.ok) {
+                const data = await res.json();
+                poolId = poolId || data.cognitoPoolId || data.userPoolId;
+                clientId = clientId || data.cognitoClientId || data.clientId;
+                region = region || data.cognitoRegion || data.region;
+                console.log(chalk.green('Auto-discovered Cognito settings'));
+            }
+            else {
+                console.log(chalk.yellow('Auto-discovery not available — provide --cognito-pool and --cognito-client'));
+                process.exit(1);
+            }
+        }
+        catch {
+            console.error(chalk.red('Could not reach API for auto-discovery. Provide --cognito-pool and --cognito-client manually.'));
+            process.exit(1);
+        }
+    }
+    if (!poolId || !clientId) {
+        console.error(chalk.red('Missing Cognito Pool ID or Client ID'));
+        process.exit(1);
+    }
+    addEnvironment(name, {
+        apiUrl: opts.apiUrl.replace(/\/$/, ''),
+        cognitoPoolId: poolId,
+        cognitoClientId: clientId,
+        cognitoRegion: region || 'us-west-2',
+    });
+    console.log(chalk.green(`Environment "${name}" configured`));
+    console.log(`  API:      ${opts.apiUrl}`);
+    console.log(`  Pool:     ${poolId}`);
+    console.log(`  Client:   ${clientId}`);
+    console.log(`  Region:   ${region || 'us-west-2'}`);
+    if (config.get('activeEnv') === name) {
+        console.log(chalk.cyan(`  Active:   yes`));
+    }
+});
+// ── Environment ─────────────────────────────────────────────
+program
+    .command('env')
+    .description('Show or switch environment')
+    .argument('[name]', 'Environment to switch to')
+    .action((name) => {
+    if (!hasEnvironments()) {
+        console.log(chalk.yellow('No environments configured. Run: fazemos init <name> --api-url <url>'));
+        return;
+    }
+    if (name) {
+        const envs = config.get('environments');
+        if (!envs[name]) {
+            console.error(chalk.red(`Unknown environment: ${name}`));
+            console.log('Available:', Object.keys(envs).join(', '));
+            process.exit(1);
+        }
+        config.set('activeEnv', name);
+        console.log(chalk.green(`Switched to ${name}`));
+    }
+    const env = getEnv();
+    console.log(`  Environment: ${chalk.cyan(env.name)}`);
+    console.log(`  API:         ${env.apiUrl}`);
+    console.log(`  Cognito:     ${env.cognitoPoolId}`);
+    const token = getToken();
+    console.log(`  Auth:        ${token ? chalk.green('authenticated') : chalk.yellow('not logged in')}`);
+});
+// ── Auth ────────────────────────────────────────────────────
+const auth = program.command('auth').description('Authentication commands');
+auth
+    .command('login')
+    .description('Login with email and password')
+    .requiredOption('-e, --email <email>', 'Email address')
+    .requiredOption('-p, --password <password>', 'Password')
+    .action(async (opts) => {
+    try {
+        const result = await login(opts.email, opts.password);
+        console.log(chalk.green(`Logged in as ${result.email}`));
+    }
+    catch (err) {
+        console.error(chalk.red(`Login failed: ${err.message}`));
+        process.exit(1);
+    }
+});
+auth
+    .command('signup')
+    .description('Create a new account')
+    .requiredOption('-e, --email <email>', 'Email address')
+    .requiredOption('-p, --password <password>', 'Password')
+    .action(async (opts) => {
+    try {
+        const result = await signup(opts.email, opts.password);
+        console.log(chalk.green(result.message));
+    }
+    catch (err) {
+        console.error(chalk.red(`Signup failed: ${err.message}`));
+        process.exit(1);
+    }
+});
+auth
+    .command('confirm')
+    .description('Confirm email with verification code')
+    .requiredOption('-e, --email <email>', 'Email address')
+    .requiredOption('-c, --code <code>', 'Verification code')
+    .action(async (opts) => {
+    try {
+        const result = await confirmSignup(opts.email, opts.code);
+        console.log(chalk.green(result.message));
+    }
+    catch (err) {
+        console.error(chalk.red(`Confirmation failed: ${err.message}`));
+        process.exit(1);
+    }
+});
+auth
+    .command('admin-login')
+    .description('Admin login (creates test user, requires AWS credentials)')
+    .requiredOption('-e, --email <email>', 'Email address')
+    .requiredOption('-p, --password <password>', 'Password')
+    .action(async (opts) => {
+    try {
+        const result = await adminLogin(opts.email, opts.password);
+        console.log(chalk.green(`Admin logged in as ${result.email}`));
+    }
+    catch (err) {
+        console.error(chalk.red(`Admin login failed: ${err.message}`));
+        process.exit(1);
+    }
+});
+auth
+    .command('token')
+    .description('Print the current JWT token')
+    .action(() => {
+    const token = getToken();
+    if (!token) {
+        console.error(chalk.yellow('Not logged in. Run: fazemos auth login'));
+        process.exit(1);
+    }
+    console.log(token);
+});
+auth
+    .command('logout')
+    .description('Clear stored credentials')
+    .action(() => {
+    const env = config.get('activeEnv');
+    const auths = config.get('auth');
+    delete auths[env];
+    config.set('auth', auths);
+    console.log(chalk.green('Logged out'));
+});
+// ── Whoami ──────────────────────────────────────────────────
+program
+    .command('whoami')
+    .description('Show current user and org context')
+    .action(async () => {
+    try {
+        const data = await api('GET', '/auth/me');
+        console.log(`  User:   ${chalk.cyan(data.user.email)}`);
+        console.log(`  Member: ${data.member.displayName} (${data.member.role})`);
+        console.log(`  Org:    ${data.member.orgId}`);
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+// ── Orgs ────────────────────────────────────────────────────
+const orgs = program.command('orgs').description('Organization commands');
+orgs
+    .command('list')
+    .description('List your organizations')
+    .action(async () => {
+    try {
+        const data = await api('GET', '/api/organizations/mine');
+        if (data.organizations.length === 0) {
+            console.log(chalk.yellow('No organizations. Create one with: fazemos orgs create'));
+            return;
+        }
+        const activeOrgId = getActiveOrgId();
+        for (const org of data.organizations) {
+            const active = org.id === activeOrgId ? chalk.green(' ✓') : '';
+            console.log(`  ${chalk.cyan(org.name)} (${org.slug}) — ${org.role}${active}`);
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+orgs
+    .command('switch')
+    .description('Switch active organization')
+    .argument('<slug>', 'Organization slug')
+    .action(async (slug) => {
+    try {
+        const data = await api('GET', '/api/organizations/mine');
+        const org = data.organizations.find((o) => o.slug === slug);
+        if (!org) {
+            console.error(chalk.red(`No organization with slug "${slug}"`));
+            console.log('Your organizations:');
+            for (const o of data.organizations) {
+                console.log(`  ${o.name} (${o.slug})`);
+            }
+            process.exit(1);
+        }
+        setActiveOrgId(org.id);
+        console.log(chalk.green(`Switched to ${org.name} (${org.slug})`));
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+orgs
+    .command('create')
+    .description('Create an organization')
+    .requiredOption('-n, --name <name>', 'Organization name')
+    .requiredOption('-s, --slug <slug>', 'URL slug')
+    .action(async (opts) => {
+    try {
+        const data = await api('POST', '/api/organizations', { name: opts.name, slug: opts.slug });
+        console.log(chalk.green(`Created: ${data.organization.name} (${data.organization.slug})`));
+        console.log(`  Org ID: ${data.organization.id}`);
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+orgs
+    .command('members')
+    .description('List org members')
+    .option('--agents', 'Show only agent members')
+    .action(async (opts) => {
+    try {
+        const orgId = getActiveOrgId();
+        if (!orgId) {
+            console.error(chalk.red('No active org. Run: fazemos orgs switch <slug>'));
+            process.exit(1);
+        }
+        const data = await api('GET', `/api/organizations/${orgId}/members`);
+        if (!data.members?.length) {
+            console.log(chalk.yellow('No members'));
+            return;
+        }
+        for (const m of data.members) {
+            if (opts.agents && m.member_type !== 'agent')
+                continue;
+            const type = m.member_type === 'agent' ? chalk.blue('agent') : 'human';
+            console.log(`  ${chalk.cyan(m.display_name)} (${m.role}, ${type}) — ${m.id}`);
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+// ── Worksheets ──────────────────────────────────────────────
+const ws = program.command('worksheets').alias('ws').description('Worksheet commands');
+ws
+    .command('list')
+    .description('List worksheets')
+    .option('-s, --status <status>', 'Filter by status', 'active')
+    .action(async (opts) => {
+    try {
+        const data = await api('GET', `/api/worksheets?status=${opts.status}`);
+        if (data.worksheets.length === 0) {
+            console.log(chalk.yellow('No worksheets'));
+            return;
+        }
+        for (const w of data.worksheets) {
+            console.log(`  ${chalk.cyan(w.name)} (${w.status}) — ${w.owner_name}`);
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+ws
+    .command('create')
+    .description('Create a worksheet')
+    .requiredOption('-n, --name <name>', 'Worksheet name')
+    .option('-p, --purpose <purpose>', 'Purpose (e.g., "From X to Y by When")')
+    .option('--cadence <cadence>', 'Check-in cadence (weekly, biweekly, monthly)', 'weekly')
+    .action(async (opts) => {
+    try {
+        const body = { name: opts.name };
+        if (opts.purpose)
+            body.purpose = opts.purpose;
+        if (opts.cadence)
+            body.checkInCadence = opts.cadence;
+        const data = await api('POST', '/api/worksheets', body);
+        const w = data.worksheet;
+        console.log(chalk.green(`Created: ${w.name}`));
+        console.log(`  ID:      ${w.id}`);
+        console.log(`  Purpose: ${w.purpose || '(none)'}`);
+        console.log(`  Cadence: ${w.check_in_cadence}`);
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+ws
+    .command('show')
+    .description('Show worksheet detail')
+    .argument('<id>', 'Worksheet ID')
+    .action(async (id) => {
+    try {
+        const data = await api('GET', `/api/worksheets/${id}`);
+        const w = data.worksheet;
+        console.log(chalk.cyan(w.name));
+        console.log(`  Purpose:  ${w.purpose || '(none)'}`);
+        console.log(`  Status:   ${w.status}`);
+        console.log(`  Cadence:  ${w.check_in_cadence}`);
+        console.log(`  Owner:    ${w.owner_name}`);
+        if (data.outcomes?.length) {
+            console.log(chalk.cyan(`\n  Outcomes (${data.outcomes.length}):`));
+            for (const o of data.outcomes) {
+                const progress = o.target_value ? ` ${o.current_value ?? 0}/${o.target_value}` : '';
+                console.log(`    ${o.status === 'achieved' ? '✓' : '○'} ${o.name}${progress} — ${o.id}`);
+                if (o.linked_outcome_id) {
+                    const linkName = o.linked_outcome_name || o.linked_outcome_id;
+                    const linkWs = o.linked_worksheet_name ? ` on ${o.linked_worksheet_name}` : '';
+                    console.log(`      ↳ linked to: ${linkName}${linkWs}`);
+                }
+            }
+        }
+        if (data.milestones?.length) {
+            console.log(chalk.cyan(`\n  Milestones (${data.milestones.length}):`));
+            for (const m of data.milestones) {
+                const icon = m.status === 'reached' ? '✓' : m.status === 'missed' ? '✗' : '○';
+                console.log(`    ${icon} ${m.name}${m.target_date ? ` (${m.target_date})` : ''}`);
+            }
+        }
+        if (data.actions?.length) {
+            console.log(chalk.cyan(`\n  Actions (${data.actions.length}):`));
+            for (const a of data.actions) {
+                const progress = a.target_value ? ` ${a.current_value ?? 0}/${a.target_value}` : '';
+                console.log(`    ${chalk.cyan(a.description)}${progress} — ${a.member_name || 'unassigned'}`);
+            }
+        }
+        if (data.commitments?.length) {
+            console.log(chalk.cyan(`\n  Commitments (${data.commitments.length}):`));
+            for (const c of data.commitments) {
+                const icon = c.status === 'completed' ? chalk.green('✓') : c.status === 'missed' ? chalk.red('✗') : '○';
+                console.log(`    ${icon} ${c.description} — due ${c.due_date} (${c.status})`);
+            }
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+// ── Outcomes ────────────────────────────────────────────────
+const outcomes = program.command('outcomes').alias('oc').description('Outcome commands');
+outcomes
+    .command('add')
+    .description('Add an outcome to a worksheet')
+    .requiredOption('-w, --worksheet <id>', 'Worksheet ID')
+    .requiredOption('-n, --name <name>', 'Outcome name')
+    .option('-d, --description <desc>', 'Description')
+    .option('-m, --measurement <method>', 'How it is measured')
+    .option('-t, --target <value>', 'Target value', parseNumber)
+    .option('-c, --current <value>', 'Current value', parseNumber)
+    .action(async (opts) => {
+    try {
+        const body = { name: opts.name };
+        if (opts.description)
+            body.description = opts.description;
+        if (opts.measurement)
+            body.measurement = opts.measurement;
+        if (opts.target !== undefined)
+            body.targetValue = opts.target;
+        if (opts.current !== undefined)
+            body.currentValue = opts.current;
+        const data = await api('POST', `/api/worksheets/${opts.worksheet}/outcomes`, body);
+        const o = data.outcome;
+        console.log(chalk.green(`Added outcome: ${o.name}`));
+        console.log(`  ID: ${o.id}`);
+        if (o.target_value)
+            console.log(`  Target: ${o.target_value}`);
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+outcomes
+    .command('list')
+    .description('List outcomes on a worksheet')
+    .requiredOption('-w, --worksheet <id>', 'Worksheet ID')
+    .action(async (opts) => {
+    try {
+        const data = await api('GET', `/api/worksheets/${opts.worksheet}`);
+        if (!data.outcomes?.length) {
+            console.log(chalk.yellow('No outcomes'));
+            return;
+        }
+        for (const o of data.outcomes) {
+            const progress = o.target_value ? ` ${o.current_value ?? 0}/${o.target_value}` : '';
+            console.log(`  ${o.status === 'achieved' ? '✓' : '○'} ${o.name}${progress} — ${o.id}`);
+            if (o.linked_outcome_id) {
+                const linkName = o.linked_outcome_name || o.linked_outcome_id;
+                const linkWs = o.linked_worksheet_name ? ` on ${o.linked_worksheet_name}` : '';
+                console.log(`    ↳ linked to: ${linkName}${linkWs}`);
+            }
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+outcomes
+    .command('link')
+    .description('Link an outcome to a parent outcome')
+    .requiredOption('-w, --worksheet <id>', 'Worksheet ID')
+    .requiredOption('-o, --outcome <id>', 'Outcome ID')
+    .requiredOption('--parent <id>', 'Parent outcome ID')
+    .action(async (opts) => {
+    try {
+        await api('PATCH', `/api/worksheets/${opts.worksheet}/outcomes/${opts.outcome}`, { linkedOutcomeId: opts.parent });
+        console.log(chalk.green('Outcome linked'));
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+outcomes
+    .command('unlink')
+    .description('Remove link from an outcome')
+    .requiredOption('-w, --worksheet <id>', 'Worksheet ID')
+    .requiredOption('-o, --outcome <id>', 'Outcome ID')
+    .action(async (opts) => {
+    try {
+        await api('PATCH', `/api/worksheets/${opts.worksheet}/outcomes/${opts.outcome}`, { linkedOutcomeId: null });
+        console.log(chalk.green('Outcome unlinked'));
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+outcomes
+    .command('update-value')
+    .description('Update an outcome current value')
+    .requiredOption('-w, --worksheet <id>', 'Worksheet ID')
+    .requiredOption('-o, --outcome <id>', 'Outcome ID')
+    .requiredOption('-v, --value <value>', 'New current value', parseNumber)
+    .action(async (opts) => {
+    try {
+        await api('PATCH', `/api/worksheets/${opts.worksheet}/outcomes/${opts.outcome}/value`, { currentValue: opts.value });
+        console.log(chalk.green(`Updated value to ${opts.value}`));
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+// ── Milestones ──────────────────────────────────────────────
+const milestones = program.command('milestones').alias('ms').description('Milestone commands');
+milestones
+    .command('add')
+    .description('Add a milestone to a worksheet')
+    .requiredOption('-w, --worksheet <id>', 'Worksheet ID')
+    .requiredOption('-n, --name <name>', 'Milestone name')
+    .option('-d, --description <desc>', 'Description')
+    .option('-t, --target-date <date>', 'Target date (YYYY-MM-DD)')
+    .action(async (opts) => {
+    try {
+        const body = { name: opts.name };
+        if (opts.description)
+            body.description = opts.description;
+        if (opts.targetDate)
+            body.targetDate = opts.targetDate;
+        const data = await api('POST', `/api/worksheets/${opts.worksheet}/milestones`, body);
+        const m = data.milestone;
+        console.log(chalk.green(`Added milestone: ${m.name}`));
+        console.log(`  ID: ${m.id}`);
+        if (m.target_date)
+            console.log(`  Target: ${m.target_date}`);
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+// ── Members ─────────────────────────────────────────────────
+const members = program.command('members').description('Worksheet member commands');
+members
+    .command('add')
+    .description('Add a member to a worksheet')
+    .requiredOption('-w, --worksheet <id>', 'Worksheet ID')
+    .requiredOption('-m, --member <id>', 'Member ID')
+    .option('-r, --role <role>', 'Worksheet role (lead, contributor)', 'contributor')
+    .action(async (opts) => {
+    try {
+        const data = await api('POST', `/api/worksheets/${opts.worksheet}/members`, {
+            memberId: opts.member,
+            role: opts.role,
+        });
+        console.log(chalk.green(`Added member: ${data.worksheetMember.display_name} (${opts.role})`));
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+members
+    .command('list')
+    .description('List worksheet members')
+    .requiredOption('-w, --worksheet <id>', 'Worksheet ID')
+    .action(async (opts) => {
+    try {
+        const data = await api('GET', `/api/worksheets/${opts.worksheet}/members`);
+        if (!data.members?.length) {
+            console.log(chalk.yellow('No members'));
+            return;
+        }
+        for (const m of data.members) {
+            console.log(`  ${chalk.cyan(m.display_name)} (${m.worksheet_role}) — ${m.member_id}`);
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+// ── Actions ─────────────────────────────────────────────────
+const actions = program.command('actions').alias('ac').description('Action (lead measure) commands');
+actions
+    .command('add')
+    .description('Add an action to a worksheet')
+    .requiredOption('-w, --worksheet <id>', 'Worksheet ID')
+    .requiredOption('-n, --name <name>', 'Action description')
+    .option('-o, --outcome <id>', 'Linked outcome ID')
+    .option('-m, --measurement <method>', 'How it is measured')
+    .option('-t, --target <value>', 'Target value', parseNumber)
+    .option('-c, --current <value>', 'Current value', parseNumber)
+    .action(async (opts) => {
+    try {
+        const body = { description: opts.name };
+        if (opts.outcome)
+            body.outcomeId = opts.outcome;
+        if (opts.measurement)
+            body.measurement = opts.measurement;
+        if (opts.target !== undefined)
+            body.targetValue = opts.target;
+        if (opts.current !== undefined)
+            body.currentValue = opts.current;
+        const data = await api('POST', `/api/worksheets/${opts.worksheet}/actions`, body);
+        const a = data.action;
+        console.log(chalk.green(`Added action: ${a.description}`));
+        console.log(`  ID: ${a.id}`);
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+actions
+    .command('list')
+    .description('List actions on a worksheet')
+    .requiredOption('-w, --worksheet <id>', 'Worksheet ID')
+    .action(async (opts) => {
+    try {
+        const data = await api('GET', `/api/worksheets/${opts.worksheet}/actions`);
+        if (!data.actions?.length) {
+            console.log(chalk.yellow('No actions'));
+            return;
+        }
+        for (const a of data.actions) {
+            const progress = a.target_value ? ` ${a.current_value ?? 0}/${a.target_value}` : '';
+            console.log(`  ${chalk.cyan(a.description)}${progress} — ${a.member_name || 'unassigned'} — ${a.id}`);
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+actions
+    .command('update-value')
+    .description('Update an action current value')
+    .requiredOption('-w, --worksheet <id>', 'Worksheet ID')
+    .requiredOption('-a, --action <id>', 'Action ID')
+    .requiredOption('-v, --value <value>', 'New current value', parseNumber)
+    .action(async (opts) => {
+    try {
+        await api('PATCH', `/api/worksheets/${opts.worksheet}/actions/${opts.action}/value`, { currentValue: opts.value });
+        console.log(chalk.green(`Updated action value to ${opts.value}`));
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+// ── Commitments ─────────────────────────────────────────────
+const commitments = program.command('commitments').alias('cm').description('Commitment commands');
+commitments
+    .command('add')
+    .description('Make a commitment')
+    .requiredOption('-w, --worksheet <id>', 'Worksheet ID')
+    .requiredOption('-d, --description <desc>', 'What you commit to do')
+    .option('-a, --action <id>', 'Linked action ID')
+    .requiredOption('--due <date>', 'Due date (YYYY-MM-DD)')
+    .action(async (opts) => {
+    try {
+        const body = { description: opts.description, dueDate: opts.due };
+        if (opts.action)
+            body.actionId = opts.action;
+        const data = await api('POST', `/api/worksheets/${opts.worksheet}/commitments`, body);
+        const c = data.commitment;
+        console.log(chalk.green(`Commitment made: ${c.description}`));
+        console.log(`  ID: ${c.id}`);
+        console.log(`  Due: ${c.due_date}`);
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+commitments
+    .command('list')
+    .description('List commitments on a worksheet')
+    .requiredOption('-w, --worksheet <id>', 'Worksheet ID')
+    .action(async (opts) => {
+    try {
+        const data = await api('GET', `/api/worksheets/${opts.worksheet}/commitments`);
+        if (!data.commitments?.length) {
+            console.log(chalk.yellow('No commitments'));
+            return;
+        }
+        for (const c of data.commitments) {
+            const icon = c.status === 'completed' ? chalk.green('✓') : c.status === 'missed' ? chalk.red('✗') : '○';
+            console.log(`  ${icon} ${c.description} — due ${c.due_date} (${c.status}) — ${c.id}`);
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+commitments
+    .command('done')
+    .description('Mark a commitment as done')
+    .requiredOption('-c, --commitment <id>', 'Commitment ID')
+    .action(async (opts) => {
+    try {
+        await api('PATCH', `/api/commitments/${opts.commitment}/complete`, {});
+        console.log(chalk.green('Commitment marked as done'));
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+// ── Templates ──────────────────────────────────────────────
+const templates = program.command('templates').alias('tpl').description('Pipeline template commands');
+templates
+    .command('list')
+    .description('List pipeline templates')
+    .option('-s, --status <status>', 'Filter by status (draft, active, archived)')
+    .action(async (opts) => {
+    try {
+        const qs = opts.status ? `?status=${opts.status}` : '';
+        const data = await api('GET', `/api/pipeline-templates${qs}`);
+        if (!data.templates?.length) {
+            console.log(chalk.yellow('No templates'));
+            return;
+        }
+        for (const t of data.templates) {
+            const phases = t.phase_count ?? '?';
+            const steps = t.step_count ?? '?';
+            console.log(`  ${chalk.cyan(t.name)} (${t.status}) — ${phases} phases, ${steps} steps — ${t.id}`);
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+templates
+    .command('show')
+    .description('Show template detail')
+    .argument('<id>', 'Template ID')
+    .action(async (id) => {
+    try {
+        const data = await api('GET', `/api/pipeline-templates/${id}`);
+        const t = data.template;
+        console.log(chalk.cyan(t.name));
+        console.log(`  ID:      ${t.id}`);
+        console.log(`  Status:  ${t.status}`);
+        console.log(`  Version: ${t.version}`);
+        if (t.definition?.phases) {
+            for (const phase of t.definition.phases) {
+                console.log(chalk.cyan(`\n  Phase: ${phase.name}`));
+                for (const step of phase.steps || []) {
+                    console.log(`    ${step.name} (${step.stepType || 'human'}) — role: ${step.role || 'unassigned'}`);
+                }
+            }
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+templates
+    .command('create')
+    .description('Create a pipeline template')
+    .requiredOption('-n, --name <name>', 'Template name')
+    .option('-d, --description <desc>', 'Description')
+    .action(async (opts) => {
+    try {
+        const body = { name: opts.name, definition: { phases: [] } };
+        if (opts.description)
+            body.description = opts.description;
+        const data = await api('POST', '/api/pipeline-templates', body);
+        const t = data.template;
+        console.log(chalk.green(`Created: ${t.name}`));
+        console.log(`  ID: ${t.id}`);
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+templates
+    .command('import')
+    .description('Import a JOE template JSON file as a Fazemos pipeline template')
+    .argument('<file>', 'Path to JOE template JSON file')
+    .action(async (file) => {
+    try {
+        const { readFileSync } = await import('fs');
+        const { resolve } = await import('path');
+        const raw = JSON.parse(readFileSync(resolve(file), 'utf-8'));
+        // Map JOE template to Fazemos format
+        const steps = raw.steps || [];
+        // Group sequential steps into a single phase for now
+        const definition = {
+            phases: [{
+                    id: crypto.randomUUID(),
+                    name: raw.name || 'Main',
+                    description: raw.description || '',
+                    deliverables: [],
+                    steps: steps.map((s, i) => ({
+                        id: crypto.randomUUID(),
+                        name: s.name,
+                        description: s.description || '',
+                        step_type: s.executionMode === 'script' ? 'script' : (s.agent ? 'agent' : 'human'),
+                        role: s.role || s.agent || 'unassigned',
+                        inputs: [],
+                        outputs: [],
+                        sections: s.sections || '',
+                        reviewer: s.reviewer || null,
+                        max_review_cycles: s.maxReviewCycles || 0,
+                        execution_config: s.executionMode === 'script' ? {
+                            image: s.image || '',
+                            command: s.command || '',
+                        } : null,
+                        parallel_group: null,
+                        sort_order: i,
+                    })),
+                }],
+        };
+        const body = {
+            name: raw.name || file,
+            description: raw.description || '',
+            definition,
+        };
+        const data = await api('POST', '/api/pipeline-templates', body);
+        const t = data.template;
+        console.log(chalk.green(`Imported: ${t.name} (${steps.length} steps)`));
+        console.log(`  ID: ${t.id}`);
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+templates
+    .command('activate')
+    .description('Activate a template (required before creating instances)')
+    .argument('<id>', 'Template ID')
+    .action(async (id) => {
+    try {
+        await api('PATCH', `/api/pipeline-templates/${id}/status`, { status: 'active' });
+        console.log(chalk.green('Template activated'));
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+// ── Pipelines ──────────────────────────────────────────────
+const pipelines = program.command('pipelines').alias('pl').description('Pipeline instance commands');
+pipelines
+    .command('list')
+    .description('List pipeline instances')
+    .option('-s, --status <status>', 'Filter by status (active, completed, archived)', 'active')
+    .option('--search <term>', 'Search by name or ID')
+    .option('--expand', 'Include steps inline (avoids N+1)')
+    .action(async (opts) => {
+    try {
+        const params = [];
+        if (opts.status)
+            params.push(`status=${opts.status}`);
+        if (opts.search)
+            params.push(`search=${encodeURIComponent(opts.search)}`);
+        if (opts.expand)
+            params.push('expand=steps');
+        const qs = params.length ? `?${params.join('&')}` : '';
+        const data = await api('GET', `/api/pipeline-instances${qs}`);
+        if (!data.instances?.length) {
+            console.log(chalk.yellow('No pipeline instances'));
+            return;
+        }
+        for (const inst of data.instances) {
+            const stepInfo = inst.total_steps ? ` — step ${inst.current_step ?? '?'}/${inst.total_steps}` : '';
+            console.log(`  ${chalk.cyan(inst.name)} (${inst.status})${stepInfo}`);
+            console.log(`    ID: ${inst.id}`);
+            if (opts.expand && inst.steps?.length) {
+                for (const s of inst.steps) {
+                    const icon = s.status === 'completed' ? chalk.green('✓')
+                        : s.status === 'in_progress' ? chalk.yellow('▸')
+                            : s.status === 'failed' ? chalk.red('✗')
+                                : '○';
+                    console.log(`      ${icon} ${s.step_name} [${s.role || '-'}] (${s.status})`);
+                }
+            }
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+pipelines
+    .command('show')
+    .description('Show pipeline instance detail')
+    .argument('<id>', 'Instance ID')
+    .action(async (id) => {
+    try {
+        const data = await api('GET', `/api/pipeline-instances/${id}`);
+        const inst = data.instance;
+        console.log(chalk.cyan(inst.name));
+        console.log(`  ID:       ${inst.id}`);
+        console.log(`  Status:   ${inst.status}`);
+        console.log(`  Template: ${inst.template_name || inst.template_id}`);
+        if (inst.phases?.length) {
+            for (const phase of inst.phases) {
+                console.log(chalk.cyan(`\n  Phase: ${phase.name}`));
+                for (const s of phase.steps || []) {
+                    const icon = s.status === 'completed' ? chalk.green('✓')
+                        : s.status === 'in_progress' ? chalk.yellow('▸')
+                            : s.status === 'failed' ? chalk.red('✗')
+                                : '○';
+                    console.log(`    ${icon} ${s.step_name} [${s.role || '-'}] (${s.status})`);
+                }
+            }
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+pipelines
+    .command('create')
+    .description('Create a pipeline instance from a template')
+    .argument('<templateId>', 'Template ID')
+    .requiredOption('-n, --name <name>', 'Instance name')
+    .option('--params <json>', 'Parameters as JSON string')
+    .action(async (templateId, opts) => {
+    try {
+        const body = { templateId, name: opts.name };
+        if (opts.params)
+            body.parameters = JSON.parse(opts.params);
+        const data = await api('POST', '/api/pipeline-instances', body);
+        const inst = data.instance;
+        console.log(chalk.green(`Created: ${inst.name}`));
+        console.log(`  ID: ${inst.id}`);
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+pipelines
+    .command('archive')
+    .description('Archive a pipeline instance')
+    .argument('<id>', 'Instance ID')
+    .action(async (id) => {
+    try {
+        const data = await api('POST', `/api/pipeline-instances/${id}/archive`);
+        console.log(chalk.green(`Archived: ${data.instance?.name || id}`));
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+pipelines
+    .command('set-params')
+    .description('Set instance parameters (atomic update)')
+    .argument('<id>', 'Instance ID')
+    .requiredOption('--params <json>', 'Parameters as JSON string')
+    .action(async (id, opts) => {
+    try {
+        const body = JSON.parse(opts.params);
+        const data = await api('PATCH', `/api/pipeline-instances/${id}/parameters`, body);
+        console.log(chalk.green(`Parameters updated: ${data.instance?.name || id}`));
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+pipelines
+    .command('set-status')
+    .description('Update instance status (running, paused, completed, failed, cancelled)')
+    .argument('<id>', 'Instance ID')
+    .requiredOption('--status <status>', 'New status')
+    .action(async (id, opts) => {
+    try {
+        const valid = ['running', 'paused', 'completed', 'failed', 'cancelled'];
+        if (!valid.includes(opts.status)) {
+            console.error(chalk.red(`Invalid status. Must be one of: ${valid.join(', ')}`));
+            process.exit(1);
+        }
+        const data = await api('PATCH', `/api/pipeline-instances/${id}`, { status: opts.status });
+        console.log(chalk.green(`Status set to ${opts.status}: ${data.instance?.name || id}`));
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+// ── Queue ──────────────────────────────────────────────────
+const queue = program.command('queue').alias('q').description('Work queue commands');
+queue
+    .command('summary')
+    .description('Show queue depth per agent')
+    .action(async () => {
+    try {
+        const data = await api('GET', '/api/work-queue/summary');
+        const entries = Object.entries(data.depths ?? {});
+        if (entries.length === 0) {
+            console.log(chalk.yellow('No agents in queue'));
+            return;
+        }
+        let total = 0;
+        for (const [agent, count] of entries) {
+            total += count;
+            console.log(`  ${agent.padEnd(12)} ${count} steps queued`);
+        }
+        console.log('  ───────────────');
+        console.log(`  ${'Total'.padEnd(12)} ${total} steps`);
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+queue
+    .command('list')
+    .description('List queued and in-progress steps')
+    .option('-a, --agent <name>', 'Filter by agent name')
+    .option('--message-id <id>', 'Filter by JOE messageId in step metadata')
+    .action(async (opts) => {
+    try {
+        const params = [];
+        if (opts.agent)
+            params.push(`agent=${encodeURIComponent(opts.agent)}`);
+        if (opts.messageId)
+            params.push(`messageId=${encodeURIComponent(opts.messageId)}`);
+        const qs = params.length ? `?${params.join('&')}` : '';
+        const data = await api('GET', `/api/work-queue${qs}`);
+        if (!data.items?.length) {
+            console.log(chalk.yellow('No queued steps'));
+            return;
+        }
+        for (const s of data.items) {
+            const icon = s.status === 'in_progress' ? chalk.yellow('▸') : '○';
+            const agent = s.agent ? ` [${s.agent}]` : '';
+            console.log(`  ${icon} ${s.step_name}${agent} — ${s.pipeline_name || s.pipeline_instance_id} (${s.status})`);
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+// ── Executions ─────────────────────────────────────────────
+program
+    .command('execute')
+    .description('Trigger an agent execution')
+    .argument('<source-id>', 'Action, commitment, or pipeline step ID')
+    .requiredOption('--agent <name>', 'Agent name or member ID')
+    .option('--source-type <type>', 'Source type (action, commitment, pipeline_step)', 'action')
+    .option('--prompt <prompt>', 'Additional prompt context')
+    .action(async (sourceId, opts) => {
+    try {
+        const validTypes = ['action', 'commitment', 'pipeline_step'];
+        if (!validTypes.includes(opts.sourceType)) {
+            console.error(chalk.red(`Invalid source type. Must be one of: ${validTypes.join(', ')}`));
+            process.exit(1);
+        }
+        const body = {
+            sourceType: opts.sourceType,
+            sourceId,
+            agent: opts.agent,
+        };
+        if (opts.prompt)
+            body.prompt = opts.prompt;
+        const data = await api('POST', '/api/executions', body);
+        const exec = data.execution;
+        console.log(chalk.green(`Execution created: ${exec.id}`));
+        console.log(`  Agent:  ${exec.agent_name}`);
+        console.log(`  Source: ${exec.source_type} ${exec.source_id}`);
+        console.log(`  Status: ${exec.status}`);
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+const executions = program.command('executions').alias('ex').description('Execution commands');
+executions
+    .command('list')
+    .description('List executions')
+    .option('-s, --status <status>', 'Filter by status (pending, running, completed, failed)')
+    .option('-a, --agent <name>', 'Filter by agent')
+    .option('--source-type <type>', 'Filter by source type')
+    .action(async (opts) => {
+    try {
+        const params = [];
+        if (opts.status)
+            params.push(`status=${opts.status}`);
+        if (opts.agent)
+            params.push(`agent=${encodeURIComponent(opts.agent)}`);
+        if (opts.sourceType)
+            params.push(`source_type=${opts.sourceType}`);
+        const qs = params.length ? `?${params.join('&')}` : '';
+        const data = await api('GET', `/api/executions${qs}`);
+        if (!data.executions?.length) {
+            console.log(chalk.yellow('No executions'));
+            return;
+        }
+        for (const e of data.executions) {
+            const icon = e.status === 'completed' ? chalk.green('✓')
+                : e.status === 'running' ? chalk.yellow('▸')
+                    : e.status === 'failed' ? chalk.red('✗')
+                        : '○';
+            const cost = e.cost_usd ? ` $${e.cost_usd}` : '';
+            console.log(`  ${icon} ${e.agent_name} — ${e.source_type} (${e.status})${cost} — ${e.id}`);
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+executions
+    .command('show')
+    .description('Show execution detail')
+    .argument('<id>', 'Execution ID')
+    .action(async (id) => {
+    try {
+        const data = await api('GET', `/api/executions/${id}`);
+        const e = data.execution;
+        console.log(chalk.cyan(`Execution: ${e.id}`));
+        console.log(`  Agent:       ${e.agent_name}`);
+        console.log(`  Source:      ${e.source_type} ${e.source_id}`);
+        console.log(`  Status:      ${e.status}`);
+        if (e.fargate_task_arn)
+            console.log(`  Task ARN:    ${e.fargate_task_arn}`);
+        if (e.cost_usd)
+            console.log(`  Cost:        $${e.cost_usd}`);
+        if (e.duration_ms)
+            console.log(`  Duration:    ${(e.duration_ms / 1000).toFixed(1)}s`);
+        if (e.input_tokens)
+            console.log(`  Tokens:      ${e.input_tokens} in / ${e.output_tokens} out`);
+        if (e.error)
+            console.log(`  Error:       ${chalk.red(e.error)}`);
+        if (e.queued_at)
+            console.log(`  Queued:      ${e.queued_at}`);
+        if (e.started_at)
+            console.log(`  Started:     ${e.started_at}`);
+        if (e.completed_at)
+            console.log(`  Completed:   ${e.completed_at}`);
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+executions
+    .command('cancel')
+    .description('Cancel a running execution')
+    .argument('<id>', 'Execution ID')
+    .action(async (id) => {
+    try {
+        await api('POST', `/api/executions/${id}/cancel`);
+        console.log(chalk.green('Execution cancelled'));
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+// ── My Work ─────────────────────────────────────────────────
+program
+    .command('my-work')
+    .description('Show pending work across all worksheets')
+    .action(async () => {
+    try {
+        const data = await api('GET', '/api/my-work');
+        const c = data.commitments;
+        const total = c.overdue.length + c.due_today.length + c.due_this_week.length + c.upcoming.length;
+        console.log(chalk.cyan(`Commitments: ${total}`));
+        if (c.overdue.length)
+            console.log(chalk.red(`  Overdue: ${c.overdue.length}`));
+        if (c.due_today.length)
+            console.log(chalk.yellow(`  Due today: ${c.due_today.length}`));
+        if (c.due_this_week.length)
+            console.log(`  This week: ${c.due_this_week.length}`);
+        if (c.upcoming.length)
+            console.log(`  Upcoming: ${c.upcoming.length}`);
+        console.log(chalk.cyan(`\nActions: ${data.actions.length}`));
+        console.log(chalk.cyan(`Worksheets: ${data.worksheets.length}`));
+        console.log(chalk.cyan(`Pipeline steps: ${data.pipeline_steps.length}`));
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+// ── Test ────────────────────────────────────────────────────
+program
+    .command('test')
+    .description('Run API tests via Bruno CLI')
+    .option('-f, --folder <folder>', 'Run only a specific folder')
+    .option('--html <path>', 'Generate HTML report')
+    .option('-c, --collection <path>', 'Path to Bruno collection', '')
+    .action(async (opts) => {
+    const token = getToken();
+    if (!token) {
+        console.error(chalk.yellow('Not logged in. Run: fazemos auth login'));
+        process.exit(1);
+    }
+    const env = getEnv();
+    // Find collection: explicit path > ./tests/api > ../fazemos-api/tests/api
+    let collectionPath = opts.collection;
+    if (!collectionPath) {
+        const candidates = [
+            'tests/api',
+            '../fazemos-api/tests/api',
+        ];
+        for (const c of candidates) {
+            try {
+                const { statSync } = await import('fs');
+                const resolved = new URL(c, `file://${process.cwd()}/`).pathname;
+                if (statSync(resolved + '/opencollection.yml').isFile()) {
+                    collectionPath = resolved;
+                    break;
+                }
+            }
+            catch { /* skip */ }
+        }
+    }
+    if (!collectionPath) {
+        console.error(chalk.red('Bruno collection not found. Run from the fazemos-api directory or use --collection <path>'));
+        process.exit(1);
+    }
+    const folder = opts.folder ? opts.folder + '/ ' : '';
+    let cmd = `bru run ${folder}--env ${env.name} --env-var "token=${token}" --env-var "baseUrl=${env.apiUrl}"`;
+    if (opts.html) {
+        cmd += ` --reporter-html ${opts.html}`;
+    }
+    console.log(chalk.cyan(`Running tests against ${env.name} (${collectionPath})...`));
+    try {
+        execSync(cmd, { stdio: 'inherit', cwd: collectionPath });
+    }
+    catch {
+        process.exit(1);
+    }
+});
+// ── Agents ──────────────────────────────────────────────────
+const agentsCmd = program.command('agents').description('Agent management');
+agentsCmd
+    .command('register')
+    .description('Register an agent')
+    .requiredOption('-n, --name <name>', 'Agent display name')
+    .option('-r, --roles <roles>', 'Comma-separated roles', (v) => v.split(','))
+    .option('--model <model>', 'Model (e.g., opus, sonnet, system)', 'sonnet')
+    .action(async (opts) => {
+    try {
+        const data = await api('POST', '/api/agents/register', {
+            agents: [{
+                    displayName: opts.name,
+                    roles: opts.roles || [opts.name],
+                    config: { model: opts.model },
+                }],
+        });
+        for (const a of data.agents) {
+            const icon = a.status === 'created' ? chalk.green('✓') : a.status === 'updated' ? chalk.yellow('↻') : '○';
+            console.log(`  ${icon} ${a.display_name} (${a.status}) — ${a.member_id}`);
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+// ── Health ──────────────────────────────────────────────────
+program
+    .command('health')
+    .description('Check API health')
+    .action(async () => {
+    try {
+        const env = getEnv();
+        const fetchJson = async (path) => {
+            const res = await fetch(`${env.apiUrl}${path}`);
+            return res.json();
+        };
+        const [health, deep] = await Promise.all([
+            fetchJson('/health'),
+            fetchJson('/health/deep').catch(() => ({ status: 'error', database: 'unreachable' })),
+        ]);
+        console.log(`  API:      ${chalk.green(health.status)} (${env.apiUrl})`);
+        console.log(`  Database: ${deep.database === 'connected' ? chalk.green('connected') : chalk.red(deep.database)}`);
+    }
+    catch (err) {
+        console.error(chalk.red(`API unreachable: ${err.message}`));
+        process.exit(1);
+    }
+});
+// ── API Keys ──────────────────────────────────────────────
+const apiKeys = program.command('api-keys').description('API key management');
+apiKeys
+    .command('create')
+    .description('Create an API key')
+    .requiredOption('-n, --name <name>', 'Key name (e.g., joe-orchestrator)')
+    .requiredOption('-m, --member <id>', 'Member ID to bind the key to')
+    .option('-d, --description <desc>', 'Description')
+    .action(async (opts) => {
+    try {
+        const body = { name: opts.name, memberId: opts.member };
+        if (opts.description)
+            body.description = opts.description;
+        const data = await api('POST', '/api/api-keys', body);
+        console.log(chalk.green(`API key created: ${opts.name}`));
+        console.log(`  Key:  ${chalk.yellow(data.rawKey)}`);
+        console.log(`  ID:   ${data.apiKey.id}`);
+        console.log('');
+        console.log(chalk.red('  ⚠ Save this key now — it will not be shown again.'));
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+apiKeys
+    .command('list')
+    .description('List API keys')
+    .action(async () => {
+    try {
+        const data = await api('GET', '/api/api-keys');
+        if (!data.apiKeys?.length) {
+            console.log(chalk.yellow('No API keys'));
+            return;
+        }
+        for (const k of data.apiKeys) {
+            console.log(`  ${chalk.cyan(k.name)} — ${k.id} (created ${k.created_at})`);
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+apiKeys
+    .command('revoke')
+    .description('Revoke an API key')
+    .argument('<id>', 'API key ID')
+    .action(async (id) => {
+    try {
+        await api('DELETE', `/api/api-keys/${id}`);
+        console.log(chalk.green('API key revoked'));
+    }
+    catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
+program.parse();
+//# sourceMappingURL=index.js.map