@sdods/cli 0.2.0

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=bin.d.ts.map

package/dist/bin.js

@@ -0,0 +1,11 @@
+import { buildProgram } from './program.js';
+import { renderError } from './ui.js';
+const program = buildProgram();
+try {
+    await program.parseAsync(process.argv);
+}
+catch (e) {
+    const code = renderError(e, program.opts().json === true);
+    process.exitCode = code;
+}
+//# sourceMappingURL=bin.js.map

package/dist/commands/agent.d.ts

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

package/dist/commands/agent.js

@@ -0,0 +1,219 @@
+import { readFileSync } from 'node:fs';
+import pc from 'picocolors';
+import { SdodsError } from '@sdods/core';
+import { createContext } from '../context.js';
+import { collect, json, ok, out, table } from '../ui.js';
+const ROLES = ['plan', 'generate', 'heal', 'upgrade', 'review'];
+const ROLE_MAP = {
+    plan: 'planner',
+    generate: 'generator',
+    heal: 'healer',
+    upgrade: 'upgrader',
+    review: 'reviewer',
+};
+export function register(program) {
+    const agent = program
+        .command('agent')
+        .description('AI agents that plan, generate, heal, upgrade and review tests (they only write proposals)');
+    for (const verb of ROLES) {
+        agent
+            .command(verb)
+            .description(verb === 'plan'
+            ? 'Explore the app or its source and write a tagged test plan'
+            : verb === 'generate'
+                ? 'Turn a plan, goal or recorded spec into features, steps and page objects'
+                : verb === 'heal'
+                    ? 'Diagnose a failing scenario and propose the smallest fix'
+                    : verb === 'upgrade'
+                        ? 'Map a code/API change to affected scenarios and propose updates'
+                        : 'Review feature files for tagging, reuse and best practices')
+            .requiredOption('-p, --project <slug>', 'project slug')
+            .option('-e, --env <name>', 'environment')
+            .option('--goal <text>', 'what to do')
+            .option('--plan <file>', 'plan markdown (generate)')
+            .option('--spec <file>', 'recorded spec to convert (generate)')
+            .option('--scenario <fingerprint>', 'scenario fingerprint or name (heal)')
+            .option('--run-id <id>', 'run id (heal), default last', 'last')
+            .option('--diff <range>', 'git range (upgrade), e.g. main..HEAD')
+            .option('--files <list>', 'feature files (review)', collect, [])
+            .option('--adapter <name>', 'claude (API key) | claude-code (logged-in Claude Code CLI) | codex (logged-in Codex CLI) | openai | ollama (a model on this machine) | fake; default: auto-detect')
+            .option('--model <id>', 'model override')
+            .option('--profile <name>', 'auto | full | small — how many tools and how much prompt the model is given')
+            .option('--browser', 'attach the browser MCP server even under the small profile (which omits it)')
+            .option('--no-browser', 'never attach the browser MCP server')
+            .option('--base-url <url>', 'model server endpoint (ollama, vLLM, LM Studio, Azure)')
+            .option('--context-tokens <n>', 'context window to load a local model with (num_ctx)')
+            .option('--max-turns <n>', 'turn budget')
+            .option('--budget-usd <n>', 'cost budget in USD')
+            .option('--dry-run', 'use the fake adapter and print the prompt, tools and budget without calling an LLM')
+            .option('--events', 'print agent events as they arrive')
+            .action(async (opts, cmd) => {
+            const ctx = createContext(cmd);
+            ctx.registry.entry(opts.project);
+            const { prepareJob, runJob } = await import('@sdods/agents');
+            const role = ROLE_MAP[verb];
+            const input = {
+                project: opts.project,
+                env: opts.env,
+                goal: opts.goal,
+                plan: opts.plan ? readFileSync(opts.plan, 'utf8') : undefined,
+                spec: opts.spec ? readFileSync(opts.spec, 'utf8') : undefined,
+                scenario: opts.scenario,
+                runId: opts.runId,
+                diff: opts.diff,
+                files: opts.files,
+            };
+            const common = {
+                role,
+                input,
+                rootDir: ctx.rootDir,
+                provider: opts.dryRun ? 'fake' : opts.adapter,
+                model: opts.model,
+                profile: opts.profile,
+                browser: opts.browser,
+                baseUrl: opts.baseUrl,
+                contextTokens: opts.contextTokens ? Number(opts.contextTokens) : undefined,
+                maxTurns: opts.maxTurns ? Number(opts.maxTurns) : undefined,
+                budgetUsd: opts.budgetUsd ? Number(opts.budgetUsd) : undefined,
+                dryRun: Boolean(opts.dryRun),
+            };
+            if (opts.dryRun) {
+                const prep = await prepareJob(common);
+                const view = {
+                    job: {
+                        id: prep.job.id,
+                        role: prep.job.role,
+                        provider: prep.job.provider,
+                        model: prep.job.model,
+                        budgetUsd: prep.job.budgetUsd,
+                        maxTurns: prep.job.maxTurns,
+                    },
+                    profile: { name: prep.profile.profile, reason: prep.profile.reason },
+                    tools: prep.tools.map((t) => t.name),
+                    mcpServers: Object.keys(prep.mcpServers),
+                    system: prep.system,
+                    prompt: prep.prompt,
+                };
+                if (ctx.opts.json)
+                    return json(view);
+                out(pc.bold(`Dry run: sdods agent ${verb} (${role})`));
+                out(`${pc.dim('adapter:')} fake  ${pc.dim('budget:')} $${view.job.budgetUsd}  ${pc.dim('max turns:')} ${view.job.maxTurns}  ${pc.dim('profile:')} ${view.profile.name} (${view.profile.reason})`);
+                out(`${pc.dim('tools:')} ${view.tools.join(', ')}`);
+                if (view.mcpServers.length)
+                    out(`${pc.dim('external MCP servers:')} ${view.mcpServers.join(', ')}`);
+                out(pc.dim('\n--- system prompt ---'));
+                out(view.system);
+                out(pc.dim('\n--- user prompt ---'));
+                out(view.prompt);
+                out(pc.dim('\nNo files were written. Drop --dry-run (and set ANTHROPIC_API_KEY or OPENAI_API_KEY) to run for real.'));
+                return;
+            }
+            const job = await runJob({
+                ...common,
+                onEvent: opts.events || !ctx.opts.json
+                    ? (e) => {
+                        if (ctx.opts.json)
+                            return;
+                        if (e.type === 'text')
+                            process.stdout.write(e.text);
+                        else if (e.type === 'tool_call')
+                            out(pc.cyan(`\n▶ ${e.name} ${JSON.stringify(e.input).slice(0, 160)}`));
+                        else if (e.type === 'tool_result')
+                            out(pc.dim(`  ↳ ${e.isError ? 'error' : 'ok'}`));
+                        else if (e.type === 'status')
+                            out(pc.dim(`  · ${e.message}`));
+                    }
+                    : undefined,
+            });
+            if (ctx.opts.json)
+                return json(job);
+            out('');
+            const line = `${job.status} · turns ${job.turns ?? 0} · tool calls ${job.toolCalls ?? 0} · cost $${(job.costUsd ?? 0).toFixed(3)} · model ${job.model}`;
+            if (job.status === 'failed')
+                throw new SdodsError('RUN_FAILED', `Agent job ${job.id} failed: ${job.error ?? 'unknown'}`, { details: { job: job.id } });
+            ok(`Job ${job.id}: ${line}`);
+            if (job.proposalIds.length) {
+                out(`Proposals: ${job.proposalIds.join(', ')}`);
+                out(pc.dim(`Review with: sdods proposals show ${job.proposalIds[0]}`));
+            }
+        });
+    }
+    agent
+        .command('jobs')
+        .description('List recent agent jobs')
+        .option('--limit <n>', 'max rows', '20')
+        .action(async (opts, cmd) => {
+        const ctx = createContext(cmd);
+        const { JobJournal } = await import('@sdods/agents');
+        const rows = new JobJournal(ctx.rootDir).list(Number(opts.limit)).map((j) => ({
+            id: j.id,
+            role: j.role,
+            project: j.project ?? '',
+            status: j.status,
+            cost: `$${(j.costUsd ?? 0).toFixed(3)}`,
+            turns: j.turns ?? 0,
+            proposals: j.proposalIds.length,
+            started: j.startedAt,
+        }));
+        if (ctx.opts.json)
+            return json(rows);
+        table(rows);
+    });
+    const installAction = async (opts, cmd, forced) => {
+        const ctx = createContext(cmd);
+        const target = (forced ?? opts.for ?? 'all');
+        if (!['claude', 'codex', 'all'].includes(target)) {
+            throw new SdodsError('NOT_SUPPORTED', `Unknown target "${target}".`, {
+                hint: 'Use --for claude, --for codex or --for all.',
+                exitCode: 2,
+            });
+        }
+        const { installCodingAgents } = await import('@sdods/agents');
+        const written = installCodingAgents(ctx.rootDir, {
+            for: target,
+            project: opts.project,
+            env: opts.env,
+            force: opts.force,
+        });
+        if (opts.mcp !== false) {
+            const { execa } = await import('execa');
+            const clients = target === 'all' ? ['claude', 'codex'] : [target];
+            for (const client of clients) {
+                const args = ['mcp', 'install', client];
+                if (opts.project)
+                    args.push('-p', opts.project);
+                if (opts.env)
+                    args.push('-e', opts.env);
+                const r = await execa(process.execPath, [...process.execArgv, process.argv[1], ...args], {
+                    cwd: ctx.rootDir,
+                    reject: false,
+                });
+                written.push(`mcp:${client} → ${r.exitCode === 0 ? 'registered' : `failed (${(r.stderr || r.stdout).trim().split('\n').pop()})`}`);
+            }
+        }
+        if (ctx.opts.json)
+            return json({ target, written });
+        for (const w of written)
+            ok(w.replace(ctx.rootDir + '/', ''));
+        if (!written.length)
+            out(pc.dim('Nothing written (files exist; use --force).'));
+    };
+    agent
+        .command('install')
+        .description('Set up coding-agent CLIs: --for claude writes .claude/agents/sdods-*.md + CLAUDE.md, --for codex writes AGENTS.md; both get AGENT.md/SKILL.md and the MCP registration')
+        .option('--for <client>', 'claude | codex | all', 'all')
+        .option('-p, --project <slug>')
+        .option('-e, --env <name>')
+        .option('--force', 'overwrite existing files')
+        .option('--no-mcp', 'skip `sdods mcp install <client>`')
+        .action((opts, cmd) => installAction(opts, cmd));
+    agent
+        .command('install-claude')
+        .description('Alias of `agent install --for claude`')
+        .option('-p, --project <slug>')
+        .option('-e, --env <name>')
+        .option('--force', 'overwrite existing files')
+        .option('--no-mcp', 'skip `sdods mcp install claude`')
+        .action((opts, cmd) => installAction(opts, cmd, 'claude'));
+}
+//# sourceMappingURL=agent.js.map

