@contentful/experience-design-system-cli 2.2.1

package/dist/src/session/migration.d.ts

@@ -0,0 +1,4 @@
+import { DatabaseSync } from 'node:sqlite';
+export declare function getReviewsDir(): string;
+export declare function getLegacyImportDbPath(): string;
+export declare function runMigrationIfNeeded(db: DatabaseSync): void;

package/dist/src/session/migration.js

@@ -0,0 +1,117 @@
+import { DatabaseSync } from 'node:sqlite';
+import { readdirSync, readFileSync, renameSync, statSync } from 'node:fs';
+import { existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { generateSessionId } from './session-id.js';
+const MIGRATION_NAME = 'v1_import_and_reviews';
+export function getReviewsDir() {
+    if (process.env.EDS_REVIEW_ARTIFACTS_DIR) {
+        return resolve(process.env.EDS_REVIEW_ARTIFACTS_DIR);
+    }
+    return resolve(homedir(), '.contentful', 'experience-design-system-cli', 'reviews');
+}
+export function getLegacyImportDbPath() {
+    if (process.env.EDS_IMPORT_DB_PATH) {
+        return resolve(process.env.EDS_IMPORT_DB_PATH);
+    }
+    return resolve(homedir(), '.contentful', 'experience-design-system-cli', 'import.db');
+}
+export function runMigrationIfNeeded(db) {
+    const alreadyRan = db.prepare('SELECT name FROM migrations WHERE name = ?').get(MIGRATION_NAME);
+    if (alreadyRan)
+        return;
+    const now = new Date().toISOString();
+    db.exec('BEGIN');
+    try {
+        migrateReviewSessions(db, now);
+        migrateImportDb(db, now);
+        db.prepare('INSERT INTO migrations (name, applied_at) VALUES (?, ?)').run(MIGRATION_NAME, now);
+        db.exec('COMMIT');
+    }
+    catch (e) {
+        db.exec('ROLLBACK');
+        process.stderr.write(`Warning: pipeline session migration failed — continuing without migrated data.\n${e instanceof Error ? e.message : String(e)}\n`);
+    }
+}
+function migrateReviewSessions(db, _now) {
+    const reviewsDir = getReviewsDir();
+    let entries;
+    try {
+        entries = readdirSync(reviewsDir);
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (entry.endsWith('.migrated'))
+            continue;
+        const sessionDir = join(reviewsDir, entry);
+        try {
+            if (!statSync(sessionDir).isDirectory())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        const stateFile = join(sessionDir, 'current-review-state.json');
+        let snapshot;
+        try {
+            snapshot = JSON.parse(readFileSync(stateFile, 'utf8'));
+        }
+        catch {
+            process.stderr.write(`Warning: skipping migration of review session ${entry} — cannot read state file.\n`);
+            continue;
+        }
+        const sessionId = generateSessionId();
+        const mtime = statSync(stateFile).mtime.toISOString();
+        db.prepare('INSERT INTO sessions (id, name, created_at, updated_at) VALUES (?, NULL, ?, ?)').run(sessionId, mtime, mtime);
+        db.prepare(`INSERT INTO steps (session_id, command, status, started_at, completed_at, inputs, outputs, updated_at)
+       VALUES (?, 'generate refine', 'interrupted', ?, ?, ?, '{}', ?)`).run(sessionId, mtime, mtime, JSON.stringify({ rawComponents: snapshot.inputPath ?? '' }), mtime);
+        try {
+            renameSync(sessionDir, `${sessionDir}.migrated`);
+        }
+        catch {
+            // non-fatal
+        }
+    }
+}
+function migrateImportDb(db, _now) {
+    const importDbPath = getLegacyImportDbPath();
+    if (!existsSync(importDbPath))
+        return;
+    let importDb;
+    try {
+        importDb = new DatabaseSync(importDbPath, { readOnly: true });
+    }
+    catch {
+        return;
+    }
+    try {
+        const importSessions = importDb
+            .prepare('SELECT space_id, environment_id, started_at, updated_at FROM sessions')
+            .all();
+        for (const s of importSessions) {
+            const sessionId = generateSessionId();
+            const sessionName = `import:${s.space_id}:${s.environment_id}`;
+            db.prepare('INSERT INTO sessions (id, name, created_at, updated_at) VALUES (?, ?, ?, ?)').run(sessionId, sessionName, s.started_at, s.updated_at);
+            // import_items is no longer in the pipeline schema — legacy push history is not migrated
+        }
+        importDb.close();
+        try {
+            renameSync(importDbPath, `${importDbPath}.migrated`);
+        }
+        catch {
+            // non-fatal
+        }
+    }
+    catch (e) {
+        try {
+            importDb.close();
+        }
+        catch {
+            // ignore
+        }
+        throw e;
+    }
+}

package/dist/src/session/session-id.d.ts

@@ -0,0 +1 @@
+export declare function generateSessionId(): string;

package/dist/src/session/session-id.js

@@ -0,0 +1,212 @@
+import { randomBytes } from 'node:crypto';
+const ADJECTIVES = [
+    'aged',
+    'amber',
+    'bare',
+    'bold',
+    'bright',
+    'calm',
+    'clear',
+    'cold',
+    'cool',
+    'dark',
+    'deep',
+    'dim',
+    'dry',
+    'dusk',
+    'dust',
+    'early',
+    'far',
+    'fast',
+    'fine',
+    'flat',
+    'free',
+    'fresh',
+    'full',
+    'faint',
+    'gold',
+    'gray',
+    'great',
+    'green',
+    'hard',
+    'high',
+    'hollow',
+    'icy',
+    'idle',
+    'iron',
+    'jade',
+    'keen',
+    'large',
+    'lean',
+    'light',
+    'lone',
+    'long',
+    'low',
+    'lunar',
+    'mild',
+    'misty',
+    'muted',
+    'neat',
+    'new',
+    'noble',
+    'north',
+    'oak',
+    'odd',
+    'old',
+    'open',
+    'pale',
+    'plain',
+    'proud',
+    'pure',
+    'quiet',
+    'rapid',
+    'raw',
+    'red',
+    'rich',
+    'rigid',
+    'ripe',
+    'round',
+    'royal',
+    'rust',
+    'sage',
+    'salt',
+    'sandy',
+    'sharp',
+    'short',
+    'shy',
+    'silent',
+    'slim',
+    'slow',
+    'small',
+    'soft',
+    'solar',
+    'solid',
+    'stark',
+    'steel',
+    'stern',
+    'still',
+    'stone',
+    'strong',
+    'sweet',
+    'tall',
+    'teal',
+    'thin',
+    'thorn',
+    'tidy',
+    'true',
+    'vast',
+    'warm',
+    'wide',
+    'wild',
+    'wise',
+    'young',
+];
+const NOUNS = [
+    'arch',
+    'ash',
+    'bay',
+    'beam',
+    'birch',
+    'blade',
+    'bloom',
+    'bluff',
+    'bolt',
+    'brook',
+    'bud',
+    'cape',
+    'cave',
+    'cedar',
+    'cliff',
+    'cloud',
+    'coast',
+    'cove',
+    'creek',
+    'crest',
+    'dale',
+    'dawn',
+    'delta',
+    'dew',
+    'drift',
+    'dune',
+    'dust',
+    'echo',
+    'edge',
+    'elk',
+    'ember',
+    'fen',
+    'fern',
+    'field',
+    'flare',
+    'flash',
+    'flint',
+    'flood',
+    'floor',
+    'flume',
+    'fog',
+    'ford',
+    'forge',
+    'forth',
+    'frost',
+    'gale',
+    'glade',
+    'glen',
+    'glow',
+    'grove',
+    'gulf',
+    'heath',
+    'hill',
+    'hollow',
+    'hull',
+    'isle',
+    'jade',
+    'knoll',
+    'lake',
+    'leaf',
+    'ledge',
+    'light',
+    'loch',
+    'maple',
+    'marsh',
+    'mead',
+    'mesa',
+    'mist',
+    'moon',
+    'moor',
+    'moss',
+    'mount',
+    'pass',
+    'peak',
+    'pine',
+    'plain',
+    'pool',
+    'ridge',
+    'rift',
+    'rim',
+    'rise',
+    'river',
+    'rock',
+    'root',
+    'rush',
+    'sand',
+    'shore',
+    'slope',
+    'snow',
+    'spark',
+    'spring',
+    'star',
+    'storm',
+    'stream',
+    'tide',
+    'vale',
+    'vapor',
+    'wake',
+    'wave',
+    'wind',
+];
+export function generateSessionId() {
+    const buf = randomBytes(4);
+    const adjIdx = buf[0] % ADJECTIVES.length;
+    const nounIdx = buf[1] % NOUNS.length;
+    const hex = (((buf[2] << 8) | buf[3]) & 0xffff).toString(16).padStart(4, '0');
+    return `${ADJECTIVES[adjIdx]}-${NOUNS[nounIdx]}-${hex}`;
+}

package/dist/src/session/stats.d.ts

@@ -0,0 +1,27 @@
+import type { DatabaseSync } from 'node:sqlite';
+export interface SessionStats {
+    dbPath: string;
+    dbBytes: number;
+    walBytes: number;
+    totalBytes: number;
+    sessions: {
+        total: number;
+        complete: number;
+        inProgress: number;
+        failed: number;
+        interrupted: number;
+    };
+    steps: number;
+    rawComponents: number;
+    oldestSession: {
+        id: string;
+        updatedAt: string;
+    } | null;
+    newestSession: {
+        id: string;
+        updatedAt: string;
+    } | null;
+}
+export declare function getStats(db: DatabaseSync, dbPath: string): SessionStats;
+export declare function formatBytes(bytes: number): string;
+export declare function formatStatsText(stats: SessionStats): string;

package/dist/src/session/stats.js

@@ -0,0 +1,89 @@
+import { statSync } from 'node:fs';
+export function getStats(db, dbPath) {
+    const pageCountRow = db.prepare('PRAGMA page_count').get();
+    const pageSizeRow = db.prepare('PRAGMA page_size').get();
+    const dbBytes = pageCountRow.page_count * pageSizeRow.page_size;
+    let walBytes = 0;
+    try {
+        walBytes = statSync(`${dbPath}-wal`).size;
+    }
+    catch {
+        // WAL file doesn't exist
+    }
+    // Session counts by status of last step
+    const sessionTotal = db.prepare('SELECT COUNT(*) AS n FROM sessions').get().n;
+    const statusCounts = db
+        .prepare(`SELECT last_status, COUNT(*) AS n
+       FROM (
+         SELECT session_id,
+                status AS last_status,
+                ROW_NUMBER() OVER (PARTITION BY session_id ORDER BY started_at DESC, id DESC) AS rn
+         FROM steps
+       )
+       WHERE rn = 1
+       GROUP BY last_status`)
+        .all();
+    const byStatus = {};
+    for (const row of statusCounts) {
+        byStatus[row.last_status] = row.n;
+    }
+    // Sessions with no steps at all count as in-progress
+    const sessionsWithSteps = statusCounts.reduce((a, r) => a + r.n, 0);
+    const sessionsWithNoSteps = sessionTotal - sessionsWithSteps;
+    const stepsTotal = db.prepare('SELECT COUNT(*) AS n FROM steps').get().n;
+    const rawComponents = db.prepare('SELECT COUNT(*) AS n FROM raw_components').get().n;
+    const oldest = db.prepare('SELECT id, updated_at FROM sessions ORDER BY updated_at ASC LIMIT 1').get();
+    const newest = db.prepare('SELECT id, updated_at FROM sessions ORDER BY updated_at DESC LIMIT 1').get();
+    return {
+        dbPath,
+        dbBytes,
+        walBytes,
+        totalBytes: dbBytes + walBytes,
+        sessions: {
+            total: sessionTotal,
+            complete: byStatus['complete'] ?? 0,
+            inProgress: (byStatus['pending'] ?? 0) + sessionsWithNoSteps,
+            failed: byStatus['failed'] ?? 0,
+            interrupted: byStatus['interrupted'] ?? 0,
+        },
+        steps: stepsTotal,
+        rawComponents,
+        oldestSession: oldest ? { id: oldest.id, updatedAt: oldest.updated_at } : null,
+        newestSession: newest ? { id: newest.id, updatedAt: newest.updated_at } : null,
+    };
+}
+export function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+export function formatStatsText(stats) {
+    const lines = [
+        `Pipeline DB: ${stats.dbPath}`,
+        ``,
+        `  Database size   ${formatBytes(stats.dbBytes).padStart(10)}`,
+        `  WAL file size   ${formatBytes(stats.walBytes).padStart(10)}`,
+        `  Total on disk   ${formatBytes(stats.totalBytes).padStart(10)}`,
+        ``,
+        `  Sessions        ${String(stats.sessions.total).padStart(10)}`,
+        `    complete      ${String(stats.sessions.complete).padStart(10)}`,
+        `    in-progress   ${String(stats.sessions.inProgress).padStart(10)}`,
+        `    failed        ${String(stats.sessions.failed).padStart(10)}`,
+        `    interrupted   ${String(stats.sessions.interrupted).padStart(10)}`,
+        ``,
+        `  Steps           ${String(stats.steps).padStart(10)}`,
+        `  Raw components  ${String(stats.rawComponents).padStart(10)}`,
+    ];
+    if (stats.oldestSession) {
+        const date = stats.oldestSession.updatedAt.slice(0, 10);
+        lines.push(``, `  Oldest session  ${date}  (${stats.oldestSession.id})`);
+    }
+    if (stats.newestSession && stats.newestSession.id !== stats.oldestSession?.id) {
+        const date = stats.newestSession.updatedAt.slice(0, 10);
+        lines.push(`  Newest session  ${date}  (${stats.newestSession.id})`);
+    }
+    lines.push(``, `Run \`session prune --older-than <age>\` to free space.`);
+    return lines.join('\n');
+}

package/dist/src/setup/command.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerSetupCommand(program: Command): void;