@doubledigit/cli 0.1.0

package/dist/commands/marketplace.js

@@ -0,0 +1,205 @@
+/**
+ * dd marketplace <subcommand> — Manage marketplace registrations.
+ *
+ * Subcommands:
+ *   add <source>    Register a marketplace (GitHub repo with .doubledigit/marketplace.json)
+ *   list            List registered marketplaces
+ *   update [name]   Update marketplace catalog(s)
+ *   remove <name>   Remove a registered marketplace
+ */
+import { readKnownMarketplaces, addKnownMarketplace, removeKnownMarketplace, fetchMarketplaceManifest, updateMarketplace, writeCachedMarketplace, readCachedMarketplace, assertValidMarketplaceName, } from '../lib/marketplace.js';
+import { resolveWorkspacePaths } from '../paths.js';
+// ---------------------------------------------------------------------------
+// marketplace add <source> [--name <name>] [--ref <ref>]
+// ---------------------------------------------------------------------------
+async function marketplaceAdd(args) {
+    const paths = resolveWorkspacePaths();
+    let source;
+    let nameOverride;
+    let ref;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--name') {
+            i++;
+            nameOverride = args[i];
+        }
+        else if (args[i] === '--ref') {
+            i++;
+            ref = args[i];
+        }
+        else if (!args[i].startsWith('--')) {
+            source = args[i];
+        }
+    }
+    if (!source) {
+        console.error('Error: <source> is required.\n' +
+            'Usage: dd marketplace add <owner/repo> [--name <name>] [--ref <ref>]');
+        process.exit(1);
+    }
+    console.log(`\n🏪 Registering marketplace from ${source}...\n`);
+    // Fetch and validate the manifest
+    console.log('   Fetching marketplace manifest...');
+    let manifest;
+    try {
+        manifest = await fetchMarketplaceManifest(source, undefined, ref);
+    }
+    catch (err) {
+        console.error(`\n❌ Failed to fetch marketplace manifest:\n   ${err instanceof Error ? err.message : err}`);
+        process.exit(1);
+    }
+    const name = nameOverride || manifest.name;
+    // Validate marketplace name early for friendly CLI errors
+    try {
+        assertValidMarketplaceName(name);
+    }
+    catch {
+        console.error(`\n❌ Invalid marketplace name: "${name}"\n` +
+            '   Names must start with an alphanumeric character and contain only [a-zA-Z0-9_-].\n' +
+            '   Use --name <safe-name> to override.');
+        process.exit(1);
+    }
+    // Check if already registered
+    const known = readKnownMarketplaces(paths.root);
+    if (name in known.marketplaces) {
+        console.error(`\n❌ Marketplace "${name}" is already registered.\n` +
+            '   Use `dd marketplace update` to refresh, or `dd marketplace remove` first.');
+        process.exit(1);
+    }
+    console.log(`   ✔ Found marketplace: ${manifest.name}`);
+    console.log(`   ✔ ${manifest.extensions.length} extension(s) available`);
+    // Register + cache
+    const entry = {
+        source,
+        manifestPath: '.doubledigit/marketplace.json',
+        ref,
+        cachedAt: new Date().toISOString(),
+        extensionCount: manifest.extensions.length,
+    };
+    addKnownMarketplace(paths.root, name, entry);
+    writeCachedMarketplace(paths.root, name, manifest);
+    console.log(`\n✅ Marketplace "${name}" registered successfully!`);
+    console.log(`\n   Browse extensions: dd browse ${name}`);
+    console.log(`   Install from it:   dd add <name>@${name}\n`);
+}
+// ---------------------------------------------------------------------------
+// marketplace list
+// ---------------------------------------------------------------------------
+async function marketplaceList() {
+    const paths = resolveWorkspacePaths();
+    const known = readKnownMarketplaces(paths.root);
+    const entries = Object.entries(known.marketplaces);
+    if (entries.length === 0) {
+        console.log('\nNo marketplaces registered.\n\n' +
+            'Add one with:\n' +
+            '  dd marketplace add owner/repo\n');
+        return;
+    }
+    console.log('\n🏪 Registered marketplaces:\n');
+    for (const [name, entry] of entries) {
+        const cached = readCachedMarketplace(paths.root, name);
+        const extCount = entry.extensionCount ?? cached?.manifest.extensions.length ?? '?';
+        const cachedAt = entry.cachedAt
+            ? new Date(entry.cachedAt).toLocaleDateString()
+            : 'never';
+        console.log(`  ${name}`);
+        console.log(`    Source:     ${entry.source}`);
+        console.log(`    Extensions: ${extCount}`);
+        console.log(`    Updated:    ${cachedAt}`);
+        console.log('');
+    }
+}
+// ---------------------------------------------------------------------------
+// marketplace update [name]
+// ---------------------------------------------------------------------------
+async function marketplaceUpdate(args) {
+    const paths = resolveWorkspacePaths();
+    const known = readKnownMarketplaces(paths.root);
+    const targetName = args[0];
+    if (Object.keys(known.marketplaces).length === 0) {
+        console.log('\nNo marketplaces registered. Nothing to update.\n');
+        return;
+    }
+    const names = targetName
+        ? [targetName]
+        : Object.keys(known.marketplaces);
+    console.log('\n🔄 Updating marketplace catalog(s)...\n');
+    for (const name of names) {
+        if (!(name in known.marketplaces)) {
+            console.error(`   ✘ Marketplace "${name}" is not registered.`);
+            continue;
+        }
+        try {
+            const manifest = await updateMarketplace(paths.root, name);
+            console.log(`   ✔ ${name} — ${manifest.extensions.length} extension(s)`);
+        }
+        catch (err) {
+            console.error(`   ✘ ${name} — ${err instanceof Error ? err.message : err}`);
+        }
+    }
+    console.log('\n✅ Marketplace update complete.\n');
+}
+// ---------------------------------------------------------------------------
+// marketplace remove <name>
+// ---------------------------------------------------------------------------
+async function marketplaceRemove(args) {
+    const name = args[0];
+    if (!name) {
+        console.error('Error: <name> is required.\nUsage: dd marketplace remove <name>');
+        process.exit(1);
+    }
+    const paths = resolveWorkspacePaths();
+    const removed = removeKnownMarketplace(paths.root, name);
+    if (!removed) {
+        console.error(`\n❌ Marketplace "${name}" is not registered.\n`);
+        process.exit(1);
+    }
+    console.log(`\n✅ Marketplace "${name}" removed.\n`);
+}
+// ---------------------------------------------------------------------------
+// Public dispatcher
+// ---------------------------------------------------------------------------
+const HELP = `
+dd marketplace — Manage marketplace registrations
+
+Subcommands:
+  add <source>    Register a marketplace (GitHub repo with .doubledigit/marketplace.json)
+  list            List registered marketplaces
+  update [name]   Update marketplace catalog(s) — updates all if no name given
+  remove <name>   Remove a registered marketplace
+
+Examples:
+  dd marketplace add digitaldouble/dd-marketplace
+  dd marketplace add digitaldouble/dd-marketplace --name community
+  dd marketplace list
+  dd marketplace update community
+  dd marketplace remove community
+`;
+export async function marketplace(args) {
+    const subcommand = args[0];
+    const subArgs = args.slice(1);
+    switch (subcommand) {
+        case 'add':
+            await marketplaceAdd(subArgs);
+            break;
+        case 'list':
+        case 'ls':
+            await marketplaceList();
+            break;
+        case 'update':
+        case 'refresh':
+            await marketplaceUpdate(subArgs);
+            break;
+        case 'remove':
+        case 'rm':
+            await marketplaceRemove(subArgs);
+            break;
+        case '--help':
+        case '-h':
+        case undefined:
+            console.log(HELP);
+            break;
+        default:
+            console.error(`Unknown marketplace subcommand: ${subcommand}`);
+            console.log(HELP);
+            process.exit(1);
+    }
+}

