@sdods/cli 0.13.2 → 0.14.1

package/dist/commands/db.d.ts

@@ -1,3 +1,8 @@
 import type { Command } from 'commander';
+/** `.sdods/runs` under the workspace, or SDODS_ARTIFACTS_DIR (absolute, or relative to it). */
+export declare function artifactsRootOf(rootDir: string): string;
+/** `.sdods/backups`, next to the artifacts (SDODS_BACKUPS_DIR overrides). */
+export declare function backupsRootOf(rootDir: string): string;
+export declare function formatBytes(n: number | null | undefined): string;
 export declare function register(program: Command): void;
 //# sourceMappingURL=db.d.ts.map

package/dist/commands/db.js

@@ -1,14 +1,36 @@
 import { existsSync, readFileSync } from 'node:fs';
-import { join, resolve } from 'node:path';
+import { dirname, 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';
+import { json, ok, out, parseIntFlag, table, warn } from '../ui.js';
 async function loadDb() {
     return import('@sdods/db');
 }
+/** `.sdods/runs` under the workspace, or SDODS_ARTIFACTS_DIR (absolute, or relative to it). */
+export function artifactsRootOf(rootDir) {
+    return resolve(rootDir, process.env.SDODS_ARTIFACTS_DIR ?? '.sdods/runs');
+}
+/** `.sdods/backups`, next to the artifacts (SDODS_BACKUPS_DIR overrides). */
+export function backupsRootOf(rootDir) {
+    return process.env.SDODS_BACKUPS_DIR
+        ? resolve(rootDir, process.env.SDODS_BACKUPS_DIR)
+        : join(dirname(artifactsRootOf(rootDir)), 'backups');
+}
+export function formatBytes(n) {
+    if (n == null)
+        return 'unknown';
+    const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+    let v = n;
+    let i = 0;
+    while (v >= 1024 && i < units.length - 1) {
+        v /= 1024;
+        i++;
+    }
+    return `${v < 10 && i > 0 ? v.toFixed(1) : Math.round(v)} ${units[i]}`;
+}
 export function register(program) {
     const db = program
         .command('db')
@@ -55,13 +77,13 @@ export function register(program) {
             if (ctx.opts.json)
                 return json({
                     driver: adb.driver,
-                    config: { ...adb.config, databaseUrl: redactUrl(adb.config.databaseUrl) },
+                    config: { ...adb.config, databaseUrl: m.redactUrl(adb.config.databaseUrl) },
                     migrations: status,
                 });
             out(pc.bold(`driver: ${adb.driver}`) +
                 pc.dim(adb.driver === 'sqlite'
                     ? `  ${adb.config.sqlitePath}`
-                    : `  ${redactUrl(adb.config.databaseUrl)}`));
+                    : `  ${m.redactUrl(adb.config.databaseUrl)}`));
             table(status.map((s) => ({
                 migration: s.name,
                 applied: s.executedAt ? s.executedAt : pc.yellow('pending'),
@@ -196,13 +218,156 @@ export function register(program) {
                 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'),
+                artifactsRoot: artifactsRootOf(ctx.rootDir),
                 dryRun: Boolean(opts.dryRun),
+                actor: { type: 'cli' },
             });
             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}`);
+            for (const s of res.skipped)
+                warn(`kept ${s.id}: ${s.reason === 'live' ? 'still running' : s.reason}`);
+            ok(`${opts.dryRun ? 'Would delete' : 'Deleted'} ${res.deleted.length} run(s), ${opts.dryRun ? 'freeing' : 'freed'} ${formatBytes(res.freedBytes)}; kept ${res.kept}`);
+        }
+        finally {
+            await adb.close();
+        }
+    });
+    db.command('stats')
+        .description('Show which database is in use, how big it is, and what it holds')
+        .action(async (_opts, cmd) => {
+        const ctx = createContext(cmd);
+        const m = await loadDb();
+        const adb = m.createDb();
+        try {
+            await m.migrateToLatest(adb);
+            const s = await m.storageStats(adb, { artifactsRoot: artifactsRootOf(ctx.rootDir) });
+            const backups = m.listBackups(backupsRootOf(ctx.rootDir));
+            if (ctx.opts.json)
+                return json({ ...s, backupsDir: backupsRootOf(ctx.rootDir), backups: backups.length });
+            out(pc.bold(`driver:    ${s.driver}`));
+            out(`location:  ${s.location}`);
+            out(`database:  ${formatBytes(s.dbBytes)}`);
+            out(`artifacts: ${formatBytes(s.artifactsBytes)}  ${pc.dim(s.artifactsDir ?? '')}`);
+            out(`backups:   ${backups.length}  ${pc.dim(backupsRootOf(ctx.rootDir))}`);
+            out(`runs:      ${s.counts.runs}${s.oldestRunAt ? pc.dim(`  ${s.oldestRunAt.slice(0, 10)} → ${s.newestRunAt?.slice(0, 10)}`) : ''}`);
+            out(`rows:      ${s.counts.scenarios} scenarios, ${s.counts.artifacts} artifacts, ${s.counts.auditLog} audit entries, ${s.counts.users} users`);
+            out(`migrations: ${s.migrations.pending ? pc.yellow(`${s.migrations.pending} pending`) : pc.green('up to date')} ${pc.dim(s.migrations.latest ?? '')}`);
+        }
+        finally {
+            await adb.close();
+        }
+    });
+    db.command('retention')
+        .description('Show or set how much run history to keep (applied daily by `sdods serve` when --auto on)')
+        .option('--keep-runs <n>', 'runs to keep per project (0 = no limit)', parseIntFlag('keep-runs'))
+        .option('--keep-days <n>', 'delete runs older than n days (0 = no limit)', parseIntFlag('keep-days'))
+        .option('--auto <on|off>', 'clean up automatically once a day')
+        .action(async (opts, cmd) => {
+        const ctx = createContext(cmd);
+        const m = await loadDb();
+        const adb = m.createDb();
+        try {
+            await m.migrateToLatest(adb);
+            const patch = {};
+            if (opts.keepRuns !== undefined)
+                patch.keepRuns = opts.keepRuns || null;
+            if (opts.keepDays !== undefined)
+                patch.keepDays = opts.keepDays || null;
+            if (opts.auto !== undefined) {
+                if (!['on', 'off'].includes(opts.auto))
+                    throw new SdodsError('NOT_SUPPORTED', '--auto expects on or off.', { exitCode: 2 });
+                patch.auto = opts.auto === 'on';
+            }
+            const r = Object.keys(patch).length
+                ? await m.setRetentionSettings(adb.db, patch)
+                : await m.getRetentionSettings(adb.db);
+            if (Object.keys(patch).length)
+                await m.audit(adb.db, {
+                    actorType: 'cli',
+                    action: 'retention.update',
+                    targetType: 'settings',
+                    targetId: 'retention',
+                    details: { ...r },
+                });
+            if (ctx.opts.json)
+                return json(r);
+            out(`keep runs per project: ${r.keepRuns ?? 'no limit'}`);
+            out(`keep days:             ${r.keepDays ?? 'no limit'}`);
+            out(`auto clean-up:         ${r.auto ? 'on (daily)' : 'off'}`);
+        }
+        finally {
+            await adb.close();
+        }
+    });
+    db.command('backup')
+        .description('Back up the database to .sdods/backups/<timestamp>/ (JSONL + manifest)')
+        .option('--out <dir>', 'backups folder (default .sdods/backups)')
+        .action(async (opts, cmd) => {
+        const ctx = createContext(cmd);
+        const m = await loadDb();
+        const adb = m.createDb();
+        try {
+            await m.migrateToLatest(adb);
+            const { VERSION } = await import('@sdods/core');
+            const b = await m.createBackup(adb, opts.out ?? backupsRootOf(ctx.rootDir), {
+                label: 'manual',
+                sdodsVersion: VERSION,
+            });
+            if (ctx.opts.json)
+                return json(b);
+            ok(`Backed up ${b.rows} row(s), ${formatBytes(b.bytes)} → ${b.dir}`);
+        }
+        finally {
+            await adb.close();
+        }
+    });
+    db.command('backups')
+        .description('List backups, newest first')
+        .option('--dir <dir>', 'backups folder (default .sdods/backups)')
+        .action(async (opts, cmd) => {
+        const ctx = createContext(cmd);
+        const m = await loadDb();
+        const list = m.listBackups(opts.dir ?? backupsRootOf(ctx.rootDir));
+        if (ctx.opts.json)
+            return json(list);
+        if (!list.length)
+            return out(pc.dim('No backups yet. Create one with `sdods db backup`.'));
+        table(list.map((b) => ({
+            id: b.id,
+            label: b.label,
+            rows: b.rows,
+            size: formatBytes(b.bytes),
+            dir: b.dir,
+        })));
+    });
+    db.command('restore <dir>')
+        .description('Replace the database contents with a backup (a pre-restore backup is taken first)')
+        .option('--yes', 'confirm: the current data is replaced')
+        .action(async (dir, opts, cmd) => {
+        const ctx = createContext(cmd);
+        if (!opts.yes)
+            throw new SdodsError('NOT_SUPPORTED', 'restore replaces every row in the database; pass --yes to confirm.', { exitCode: 2 });
+        const m = await loadDb();
+        const adb = m.createDb();
+        try {
+            await m.migrateToLatest(adb);
+            const { VERSION } = await import('@sdods/core');
+            const res = await m.restoreBackup(adb, resolve(dir), {
+                safetyRoot: backupsRootOf(ctx.rootDir),
+                sdodsVersion: VERSION,
+            });
+            await m.audit(adb.db, {
+                actorType: 'cli',
+                action: 'backup.restore',
+                targetType: 'backup',
+                targetId: resolve(dir),
+                details: { safety: res.safety?.id ?? null },
+            });
+            if (ctx.opts.json)
+                return json(res);
+            table(res.imported.tables.filter((x) => x.rows).map((x) => ({ table: x.table, rows: x.rows })));
+            ok(`Restored from ${resolve(dir)}${res.safety ? `. The previous data is in ${res.safety.dir}` : ''}`);
         }
         finally {
             await adb.close();
@@ -233,9 +398,4 @@ export function register(program) {
         }
     });
 }
-function redactUrl(url) {
-    if (!url)
-        return '';
-    return url.replace(/\/\/([^:]+):[^@]+@/, '//$1:***@');
-}
 //# sourceMappingURL=db.js.map

package/dist/commands/doctor.js

@@ -241,11 +241,6 @@ function tokenMatrix(cliStatus, localLlm) {
         requirement: 'optional',
         present: has('SDODS_TOKEN'),
         detail: 'self-issued, free: MCP over HTTP and CI result ingest (`sdods tokens create`)',
-    }, {
-        name: 'NPM_TOKEN',
-        requirement: 'ci-only',
-        present: has('NPM_TOKEN'),
-        detail: 'GitHub secret for publishing @sdods/* packages',
     });
     return rows;
 }

package/dist/commands/runs.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from 'commander';
+/** `sdods runs …`: manage stored run history (`sdods run` starts a run). */
+export declare function register(program: Command): void;
+//# sourceMappingURL=runs.d.ts.map

package/dist/commands/runs.js

@@ -0,0 +1,49 @@
+import pc from 'picocolors';
+import { SdodsError } from '@sdods/core';
+import { createContext } from '../context.js';
+import { json, ok, out, table, warn } from '../ui.js';
+import { artifactsRootOf, formatBytes } from './db.js';
+/** `sdods runs …`: manage stored run history (`sdods run` starts a run). */
+export function register(program) {
+    const runs = program.command('runs').description('Manage stored run history');
+    runs
+        .command('rm <ids...>')
+        .alias('delete')
+        .description('Delete runs, their results and artifact folders (running runs are skipped)')
+        .option('--dry-run', 'show what would be deleted')
+        .option('--yes', 'confirm the delete')
+        .action(async (ids, opts, cmd) => {
+        const ctx = createContext(cmd);
+        if (!opts.dryRun && !opts.yes)
+            throw new SdodsError('NOT_SUPPORTED', 'Deleting runs cannot be undone; pass --yes to confirm (or --dry-run to preview).', { exitCode: 2 });
+        const m = await import('@sdods/db');
+        const adb = m.createDb();
+        try {
+            await m.migrateToLatest(adb);
+            const res = await m.deleteRuns(adb, ids, {
+                artifactsRoot: artifactsRootOf(ctx.rootDir),
+                actor: { type: 'cli' },
+                reason: 'manual',
+                dryRun: Boolean(opts.dryRun),
+            });
+            if (ctx.opts.json)
+                return json(res);
+            if (res.deleted.length)
+                table(res.deleted.map((d) => ({
+                    run: d.id,
+                    project: d.projectSlug,
+                    created: d.createdAt,
+                    size: formatBytes(d.bytes),
+                })));
+            for (const s of res.skipped)
+                warn(`${s.id}: ${s.reason === 'live' ? 'still running, stop it first' : 'not found'}`);
+            if (!res.deleted.length)
+                return out(pc.dim('Nothing to delete.'));
+            ok(`${opts.dryRun ? 'Would delete' : 'Deleted'} ${res.deleted.length} run(s), ${opts.dryRun ? 'freeing' : 'freed'} ${formatBytes(res.freedBytes)}`);
+        }
+        finally {
+            await adb.close();
+        }
+    });
+}
+//# sourceMappingURL=runs.js.map

package/dist/program.js

@@ -15,6 +15,7 @@ import { register as registerHar } from './commands/har.js';
 import { register as registerAuth } from './commands/auth.js';
 import { register as registerData } from './commands/data.js';
 import { register as registerDb } from './commands/db.js';
+import { register as registerRuns } from './commands/runs.js';
 import { register as registerReport } from './commands/report.js';
 import { register as registerHeal } from './commands/heal.js';
 import { register as registerInsights } from './commands/insights.js';
@@ -75,6 +76,7 @@ export function buildProgram() {
     registerAuth(program);
     registerData(program);
     registerDb(program);
+    registerRuns(program);
     registerReport(program);
     registerHeal(program);
     registerInsights(program);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sdods/cli",
-  "version": "0.13.2",
+  "version": "0.14.1",
   "description": "SDODS command line: run, record, analyze, agents, MCP server, scheduler and the web server.",
   "license": "Apache-2.0",
   "funding": "https://sdods.com/sponsor/",
@@ -26,8 +26,8 @@
     "node": ">=22"
   },
   "dependencies": {
-    "@sdods/contracts": "0.13.2",
-    "@sdods/core": "0.13.2",
+    "@sdods/contracts": "0.14.1",
+    "@sdods/core": "0.14.1",
     "commander": "^15.0.0",
     "execa": "^10.1.0",
     "picocolors": "^1.1.1",
@@ -36,12 +36,12 @@
     "zod": "^4.6.5",
     "@playwright/test": "^1.64.0",
     "playwright-core": "^1.64.0",
-    "@sdods/integrations": "0.13.2",
-    "@sdods/mcp": "0.13.2",
-    "@sdods/agents": "0.13.2",
-    "@sdods/db": "0.13.2",
+    "@sdods/integrations": "0.14.1",
+    "@sdods/mcp": "0.14.1",
+    "@sdods/agents": "0.14.1",
+    "@sdods/db": "0.14.1",
     "csv-parse": "^7.0.3",
-    "@sdods/server": "0.13.2"
+    "@sdods/server": "0.14.1"
   },
   "homepage": "https://sdods.com",
   "bugs": {

package/skills/sdods-start-ui/SKILL.md

@@ -295,8 +295,8 @@ sdods browsers install --with-deps  # refresh engines afterwards (Linux needs ro
 sdods doctor                        # confirm
 ```
 
-CI does this on a schedule: `.github/workflows/dependencies.yml` reports freshness into one rolling
-issue every morning, and on the 1st of the month upgrades `@sdods/*` and Playwright, runs the suite,
+CI does this on a schedule: `.github/workflows/dependencies.yml` posts a freshness report to Yarlis
+Dev (Google Chat, through Yarlis Relay) on the 15th, and on the 1st of the month upgrades `@sdods/*` and Playwright, runs the suite,
 and opens a PR only if it passes.
 
 After any upgrade, restart `serve` — a running server keeps the old bundle in memory.

package/templates/.env.example

@@ -5,7 +5,6 @@
 #   mandatory  only when the feature next to it is used
 #   one-of     agents need ANY ONE of the four options in the Agents block
 #   optional   turns on an integration
-#   ci-only    GitHub Actions secrets, never needed locally
 
 # ── Database (mandatory: none; DATABASE_URL only when DB_DRIVER=postgres) ─────
 DB_DRIVER=sqlite
@@ -57,7 +56,3 @@ SESSION_SECRET=change-me-32-chars-minimum-please   # openssl rand -hex 32
 # ── SDODS's own token (optional, free): MCP over HTTP and CI ingest ─────────
 # SDODS_SERVER_URL=http://127.0.0.1:4444
 # SDODS_TOKEN=amx_...    # sdods tokens create --user <name> --scopes runs:ingest,runs:read
-
-# ── CI-only GitHub secrets (never needed locally) ────────────────────────────
-# FIREBASE_SERVICE_ACCOUNT_AUTOMAX_DOCS   docs deploy (Firebase Hosting)
-# NPM_TOKEN                               publishing @sdods/* packages