package/dist/commands/analyze.d.ts

@@ -0,0 +1,20 @@
+import type { Command } from 'commander';
+import type { AnalysisReport, ProjectProposal } from '@sdods/contracts';
+export interface InitFromAppOptions {
+    appPath: string;
+    rootDir: string;
+    slug?: string;
+    name?: string;
+    openapi?: string;
+    force?: boolean;
+    importSpecs?: boolean;
+    browsers?: string[];
+}
+/** Programmatic entry used by `sdods init --from <app>`: analyze → propose → apply. */
+export declare function initFromApp(opts: InitFromAppOptions): Promise<{
+    report: AnalysisReport;
+    proposal: ProjectProposal;
+    result: import("@sdods/core/analyze").ApplyResult;
+}>;
+export declare function register(program: Command): void;
+//# sourceMappingURL=analyze.d.ts.map

package/dist/commands/analyze.js

@@ -0,0 +1,216 @@
+import { resolve as resolvePath } from 'node:path';
+import pc from 'picocolors';
+import { parse as parseYaml } from 'yaml';
+import { ProjectConfigSchema } from '@sdods/contracts';
+import { createContext } from '../context.js';
+import { heading, json, ok, out, table, warn } from '../ui.js';
+import { projectTemplateFiles } from '../templates/project.js';
+/** Programmatic entry used by `sdods init --from <app>`: analyze → propose → apply. */
+export async function initFromApp(opts) {
+    const { analyzeProject, proposeProject, applyProposal } = await import('@sdods/core/analyze');
+    const report = analyzeProject(opts.appPath, { openapi: opts.openapi });
+    const proposal = proposeProject(report, {
+        slug: opts.slug,
+        name: opts.name,
+        browsers: opts.browsers,
+    });
+    const result = applyProposal(proposal, {
+        rootDir: opts.rootDir,
+        scaffold: scaffoldFor(proposal),
+        force: opts.force,
+        appPath: opts.appPath,
+        importSpecs: opts.importSpecs ?? true,
+    });
+    return { report, proposal, result };
+}
+/** Code/data scaffolding from the project template; the proposal owns yaml, envs and features. */
+function scaffoldFor(proposal) {
+    const config = ProjectConfigSchema.parse(parseYaml(proposal.projectYaml));
+    const files = projectTemplateFiles({
+        config,
+        envName: config.envs.default,
+        uiUrl: '',
+        apiUrl: '',
+    });
+    for (const key of Object.keys(files)) {
+        if (key.startsWith('envs/') || key.startsWith('features/') || key === '.env.example') {
+            delete files[key];
+        }
+    }
+    return files;
+}
+export function register(program) {
+    program
+        .command('analyze [path]')
+        .description('Analyze an application repository and propose an SDODS project (read-only unless --apply)')
+        .option('-p, --project <slug>', 'slug for the proposed project (default: from the app directory)')
+        .option('--slug <slug>', 'alias of --project')
+        .option('--name <name>', 'display name')
+        .option('--openapi <file>', 'OpenAPI spec path relative to the app (auto-detected otherwise)')
+        .option('--browsers <list>', 'comma list of browsers for the proposal', (v) => v.split(',').map((s) => s.trim()))
+        .option('--apply', 'write the proposed project under projects/<slug>')
+        .option('--force', 'overwrite an existing project when applying')
+        .option('--no-import-specs', 'do not copy existing Playwright specs into recorded/imported')
+        .option('--report-only', 'print the analysis, skip the proposal')
+        .action(async (path, opts, cmd) => {
+        const ctx = createContext(cmd);
+        // the app path is relative to where the command was typed, not to --cwd (the SDODS repo)
+        const appPath = resolvePath(process.cwd(), path ?? '.');
+        const { analyzeProject, proposeProject, applyProposal } = await import('@sdods/core/analyze');
+        const report = analyzeProject(appPath, { openapi: opts.openapi });
+        const slug = opts.project ?? opts.slug;
+        const proposal = opts.reportOnly
+            ? undefined
+            : proposeProject(report, { slug, name: opts.name, browsers: opts.browsers });
+        let applied;
+        if (opts.apply && proposal) {
+            applied = applyProposal(proposal, {
+                rootDir: ctx.rootDir,
+                scaffold: scaffoldFor(proposal),
+                force: opts.force,
+                appPath,
+                importSpecs: opts.importSpecs !== false,
+            });
+        }
+        if (ctx.opts.json) {
+            return json({
+                report,
+                proposal: proposal ? { ...proposal, files: undefined } : undefined,
+                applied,
+            });
+        }
+        printReport(report);
+        if (proposal)
+            printProposal(proposal);
+        if (applied && proposal) {
+            heading('Applied');
+            ok(`Project ${proposal.slug} written to ${applied.root}`);
+            for (const f of applied.written)
+                out(`  ${f}`);
+            if (applied.skipped.length)
+                warn(`Skipped existing files: ${applied.skipped.join(', ')}`);
+            if (applied.importedSpecs.length) {
+                out(pc.dim(`  imported ${applied.importedSpecs.length} Playwright spec(s) into recorded/imported/`));
+            }
+            const envName = Object.keys(proposal.envYamls)[0] ?? 'local';
+            out(`\nNext:\n  sdods lint -p ${proposal.slug}\n  sdods run -p ${proposal.slug} -e ${envName} -l api\n  sdods run -p ${proposal.slug} -e ${envName} -l ui -b chromium -t @smoke`);
+        }
+        else if (proposal) {
+            out(pc.dim('\nRun again with --apply to write the project.'));
+        }
+    });
+}
+function printReport(r) {
+    heading(`Analysis of ${r.appPath}`);
+    out(pc.dim(`${r.filesScanned} files scanned · ${r.analyzedAt}`));
+    const mono = r.packageManager.monorepo
+        ? ` (monorepo: ${r.packageManager.workspaces.join(', ') || 'yes'})`
+        : '';
+    out(`${pc.bold('Package manager')}   ${r.packageManager.name}${mono}`);
+    out(`${pc.bold('Frameworks')}        ${r.frameworks
+        .map((f) => `${f.name}${f.version ? ` ${f.version}` : ''} (${Math.round(f.confidence * 100)}%)`)
+        .join(', ') || pc.dim('none detected')}`);
+    out(`${pc.bold('Test-id attribute')} ${r.testIds.attribute ?? pc.dim('none')}${r.testIds.attribute ? ` (${r.testIds.counts[r.testIds.attribute]} uses)` : ''}`);
+    out(`${pc.bold('Auth')}              ${r.auth.strategyGuess}${r.auth.libraries.length ? ` via ${r.auth.libraries.join(', ')}` : ''}${r.auth.pages.length ? `; pages: ${r.auth.pages.join(', ')}` : ''}`);
+    out(`${pc.bold('Base URLs')}         ui ${r.baseUrls.ui ?? '?'} · api ${r.baseUrls.api ?? '?'}`);
+    out(`${pc.bold('CI')}                ${r.ci.provider}${r.ci.files.length ? ` (${r.ci.files.length} file(s))` : ''}`);
+    if (r.i18n.libraries.length || r.i18n.locales.length) {
+        out(`${pc.bold('i18n')}              ${r.i18n.libraries.join(', ')}${r.i18n.locales.length ? ` locales ${r.i18n.locales.join(', ')}` : ''}`);
+    }
+    if (r.a11y.tooling.length)
+        out(`${pc.bold('a11y tooling')}      ${r.a11y.tooling.join(', ')}`);
+    const pages = r.routes.filter((x) => x.kind === 'page');
+    const apis = r.routes.filter((x) => x.kind === 'api');
+    heading(`Routes (${pages.length} pages, ${apis.length} API)`);
+    table(r.routes.slice(0, 40).map((x) => ({
+        kind: x.kind,
+        method: x.method ?? '',
+        path: x.path,
+        source: x.source,
+        file: `${x.file}${x.line ? `:${x.line}` : ''}`,
+    })), ['kind', 'method', 'path', 'source', 'file']);
+    if (r.routes.length > 40)
+        out(pc.dim(`  … ${r.routes.length - 40} more`));
+    if (r.openapi.length) {
+        heading('OpenAPI');
+        for (const o of r.openapi) {
+            out(`  ${o.file} — ${o.title ?? ''} ${o.version ?? ''} · ${o.endpoints.length} operations`);
+        }
+    }
+    if (r.existingTests.length) {
+        heading('Existing tests');
+        table(r.existingTests.map((t) => ({
+            framework: t.framework,
+            files: t.files,
+            css: t.locators.css,
+            xpath: t.locators.xpath,
+            role: t.locators.role,
+            testId: t.locators.testId,
+            text: t.locators.text,
+        })));
+    }
+    if (r.envs.length) {
+        heading('Environment files');
+        table(r.envs.map((e) => ({
+            env: e.name,
+            file: e.file,
+            ui: e.uiBaseUrl ?? '',
+            api: e.apiBaseUrl ?? '',
+            vars: e.vars.length,
+        })));
+    }
+    heading('Checklist');
+    for (const c of r.checklist) {
+        const icon = c.severity === 'error'
+            ? pc.red('✖')
+            : c.severity === 'warning'
+                ? pc.yellow('⚠')
+                : pc.cyan('ℹ');
+        out(`${icon} ${pc.bold(c.title)} — ${c.detail}${c.fix ? pc.dim(`\n    → ${c.fix}`) : ''}`);
+    }
+}
+/**
+ * Why each module exists. Modules are inferred by fusing several signals - the file that defines
+ * a route, the monorepo workspace, a domain directory, an OpenAPI tag - so the winning signal and
+ * its confidence are the part a reviewer actually needs to judge the proposal.
+ */
+function printModules(p) {
+    const mods = p.detectedModules ?? [];
+    if (!mods.length)
+        return;
+    out(pc.dim('--- modules ---'));
+    const w = Math.max(6, ...mods.map((m) => m.name.length));
+    for (const m of mods) {
+        const targets = [
+            m.routes ? `${m.routes} route${m.routes === 1 ? '' : 's'}` : '',
+            m.endpoints ? `${m.endpoints} endpoint${m.endpoints === 1 ? '' : 's'}` : '',
+        ]
+            .filter(Boolean)
+            .join(', ');
+        const from = m.evidence[0]?.file;
+        out(`  ${m.name.padEnd(w)}  ${pc.dim(m.confidence.toFixed(2))}  ${targets.padEnd(22)}` +
+            `${pc.dim(m.signals.join('+'))}${from ? pc.dim(`  ← ${from}`) : ''}`);
+    }
+    const ignored = p.ignoredTargets ?? [];
+    if (ignored.length) {
+        out(pc.dim(`--- skipped (${ignored.length}) ---`));
+        for (const i of ignored)
+            out(pc.dim(`  ${i.target.padEnd(20)} ${i.reason}`));
+    }
+}
+function printProposal(p) {
+    heading(`Proposed project: ${p.slug}`);
+    out(pc.dim(`envs: ${Object.keys(p.envYamls).join(', ')} · starter features: ${Object.keys(p.starterFeatures).length} · coverage targets: ${p.coverageMap.length}`));
+    for (const n of p.notes)
+        warn(n);
+    printModules(p);
+    out(pc.dim('--- sdods.project.yaml ---'));
+    const lines = p.projectYaml.split('\n');
+    out(lines.slice(0, 60).join('\n'));
+    if (lines.length > 60)
+        out(pc.dim('  …'));
+    out(pc.dim('--- starter features ---'));
+    for (const f of Object.keys(p.starterFeatures))
+        out(`  ${f}`);
+}
+//# sourceMappingURL=analyze.js.map

