@sdods/cli 0.2.0

package/dist/commands/db.js

@@ -0,0 +1,241 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import pc from 'picocolors';
+import { parse as parseYaml } from 'yaml';
+import { WorkspaceFileSchema } from '@sdods/contracts';
+import { SdodsError } from '@sdods/core';
+import { createContext } from '../context.js';
+import { json, ok, out, table, warn } from '../ui.js';
+async function loadDb() {
+    return import('@sdods/db');
+}
+export function register(program) {
+    const db = program
+        .command('db')
+        .description('Migrate, inspect and switch the platform database (DB_DRIVER=sqlite|postgres)');
+    db.command('migrate')
+        .description('Apply pending migrations (creates the SQLite file on first use)')
+        .option('--to <name>', 'migrate up/down to a specific migration')
+        .option('--down', 'roll back one migration')
+        .action(async (opts, cmd) => {
+        const ctx = createContext(cmd);
+        const m = await loadDb();
+        const adb = m.createDb();
+        try {
+            const results = opts.down
+                ? await m.migrateDown(adb)
+                : opts.to
+                    ? await m.migrateTo(adb, opts.to)
+                    : await m.migrateToLatest(adb);
+            const rows = results.map((r) => ({
+                migration: r.migrationName,
+                direction: r.direction,
+                status: r.status,
+            }));
+            if (ctx.opts.json)
+                return json({ driver: adb.driver, results: rows });
+            out(pc.dim(`driver: ${adb.driver}${adb.driver === 'sqlite' ? ` (${adb.config.sqlitePath})` : ''}`));
+            if (rows.length === 0)
+                ok('Database is up to date');
+            else
+                table(rows);
+        }
+        finally {
+            await adb.close();
+        }
+    });
+    db.command('status')
+        .description('Show applied and pending migrations')
+        .action(async (_opts, cmd) => {
+        const ctx = createContext(cmd);
+        const m = await loadDb();
+        const adb = m.createDb();
+        try {
+            const status = await m.migrationStatus(adb);
+            if (ctx.opts.json)
+                return json({
+                    driver: adb.driver,
+                    config: { ...adb.config, databaseUrl: redactUrl(adb.config.databaseUrl) },
+                    migrations: status,
+                });
+            out(pc.bold(`driver: ${adb.driver}`) +
+                pc.dim(adb.driver === 'sqlite'
+                    ? `  ${adb.config.sqlitePath}`
+                    : `  ${redactUrl(adb.config.databaseUrl)}`));
+            table(status.map((s) => ({
+                migration: s.name,
+                applied: s.executedAt ? s.executedAt : pc.yellow('pending'),
+            })));
+        }
+        finally {
+            await adb.close();
+        }
+    });
+    db.command('reset')
+        .description('Drop every SDODS table (sqlite only)')
+        .option('--yes', 'confirm')
+        .action(async (opts, cmd) => {
+        const ctx = createContext(cmd);
+        if (!opts.yes)
+            throw new SdodsError('NOT_SUPPORTED', 'db reset is destructive; pass --yes to confirm.', {
+                exitCode: 2,
+            });
+        const m = await loadDb();
+        const adb = m.createDb();
+        try {
+            await m.resetDatabase(adb);
+            if (ctx.opts.json)
+                return json({ ok: true });
+            ok('Database reset');
+        }
+        finally {
+            await adb.close();
+        }
+    });
+    db.command('switch <target>')
+        .description('Copy the database to sqlite|postgres, verify counts and update .env')
+        .option('--target-url <url>', 'Postgres connection string for the target')
+        .option('--target-path <path>', 'SQLite file for the target')
+        .option('--dry-run', 'verify the target and report row counts without writing anything')
+        .option('--truncate', 'clear the target platform tables first (required when the target already has data)')
+        .option('--env-file <file>', 'dotenv file to update', '.env')
+        .option('--yes', 'skip confirmation')
+        .action(async (target, opts, cmd) => {
+        const ctx = createContext(cmd);
+        if (target !== 'sqlite' && target !== 'postgres') {
+            throw new SdodsError('NOT_SUPPORTED', `Unknown target "${target}"; use sqlite or postgres.`, { exitCode: 2 });
+        }
+        if (!opts.dryRun && !opts.yes) {
+            throw new SdodsError('NOT_SUPPORTED', 'db switch rewrites .env; pass --yes (or --dry-run to preview).', { exitCode: 2 });
+        }
+        const m = await loadDb();
+        const source = m.createDb();
+        try {
+            const result = await m.switchDriver({
+                source,
+                target,
+                targetUrl: opts.targetUrl,
+                targetPath: opts.targetPath,
+                dryRun: Boolean(opts.dryRun),
+                truncate: Boolean(opts.truncate),
+                envFile: resolve(ctx.rootDir, opts.envFile),
+            });
+            if (ctx.opts.json)
+                return json(result);
+            table(result.tables.map((t) => ({
+                table: t.table,
+                source: t.source,
+                target: t.target,
+                ok: t.ok ? pc.green('ok') : pc.red('MISMATCH'),
+            })));
+            if (!result.ok) {
+                warn('Row counts do not match; .env was not changed.');
+                process.exitCode = 1;
+                return;
+            }
+            if (result.dryRun)
+                ok(`Dry run: ${target} copy verified. Re-run with --yes to switch.`);
+            else
+                ok(`Switched to ${target}. Updated ${result.envFile}: ${result.envChanges?.join(', ')}`);
+        }
+        finally {
+            await source.close();
+        }
+    });
+    db.command('export <dir>')
+        .description('Export every table to <dir>/<table>.jsonl')
+        .action(async (dir, _opts, cmd) => {
+        const ctx = createContext(cmd);
+        const m = await loadDb();
+        const adb = m.createDb();
+        try {
+            const res = await m.exportAll(adb, dir);
+            if (ctx.opts.json)
+                return json(res);
+            table(res.tables.map((t) => ({ table: t.table, rows: t.rows })));
+            ok(`Exported to ${res.dir}`);
+        }
+        finally {
+            await adb.close();
+        }
+    });
+    db.command('import <dir>')
+        .description('Import <dir>/<table>.jsonl files (ON CONFLICT DO NOTHING)')
+        .action(async (dir, _opts, cmd) => {
+        const ctx = createContext(cmd);
+        const m = await loadDb();
+        const adb = m.createDb();
+        try {
+            await m.migrateToLatest(adb);
+            const res = await m.importAll(adb, dir);
+            if (ctx.opts.json)
+                return json(res);
+            table(res.tables.map((t) => ({ table: t.table, inserted: t.rows, skipped: t.skipped })));
+        }
+        finally {
+            await adb.close();
+        }
+    });
+    db.command('prune')
+        .description('Delete old runs and their artifact directories')
+        .option('--keep-runs <n>', 'runs to keep per project')
+        .option('--keep-days <n>', 'delete runs older than n days')
+        .option('-p, --project <slug>', 'limit to one project')
+        .option('--dry-run', 'list what would be deleted')
+        .action(async (opts, cmd) => {
+        const ctx = createContext(cmd);
+        if (!opts.keepRuns && !opts.keepDays) {
+            throw new SdodsError('NOT_SUPPORTED', 'Pass --keep-runs and/or --keep-days.', {
+                exitCode: 2,
+            });
+        }
+        const m = await loadDb();
+        const adb = m.createDb();
+        try {
+            const res = await m.prune(adb, {
+                keepRuns: opts.keepRuns ? Number(opts.keepRuns) : undefined,
+                keepDays: opts.keepDays ? Number(opts.keepDays) : undefined,
+                projectSlug: opts.project,
+                artifactsRoot: join(ctx.rootDir, process.env.SDODS_ARTIFACTS_DIR ?? '.sdods/runs'),
+                dryRun: Boolean(opts.dryRun),
+            });
+            if (ctx.opts.json)
+                return json(res);
+            table(res.deleted.map((d) => ({ run: d.id, project: d.projectSlug, created: d.createdAt })));
+            ok(`${opts.dryRun ? 'Would delete' : 'Deleted'} ${res.deleted.length} run(s); kept ${res.kept}`);
+        }
+        finally {
+            await adb.close();
+        }
+    });
+    db.command('sync')
+        .description('Upsert organization, workspaces, projects, modules and processes from the yaml files')
+        .action(async (_opts, cmd) => {
+        const ctx = createContext(cmd);
+        const m = await loadDb();
+        const adb = m.createDb();
+        try {
+            await m.migrateToLatest(adb);
+            const wsFile = join(ctx.rootDir, 'sdods.workspace.yaml');
+            const workspaceFile = existsSync(wsFile)
+                ? WorkspaceFileSchema.parse(parseYaml(readFileSync(wsFile, 'utf8')))
+                : null;
+            const projects = ctx.registry
+                .entriesList()
+                .map((e) => ({ config: e.config, root: e.root }));
+            const res = await m.syncHierarchy(adb.db, adb.driver, { workspaceFile, projects });
+            if (ctx.opts.json)
+                return json(res);
+            ok(`Synced ${workspaceFile ? `organization ${workspaceFile.organization.slug}, ${Object.keys(res.workspaces).length} workspace(s), ` : ''}${Object.keys(res.projects).length} project(s), ${res.modules} module(s), ${res.processes} process(es)`);
+        }
+        finally {
+            await adb.close();
+        }
+    });
+}
+function redactUrl(url) {
+    if (!url)
+        return '';
+    return url.replace(/\/\/([^:]+):[^@]+@/, '//$1:***@');
+}
+//# sourceMappingURL=db.js.map

