@sdods/cli 0.2.0

package/dist/commands/trace.js

@@ -0,0 +1,104 @@
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { join, resolve as resolvePath } from 'node:path';
+import { execa } from 'execa';
+import pc from 'picocolors';
+import { SdodsError, DEFAULT_ARTIFACTS_DIR } from '@sdods/core';
+import { createContext } from '../context.js';
+import { json, out, table } from '../ui.js';
+/** Recursively find `trace.zip` files (runner output) below a directory. */
+export function findTraceZips(dir, depth = 8) {
+    const found = [];
+    const walk = (d, level) => {
+        if (level > depth || !existsSync(d))
+            return;
+        for (const name of readdirSync(d)) {
+            const p = join(d, name);
+            let st;
+            try {
+                st = statSync(p);
+            }
+            catch {
+                continue;
+            }
+            if (st.isDirectory())
+                walk(p, level + 1);
+            else if (/^trace(-\d+)?\.zip$/.test(name))
+                found.push(p);
+        }
+    };
+    walk(dir, 0);
+    return found.sort();
+}
+export function listRuns(artifactsDir) {
+    if (!existsSync(artifactsDir))
+        return [];
+    return readdirSync(artifactsDir)
+        .map((runId) => {
+        const dir = join(artifactsDir, runId);
+        try {
+            const st = statSync(dir);
+            return st.isDirectory() ? { runId, dir, mtime: st.mtimeMs } : null;
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((r) => r !== null)
+        .sort((a, b) => b.mtime - a.mtime);
+}
+export function register(program) {
+    program
+        .command('trace [zip]')
+        .description('Open traces: a zip file, the traces of a run (--run), or of the latest run (--last)')
+        .option('--last', 'use the most recent run (default when no zip or --run is given)')
+        .option('--run <id>', 'run id under the artifacts directory')
+        .option('--artifacts-dir <dir>', `artifacts directory (default: ${DEFAULT_ARTIFACTS_DIR})`)
+        .option('--list', 'list trace files instead of opening them')
+        .action(async (zip, opts, cmd) => {
+        const ctx = createContext(cmd);
+        let zips = [];
+        let source = '';
+        if (zip) {
+            const p = resolvePath(ctx.opts.cwd ?? process.cwd(), zip);
+            if (!existsSync(p))
+                throw new SdodsError('CONFIG_NOT_FOUND', `No such file: ${p}`, { exitCode: 2 });
+            zips = statSync(p).isDirectory() ? findTraceZips(p) : [p];
+            source = p;
+        }
+        else {
+            const artifactsDir = resolvePath(ctx.rootDir, opts.artifactsDir ?? process.env.SDODS_ARTIFACTS_DIR ?? DEFAULT_ARTIFACTS_DIR);
+            const runs = listRuns(artifactsDir);
+            const run = opts.run ? runs.find((r) => r.runId === opts.run) : runs[0];
+            if (!run) {
+                throw new SdodsError('CONFIG_NOT_FOUND', opts.run
+                    ? `Run ${opts.run} not found under ${artifactsDir}.`
+                    : `No runs under ${artifactsDir}.`, {
+                    hint: 'Run `sdods run …` first. Traces are kept on the first retry and on failure (trace: on-first-retry).',
+                    exitCode: 2,
+                });
+            }
+            zips = findTraceZips(run.dir);
+            source = run.dir;
+        }
+        if (!zips.length) {
+            throw new SdodsError('CONFIG_NOT_FOUND', `No trace.zip under ${source}.`, {
+                hint: 'Traces are recorded on the first retry and for failures. Re-run with `--retries 1` or set trace: on in the project timeouts/use.',
+                exitCode: 2,
+            });
+        }
+        if (opts.list || ctx.opts.json) {
+            if (ctx.opts.json)
+                return json({ source, traces: zips });
+            table(zips.map((z) => ({ trace: z })));
+            return;
+        }
+        out(pc.cyan(`Opening ${zips.length} trace(s) from ${source}`));
+        const res = await execa('npx', ['playwright', 'show-trace', ...zips], {
+            cwd: ctx.rootDir,
+            stdio: 'inherit',
+            reject: false,
+        });
+        process.exitCode = res.exitCode ?? 0;
+    });
+}
+//# sourceMappingURL=trace.js.map

package/dist/commands/upgrade.d.ts

@@ -0,0 +1,14 @@
+import type { Command } from 'commander';
+export declare const SDODS_PACKAGES: readonly ["@sdods/cli", "@sdods/core", "@sdods/contracts", "@sdods/db", "@sdods/mcp", "@sdods/agents", "@sdods/integrations", "@sdods/server"];
+export interface UpgradeRow {
+    package: string;
+    installed: string | null;
+    latest: string | null;
+    status: 'up-to-date' | 'outdated' | 'not-installed' | 'unavailable';
+}
+export declare function installedVersion(rootDir: string, pkg: string): string | null;
+export declare function latestVersion(pkg: string, fetchImpl?: typeof fetch, registry?: string): Promise<string | null>;
+export declare function checkUpgrades(rootDir: string, fetchImpl?: typeof fetch): Promise<UpgradeRow[]>;
+export declare function register(program: Command): void;
+export declare function detectPm(rootDir: string): 'bun' | 'pnpm' | 'npm';
+//# sourceMappingURL=upgrade.d.ts.map

package/dist/commands/upgrade.js

@@ -0,0 +1,115 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { execa } from 'execa';
+import pc from 'picocolors';
+import semver from 'semver';
+import { VERSION } from '@sdods/core';
+import { createContext } from '../context.js';
+import { json, ok, out, table, warn } from '../ui.js';
+export const SDODS_PACKAGES = [
+    '@sdods/cli',
+    '@sdods/core',
+    '@sdods/contracts',
+    '@sdods/db',
+    '@sdods/mcp',
+    '@sdods/agents',
+    '@sdods/integrations',
+    '@sdods/server',
+];
+export function installedVersion(rootDir, pkg) {
+    const file = join(rootDir, 'node_modules', pkg, 'package.json');
+    if (!existsSync(file))
+        return null;
+    try {
+        const v = JSON.parse(readFileSync(file, 'utf8')).version;
+        return v ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function latestVersion(pkg, fetchImpl = fetch, registry = process.env.NPM_CONFIG_REGISTRY ?? 'https://registry.npmjs.org') {
+    try {
+        const res = await fetchImpl(`${registry.replace(/\/$/, '')}/${pkg}/latest`, {
+            signal: AbortSignal.timeout(8000),
+        });
+        if (!res.ok)
+            return null;
+        const body = (await res.json());
+        return body.version ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function checkUpgrades(rootDir, fetchImpl) {
+    const rows = await Promise.all(SDODS_PACKAGES.map(async (pkg) => {
+        const installed = installedVersion(rootDir, pkg) ?? (pkg === '@sdods/cli' ? VERSION : null);
+        const latest = await latestVersion(pkg, fetchImpl);
+        let status;
+        if (!latest)
+            status = 'unavailable';
+        else if (!installed)
+            status = 'not-installed';
+        else
+            status =
+                semver.valid(installed) && semver.lt(installed, latest) ? 'outdated' : 'up-to-date';
+        return { package: pkg, installed, latest, status };
+    }));
+    return rows;
+}
+export function register(program) {
+    program
+        .command('upgrade')
+        .description('Check the npm registry for newer @sdods/* packages')
+        .option('--apply', 'install the latest versions with the package manager')
+        .option('--pm <manager>', 'bun | pnpm | npm (default: detected from lockfile)')
+        .action(async (opts, cmd) => {
+        const ctx = createContext(cmd);
+        const rows = await checkUpgrades(ctx.rootDir);
+        if (ctx.opts.json)
+            return json(rows);
+        table(rows.map((r) => ({
+            package: r.package,
+            installed: r.installed ?? pc.dim('—'),
+            latest: r.latest ?? pc.dim('?'),
+            status: r.status === 'outdated'
+                ? pc.yellow(r.status)
+                : r.status === 'up-to-date'
+                    ? pc.green(r.status)
+                    : pc.dim(r.status),
+        })));
+        const outdated = rows.filter((r) => r.status === 'outdated');
+        if (!outdated.length) {
+            if (rows.every((r) => r.status === 'unavailable'))
+                warn('Registry unreachable (offline?) — nothing compared.');
+            else
+                ok('Everything installed is up to date.');
+            return;
+        }
+        if (!opts.apply) {
+            out(pc.dim(`Run \`sdods upgrade --apply\` to install ${outdated.map((r) => r.package).join(', ')}.`));
+            return;
+        }
+        const pm = opts.pm ?? detectPm(ctx.rootDir);
+        const specs = outdated.map((r) => `${r.package}@${r.latest}`);
+        const args = pm === 'bun'
+            ? ['add', ...specs]
+            : pm === 'pnpm'
+                ? ['add', ...specs]
+                : ['install', ...specs];
+        const res = await execa(pm, args, { cwd: ctx.rootDir, stdio: 'inherit', reject: false });
+        if (res.exitCode !== 0)
+            process.exitCode = 1;
+        else
+            ok(`Upgraded ${specs.length} package(s) with ${pm}.`);
+    });
+}
+export function detectPm(rootDir) {
+    if (existsSync(join(rootDir, 'bun.lock')) || existsSync(join(rootDir, 'bun.lockb')))
+        return 'bun';
+    if (existsSync(join(rootDir, 'pnpm-lock.yaml')))
+        return 'pnpm';
+    return 'npm';
+}
+//# sourceMappingURL=upgrade.js.map

package/dist/commands/users.d.ts

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

package/dist/commands/users.js

@@ -0,0 +1,183 @@
+import { SdodsError } from '@sdods/core';
+import { createContext } from '../context.js';
+import { json, ok, table } from '../ui.js';
+async function openDb() {
+    const db = await import('@sdods/db');
+    return db.openDb();
+}
+export function register(program) {
+    const users = program
+        .command('users')
+        .description('Manage web UI users (stored in the platform database)');
+    users
+        .command('create')
+        .description('Create a user; --admin makes a platform admin and organization owner')
+        .requiredOption('--username <name>', 'login name')
+        .requiredOption('--password <password>', 'password (min 8 chars)')
+        .option('--admin', 'platform admin + owner of every organization without an owner')
+        .option('--role <role>', 'viewer | editor | admin', 'viewer')
+        .option('--email <email>', 'email')
+        .option('--org-owner', 'grant organization owner on orgs without an owner')
+        .action(async (opts, cmd) => {
+        const ctx = createContext(cmd);
+        if (String(opts.password).length < 8)
+            throw new SdodsError('CONFIG_INVALID', 'Password must be at least 8 characters.', {
+                exitCode: 2,
+            });
+        const adb = await openDb();
+        try {
+            const db = await import('@sdods/db');
+            const { hashPassword } = await import('@sdods/server');
+            if (await db.getUserByUsername(adb.db, opts.username))
+                throw new SdodsError('CONFIG_INVALID', `User ${opts.username} already exists.`, {
+                    exitCode: 2,
+                });
+            const role = opts.admin ? 'admin' : opts.role;
+            if (!['viewer', 'editor', 'admin'].includes(role))
+                throw new SdodsError('CONFIG_INVALID', `Unknown role ${role}.`, { exitCode: 2 });
+            const id = await db.createUser(adb.db, adb.driver, {
+                username: opts.username,
+                passwordHash: await hashPassword(opts.password),
+                role,
+                email: opts.email ?? null,
+            });
+            // make sure the hierarchy exists before granting ownership
+            const { HierarchyService } = await import('@sdods/server');
+            const h = new HierarchyService(adb);
+            await h.sync(ctx.registry).catch(() => undefined);
+            const ownerOf = opts.admin || opts.orgOwner ? await h.bootstrapOwner(id) : [];
+            await db.audit(adb.db, {
+                actorType: 'cli',
+                action: 'user.create',
+                targetType: 'user',
+                targetId: id,
+                details: { username: opts.username, role },
+            });
+            if (ctx.opts.json)
+                return json({ id, username: opts.username, role, ownerOf });
+            ok(`Created ${role} user ${opts.username}${ownerOf.length ? ` (owner of ${ownerOf.join(', ')})` : ''}`);
+        }
+        finally {
+            await adb.close();
+        }
+    });
+    users
+        .command('list')
+        .description('List users')
+        .action(async (_opts, cmd) => {
+        const ctx = createContext(cmd);
+        const adb = await openDb();
+        try {
+            const db = await import('@sdods/db');
+            const rows = (await db.listUsers(adb.db)).map((u) => ({
+                id: u.id,
+                username: u.username,
+                role: u.role,
+                active: u.active,
+                email: u.email ?? '',
+                lastLogin: u.lastLoginAt ?? '',
+            }));
+            if (ctx.opts.json)
+                return json(rows);
+            table(rows);
+        }
+        finally {
+            await adb.close();
+        }
+    });
+    users
+        .command('set-role <username> <role>')
+        .description('Change a platform role (viewer | editor | admin)')
+        .action(async (username, role, cmd) => {
+        const ctx = createContext(cmd);
+        const adb = await openDb();
+        try {
+            const db = await import('@sdods/db');
+            const u = await db.getUserByUsername(adb.db, username);
+            if (!u)
+                throw new SdodsError('CONFIG_NOT_FOUND', `User ${username} not found.`, {
+                    exitCode: 2,
+                });
+            await db.updateUser(adb.db, adb.driver, u.id, {
+                role: role,
+            });
+            if (ctx.opts.json)
+                return json({ id: u.id, username, role });
+            ok(`${username} is now ${role}`);
+        }
+        finally {
+            await adb.close();
+        }
+    });
+    users
+        .command('deactivate <username>')
+        .description('Deactivate a user (sessions and tokens stop working)')
+        .action(async (username, cmd) => {
+        const ctx = createContext(cmd);
+        const adb = await openDb();
+        try {
+            const db = await import('@sdods/db');
+            const u = await db.getUserByUsername(adb.db, username);
+            if (!u)
+                throw new SdodsError('CONFIG_NOT_FOUND', `User ${username} not found.`, {
+                    exitCode: 2,
+                });
+            await db.updateUser(adb.db, adb.driver, u.id, { active: false });
+            if (ctx.opts.json)
+                return json({ id: u.id, username, active: false });
+            ok(`${username} deactivated`);
+        }
+        finally {
+            await adb.close();
+        }
+    });
+    users
+        .command('grant <username>')
+        .description('Grant a membership role: --org <slug> --role owner|admin|member, or --workspace <slug> --role admin|editor|viewer')
+        .option('--org <slug>', 'organization slug')
+        .option('--workspace <slug>', 'workspace slug')
+        .requiredOption('--role <role>', 'role')
+        .action(async (username, opts, cmd) => {
+        const ctx = createContext(cmd);
+        const adb = await openDb();
+        try {
+            const db = await import('@sdods/db');
+            const { HierarchyService } = await import('@sdods/server');
+            const h = new HierarchyService(adb);
+            await h.sync(ctx.registry);
+            const u = await db.getUserByUsername(adb.db, username);
+            if (!u)
+                throw new SdodsError('CONFIG_NOT_FOUND', `User ${username} not found.`, {
+                    exitCode: 2,
+                });
+            if (opts.workspace) {
+                const ws = (await h.workspaces()).find((w) => w.slug === opts.workspace);
+                if (!ws)
+                    throw new SdodsError('CONFIG_NOT_FOUND', `Workspace ${opts.workspace} not found.`, {
+                        exitCode: 2,
+                    });
+                await h.setWorkspaceRole(ws.id, u.id, opts.role);
+            }
+            else if (opts.org) {
+                const org = (await h.organizations()).find((o) => o.slug === opts.org);
+                if (!org)
+                    throw new SdodsError('CONFIG_NOT_FOUND', `Organization ${opts.org} not found.`, {
+                        exitCode: 2,
+                    });
+                await h.setOrgRole(org.id, u.id, opts.role);
+            }
+            else
+                throw new SdodsError('CONFIG_INVALID', 'Pass --org <slug> or --workspace <slug>.', {
+                    exitCode: 2,
+                });
+            const list = await h.workspacesForUser(u.id, u.role);
+            if (ctx.opts.json)
+                return json(list);
+            ok(`${username}: ${list.map((w) => `${w.slug}=${w.role}`).join(', ') || '(no workspace access)'}`);
+        }
+        finally {
+            await adb.close();
+        }
+    });
+}
+//# sourceMappingURL=users.js.map

package/dist/commands/watch.d.ts

@@ -0,0 +1,7 @@
+import type { Command } from 'commander';
+/**
+ * Spec generation runs in watch mode while the interactive UI
+ * re-runs them. Both children share the same SDODS_* environment that `sdods run` uses.
+ */
+export declare function register(program: Command): void;
+//# sourceMappingURL=watch.d.ts.map

package/dist/commands/watch.js

@@ -0,0 +1,116 @@
+import { join } from 'node:path';
+import { execa } from 'execa';
+import pc from 'picocolors';
+import { newRunId } from '@sdods/contracts';
+import { SdodsError, listGeneratedProjects, normalizeTagExpr } from '@sdods/core';
+import { createContext } from '../context.js';
+import { collect, out } from '../ui.js';
+/**
+ * Spec generation runs in watch mode while the interactive UI
+ * re-runs them. Both children share the same SDODS_* environment that `sdods run` uses.
+ */
+export function register(program) {
+    program
+        .command('watch')
+        .description('regenerate specs on change and re-run them in interactive UI mode (hot reload)')
+        .option('-p, --project <slug>', 'project slug (default: the only project)')
+        .option('-e, --env <name>', 'environment name')
+        .option('-t, --tags <expr>', 'Cucumber tag expression')
+        .option('-l, --layer <layer>', 'ui | api | hybrid | recorded (repeatable)', collect, [])
+        .option('-b, --browser <name>', 'browser (repeatable)', collect, [])
+        .option('--headed', 'headed browser (only meaningful with --no-ui)')
+        .option('--no-ui', 'run the suite in watch mode instead of the interactive UI')
+        .action(async (flags, cmd) => {
+        const ctx = createContext(cmd);
+        const entry = ctx.registry.pick(flags.project);
+        const cfg = ctx.registry.resolve(entry.slug, flags.env, { runId: newRunId() });
+        const tags = normalizeTagExpr(flags.tags);
+        for (const l of flags.layer) {
+            if (!entry.config.layers.includes(l)) {
+                throw new SdodsError('CONFIG_INVALID', `Layer "${l}" is not enabled for ${entry.slug}.`, {
+                    exitCode: 2,
+                });
+            }
+        }
+        const selection = {
+            project: entry.slug,
+            env: cfg.env.name,
+            layers: flags.layer.length ? flags.layer : undefined,
+            browsers: flags.browser.length ? flags.browser : undefined,
+            tags,
+            runId: cfg.runtime.runId,
+        };
+        const childEnv = {
+            ...process.env,
+            SDODS_ROOT: ctx.rootDir,
+            SDODS_PROJECT: entry.slug,
+            SDODS_ENV: cfg.env.name,
+            SDODS_TAGS: tags ?? '',
+            SDODS_LAYERS: selection.layers?.join(',') ?? '',
+            SDODS_BROWSERS: selection.browsers?.join(',') ?? '',
+            SDODS_RUN_ID: cfg.runtime.runId,
+            SDODS_REPORTER_MODE: 'quiet',
+        };
+        const configPath = join(ctx.rootDir, 'sdods.runner.config.ts');
+        const names = listGeneratedProjects(ctx.registry, selection).map((p) => p.name);
+        if (!names.length) {
+            throw new SdodsError('CONFIG_INVALID', 'Nothing to watch: no run targets match the selection.', {
+                hint: 'Check --layer/--browser against the project yaml.',
+                exitCode: 2,
+            });
+        }
+        out(pc.cyan(`Watching ${entry.slug} (${cfg.env.name}) → ${names.join(', ')}`));
+        const children = [];
+        const stop = () => {
+            for (const c of children)
+                c.kill('SIGTERM');
+        };
+        process.on('SIGINT', stop);
+        process.on('SIGTERM', stop);
+        // initial generation so UI mode has specs to show
+        const gen = await execa('npx', ['bddgen', '-c', configPath], {
+            cwd: ctx.rootDir,
+            env: childEnv,
+            stdio: 'inherit',
+            reject: false,
+        });
+        if (gen.exitCode !== 0) {
+            throw new SdodsError('RUN_FAILED', 'bddgen failed; fix the errors above and retry.', {
+                exitCode: 1,
+            });
+        }
+        const watcher = execa('npx', ['bddgen', '-c', configPath, '--watch'], {
+            cwd: ctx.rootDir,
+            env: childEnv,
+            stdio: 'inherit',
+            reject: false,
+        });
+        children.push(watcher);
+        const pwArgs = [
+            'playwright',
+            'test',
+            '-c',
+            configPath,
+            ...names.flatMap((n) => ['--project', n]),
+        ];
+        if (flags.noUi) {
+            pwArgs.push('--watch');
+            if (flags.headed)
+                pwArgs.push('--headed');
+        }
+        else {
+            pwArgs.push('--ui');
+        }
+        const pw = execa('npx', pwArgs, {
+            cwd: ctx.rootDir,
+            env: childEnv,
+            stdio: 'inherit',
+            reject: false,
+        });
+        children.push(pw);
+        const res = await pw;
+        stop();
+        process.exitCode = res.exitCode ?? 0;
+    });
+}
+//# sourceMappingURL=watch.js.map

package/dist/commands/workspace.d.ts

@@ -0,0 +1,8 @@
+import type { Command } from 'commander';
+/**
+ * Hierarchy commands: organization → workspaces → projects → modules → processes.
+ * File-based (no database needed). Membership roles are shown by `sdods users` / the web UI
+ * once a database is configured.
+ */
+export declare function registerWorkspaceCommands(program: Command): void;
+//# sourceMappingURL=workspace.d.ts.map

package/dist/commands/workspace.js

@@ -0,0 +1,83 @@
+import pc from 'picocolors';
+import { WORKSPACE_FILE } from '@sdods/core';
+import { createContext } from '../context.js';
+import { json, out, table } from '../ui.js';
+/**
+ * Hierarchy commands: organization → workspaces → projects → modules → processes.
+ * File-based (no database needed). Membership roles are shown by `sdods users` / the web UI
+ * once a database is configured.
+ */
+export function registerWorkspaceCommands(program) {
+    const ws = program
+        .command('workspace')
+        .description('Organization, workspaces and their projects');
+    ws.command('tree')
+        .description(`Show the hierarchy from ${WORKSPACE_FILE} and projects/*`)
+        .action((_opts, cmd) => {
+        const ctx = createContext(cmd);
+        const tree = ctx.registry.tree();
+        if (ctx.opts.json)
+            return json(tree);
+        out(`${pc.bold('org')} ${tree.organization.name} ${pc.dim(`(${tree.organization.slug})`)}`);
+        for (const w of tree.workspaces) {
+            out(`  ${pc.cyan('workspace')} ${w.workspace.name} ${pc.dim(`(${w.workspace.slug})`)}`);
+            if (w.projects.length === 0)
+                out(pc.dim('    (no projects)'));
+            for (const p of w.projects) {
+                out(`    ${pc.green('project')} ${p.name} ${pc.dim(`(${p.slug})`)}`);
+                for (const m of p.modules) {
+                    out(`      ${pc.magenta('module')} ${m.name} ${pc.dim(`[${m.testingTypes.join(', ')}]`)}${m.tags.length ? pc.dim(` tags ${m.tags.join(' ')}`) : ''}`);
+                }
+                if (p.processes.length)
+                    out(`      ${pc.yellow('processes')} ${p.processes.join(', ')}`);
+            }
+        }
+        if (!ctx.registry.workspaceFilePath) {
+            out(pc.dim(`\nNo ${WORKSPACE_FILE} found; showing the built-in default organization/workspace.`));
+        }
+    });
+    ws.command('list')
+        .description('List workspaces of the organization with project counts')
+        .action((_opts, cmd) => {
+        const ctx = createContext(cmd);
+        const rows = ctx.registry.workspaces().map((w) => ({
+            slug: w.slug,
+            name: w.name,
+            default: w.slug === ctx.registry.workspaceFile.defaultWorkspace ? '*' : '',
+            projects: ctx.registry
+                .projectsInWorkspace(w.slug)
+                .map((p) => p.slug)
+                .join(', '),
+        }));
+        if (ctx.opts.json)
+            return json(rows);
+        table(rows);
+    });
+    const processes = program
+        .command('processes')
+        .description('Named run recipes (pr-check, nightly-regression, release-gate …)');
+    processes
+        .command('list')
+        .description('List processes visible to a project (workspace defaults + project overrides)')
+        .requiredOption('-p, --project <slug>', 'project slug')
+        .action((opts, cmd) => {
+        const ctx = createContext(cmd);
+        const rows = ctx.registry.processesOf(opts.project).map((p) => ({
+            name: p.name,
+            trigger: p.trigger,
+            tags: p.tags ?? '',
+            layers: p.layers?.join(',') ?? '(all)',
+            browsers: p.browsers?.join(',') ?? '(project)',
+            env: p.env ?? '(default)',
+            gates: Object.entries(p.gates)
+                .filter(([, v]) => v !== undefined && v !== false)
+                .map(([k, v]) => `${k}=${v}`)
+                .join(' '),
+            schedule: p.schedule ?? '',
+        }));
+        if (ctx.opts.json)
+            return json(ctx.registry.processesOf(opts.project));
+        table(rows);
+    });
+}
+//# sourceMappingURL=workspace.js.map

package/dist/context.d.ts

@@ -0,0 +1,17 @@
+import type { Command } from 'commander';
+import { ProjectRegistry } from '@sdods/core';
+export interface GlobalOptions {
+    json?: boolean;
+    quiet?: boolean;
+    verbose?: boolean;
+    cwd?: string;
+    color?: boolean;
+}
+export interface CliContext {
+    rootDir: string;
+    registry: ProjectRegistry;
+    opts: GlobalOptions;
+}
+export declare function globalOptions(cmd: Command): GlobalOptions;
+export declare function createContext(cmd: Command): CliContext;
+//# sourceMappingURL=context.d.ts.map