@sdods/cli 0.2.0

package/dist/commands/schedule.js

@@ -0,0 +1,337 @@
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { SdodsError } from '@sdods/core';
+import { createContext } from '../context.js';
+import { collect, info, json, ok, out, table } from '../ui.js';
+async function withServices(rootDir) {
+    const db = await import('@sdods/db');
+    const srv = await import('@sdods/server');
+    const adb = await db.openDb();
+    const config = srv.loadServerConfig({ rootDir });
+    const runManager = new srv.RunManager(config, adb);
+    const scheduler = new srv.Scheduler(adb, runManager, {
+        info: () => undefined,
+        warn: (m) => console.error(m),
+    });
+    return { db, srv, adb, config, runManager, scheduler };
+}
+export function register(program) {
+    const schedule = program
+        .command('schedule')
+        .description('Cron schedules for runs (project yaml + database; the server executes them)');
+    schedule
+        .command('add')
+        .description('Create or update a schedule')
+        .requiredOption('-p, --project <slug>', 'project')
+        .requiredOption('--name <name>', 'schedule name')
+        .requiredOption('--cron <expr>', 'cron expression, e.g. "0 2 * * *"')
+        .option('--tz <timezone>', 'IANA timezone', 'UTC')
+        .option('-e, --env <name>', 'environment')
+        .option('-t, --tags <expr>', 'tag expression')
+        .option('-l, --layer <layer>', 'layer (repeatable)', collect, [])
+        .option('-b, --browser <name>', 'browser (repeatable)', collect, [])
+        .option('--process <name>', 'run a named process')
+        .option('--overlap <policy>', 'skip | queue | cancel-previous', 'skip')
+        .option('--jitter <seconds>', 'random start delay', '0')
+        .option('--notify <list>', 'github,jira,webhook', collect, [])
+        .option('--disabled', 'create disabled')
+        .action(async (opts, cmd) => {
+        const ctx = createContext(cmd);
+        const project = ctx.registry.entry(opts.project);
+        const s = await withServices(ctx.rootDir);
+        try {
+            const { HierarchyService } = s.srv;
+            await new HierarchyService(s.adb).sync(ctx.registry);
+            const row = await s.db.getProjectBySlug(s.adb.db, project.slug);
+            if (!row)
+                throw new SdodsError('CONFIG_NOT_FOUND', `Project row for ${project.slug} missing.`, {
+                    exitCode: 2,
+                });
+            const next = s.srv.nextTimes(opts.cron, opts.tz, 5);
+            if (!next.length)
+                throw new SdodsError('CONFIG_INVALID', `Invalid cron "${opts.cron}".`, { exitCode: 2 });
+            const id = await s.db.upsertSchedule(s.adb.db, s.adb.driver, {
+                projectId: row.id,
+                name: opts.name,
+                cronExpr: opts.cron,
+                timezone: opts.tz,
+                runInput: {
+                    env: opts.env,
+                    tags: opts.tags,
+                    layers: opts.layer.length ? opts.layer : undefined,
+                    browsers: opts.browser.length ? opts.browser : undefined,
+                    process: opts.process,
+                },
+                overlapPolicy: opts.overlap,
+                jitterSeconds: Number(opts.jitter),
+                enabled: !opts.disabled,
+                notify: opts.notify,
+                nextRunAt: next[0],
+            });
+            if (ctx.opts.json)
+                return json({ id, nextFireTimes: next });
+            ok(`Schedule ${opts.name} (${opts.cron} ${opts.tz}) saved`);
+            info(`Next: ${next.slice(0, 3).join(', ')}`);
+            info('The server runs schedules (`sdods serve`); for server-less setups use `sdods schedule install`.');
+        }
+        finally {
+            await s.adb.close();
+        }
+    });
+    schedule
+        .command('list')
+        .description('List schedules with next fire times')
+        .option('-p, --project <slug>', 'project')
+        .action(async (opts, cmd) => {
+        const ctx = createContext(cmd);
+        const s = await withServices(ctx.rootDir);
+        try {
+            const row = opts.project ? await s.db.getProjectBySlug(s.adb.db, opts.project) : null;
+            const list = await s.scheduler.list(row?.id);
+            const rows = list.map((x) => ({
+                id: x.id,
+                project: x.projectSlug ?? '',
+                name: x.name,
+                cron: x.cronExpr,
+                tz: x.timezone,
+                enabled: x.enabled ? 'yes' : 'no',
+                next: x.nextFireTimes?.[0] ?? '',
+                last: x.lastStatus ?? '',
+            }));
+            if (ctx.opts.json)
+                return json(list);
+            table(rows);
+        }
+        finally {
+            await s.adb.close();
+        }
+    });
+    for (const action of ['pause', 'resume', 'remove']) {
+        schedule
+            .command(`${action} <name>`)
+            .description(`${action[0].toUpperCase()}${action.slice(1)} a schedule by name`)
+            .requiredOption('-p, --project <slug>', 'project')
+            .action(async (name, opts, cmd) => {
+            const ctx = createContext(cmd);
+            const s = await withServices(ctx.rootDir);
+            try {
+                const row = await s.db.getProjectBySlug(s.adb.db, opts.project);
+                const target = (await s.scheduler.list(row?.id)).find((x) => x.name === name);
+                if (!target)
+                    throw new SdodsError('CONFIG_NOT_FOUND', `Schedule ${name} not found.`, {
+                        exitCode: 2,
+                    });
+                if (action === 'remove')
+                    await s.db.deleteSchedule(s.adb.db, target.id);
+                else
+                    await s.db.updateScheduleState(s.adb.db, target.id, { enabled: action === 'resume' }, s.adb.driver);
+                if (ctx.opts.json)
+                    return json({ id: target.id, action });
+                ok(`${name}: ${action}d`);
+            }
+            finally {
+                await s.adb.close();
+            }
+        });
+    }
+    schedule
+        .command('run-now <name>')
+        .description('Fire a schedule immediately (waits for the run to finish)')
+        .requiredOption('-p, --project <slug>', 'project')
+        .action(async (name, opts, cmd) => {
+        const ctx = createContext(cmd);
+        const s = await withServices(ctx.rootDir);
+        try {
+            const row = await s.db.getProjectBySlug(s.adb.db, opts.project);
+            const target = (await s.scheduler.list(row?.id)).find((x) => x.name === name);
+            if (!target)
+                throw new SdodsError('CONFIG_NOT_FOUND', `Schedule ${name} not found.`, {
+                    exitCode: 2,
+                });
+            const r = await s.scheduler.fire(target.id, { force: true });
+            if (!r.runId)
+                throw new SdodsError('RUN_FAILED', `Schedule did not start: ${r.skipped}`);
+            info(`Started run ${r.runId}; streaming log…`);
+            const job = s.runManager.get(r.runId);
+            for await (const line of job.log.stream(0))
+                if (!ctx.opts.quiet)
+                    out(line.line);
+            if (ctx.opts.json)
+                return json({ runId: r.runId, status: job.status, exitCode: job.exitCode });
+            process.exitCode = job.exitCode ?? 0;
+        }
+        finally {
+            await s.adb.close();
+        }
+    });
+    schedule
+        .command('next')
+        .description('Preview upcoming fire times for a cron expression')
+        .requiredOption('--cron <expr>', 'cron expression')
+        .option('--tz <timezone>', 'IANA timezone', 'UTC')
+        .option('--count <n>', 'how many', '5')
+        .action(async (opts, cmd) => {
+        const ctx = createContext(cmd);
+        const srv = await import('@sdods/server');
+        const times = srv.nextTimes(opts.cron, opts.tz, Number(opts.count));
+        if (!times.length)
+            throw new SdodsError('CONFIG_INVALID', `Invalid cron "${opts.cron}".`, { exitCode: 2 });
+        if (ctx.opts.json)
+            return json({ cron: opts.cron, timezone: opts.tz, times });
+        for (const t of times)
+            out(t);
+    });
+    schedule
+        .command('history <name>')
+        .description('Show recent firings of a schedule')
+        .requiredOption('-p, --project <slug>', 'project')
+        .action(async (name, opts, cmd) => {
+        const ctx = createContext(cmd);
+        const s = await withServices(ctx.rootDir);
+        try {
+            const row = await s.db.getProjectBySlug(s.adb.db, opts.project);
+            const target = (await s.scheduler.list(row?.id)).find((x) => x.name === name);
+            if (!target)
+                throw new SdodsError('CONFIG_NOT_FOUND', `Schedule ${name} not found.`, {
+                    exitCode: 2,
+                });
+            const rows = await s.db.listScheduleRuns(s.adb.db, target.id);
+            if (ctx.opts.json)
+                return json(rows);
+            table(rows.map((r) => ({
+                firedAt: String(r.fired_at),
+                status: r.status,
+                runId: r.run_id ?? '',
+                note: r.note ?? '',
+            })));
+        }
+        finally {
+            await s.adb.close();
+        }
+    });
+    schedule
+        .command('sync')
+        .description('Mirror yaml schedules (project schedules[] and processes with a schedule) into the database')
+        .action(async (_opts, cmd) => {
+        const ctx = createContext(cmd);
+        const s = await withServices(ctx.rootDir);
+        try {
+            await new s.srv.HierarchyService(s.adb).sync(ctx.registry);
+            const n = await s.scheduler.syncFromRegistry(ctx.registry);
+            if (ctx.opts.json)
+                return json({ synced: n });
+            ok(`Synced ${n} schedule(s) from yaml`);
+        }
+        finally {
+            await s.adb.close();
+        }
+    });
+    schedule
+        .command('install')
+        .description('Write OS/CI scheduler entries for server-less setups')
+        .requiredOption('--target <kind>', 'crontab | launchd | systemd | github')
+        .option('-p, --project <slug>', 'project (default: all)')
+        .option('--out <dir>', 'output directory for launchd/systemd/github files')
+        .action(async (opts, cmd) => {
+        const ctx = createContext(cmd);
+        const entries = [];
+        for (const e of ctx.registry.entriesList()) {
+            if (opts.project && e.slug !== opts.project)
+                continue;
+            for (const s of e.config.schedules) {
+                const args = [
+                    '-p',
+                    e.slug,
+                    ...(s.env ? ['-e', s.env] : []),
+                    ...(s.tags ? ['-t', s.tags] : []),
+                    ...(s.layers ?? []).flatMap((l) => ['-l', l]),
+                    ...(s.browsers ?? []).flatMap((b) => ['-b', b]),
+                    ...(s.harMode === 'replay' ? ['--har-replay'] : []),
+                ];
+                entries.push({ project: e.slug, name: s.name, cron: s.cron, tz: s.timezone, args });
+            }
+            for (const p of ctx.registry.processesOf(e.slug))
+                if (p.schedule)
+                    entries.push({
+                        project: e.slug,
+                        name: `process-${p.name}`,
+                        cron: p.schedule,
+                        tz: 'UTC',
+                        args: ['-p', e.slug, '--process', p.name],
+                    });
+        }
+        if (!entries.length)
+            throw new SdodsError('CONFIG_NOT_FOUND', 'No schedules found in project yaml files.', {
+                exitCode: 2,
+            });
+        const bin = 'bun run sdods';
+        const cwd = ctx.rootDir;
+        const outDir = opts.out ?? join(ctx.rootDir, '.sdods', 'schedules');
+        const written = [];
+        if (opts.target === 'crontab') {
+            const lines = entries.map((e) => `# sdods ${e.project}/${e.name} (${e.tz})\n${e.cron} cd ${cwd} && ${bin} run ${e.args.join(' ')} --trigger schedule >> .sdods/cron-${e.project}-${e.name}.log 2>&1`);
+            out(lines.join('\n'));
+            info('\nAppend with: (crontab -l; sdods schedule install --target crontab) | crontab -');
+            return;
+        }
+        mkdirSync(outDir, { recursive: true });
+        for (const e of entries) {
+            if (opts.target === 'github') {
+                const file = join(ctx.rootDir, '.github', 'workflows', `scheduled-${e.project}-${e.name}.yml`);
+                mkdirSync(join(ctx.rootDir, '.github', 'workflows'), { recursive: true });
+                writeFileSync(file, `name: scheduled ${e.project} ${e.name}\non:\n  schedule:\n    - cron: '${e.cron}'\n  workflow_dispatch: {}\njobs:\n  run:\n    runs-on: ubuntu-latest\n    steps:\n      - uses: actions/checkout@v4\n      - uses: oven-sh/setup-bun@v2\n      - uses: actions/setup-node@v4\n        with: { node-version: 22 }\n      - run: bun install\n      - run: bun run sdods browsers install --with-deps\n      - run: bun run sdods run ${e.args.join(' ')} --trigger schedule --run-id sched-${e.name}-\${{ github.run_id }}\n        env:\n          SDODS_SERVER_URL: \${{ secrets.SDODS_SERVER_URL }}\n          SDODS_TOKEN: \${{ secrets.SDODS_TOKEN }}\n      - uses: actions/upload-artifact@v4\n        if: always()\n        with: { name: sdods-${e.project}-${e.name}, path: .sdods/runs }\n`);
+                written.push(file);
+            }
+            else if (opts.target === 'launchd') {
+                const file = join(outDir, `com.sdods.${e.project}.${e.name}.plist`);
+                const [min, hour] = e.cron.split(' ');
+                writeFileSync(file, `<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n<plist version="1.0"><dict>\n  <key>Label</key><string>com.sdods.${e.project}.${e.name}</string>\n  <key>ProgramArguments</key><array><string>/bin/sh</string><string>-c</string><string>cd ${cwd} && ${bin} run ${e.args.join(' ')} --trigger schedule</string></array>\n  <key>StartCalendarInterval</key><dict>${/^\d+$/.test(min ?? '') ? `<key>Minute</key><integer>${min}</integer>` : ''}${/^\d+$/.test(hour ?? '') ? `<key>Hour</key><integer>${hour}</integer>` : ''}</dict>\n  <key>StandardOutPath</key><string>${cwd}/.sdods/launchd-${e.name}.log</string>\n  <key>StandardErrorPath</key><string>${cwd}/.sdods/launchd-${e.name}.log</string>\n</dict></plist>\n`);
+                written.push(file);
+            }
+            else if (opts.target === 'systemd') {
+                const base = join(outDir, `sdods-${e.project}-${e.name}`);
+                writeFileSync(`${base}.service`, `[Unit]\nDescription=SDODS ${e.project} ${e.name}\n\n[Service]\nType=oneshot\nWorkingDirectory=${cwd}\nExecStart=/bin/sh -c '${bin} run ${e.args.join(' ')} --trigger schedule'\n`);
+                writeFileSync(`${base}.timer`, `[Unit]\nDescription=SDODS ${e.project} ${e.name} timer\n\n[Timer]\nOnCalendar=${cronToOnCalendar(e.cron)}\nPersistent=false\n\n[Install]\nWantedBy=timers.target\n`);
+                written.push(`${base}.service`, `${base}.timer`);
+            }
+            else
+                throw new SdodsError('CONFIG_INVALID', `Unknown target ${opts.target}.`, {
+                    exitCode: 2,
+                });
+        }
+        if (ctx.opts.json)
+            return json({ written });
+        for (const f of written)
+            ok(`wrote ${f}`);
+        if (opts.target === 'launchd')
+            info(`Load with: launchctl load ${outDir}/*.plist`);
+        if (opts.target === 'systemd')
+            info(`Install with: sudo cp ${outDir}/* /etc/systemd/system/ && sudo systemctl daemon-reload && sudo systemctl enable --now <timer>`);
+        if (!existsSync(join(ctx.rootDir, '.sdods')))
+            mkdirSync(join(ctx.rootDir, '.sdods'), { recursive: true });
+    });
+    schedule
+        .command('export')
+        .description('Print schedules from yaml as JSON')
+        .action((_opts, cmd) => {
+        const ctx = createContext(cmd);
+        json(ctx.registry.entriesList().map((e) => ({
+            project: e.slug,
+            schedules: e.config.schedules,
+            processes: ctx.registry.processesOf(e.slug).filter((p) => p.schedule),
+        })));
+    });
+}
+/** Best-effort cron → systemd OnCalendar (minute hour dom month dow). */
+function cronToOnCalendar(cron) {
+    const [min = '*', hour = '*', dom = '*', mon = '*', dow = '*'] = cron.split(/\s+/);
+    const days = dow === '*'
+        ? ''
+        : dow
+            .split(',')
+            .map((d) => ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'][Number(d) % 7])
+            .join(',') + ' ';
+    const f = (v) => (v === '*' ? '*' : v.padStart(2, '0'));
+    return `${days}*-${mon === '*' ? '*' : mon.padStart(2, '0')}-${dom === '*' ? '*' : dom.padStart(2, '0')} ${f(hour)}:${f(min)}:00`;
+}
+//# sourceMappingURL=schedule.js.map

package/dist/commands/serve.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from 'commander';
+export declare function register(program: Command): void;
+//# sourceMappingURL=serve.d.ts.map

package/dist/commands/serve.js

@@ -0,0 +1,38 @@
+import { createContext } from '../context.js';
+import { info, ok, parseIntFlag } from '../ui.js';
+export function register(program) {
+    program
+        .command('serve')
+        .description('Start the SDODS web server (REST API, SSE, web UI, MCP over HTTP, scheduler)')
+        .option('--port <n>', 'port (default: PORT env or 4444)', parseIntFlag('port'))
+        .option('--host <host>', 'bind address (default: HOST env or 127.0.0.1)')
+        .option('--open', 'open the browser after start')
+        .option('--no-scheduler', 'do not start the cron scheduler')
+        .option('--auth-disabled', 'development only: every request is a local admin')
+        .action(async (opts, cmd) => {
+        const ctx = createContext(cmd);
+        const { startServer } = await import('@sdods/server');
+        const { app, url } = await startServer({
+            config: {
+                rootDir: ctx.rootDir,
+                port: opts.port,
+                host: opts.host,
+                authDisabled: opts.authDisabled ? true : undefined,
+            },
+            scheduler: opts.scheduler !== false,
+            open: Boolean(opts.open),
+        });
+        ok(`SDODS server listening on ${url}`);
+        if (app.setupState.token)
+            info(`First run: create the admin at ${url}/setup?token=${app.setupState.token} (or: sdods users create --admin --username <name> --password <pw>)`);
+        info('Press Ctrl+C to stop.');
+        const stop = async () => {
+            await app.close();
+            process.exit(0);
+        };
+        process.on('SIGINT', stop);
+        process.on('SIGTERM', stop);
+        await new Promise(() => undefined);
+    });
+}
+//# sourceMappingURL=serve.js.map

package/dist/commands/steps.d.ts

@@ -0,0 +1,8 @@
+import type { Command } from 'commander';
+import type { StepDef } from '@sdods/contracts';
+/** Parse `bddgen export` output (`* Given ...` lines) into StepDef[]. */
+export declare function listSteps(rootDir: string, slug: string, opts?: {
+    unused?: boolean;
+}): Promise<StepDef[]>;
+export declare function register(program: Command): void;
+//# sourceMappingURL=steps.d.ts.map

package/dist/commands/steps.js

@@ -0,0 +1,67 @@
+import { join } from 'node:path';
+import { execa } from 'execa';
+import { SdodsError, coreStepsDir } from '@sdods/core';
+import { createContext } from '../context.js';
+import { json, table } from '../ui.js';
+/** Parse `bddgen export` output (`* Given ...` lines) into StepDef[]. */
+export async function listSteps(rootDir, slug, opts = {}) {
+    const env = {
+        ...process.env,
+        SDODS_PROJECT: slug,
+        SDODS_ARTIFACTS_DIR: join(rootDir, '.sdods', 'lint'),
+        SDODS_LAYERS: '',
+    };
+    const args = ['bddgen', 'export', '-c', join(rootDir, 'sdods.runner.config.ts')];
+    if (opts.unused)
+        args.push('--unused-steps');
+    const result = await execa('npx', args, { cwd: rootDir, env, reject: false, all: true });
+    if (result.exitCode !== 0) {
+        throw new SdodsError('RUN_FAILED', `bddgen export failed for ${slug}.`, {
+            details: { output: result.all?.slice(-2000) },
+        });
+    }
+    const steps = [];
+    for (const raw of (result.all ?? '').split('\n')) {
+        const line = raw.replace(new RegExp(String.fromCharCode(27) + '\\[[0-9;]*m', 'g'), '').trim();
+        const m = /^\*\s+(Given|When|Then)\s+(.+)$/.exec(line);
+        if (m)
+            steps.push({ keyword: m[1], pattern: m[2].trim(), source: 'project' });
+        else if (opts.unused) {
+            const u = /^\|\s*(.+?)\s*\|\s*(.+?):(\d+)\s*\|$/.exec(line);
+            if (u)
+                steps.push({
+                    keyword: 'Unknown',
+                    pattern: u[1],
+                    file: u[2],
+                    line: Number(u[3]),
+                    source: u[2].includes(coreStepsDir()) ? 'core' : 'project',
+                });
+        }
+    }
+    return steps;
+}
+export function register(program) {
+    const steps = program
+        .command('steps')
+        .description('Inspect step definitions available to a project');
+    steps
+        .command('list')
+        .description('List all step definitions (core library + project) as seen by bddgen')
+        .requiredOption('-p, --project <slug>', 'project slug')
+        .option('--unused', 'only steps not used by any feature')
+        .option('--grep <text>', 'filter by substring')
+        .action(async (opts, cmd) => {
+        const ctx = createContext(cmd);
+        let result = await listSteps(ctx.rootDir, opts.project, { unused: opts.unused });
+        if (opts.grep)
+            result = result.filter((s) => s.pattern.toLowerCase().includes(String(opts.grep).toLowerCase()));
+        if (ctx.opts.json)
+            return json(result);
+        table(result.map((s) => ({
+            keyword: s.keyword,
+            pattern: s.pattern,
+            ...(s.file ? { location: `${s.file}:${s.line}` } : {}),
+        })));
+    });
+}
+//# sourceMappingURL=steps.js.map

package/dist/commands/tokens.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from 'commander';
+export declare function register(program: Command): void;
+//# sourceMappingURL=tokens.d.ts.map

package/dist/commands/tokens.js

@@ -0,0 +1,110 @@
+import { SdodsError } from '@sdods/core';
+import { createContext } from '../context.js';
+import { collect, json, ok, table, warn } from '../ui.js';
+export function register(program) {
+    const tokens = program
+        .command('tokens')
+        .description('API tokens: free, scoped, revocable (used by MCP over HTTP and CI ingest)');
+    tokens
+        .command('create')
+        .description('Create a token for a user; the value is printed once')
+        .requiredOption('--user <username>', 'owner')
+        .requiredOption('--name <name>', 'label, e.g. ci or mcp-laptop')
+        .option('--scopes <list>', 'comma list (default: all scopes of the owner role)', collect, [])
+        .option('--expires <days>', 'expiry in days (default: never)')
+        .action(async (opts, cmd) => {
+        const ctx = createContext(cmd);
+        const db = await import('@sdods/db');
+        const adb = await db.openDb();
+        try {
+            const u = await db.getUserByUsername(adb.db, opts.user);
+            if (!u)
+                throw new SdodsError('CONFIG_NOT_FOUND', `User ${opts.user} not found.`, {
+                    exitCode: 2,
+                });
+            const scopes = opts.scopes.length ? opts.scopes : db.scopesForRole(u.role);
+            const created = await db.createApiToken(adb.db, {
+                userId: u.id,
+                name: opts.name,
+                scopes,
+                expiresInDays: opts.expires ? Number(opts.expires) : null,
+                ownerRole: u.role,
+            });
+            await db.audit(adb.db, {
+                actorType: 'cli',
+                action: 'token.create',
+                targetType: 'api_token',
+                targetId: created.id,
+                details: { name: opts.name, scopes: created.scopes },
+            });
+            if (ctx.opts.json)
+                return json(created);
+            ok(`Token ${opts.name} for ${opts.user} (scopes: ${created.scopes.join(', ')})`);
+            console.log(`\n  ${created.token}\n`);
+            warn('Store it now; it is not shown again. Tokens are free and unlimited.');
+        }
+        finally {
+            await adb.close();
+        }
+    });
+    tokens
+        .command('list')
+        .description('List tokens (prefix, scopes, expiry, last use)')
+        .option('--user <username>', 'only this user')
+        .action(async (opts, cmd) => {
+        const ctx = createContext(cmd);
+        const db = await import('@sdods/db');
+        const adb = await db.openDb();
+        try {
+            let userId;
+            if (opts.user) {
+                const u = await db.getUserByUsername(adb.db, opts.user);
+                if (!u)
+                    throw new SdodsError('CONFIG_NOT_FOUND', `User ${opts.user} not found.`, {
+                        exitCode: 2,
+                    });
+                userId = u.id;
+            }
+            const rows = (await db.listApiTokens(adb.db, userId)).map((t) => ({
+                id: t.id,
+                user: t.username,
+                name: t.name,
+                prefix: t.prefix,
+                scopes: t.scopes.join(','),
+                expires: t.expiresAt ?? 'never',
+                lastUsed: t.lastUsedAt ?? '',
+                revoked: t.revokedAt ? 'yes' : '',
+            }));
+            if (ctx.opts.json)
+                return json(rows);
+            table(rows);
+        }
+        finally {
+            await adb.close();
+        }
+    });
+    tokens
+        .command('revoke <id>')
+        .description('Revoke a token by id')
+        .action(async (id, cmd) => {
+        const ctx = createContext(cmd);
+        const db = await import('@sdods/db');
+        const adb = await db.openDb();
+        try {
+            await db.revokeApiToken(adb.db, id);
+            await db.audit(adb.db, {
+                actorType: 'cli',
+                action: 'token.revoke',
+                targetType: 'api_token',
+                targetId: id,
+            });
+            if (ctx.opts.json)
+                return json({ id, revoked: true });
+            ok(`Revoked ${id}`);
+        }
+        finally {
+            await adb.close();
+        }
+    });
+}
+//# sourceMappingURL=tokens.js.map

package/dist/commands/trace.d.ts

@@ -0,0 +1,10 @@
+import type { Command } from 'commander';
+/** Recursively find `trace.zip` files (runner output) below a directory. */
+export declare function findTraceZips(dir: string, depth?: number): string[];
+export declare function listRuns(artifactsDir: string): Array<{
+    runId: string;
+    dir: string;
+    mtime: number;
+}>;
+export declare function register(program: Command): void;
+//# sourceMappingURL=trace.d.ts.map