package/dist/commands/onboard.d.ts

@@ -0,0 +1,2 @@
+export declare function onboard(args: string[]): Promise<void>;
+//# sourceMappingURL=onboard.d.ts.map

package/dist/commands/onboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onboard.d.ts","sourceRoot":"","sources":["../../src/commands/onboard.ts"],"names":[],"mappings":"AAuCA,wBAAsB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAmD3D"}

package/dist/commands/onboard.js

@@ -0,0 +1,58 @@
+import { resolveWorkspacePaths } from '../paths.js';
+import { applyRuntimeDatabaseUrl, captureCommand, databaseRuntimeToEnvOptions, ensureDatabaseReady, ensureLocalEnv, localDependenciesInstalled, printNextSteps, runChecked, startDevServer, } from '../lib/onboarding.js';
+function parseOnboardArgs(args) {
+    let yes = false;
+    let start = true;
+    for (const arg of args) {
+        if (arg === '--yes' || arg === '-y') {
+            yes = true;
+        }
+        if (arg === '--no-start' || arg === '--setup-only') {
+            start = false;
+        }
+    }
+    if (process.env.CI === 'true') {
+        start = false;
+    }
+    return { yes, start };
+}
+export async function onboard(args) {
+    const paths = resolveWorkspacePaths();
+    const options = parseOnboardArgs(args);
+    console.log('\n🚀 Double Digit onboarding\n');
+    const envSetup = ensureLocalEnv(paths);
+    console.log(`✔ ${envSetup.created ? 'Created' : 'Found'} ${envSetup.envPath.replace(`${paths.root}/`, '')}`);
+    if (envSetup.updatedKeys.length > 0) {
+        console.log(`  Updated: ${envSetup.updatedKeys.join(', ')}`);
+    }
+    const installedBefore = localDependenciesInstalled(paths);
+    runChecked('pnpm', ['install'], paths.root, 'Dependency install');
+    console.log(`✔ Dependencies ${installedBefore ? 'verified' : 'installed'}`);
+    const databaseRuntime = await ensureDatabaseReady(paths, {
+        yes: options.yes,
+        allowDockerFallback: true,
+    });
+    const runtimeEnv = applyRuntimeDatabaseUrl(ensureLocalEnv(paths, databaseRuntimeToEnvOptions(databaseRuntime)).env, databaseRuntime);
+    console.log(`✔ ${databaseRuntime.mode === 'embedded' ? 'Embedded' : databaseRuntime.mode === 'docker' ? 'Docker' : 'External'} PostgreSQL is ready`);
+    if (databaseRuntime.mode === 'embedded' && databaseRuntime.embeddedPort) {
+        console.log(`  Port: ${databaseRuntime.embeddedPort}`);
+    }
+    if (databaseRuntime.mode === 'docker' && databaseRuntime.dockerPort) {
+        console.log(`  Docker host port: ${databaseRuntime.dockerPort}`);
+    }
+    runChecked('pnpm', ['db:migrate'], paths.root, 'Migration run');
+    console.log('✔ Migrations applied');
+    runChecked('pnpm', ['payload:generate-types:main'], paths.root, 'Type generation');
+    console.log('✔ Payload types generated');
+    const migrationStatus = captureCommand('pnpm', ['db:migrate:status'], paths.root);
+    if (migrationStatus.ok && migrationStatus.output.trim()) {
+        console.log('\nMigration status:');
+        console.log(migrationStatus.output.trim());
+    }
+    if (options.start) {
+        console.log('\nStarting development server...\n');
+        await startDevServer(paths, runtimeEnv);
+        return;
+    }
+    printNextSteps();
+}