package/dist/commands/auth.d.ts

@@ -0,0 +1,7 @@
+import type { Command } from 'commander';
+/**
+ * Login-state commands. Capture/list are thin wrappers over `@sdods/core/auth/capture`
+ * (the same library `sdods record --user` uses) so there is a single implementation.
+ */
+export declare function register(program: Command): void;
+//# sourceMappingURL=auth.d.ts.map

package/dist/commands/auth.js

@@ -0,0 +1,97 @@
+import { execa } from 'execa';
+import { SdodsError } from '@sdods/core';
+import { createContext } from '../context.js';
+import { json, ok, table } from '../ui.js';
+/**
+ * Login-state commands. Capture/list are thin wrappers over `@sdods/core/auth/capture`
+ * (the same library `sdods record --user` uses) so there is a single implementation.
+ */
+export function register(program) {
+    const auth = program
+        .command('auth')
+        .description('Capture and inspect login state for pool users');
+    auth
+        .command('capture')
+        .description('Log in as pool user(s) and store storageState under projects/<slug>/.auth/<env>/')
+        .requiredOption('-p, --project <slug>', 'project slug')
+        .option('-e, --env <name>', 'environment')
+        .option('-u, --user <role>', 'pool role to capture (default: every role)')
+        .option('--index <n>', 'pool index within the role', '0')
+        .option('--all', 'every user of the role, not only --index')
+        .option('--interactive', 'open a headed browser (SSO/MFA): finish the login by hand, then close the window')
+        .option('-b, --browser <name>', 'chromium | firefox | webkit', 'chromium')
+        .option('--headed', 'run the login with a visible browser')
+        .option('--force', 'recapture even when a fresh state exists')
+        .action(async (opts, cmd) => {
+        const ctx = createContext(cmd);
+        const cfg = ctx.registry.resolve(opts.project, opts.env);
+        const { captureAuth, poolUsers } = await import('@sdods/core/auth/capture');
+        const roles = opts.user
+            ? [opts.user]
+            : [...new Set((await poolUsers(cfg)).map((u) => u.role))];
+        const results = [];
+        for (const role of roles) {
+            const captured = await captureAuth({
+                config: cfg,
+                role,
+                index: Number(opts.index),
+                all: Boolean(opts.all),
+                interactive: Boolean(opts.interactive),
+                browserName: opts.browser,
+                headed: Boolean(opts.headed || opts.interactive),
+                force: Boolean(opts.force),
+            });
+            for (const r of captured) {
+                results.push({
+                    user: r.user,
+                    role: r.role,
+                    index: r.index,
+                    strategy: r.strategy,
+                    file: r.file,
+                    tokenFile: r.tokenFile,
+                    status: r.skipped ? `skipped: ${r.skipped}` : r.file ? 'captured' : 'no state',
+                });
+            }
+        }
+        if (ctx.opts.json)
+            return json(results);
+        table(results, ['user', 'role', 'index', 'strategy', 'status', 'file']);
+        ok(`states under ${cfg.project.root}/.auth/${cfg.env.name}`);
+    });
+    auth
+        .command('list')
+        .description('Show cached login states and their age')
+        .requiredOption('-p, --project <slug>', 'project slug')
+        .option('-e, --env <name>', 'environment')
+        .action(async (opts, cmd) => {
+        const ctx = createContext(cmd);
+        const cfg = ctx.registry.resolve(opts.project, opts.env);
+        const { listAuthStates } = await import('@sdods/core/auth/capture');
+        const rows = listAuthStates(cfg).map((s) => ({
+            user: s.user,
+            role: s.role,
+            ageMinutes: s.ageMinutes,
+            fresh: s.fresh ? 'yes' : 'no',
+            file: s.file,
+            tokenFile: s.tokenFile ?? '',
+        }));
+        if (ctx.opts.json)
+            return json(rows);
+        table(rows, ['user', 'role', 'ageMinutes', 'fresh', 'file']);
+    });
+    auth
+        .command('token')
+        .description('Manage API tokens (server feature; delegates to `sdods tokens`)')
+        .allowUnknownOption()
+        .action(async () => {
+        const r = await execa('sdods', ['tokens', ...process.argv.slice(4)], {
+            stdio: 'inherit',
+            reject: false,
+        });
+        if (r.exitCode)
+            throw new SdodsError('NOT_SUPPORTED', '`sdods tokens` is provided by the server package.', {
+                exitCode: 2,
+            });
+    });
+}
+//# sourceMappingURL=auth.js.map

package/dist/commands/browsers.d.ts

@@ -0,0 +1,17 @@
+import type { Command } from 'commander';
+export interface BrowserStatus {
+    name: string;
+    engine: 'chromium' | 'firefox' | 'webkit';
+    installed: boolean;
+    executable: string | null;
+    playwrightVersion: string;
+}
+export declare function browserStatuses(names?: string[]): Promise<BrowserStatus[]>;
+/** Install browser engines (used by `browsers install`, `doctor --fix`, `init`). */
+export declare function installBrowsers(opts?: {
+    browsers?: string[];
+    withDeps?: boolean;
+    cwd?: string;
+}): Promise<void>;
+export declare function register(program: Command): void;
+//# sourceMappingURL=browsers.d.ts.map