@sdods/cli 0.2.0

package/dist/commands/browsers.js

@@ -0,0 +1,103 @@
+import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { execa } from 'execa';
+import pc from 'picocolors';
+import { BrowserSchema } from '@sdods/contracts';
+import { SdodsError } from '@sdods/core';
+import { createContext } from '../context.js';
+import { collect, json, ok, table } from '../ui.js';
+const ENGINE_OF = {
+    chromium: 'chromium',
+    firefox: 'firefox',
+    webkit: 'webkit',
+    'mobile-chrome': 'chromium',
+    'mobile-safari': 'webkit',
+};
+export async function browserStatuses(names = Object.keys(ENGINE_OF)) {
+    const require = createRequire(import.meta.url);
+    let pw;
+    let version = 'unknown';
+    try {
+        pw = await import('playwright-core');
+        version = require('playwright-core/package.json').version;
+    }
+    catch {
+        return names.map((name) => ({
+            name,
+            engine: ENGINE_OF[name] ?? 'chromium',
+            installed: false,
+            executable: null,
+            playwrightVersion: version,
+        }));
+    }
+    return names.map((name) => {
+        const engine = ENGINE_OF[name] ?? 'chromium';
+        let executable = null;
+        try {
+            executable = pw[engine].executablePath();
+        }
+        catch {
+            executable = null;
+        }
+        return {
+            name,
+            engine,
+            installed: Boolean(executable && existsSync(executable)),
+            executable,
+            playwrightVersion: version,
+        };
+    });
+}
+/** Install browser engines (used by `browsers install`, `doctor --fix`, `init`). */
+export async function installBrowsers(opts = {}) {
+    const engines = [
+        ...new Set((opts.browsers?.length ? opts.browsers : Object.keys(ENGINE_OF)).map((b) => ENGINE_OF[b] ?? b)),
+    ];
+    const args = ['playwright', 'install', ...(opts.withDeps ? ['--with-deps'] : []), ...engines];
+    await execa('npx', args, { stdio: 'inherit', cwd: opts.cwd });
+}
+export function register(program) {
+    const browsers = program.command('browsers').description('Install and list browser engines');
+    browsers
+        .command('install')
+        .description('Install browser engines (default: chromium, firefox, webkit)')
+        .option('-b, --browser <name>', 'browser to install (repeatable)', collect, [])
+        .option('--with-deps', 'also install OS dependencies (Linux CI)')
+        .option('-p, --project <slug>', 'install the browsers declared by a project')
+        .action(async (opts, cmd) => {
+        const ctx = createContext(cmd);
+        let list = opts.browser;
+        if (opts.project)
+            list = ctx.registry.get(opts.project).browsers;
+        for (const b of list)
+            BrowserSchema.parse(b);
+        await installBrowsers({ browsers: list, withDeps: opts.withDeps, cwd: ctx.rootDir });
+        ok(`Installed ${list.length ? list.join(', ') : 'chromium, firefox, webkit'}`);
+    });
+    browsers
+        .command('list')
+        .description('Show which browsers are installed and where')
+        .option('-p, --project <slug>', 'limit to the browsers declared by a project')
+        .action(async (opts, cmd) => {
+        const ctx = createContext(cmd);
+        const names = opts.project ? ctx.registry.get(opts.project).browsers : Object.keys(ENGINE_OF);
+        const statuses = await browserStatuses(names);
+        if (ctx.opts.json)
+            return json(statuses);
+        table(statuses.map((s) => ({
+            browser: s.name,
+            engine: s.engine,
+            installed: s.installed ? pc.green('yes') : pc.red('no'),
+            playwright: s.playwrightVersion,
+            executable: s.executable ?? '',
+        })));
+        if (statuses.some((s) => !s.installed)) {
+            process.exitCode = 1;
+            throw new SdodsError('NOT_SUPPORTED', 'Some browsers are not installed.', {
+                hint: 'Run `sdods browsers install --with-deps`.',
+                exitCode: 1,
+            });
+        }
+    });
+}
+//# sourceMappingURL=browsers.js.map

package/dist/commands/completion.d.ts