package/dist/commands/outdated.d.ts

@@ -0,0 +1,8 @@
+/**
+ * dd outdated — Compare installed extensions against marketplace catalogs.
+ *
+ * For each lock entry with a `marketplace` field, looks up the current
+ * marketplace catalog and reports version, SHA, or ref differences.
+ */
+export declare function outdated(): Promise<void>;
+//# sourceMappingURL=outdated.d.ts.map

package/dist/commands/outdated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outdated.d.ts","sourceRoot":"","sources":["../../src/commands/outdated.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAiBH,wBAAsB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAkH9C"}

package/dist/commands/outdated.js

@@ -0,0 +1,107 @@
+/**
+ * dd outdated — Compare installed extensions against marketplace catalogs.
+ *
+ * For each lock entry with a `marketplace` field, looks up the current
+ * marketplace catalog and reports version, SHA, or ref differences.
+ */
+import { resolveWorkspacePaths } from '../paths.js';
+import { readLockFile } from '../lib/lock-file.js';
+import { readCachedMarketplace } from '../lib/marketplace.js';
+export async function outdated() {
+    const paths = resolveWorkspacePaths();
+    const lock = readLockFile(paths.lockFilePath);
+    const entries = Object.entries(lock.apps);
+    if (entries.length === 0) {
+        console.log('\nNo extensions installed.\n');
+        return;
+    }
+    const marketplaceEntries = entries.filter(([, e]) => e.marketplace);
+    if (marketplaceEntries.length === 0) {
+        console.log('\nNo marketplace-installed extensions found. Nothing to check.\n');
+        return;
+    }
+    const outdatedList = [];
+    const unchecked = [];
+    for (const [name, entry] of marketplaceEntries) {
+        const mpName = entry.marketplace;
+        const cached = readCachedMarketplace(paths.root, mpName);
+        if (!cached) {
+            unchecked.push({ name, marketplace: mpName, reason: 'catalog not cached' });
+            continue;
+        }
+        const ext = cached.manifest.extensions.find((e) => e.name === name);
+        if (!ext) {
+            unchecked.push({ name, marketplace: mpName, reason: 'removed from marketplace' });
+            continue;
+        }
+        const versionDiff = entry.marketplaceVersion !== undefined &&
+            ext.version !== undefined &&
+            entry.marketplaceVersion !== ext.version;
+        const shaDiff = ext.source.sha && entry.sha !== ext.source.sha;
+        const refDiff = ext.source.ref && entry.ref !== ext.source.ref;
+        if (versionDiff || shaDiff || refDiff) {
+            outdatedList.push({
+                name,
+                marketplace: mpName,
+                installedVersion: entry.marketplaceVersion,
+                latestVersion: ext.version,
+                installedSha: entry.sha,
+                latestSha: ext.source.sha,
+                installedRef: entry.ref,
+                latestRef: ext.source.ref,
+            });
+        }
+    }
+    if (outdatedList.length === 0 && unchecked.length === 0) {
+        console.log('\n✅ All marketplace extensions are up to date.\n');
+        return;
+    }
+    if (outdatedList.length > 0) {
+        console.log('\n📋 Outdated extensions:\n');
+        // Table header
+        const nameW = Math.max(10, ...outdatedList.map((e) => e.name.length));
+        const mpW = Math.max(12, ...outdatedList.map((e) => e.marketplace.length));
+        const header = [
+            'Name'.padEnd(nameW),
+            'Marketplace'.padEnd(mpW),
+            'Installed'.padEnd(16),
+            'Latest'.padEnd(16),
+            'Field',
+        ].join('  ');
+        console.log(`  ${header}`);
+        console.log(`  ${'─'.repeat(header.length)}`);
+        for (const e of outdatedList) {
+            const diffs = [];
+            if (e.latestVersion && e.installedVersion !== e.latestVersion) {
+                diffs.push({ field: 'version', installed: e.installedVersion ?? '–', latest: e.latestVersion });
+            }
+            if (e.latestSha && e.installedSha !== e.latestSha) {
+                diffs.push({
+                    field: 'sha',
+                    installed: e.installedSha ? e.installedSha.slice(0, 12) : '–',
+                    latest: e.latestSha.slice(0, 12),
+                });
+            }
+            if (e.latestRef && e.installedRef !== e.latestRef && !e.latestVersion) {
+                diffs.push({ field: 'ref', installed: e.installedRef ?? '–', latest: e.latestRef });
+            }
+            for (const d of diffs) {
+                const row = [
+                    e.name.padEnd(nameW),
+                    e.marketplace.padEnd(mpW),
+                    d.installed.padEnd(16),
+                    d.latest.padEnd(16),
+                    d.field,
+                ].join('  ');
+                console.log(`  ${row}`);
+            }
+        }
+    }
+    if (unchecked.length > 0) {
+        console.log('\n⚠ Could not check:\n');
+        for (const u of unchecked) {
+            console.log(`  ${u.name} (${u.marketplace}): ${u.reason}`);
+        }
+    }
+    console.log('');
+}