package/dist/commands/doctor.d.ts

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

package/dist/commands/doctor.js

@@ -0,0 +1,323 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { execa } from 'execa';
+import pc from 'picocolors';
+import { collectVarRefs, loadDotEnvLayer, loadEnvFile } from '@sdods/core';
+import { createContext } from '../context.js';
+import { json, out } from '../ui.js';
+export function registerDoctorCommand(program) {
+    program
+        .command('doctor')
+        .description('Check Node, Bun, browsers, projects, env vars and database reachability')
+        .option('-p, --project <slug>', 'limit env-var checks to one project')
+        .option('--fix', 'install missing browsers')
+        .action(async (opts, cmd) => {
+        const ctx = createContext(cmd);
+        const checks = [];
+        const nodeMajor = Number(process.versions.node.split('.')[0]);
+        checks.push({
+            name: 'node',
+            ok: nodeMajor >= 22,
+            detail: `v${process.versions.node}`,
+            fix: 'Install Node 22 LTS (nvm use 22).',
+        });
+        checks.push(await versionCheck('bun', ['--version'], 'optional: bun install/build are faster'));
+        checks.push(await versionCheck('runner', ['playwright', '--version'], 'install workspace dependencies: bun install (or npm install)', 'npx'));
+        const browsers = await browserCheck();
+        checks.push(...browsers);
+        if (opts.fix && browsers.some((b) => !b.ok)) {
+            out(pc.cyan('Installing browsers…'));
+            await execa('npx', ['playwright', 'install', '--with-deps'], {
+                stdio: 'inherit',
+                cwd: ctx.rootDir,
+            }).catch(() => undefined);
+        }
+        const entries = opts.project
+            ? [ctx.registry.entry(opts.project)]
+            : ctx.registry.entriesList();
+        checks.push({
+            name: 'projects',
+            ok: entries.length > 0,
+            detail: entries.map((e) => e.slug).join(', ') || 'none',
+            fix: 'sdods project create <slug>',
+        });
+        for (const e of entries) {
+            for (const envName of e.config.envs.available) {
+                const file = join(e.root, 'envs', `${envName}.yaml`);
+                if (!existsSync(file)) {
+                    checks.push({
+                        name: `${e.slug}/${envName}`,
+                        ok: false,
+                        detail: 'env yaml missing',
+                        fix: `sdods env add ${envName} -p ${e.slug} --ui-url ... --api-url ...`,
+                    });
+                    continue;
+                }
+                const envCfg = loadEnvFile(e.root, envName);
+                const refs = collectVarRefs(envCfg);
+                const dotenv = loadDotEnvLayer(ctx.rootDir, e.root, envName).values;
+                const missing = [...refs].filter((v) => dotenv[v] === undefined && process.env[v] === undefined);
+                checks.push({
+                    name: `${e.slug}/${envName} vars`,
+                    ok: missing.length === 0,
+                    detail: missing.length
+                        ? `missing: ${missing.join(', ')}`
+                        : `${refs.size} var(s) resolved`,
+                    fix: missing.length
+                        ? `Add ${missing.join(', ')} to ${join(e.root, `.env.${envName}`)}`
+                        : undefined,
+                });
+            }
+        }
+        const driver = process.env.DB_DRIVER ?? 'sqlite';
+        checks.push({
+            name: 'database',
+            ok: driver === 'sqlite' || Boolean(process.env.DATABASE_URL),
+            detail: driver === 'sqlite'
+                ? `sqlite (${process.env.SQLITE_PATH ?? '.sdods/sdods.db'})`
+                : `postgres ${process.env.DATABASE_URL ? '(url set)' : '(DATABASE_URL missing)'}`,
+            fix: 'Set DB_DRIVER=sqlite or provide DATABASE_URL.',
+        });
+        // Coding-agent CLIs (optional: they let agents run on your existing login instead of an API key)
+        const cliStatus = await codingCliStatus();
+        for (const c of cliStatus)
+            checks.push(c);
+        // A model server on this machine is the fourth way to reach a model, and the only free one.
+        const localLlm = await localModelStatus();
+        checks.push(localLlm);
+        const tokens = tokenMatrix(cliStatus, localLlm);
+        if (ctx.opts.json)
+            return json({ checks, tokens });
+        for (const c of checks) {
+            out(`${c.ok ? pc.green('✔') : pc.red('✖')} ${c.name.padEnd(28)} ${c.detail}${!c.ok && c.fix ? pc.dim(`  → ${c.fix}`) : ''}`);
+        }
+        out(pc.bold('\nTokens and keys'));
+        for (const t of tokens) {
+            const icon = t.present
+                ? pc.green('✔')
+                : t.requirement === 'mandatory'
+                    ? pc.red('✖')
+                    : t.requirement === 'one-of' && !t.groupSatisfied
+                        ? pc.yellow('!')
+                        : pc.dim('·');
+            out(`${icon} ${t.name.padEnd(36)} ${pc.dim(t.requirement.padEnd(10))} ${t.detail}${t.hint && !t.present ? pc.dim(`  → ${t.hint}`) : ''}`);
+        }
+        out(pc.dim('\nNothing is mandatory for the platform itself (SDODS API tokens are self-issued and free). Agents need one of the "one-of" rows.'));
+        const blocking = checks.some((c) => !c.ok && !c.optional);
+        if (blocking)
+            process.exitCode = 1;
+    });
+}
+/**
+ * The token matrix. "one-of" rows form a group: agents need ANY one of them.
+ * Platform features never need an external token.
+ */
+function tokenMatrix(cliStatus, localLlm) {
+    const has = (k) => Boolean(process.env[k]);
+    const claudeOk = cliStatus.find((c) => c.name === 'cli:claude')?.ok ?? false;
+    const codexOk = cliStatus.find((c) => c.name === 'cli:codex')?.ok ?? false;
+    const agentsGroup = [
+        {
+            name: 'ANTHROPIC_API_KEY',
+            present: has('ANTHROPIC_API_KEY'),
+            detail: 'Claude via the Agent SDK / Messages API (billed by Anthropic)',
+            hint: 'or log in to Claude Code (`claude login`) — no key needed',
+        },
+        {
+            name: 'claude CLI login',
+            present: claudeOk,
+            detail: 'adapter claude-code: uses your Claude Code login (subscription or key)',
+            hint: '`npm i -g @anthropic-ai/claude-code && claude login`',
+        },
+        {
+            name: 'codex CLI login',
+            present: codexOk,
+            detail: 'adapter codex: uses your Codex login (ChatGPT account)',
+            hint: '`npm i -g @openai/codex && codex login`',
+        },
+        {
+            name: 'OPENAI_API_KEY (+OPENAI_BASE_URL)',
+            present: has('OPENAI_API_KEY'),
+            detail: 'any OpenAI-compatible chat-completions endpoint',
+            hint: 'optional OPENAI_BASE_URL for Azure, vLLM, LM Studio',
+        },
+        {
+            name: 'local models (ollama)',
+            present: localLlm?.ok ?? false,
+            detail: localLlm?.ok
+                ? `adapter ollama: ${localLlm.detail}`
+                : 'adapter ollama: a model on this machine — no key, no per-token cost',
+            hint: localLlm?.fix ?? 'ollama serve && ollama pull qwen2.5-coder:7b',
+        },
+    ];
+    const groupSatisfied = agentsGroup.some((g) => g.present);
+    const rows = agentsGroup.map((g) => ({
+        ...g,
+        requirement: 'one-of',
+        group: 'agents',
+        groupSatisfied,
+    }));
+    const serve = process.argv.includes('serve');
+    rows.push({
+        name: 'SESSION_SECRET',
+        requirement: serve ? 'mandatory' : 'optional',
+        present: has('SESSION_SECRET'),
+        detail: 'web server session signing (≥32 chars); needed only for `sdods serve`',
+        hint: 'generate: `openssl rand -hex 32`',
+    }, {
+        name: 'DATABASE_URL',
+        requirement: process.env.DB_DRIVER === 'postgres' ? 'mandatory' : 'optional',
+        present: has('DATABASE_URL'),
+        detail: 'only when DB_DRIVER=postgres (SQLite needs nothing)',
+    }, {
+        name: 'GITHUB_TOKEN',
+        requirement: 'optional',
+        present: has('GITHUB_TOKEN'),
+        detail: 'GitHub check runs, PR comments, issues (integrations.github)',
+    }, {
+        name: 'JIRA_EMAIL + JIRA_API_TOKEN',
+        requirement: 'optional',
+        present: has('JIRA_EMAIL') && has('JIRA_API_TOKEN'),
+        detail: 'Jira issues, links, transitions (integrations.jira)',
+    }, {
+        name: 'SDODS_TOKEN (+SDODS_SERVER_URL)',
+        requirement: 'optional',
+        present: has('SDODS_TOKEN'),
+        detail: 'self-issued, free: MCP over HTTP and CI result ingest (`sdods tokens create`)',
+    }, {
+        name: 'FIREBASE_SERVICE_ACCOUNT_AUTOMAX_DOCS',
+        requirement: 'ci-only',
+        present: has('FIREBASE_SERVICE_ACCOUNT_AUTOMAX_DOCS'),
+        detail: 'GitHub secret for the docs deploy workflow',
+    }, {
+        name: 'NPM_TOKEN',
+        requirement: 'ci-only',
+        present: has('NPM_TOKEN'),
+        detail: 'GitHub secret for publishing @sdods/* packages',
+    });
+    return rows;
+}
+/**
+ * `llm:local` row: is a model server answering, and is the model it would use pulled?
+ *
+ * Optional, and quick — a laptop without Ollama must not pay for this check. The context the
+ * models are loaded with is reported because that, not the model, is what usually makes a local
+ * agent run produce nonsense.
+ */
+async function localModelStatus() {
+    const name = 'llm:local';
+    try {
+        const { OllamaAdapter } = await import('@sdods/agents');
+        if (!(await OllamaAdapter.reachable()))
+            return {
+                name,
+                ok: false,
+                optional: true,
+                detail: 'no model server answering (optional)',
+                fix: 'ollama serve && ollama pull qwen2.5-coder:7b',
+            };
+        const adapter = new OllamaAdapter();
+        const [version, models] = await Promise.all([
+            adapter.version().catch(() => 'unknown'),
+            adapter.models().catch(() => []),
+        ]);
+        if (!models.length)
+            return {
+                name,
+                ok: false,
+                optional: true,
+                detail: `ollama ${version} · no models pulled`,
+                fix: 'ollama pull qwen2.5-coder:7b',
+            };
+        const configured = models.find((m) => m.name === adapter.defaultModel);
+        const preferred = configured ?? models[0];
+        const loaded = await adapter.loadedContext(preferred.name).catch(() => undefined);
+        const tight = loaded !== undefined && loaded < 8192;
+        return {
+            name,
+            ok: true,
+            optional: true,
+            detail: `ollama ${version} · ${models.length} model(s) · ${preferred.name}${loaded ? ` · loaded ctx ${loaded}` : ''}${tight ? ' (small)' : ''}${configured ? '' : ` · default ${adapter.defaultModel} not pulled`}`,
+            fix: !configured
+                ? `ollama pull ${adapter.defaultModel}, or set agents.models.default to one you have`
+                : tight
+                    ? 'agents.local.contextTokens: 16384, or OLLAMA_CONTEXT_LENGTH=16384 ollama serve'
+                    : undefined,
+        };
+    }
+    catch {
+        return { name, ok: false, optional: true, detail: 'agents package unavailable' };
+    }
+}
+/** `cli:claude` / `cli:codex` rows: installed + logged in. Missing CLIs are not failures. */
+async function codingCliStatus() {
+    const rows = [];
+    try {
+        const { ClaudeCodeCliAdapter, CodexCliAdapter } = await import('@sdods/agents');
+        const c = ClaudeCodeCliAdapter.loginStatus();
+        rows.push({
+            name: 'cli:claude',
+            ok: c.installed && c.loggedIn !== false,
+            optional: true,
+            detail: c.detail,
+            fix: c.installed ? 'claude login' : 'npm i -g @anthropic-ai/claude-code (optional)',
+        });
+        const x = CodexCliAdapter.loginStatus();
+        rows.push({
+            name: 'cli:codex',
+            ok: x.installed && x.loggedIn !== false,
+            optional: true,
+            detail: x.detail,
+            fix: x.installed ? 'codex login' : 'npm i -g @openai/codex (optional)',
+        });
+    }
+    catch {
+        rows.push({
+            name: 'cli:claude',
+            ok: false,
+            optional: true,
+            detail: 'agents package unavailable',
+        });
+        rows.push({
+            name: 'cli:codex',
+            ok: false,
+            optional: true,
+            detail: 'agents package unavailable',
+        });
+    }
+    return rows;
+}
+async function versionCheck(name, args, fix, bin = name) {
+    try {
+        const { stdout } = await execa(bin, args, { timeout: 20_000 });
+        return { name, ok: true, detail: stdout.trim().split('\n')[0] ?? '' };
+    }
+    catch {
+        return { name, ok: false, detail: 'not found', fix };
+    }
+}
+async function browserCheck() {
+    const out = [];
+    for (const b of ['chromium', 'firefox', 'webkit']) {
+        try {
+            const mod = await import('playwright-core');
+            const path = mod[b].executablePath();
+            out.push({
+                name: `browser:${b}`,
+                ok: existsSync(path),
+                detail: existsSync(path) ? path : 'not installed',
+                fix: `sdods browsers install -b ${b}`,
+            });
+        }
+        catch {
+            out.push({
+                name: `browser:${b}`,
+                ok: false,
+                detail: 'browser runner not resolvable',
+                fix: 'install workspace dependencies: bun install (or npm install)',
+            });
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=doctor.js.map

package/dist/commands/env.d.ts

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

package/dist/commands/env.js

@@ -0,0 +1,65 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { parseDocument } from 'yaml';
+import { SdodsError, PROJECT_FILE } from '@sdods/core';
+import { createContext } from '../context.js';
+import { json, ok, table } from '../ui.js';
+export function registerEnvCommands(program) {
+    const env = program.command('env').description('Manage project environments');
+    env
+        .command('list')
+        .description('List environments of a project')
+        .requiredOption('-p, --project <slug>', 'project slug')
+        .action((opts, cmd) => {
+        const ctx = createContext(cmd);
+        const e = ctx.registry.entry(opts.project);
+        const rows = e.config.envs.available.map((name) => {
+            let ui = '';
+            let api = '';
+            let status = 'ok';
+            try {
+                const cfg = ctx.registry.resolve(e.slug, name, {}, { ...process.env });
+                ui = cfg.env.ui.baseUrl;
+                api = cfg.env.api.baseUrl;
+            }
+            catch (err) {
+                status = err.message.split('\n')[0];
+            }
+            return { name, default: name === e.config.envs.default ? '*' : '', ui, api, status };
+        });
+        if (ctx.opts.json)
+            return json(rows);
+        table(rows);
+    });
+    env
+        .command('add <name>')
+        .description('Create envs/<name>.yaml and register it in envs.available')
+        .requiredOption('-p, --project <slug>', 'project slug')
+        .requiredOption('--ui-url <url>', 'UI base URL')
+        .requiredOption('--api-url <url>', 'API base URL')
+        .option('--default', 'make it the default environment')
+        .option('--pool-size <n>', 'user pool size', '2')
+        .action((name, opts, cmd) => {
+        const ctx = createContext(cmd);
+        const e = ctx.registry.entry(opts.project);
+        const file = join(e.root, 'envs', `${name}.yaml`);
+        if (existsSync(file))
+            throw new SdodsError('CONFIG_INVALID', `${file} already exists.`, { exitCode: 2 });
+        writeFileSync(file, `name: ${name}\nui:\n  baseUrl: ${opts.uiUrl}\napi:\n  baseUrl: ${opts.apiUrl}\n  headers: { Accept: application/json }\n  auth: { type: none }\nusers:\n  poolSize: ${Number(opts.poolSize)}\nvars: {}\n`);
+        const projectFile = join(e.root, PROJECT_FILE);
+        const doc = parseDocument(readFileSync(projectFile, 'utf8'));
+        const available = doc.getIn(['envs', 'available']);
+        const list = Array.isArray(available?.items)
+            ? available.items.map((i) => String(i.value ?? i))
+            : [];
+        if (!list.includes(name))
+            doc.setIn(['envs', 'available'], [...list, name]);
+        if (opts.default)
+            doc.setIn(['envs', 'default'], name);
+        writeFileSync(projectFile, doc.toString({ lineWidth: 100 }));
+        if (ctx.opts.json)
+            return json({ project: e.slug, env: name, file });
+        ok(`Added environment ${name} → ${file}`);
+    });
+}
+//# sourceMappingURL=env.js.map

package/dist/commands/features.d.ts

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