@@ -0,0 +1,17 @@
+import type { Command } from 'commander';
+type Shell = 'bash' | 'zsh' | 'fish';
+interface Node {
+    name: string;
+    description: string;
+    options: Array<{
+        flags: string[];
+        description: string;
+    }>;
+    children: Node[];
+}
+/** Walk commander metadata into a plain tree (no actions executed). */
+export declare function commandTree(cmd: Command): Node;
+export declare function renderCompletion(shell: Shell, root: Node): string;
+export declare function register(program: Command): void;
+export {};
+//# sourceMappingURL=completion.d.ts.map

package/dist/commands/completion.js

@@ -0,0 +1,143 @@
+import { SdodsError } from '@sdods/core';
+/** Walk commander metadata into a plain tree (no actions executed). */
+export function commandTree(cmd) {
+    return {
+        name: cmd.name(),
+        description: cmd.description(),
+        options: cmd.options.map((o) => ({
+            flags: [o.short, o.long].filter((f) => Boolean(f)),
+            description: o.description,
+        })),
+        children: cmd.commands
+            .filter((c) => !c.name().startsWith('_'))
+            .map((c) => commandTree(c))
+            .sort((a, b) => a.name.localeCompare(b.name)),
+    };
+}
+export function renderCompletion(shell, root) {
+    switch (shell) {
+        case 'bash':
+            return bash(root);
+        case 'zsh':
+            return zsh(root);
+        case 'fish':
+            return fish(root);
+    }
+}
+function q(s) {
+    return s.replace(/'/g, "'\\''");
+}
+function words(n) {
+    return [...n.children.map((c) => c.name), ...n.options.flatMap((o) => o.flags)].join(' ');
+}
+function bash(root) {
+    const cases = root.children
+        .map((c) => {
+        const sub = c.children.length
+            ? c.children
+                .map((s) => `        ${s.name}) COMPREPLY=( $(compgen -W '${q(words(s))} ${q(root.options.flatMap((o) => o.flags).join(' '))}' -- "$cur") ); return 0 ;;`)
+                .join('\n')
+            : '';
+        return `    ${c.name})
+      case "\${COMP_WORDS[2]}" in
+${sub}
+        *) COMPREPLY=( $(compgen -W '${q(words(c))}' -- "$cur") ); return 0 ;;
+      esac ;;`;
+    })
+        .join('\n');
+    return `# bash completion for sdods — generated by \`sdods completion bash\`
+# Install: sdods completion bash > ~/.sdods-completion.bash && echo 'source ~/.sdods-completion.bash' >> ~/.bashrc
+_sdods() {
+  local cur="\${COMP_WORDS[COMP_CWORD]}"
+  if [[ $COMP_CWORD -eq 1 ]]; then
+    COMPREPLY=( $(compgen -W '${q(words(root))}' -- "$cur") ); return 0
+  fi
+  case "\${COMP_WORDS[1]}" in
+${cases}
+    *) COMPREPLY=( $(compgen -W '${q(root.options.flatMap((o) => o.flags).join(' '))}' -- "$cur") ) ;;
+  esac
+}
+complete -F _sdods sdods
+`;
+}
+function zsh(root) {
+    const describe = (n, indent) => n.children.map((c) => `${indent}'${q(c.name)}:${q(c.description || c.name)}'`).join('\n');
+    const optSpecs = (n) => n.options.flatMap((o) => o.flags.map((f) => `'${q(f)}[${q(o.description || f)}]'`)).join(' ');
+    const level2 = root.children
+        .map((c) => `    ${c.name})
+      if (( CURRENT == 3 )) && [[ -n "${c.children.length ? 'x' : ''}" ]]; then
+        local -a subcmds; subcmds=(
+${describe(c, '          ')}
+        )
+        _describe 'subcommand' subcmds
+      else
+        _arguments -s ${optSpecs(c)} ${optSpecs(root)} '*:file:_files'
+      fi ;;`)
+        .join('\n');
+    return `#compdef sdods
+# zsh completion for sdods — generated by \`sdods completion zsh\`
+# Install: sdods completion zsh > "\${fpath[1]}/_sdods" && autoload -Uz compinit && compinit
+_sdods() {
+  local -a cmds
+  cmds=(
+${describe(root, '    ')}
+  )
+  if (( CURRENT == 2 )); then
+    _describe 'command' cmds
+    _arguments -s ${optSpecs(root)}
+    return
+  fi
+  case "\${words[2]}" in
+${level2}
+    *) _arguments -s ${optSpecs(root)} ;;
+  esac
+}
+_sdods "$@"
+`;
+}
+function fish(root) {
+    const lines = [
+        '# fish completion for sdods — generated by `sdods completion fish`',
+        '# Install: sdods completion fish > ~/.config/fish/completions/sdods.fish',
+        `complete -c sdods -f`,
+    ];
+    for (const o of root.options) {
+        for (const f of o.flags) {
+            lines.push(`complete -c sdods ${f.startsWith('--') ? `-l ${f.slice(2)}` : `-s ${f.slice(1)}`} -d '${q(o.description)}'`);
+        }
+    }
+    for (const c of root.children) {
+        lines.push(`complete -c sdods -n '__fish_use_subcommand' -a ${c.name} -d '${q(c.description)}'`);
+        for (const s of c.children) {
+            lines.push(`complete -c sdods -n '__fish_seen_subcommand_from ${c.name}' -a ${s.name} -d '${q(s.description)}'`);
+            for (const o of s.options) {
+                for (const f of o.flags) {
+                    lines.push(`complete -c sdods -n '__fish_seen_subcommand_from ${s.name}' ${f.startsWith('--') ? `-l ${f.slice(2)}` : `-s ${f.slice(1)}`} -d '${q(o.description)}'`);
+                }
+            }
+        }
+        for (const o of c.options) {
+            for (const f of o.flags) {
+                lines.push(`complete -c sdods -n '__fish_seen_subcommand_from ${c.name}' ${f.startsWith('--') ? `-l ${f.slice(2)}` : `-s ${f.slice(1)}`} -d '${q(o.description)}'`);
+            }
+        }
+    }
+    return lines.join('\n') + '\n';
+}
+export function register(program) {
+    program
+        .command('completion <shell>')
+        .description('Print a shell completion script (bash | zsh | fish)')
+        .action((shell) => {
+        if (!['bash', 'zsh', 'fish'].includes(shell)) {
+            throw new SdodsError('CONFIG_INVALID', `Unknown shell "${shell}". Use bash, zsh or fish.`, {
+                exitCode: 2,
+            });
+        }
+        let root = program;
+        while (root.parent)
+            root = root.parent;
+        process.stdout.write(renderCompletion(shell, commandTree(root)));
+    });
+}
+//# sourceMappingURL=completion.js.map

package/dist/commands/config.d.ts

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

package/dist/commands/config.js

@@ -0,0 +1,79 @@
+import pc from 'picocolors';
+import { explainConfig, redact } from '@sdods/core';
+import { createContext } from '../context.js';
+import { json, out, table } from '../ui.js';
+export function registerConfigCommands(program) {
+    const config = program.command('config').description('Inspect resolved configuration');
+    config
+        .command('show')
+        .description('Print the merged config for a project/env with the winning layer per key')
+        .requiredOption('-p, --project <slug>', 'project slug')
+        .option('-e, --env <name>', 'environment name (default: project envs.default)')
+        .option('--explain', 'show provenance table instead of the tree')
+        .option('--show-secrets', 'do not redact secret-looking values')
+        .action((opts, cmd) => {
+        const ctx = createContext(cmd);
+        const cfg = ctx.registry.resolve(opts.project, opts.env);
+        const view = opts.showSecrets ? cfg : redact(cfg);
+        if (opts.explain) {
+            const rows = explainConfig(cfg).map((r) => ({
+                path: r.path,
+                layer: r.layer,
+                value: typeof r.value === 'object'
+                    ? JSON.stringify(r.value)
+                    : String(opts.showSecrets ? r.value : redactLeaf(r.path, r.value)),
+            }));
+            if (ctx.opts.json)
+                return json(rows);
+            return table(rows, ['path', 'layer', 'value']);
+        }
+        if (ctx.opts.json)
+            return json({
+                project: view.project,
+                env: view.env,
+                runtime: view.runtime,
+                sources: view.sources,
+            });
+        out(pc.bold(`Project ${cfg.project.slug} · env ${cfg.env.name}`));
+        out(pc.dim(`dotenv files: ${cfg.sources.dotenvFiles.length ? cfg.sources.dotenvFiles.join(', ') : '(none)'}`));
+        out(JSON.stringify({ project: view.project, env: view.env, runtime: view.runtime }, null, 2));
+    });
+    config
+        .command('validate')
+        .description('Validate every project and environment file without running anything')
+        .action((_opts, cmd) => {
+        const ctx = createContext(cmd);
+        const results = [];
+        for (const e of ctx.registry.entriesList()) {
+            for (const env of e.config.envs.available) {
+                try {
+                    ctx.registry.resolve(e.slug, env, {}, { ...process.env });
+                    results.push({ project: e.slug, env, ok: true });
+                }
+                catch (err) {
+                    results.push({
+                        project: e.slug,
+                        env,
+                        ok: false,
+                        error: err.message.split('\n')[0],
+                    });
+                }
+            }
+        }
+        if (ctx.opts.json)
+            return json(results);
+        table(results.map((r) => ({
+            ...r,
+            ok: r.ok ? pc.green('ok') : pc.red('FAIL'),
+            error: r.error ?? '',
+        })));
+        if (results.some((r) => !r.ok))
+            process.exitCode = 2;
+    });
+}
+function redactLeaf(path, value) {
+    return /(password|secret|token|apikey|api_key)/i.test(path) && typeof value === 'string' && value
+        ? '***'
+        : value;
+}
+//# sourceMappingURL=config.js.map

package/dist/commands/coverage.d.ts

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

package/dist/commands/coverage.js

@@ -0,0 +1,65 @@
+import pc from 'picocolors';
+import { createContext } from '../context.js';
+import { heading, json, out, table } from '../ui.js';
+export function register(program) {
+    program
+        .command('coverage')
+        .description('Route, endpoint and role coverage by scenarios, split by suite tag')
+        .requiredOption('-p, --project <slug>', 'project slug')
+        .option('-e, --env <name>', 'environment (for the OpenAPI spec and API base URL)')
+        .option('--openapi [file]', 'include endpoints from the OpenAPI spec (env api.openapi or a file)')
+        .option('--routes', 'only routes')
+        .option('--endpoints', 'only endpoints')
+        .option('--roles', 'only roles')
+        .option('--uncovered', 'only rows without scenarios')
+        .action(async (opts, cmd) => {
+        const ctx = createContext(cmd);
+        const { computeCoverage } = await import('@sdods/core/analyze');
+        const report = computeCoverage(ctx.registry, opts.project, {
+            env: opts.env,
+            openapi: opts.openapi === true ? true : (opts.openapi ?? false),
+        });
+        if (ctx.opts.json)
+            return json(report);
+        printCoverage(report, opts);
+        if (report.summary.uncoveredModules.length)
+            process.exitCode = 1;
+    });
+}
+function rows(list, suites, onlyUncovered) {
+    return list
+        .filter((r) => !onlyUncovered || !r.covered)
+        .map((r) => ({
+        name: r.name,
+        target: r.target,
+        module: r.module ?? '',
+        covered: r.covered ? pc.green('yes') : pc.red('no'),
+        ...Object.fromEntries(suites.map((s) => [s, r.bySuite[s] ?? 0])),
+        scenarios: r.scenarios.length,
+    }));
+}
+function printCoverage(report, opts) {
+    const all = !opts.routes && !opts.endpoints && !opts.roles;
+    const s = report.summary;
+    heading(`Coverage for ${report.project}`);
+    out(`${pc.bold('routes')} ${s.routes.covered}/${s.routes.total}  ${pc.bold('endpoints')} ${s.endpoints.covered}/${s.endpoints.total}  ${pc.bold('roles')} ${s.roles.covered}/${s.roles.total}  ${pc.bold('scenarios')} ${s.scenarios}  ${pc.dim(Object.entries(s.bySuite)
+        .map(([k, v]) => `${k}=${v}`)
+        .join(' '))}`);
+    const cols = ['name', 'target', 'module', 'covered', ...report.suites, 'scenarios'];
+    if (all || opts.routes) {
+        heading('Routes');
+        table(rows(report.routes, report.suites, Boolean(opts.uncovered)), cols);
+    }
+    if (all || opts.endpoints) {
+        heading('Endpoints');
+        table(rows(report.endpoints, report.suites, Boolean(opts.uncovered)), cols);
+    }
+    if (all || opts.roles) {
+        heading('Roles');
+        table(rows(report.roles, report.suites, Boolean(opts.uncovered)), cols);
+    }
+    if (s.uncoveredModules.length) {
+        out(`\n${pc.yellow('⚠')} Modules without any covered target: ${s.uncoveredModules.join(', ')}`);
+    }
+}
+//# sourceMappingURL=coverage.js.map

package/dist/commands/data.d.ts

@@ -0,0 +1,7 @@
+import type { Command } from 'commander';
+type Row = Record<string, unknown>;
+/** CSV/JSON/YAML → rows (CSV via csv-parse, loaded lazily). */
+export declare function readRows(file: string): Promise<Row[]>;
+export declare function register(program: Command): void;
+export {};
+//# sourceMappingURL=data.d.ts.map

package/dist/commands/data.js

@@ -0,0 +1,188 @@
+import { readFileSync } from 'node:fs';
+import { extname, resolve } from 'node:path';
+import pc from 'picocolors';
+import { parse as parseYaml } from 'yaml';
+import { SdodsError } from '@sdods/core';
+import { createContext } from '../context.js';
+import { json, ok, out, table } from '../ui.js';
+/** CSV/JSON/YAML → rows (CSV via csv-parse, loaded lazily). */
+export async function readRows(file) {
+    const abs = resolve(file);
+    const text = readFileSync(abs, 'utf8');
+    const ext = extname(abs).toLowerCase();
+    if (ext === '.json') {
+        const data = JSON.parse(text);
+        return Array.isArray(data) ? data : Array.isArray(data?.rows) ? data.rows : [data];
+    }
+    if (ext === '.yaml' || ext === '.yml') {
+        const data = parseYaml(text);
+        return Array.isArray(data) ? data : Array.isArray(data?.rows) ? data.rows : [data];
+    }
+    const { parse } = await import('csv-parse/sync');
+    return parse(text, {
+        columns: true,
+        skip_empty_lines: true,
+        trim: true,
+        bom: true,
+        cast: true,
+        cast_date: false,
+    });
+}
+export function register(program) {
+    const data = program
+        .command('data')
+        .description('Import, preview and seed test data (CSV, JSON, YAML)');
+    data
+        .command('preview <file>')
+        .description('Show the first rows and inferred columns of a data file')
+        .option('--limit <n>', 'rows to show', '10')
+        .action(async (file, opts, cmd) => {
+        const ctx = createContext(cmd);
+        const rows = await readRows(file);
+        const columns = [...new Set(rows.flatMap((r) => Object.keys(r)))];
+        const head = rows.slice(0, Number(opts.limit));
+        if (ctx.opts.json)
+            return json({ file, rows: rows.length, columns, sample: head });
+        out(pc.dim(`${rows.length} row(s), columns: ${columns.join(', ')}`));
+        table(head.map((r) => Object.fromEntries(columns.map((c) => [c, String(r[c] ?? '')]))));
+    });
+    data
+        .command('import <dataset> <file>')
+        .description('Import a data file into the database (datasets table or a td_<project>_<dataset> table)')
+        .requiredOption('-p, --project <slug>', 'project slug')
+        .option('-e, --env <name>', 'environment key (default: * = every environment)')
+        .option('--to <target>', 'db (datasets/dataset_rows) or table (td_* table)', 'db')
+        .option('--truncate', 'replace existing rows for this env when --to table')
+        .action(async (dataset, file, opts, cmd) => {
+        const ctx = createContext(cmd);
+        const entry = ctx.registry.entry(opts.project);
+        const rows = await readRows(file);
+        const m = await import('@sdods/db');
+        const adb = m.createDb();
+        try {
+            await m.migrateToLatest(adb);
+            const projectId = await m.ensureProject(adb.db, adb.driver, entry.slug, entry.config.name);
+            if (opts.to === 'table') {
+                const res = await m.importRowsToTable(adb.db, adb.driver, {
+                    projectSlug: entry.slug,
+                    dataset,
+                    env: opts.env ?? '*',
+                    rows,
+                    truncate: Boolean(opts.truncate),
+                });
+                if (ctx.opts.json)
+                    return json(res);
+                ok(`Imported ${res.inserted} row(s) into ${res.table} (${res.columns.join(', ')})`);
+                return;
+            }
+            if (opts.to !== 'db')
+                throw new SdodsError('NOT_SUPPORTED', `--to must be db or table (got ${opts.to}).`, {
+                    exitCode: 2,
+                });
+            const res = await m.upsertDataset(adb.db, adb.driver, {
+                projectId,
+                envKey: opts.env ?? '*',
+                name: dataset,
+                kind: extname(file).slice(1) || 'json',
+                storage: 'db',
+                sourcePath: resolve(file),
+                rows,
+            });
+            if (ctx.opts.json)
+                return json(res);
+            ok(`Imported dataset ${dataset} (${res.rowCount} row(s)) for ${entry.slug} [${opts.env ?? '*'}]`);
+        }
+        finally {
+            await adb.close();
+        }
+    });
+    data
+        .command('list')
+        .description('List datasets stored in the database for a project')
+        .requiredOption('-p, --project <slug>', 'project slug')
+        .action(async (opts, cmd) => {
+        const ctx = createContext(cmd);
+        const m = await import('@sdods/db');
+        const adb = m.createDb();
+        try {
+            await m.migrateToLatest(adb);
+            const project = await m.getProjectBySlug(adb.db, opts.project);
+            const rows = project ? await m.listDatasets(adb.db, project.id) : [];
+            const tables = (await m.listTdTables(adb.db, adb.driver)).filter((t) => t.startsWith(`td_${opts.project.replace(/[^a-z0-9]+/g, '_')}_`));
+            if (ctx.opts.json)
+                return json({ datasets: rows, tables });
+            table(rows.map((d) => ({
+                name: d.name,
+                env: d.envKey,
+                kind: d.kind,
+                rows: d.rowCount,
+                columns: d.columns.join(','),
+            })));
+            if (tables.length)
+                out(pc.dim(`td tables: ${tables.join(', ')}`));
+        }
+        finally {
+            await adb.close();
+        }
+    });
+    data
+        .command('seed')
+        .description('Import every file under projects/<slug>/data/<env>/ and data/common/ into the database')
+        .requiredOption('-p, --project <slug>', 'project slug')
+        .option('-e, --env <name>', 'environment (default: project default)')
+        .option('--to <target>', 'db or table', 'db')
+        .action(async (opts, cmd) => {
+        const ctx = createContext(cmd);
+        const entry = ctx.registry.entry(opts.project);
+        const env = opts.env ?? entry.config.envs.default;
+        const { existsSync, readdirSync } = await import('node:fs');
+        const { join } = await import('node:path');
+        const m = await import('@sdods/db');
+        const adb = m.createDb();
+        const imported = [];
+        try {
+            await m.migrateToLatest(adb);
+            const projectId = await m.ensureProject(adb.db, adb.driver, entry.slug, entry.config.name);
+            for (const [envKey, dir] of [
+                ['*', join(entry.root, 'data', 'common')],
+                [env, join(entry.root, 'data', env)],
+            ]) {
+                if (!existsSync(dir))
+                    continue;
+                for (const f of readdirSync(dir)) {
+                    if (!/\.(csv|json|ya?ml)$/i.test(f))
+                        continue;
+                    const dataset = f.replace(/\.(csv|json|ya?ml)$/i, '');
+                    const rows = await readRows(join(dir, f));
+                    if (opts.to === 'table')
+                        await m.importRowsToTable(adb.db, adb.driver, {
+                            projectSlug: entry.slug,
+                            dataset,
+                            env: envKey,
+                            rows,
+                            truncate: true,
+                        });
+                    else
+                        await m.upsertDataset(adb.db, adb.driver, {
+                            projectId,
+                            envKey,
+                            name: dataset,
+                            kind: f.split('.').pop(),
+                            storage: 'db',
+                            sourcePath: join(dir, f),
+                            rows,
+                        });
+                    imported.push({ dataset, env: envKey, rows: rows.length });
+                }
+            }
+            if (ctx.opts.json)
+                return json(imported);
+            table(imported);
+            ok(`Seeded ${imported.length} dataset(s) for ${entry.slug}`);
+        }
+        finally {
+            await adb.close();
+        }
+    });
+}
+//# sourceMappingURL=data.js.map

package/dist/commands/db.d.ts

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