package/dist/commands/reconcile.d.ts

@@ -0,0 +1,12 @@
+/**
+ * dd reconcile — Comprehensive drift detection for installed extensions.
+ *
+ * Compares marketplace entries vs lock file vs vendored content and reports:
+ *   - Source drift: marketplace extension source changed vs lock entry
+ *   - Local modifications: content hash changed since install
+ *   - Missing install path: lock entry exists but directory is gone
+ *   - Marketplace removal: lock entry references a marketplace extension no longer in the catalog
+ *   - Version/SHA mismatch: marketplace has newer version/SHA than lock
+ */
+export declare function reconcile(): Promise<void>;
+//# sourceMappingURL=reconcile.d.ts.map

package/dist/commands/reconcile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconcile.d.ts","sourceRoot":"","sources":["../../src/commands/reconcile.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAwBH,wBAAsB,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,CAiL/C"}

package/dist/commands/reconcile.js

@@ -0,0 +1,175 @@
+/**
+ * dd reconcile — Comprehensive drift detection for installed extensions.
+ *
+ * Compares marketplace entries vs lock file vs vendored content and reports:
+ *   - Source drift: marketplace extension source changed vs lock entry
+ *   - Local modifications: content hash changed since install
+ *   - Missing install path: lock entry exists but directory is gone
+ *   - Marketplace removal: lock entry references a marketplace extension no longer in the catalog
+ *   - Version/SHA mismatch: marketplace has newer version/SHA than lock
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { resolveWorkspacePaths, installDirForKind, installRelPath } from '../paths.js';
+import { readLockFile, computeContentHash } from '../lib/lock-file.js';
+import { readCachedMarketplace, readKnownMarketplaces, extensionSourceToGhString } from '../lib/marketplace.js';
+const SEVERITY_ICON = {
+    error: '✘',
+    warning: '⚠',
+    info: 'ℹ',
+};
+export async function reconcile() {
+    const paths = resolveWorkspacePaths();
+    const lock = readLockFile(paths.lockFilePath);
+    const entries = Object.entries(lock.apps);
+    if (entries.length === 0) {
+        console.log('\nNo extensions installed. Nothing to reconcile.\n');
+        return;
+    }
+    console.log('\n🔍 Reconciling installed extensions...\n');
+    const issues = [];
+    for (const [name, entry] of entries) {
+        // 1. Missing install path
+        let installDir;
+        if (entry.installPath) {
+            installDir = path.join(paths.root, entry.installPath);
+        }
+        else {
+            // Legacy entry without installPath: probe extensions/ first, then packages/
+            const kind = entry.kind ?? 'micro-app';
+            const extDir = installDirForKind(paths, kind, name);
+            installDir = fs.existsSync(extDir) ? extDir : path.join(paths.packagesDir, name);
+        }
+        if (!fs.existsSync(installDir)) {
+            const searchedPaths = entry.installPath
+                ? [entry.installPath]
+                : [
+                    installRelPath(entry.kind ?? 'micro-app', name),
+                    `packages/${name}`,
+                ];
+            issues.push({
+                name,
+                severity: 'error',
+                category: 'Missing install path',
+                message: `Extension not found. Searched: ${searchedPaths.join(', ')}`,
+            });
+            continue; // Can't check content hash if directory is missing
+        }
+        // 2. Local modifications (content hash drift)
+        const currentHash = await computeContentHash(installDir);
+        if (currentHash !== entry.contentHash) {
+            issues.push({
+                name,
+                severity: 'warning',
+                category: 'Local modifications',
+                message: `Content hash changed (lock: ${entry.contentHash.slice(0, 12)}… → current: ${currentHash.slice(0, 12)}…)`,
+            });
+        }
+        // 3. Marketplace-specific checks
+        if (entry.marketplace) {
+            const known = readKnownMarketplaces(paths.root);
+            if (!(entry.marketplace in known.marketplaces)) {
+                issues.push({
+                    name,
+                    severity: 'warning',
+                    category: 'Marketplace removed',
+                    message: `Marketplace "${entry.marketplace}" is no longer registered`,
+                });
+                continue;
+            }
+            const cached = readCachedMarketplace(paths.root, entry.marketplace);
+            if (!cached) {
+                issues.push({
+                    name,
+                    severity: 'info',
+                    category: 'Marketplace not cached',
+                    message: `Catalog for "${entry.marketplace}" not cached — run: dd marketplace update ${entry.marketplace}`,
+                });
+                continue;
+            }
+            const ext = cached.manifest.extensions.find((e) => e.name === name);
+            if (!ext) {
+                // 4. Marketplace removal
+                issues.push({
+                    name,
+                    severity: 'error',
+                    category: 'Marketplace removal',
+                    message: `Extension no longer listed in "${entry.marketplace}" catalog`,
+                });
+                continue;
+            }
+            // 5. Source drift — compare only repo + path; ref/SHA drift is reported separately
+            const stripSourceFragment = (value) => value.replace(/^gh:/, '').split('#', 1)[0];
+            const lockResolvedBase = stripSourceFragment(entry.resolvedSource);
+            const marketplaceSourceBase = stripSourceFragment(extensionSourceToGhString(ext));
+            if (lockResolvedBase !== marketplaceSourceBase) {
+                issues.push({
+                    name,
+                    severity: 'warning',
+                    category: 'Source drift',
+                    message: `Marketplace source changed (lock: gh:${lockResolvedBase} → marketplace: gh:${marketplaceSourceBase})`,
+                });
+            }
+            // 6. Version mismatch — compare marketplace version, not ref
+            if (ext.version && entry.marketplaceVersion && ext.version !== entry.marketplaceVersion) {
+                issues.push({
+                    name,
+                    severity: 'info',
+                    category: 'Version mismatch',
+                    message: `Installed marketplace version "${entry.marketplaceVersion}" differs from latest "${ext.version}"`,
+                });
+            }
+            else if (ext.version && !entry.marketplaceVersion && entry.ref && ext.version !== entry.ref) {
+                // Legacy lock entries without marketplaceVersion: fall back to ref comparison
+                issues.push({
+                    name,
+                    severity: 'info',
+                    category: 'Version mismatch',
+                    message: `Installed ref "${entry.ref}" differs from marketplace version "${ext.version}" (legacy lock entry)`,
+                });
+            }
+            if (ext.source.ref && entry.ref && ext.source.ref !== entry.ref) {
+                issues.push({
+                    name,
+                    severity: 'info',
+                    category: 'Ref mismatch',
+                    message: `Installed ref "${entry.ref}" differs from marketplace ref "${ext.source.ref}"`,
+                });
+            }
+            if (ext.source.sha && entry.sha && ext.source.sha !== entry.sha) {
+                issues.push({
+                    name,
+                    severity: 'info',
+                    category: 'SHA mismatch',
+                    message: `Installed SHA ${entry.sha.slice(0, 12)}… differs from marketplace SHA ${ext.source.sha.slice(0, 12)}…`,
+                });
+            }
+        }
+    }
+    // Print results
+    if (issues.length === 0) {
+        console.log('✅ All extensions are in sync. No drift detected.\n');
+        return;
+    }
+    const errors = issues.filter((i) => i.severity === 'error');
+    const warnings = issues.filter((i) => i.severity === 'warning');
+    const infos = issues.filter((i) => i.severity === 'info');
+    const printGroup = (label, items) => {
+        if (items.length === 0)
+            return;
+        console.log(`${label}:\n`);
+        for (const issue of items) {
+            const icon = SEVERITY_ICON[issue.severity];
+            console.log(`  ${icon} ${issue.name} — ${issue.category}`);
+            console.log(`    ${issue.message}`);
+        }
+        console.log('');
+    };
+    printGroup('Errors', errors);
+    printGroup('Warnings', warnings);
+    printGroup('Info', infos);
+    console.log(`Summary: ${errors.length} error(s), ${warnings.length} warning(s), ${infos.length} info(s)\n`);
+    if (errors.length > 0) {
+        process.exitCode = 1;
+    }
+}

package/dist/commands/run.d.ts

@@ -0,0 +1,2 @@
+export declare function run(): Promise<void>;
+//# sourceMappingURL=run.d.ts.map

package/dist/commands/run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/commands/run.ts"],"names":[],"mappings":"AAcA,wBAAsB,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC,CA4CzC"}

package/dist/commands/run.js

@@ -0,0 +1,37 @@
+import fs from 'node:fs';
+import { resolveWorkspacePaths } from '../paths.js';
+import { applyRuntimeDatabaseUrl, databaseRuntimeToEnvOptions, ensureDatabaseReady, ensureLocalEnv, getGeneratedTypesPath, localDependenciesInstalled, runChecked, startDevServer, } from '../lib/onboarding.js';
+export async function run() {
+    const paths = resolveWorkspacePaths();
+    console.log('\n🚀 Double Digit run\n');
+    const envSetup = ensureLocalEnv(paths);
+    console.log(`✔ ${envSetup.created ? 'Created' : 'Found'} ${envSetup.envPath.replace(`${paths.root}/`, '')}`);
+    if (envSetup.updatedKeys.length > 0) {
+        console.log(`  Updated: ${envSetup.updatedKeys.join(', ')}`);
+    }
+    const installedBefore = localDependenciesInstalled(paths);
+    if (!installedBefore) {
+        runChecked('pnpm', ['install'], paths.root, 'Dependency install');
+        console.log('✔ Dependencies installed');
+    }
+    const runtime = await ensureDatabaseReady(paths, {
+        yes: true,
+        allowDockerFallback: true,
+    });
+    const runtimeEnv = applyRuntimeDatabaseUrl(ensureLocalEnv(paths, databaseRuntimeToEnvOptions(runtime)).env, runtime);
+    console.log(`✔ ${runtime.mode === 'embedded' ? 'Embedded' : runtime.mode === 'docker' ? 'Docker' : 'External'} PostgreSQL is ready`);
+    if (runtime.mode === 'embedded' && runtime.embeddedPort) {
+        console.log(`  Port: ${runtime.embeddedPort}`);
+    }
+    if (runtime.mode === 'docker' && runtime.dockerPort) {
+        console.log(`  Docker host port: ${runtime.dockerPort}`);
+    }
+    runChecked('pnpm', ['db:migrate'], paths.root, 'Migration run');
+    console.log('✔ Migrations applied');
+    if (!fs.existsSync(getGeneratedTypesPath(paths))) {
+        runChecked('pnpm', ['payload:generate-types:main'], paths.root, 'Type generation');
+        console.log('✔ Payload types generated');
+    }
+    console.log('\nStarting development server...\n');
+    await startDevServer(paths, runtimeEnv);
+}

package/dist/commands/sync.d.ts

@@ -0,0 +1,5 @@
+/**
+ * dd sync — Regenerate micro-apps.ts and payload-plugins.ts from config + discovered packages.
+ */
+export declare function sync(): Promise<void>;
+//# sourceMappingURL=sync.d.ts.map

package/dist/commands/sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../../src/commands/sync.ts"],"names":[],"mappings":"AAAA;;GAEG;AAOH,wBAAsB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CA8B1C"}