@doubledigit/cli 0.1.0

package/dist/commands/create.d.ts

@@ -0,0 +1,12 @@
+/**
+ * dd create <name> — Scaffold a new micro-app from the template.
+ *
+ * Steps:
+ * 1. Copy template-micro-app → packages/<name>/
+ * 2. Replace template tokens in files
+ * 3. Add dependency to main-app/package.json
+ * 4. Add entry to dd-apps.config.json
+ * 5. Run sync to regenerate micro-apps.ts
+ */
+export declare function create(name: string): Promise<void>;
+//# sourceMappingURL=create.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../src/commands/create.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAwFH,wBAAsB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA8JxD"}

package/dist/commands/create.js

@@ -0,0 +1,218 @@
+/**
+ * dd create <name> — Scaffold a new micro-app from the template.
+ *
+ * Steps:
+ * 1. Copy template-micro-app → packages/<name>/
+ * 2. Replace template tokens in files
+ * 3. Add dependency to main-app/package.json
+ * 4. Add entry to dd-apps.config.json
+ * 5. Run sync to regenerate micro-apps.ts
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+import { resolveWorkspacePaths, installDirForKind, installRelPath, allInstallRoots, allScanRoots, } from '../paths.js';
+import { readConfig, writeConfig } from '../config.js';
+import { sync } from './sync.js';
+import { rewriteExtensionTsconfig } from '../lib/rewrite-extension-tsconfig.js';
+import { validateNoNameCollision, validateSlugPrefix, } from '../lib/validators.js';
+const SLUG_PREFIX_PATTERN = /^[a-z][a-z0-9]*(-[a-z][a-z0-9]*)*$/;
+function toSlugPrefix(name) {
+    // Take first letter of each hyphenated word, max 3 chars
+    const parts = name.split('-');
+    return parts
+        .map((p) => p[0])
+        .join('')
+        .slice(0, 3)
+        .toLowerCase();
+}
+function toPascalCase(name) {
+    return name
+        .split('-')
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join('');
+}
+function toCamelCase(name) {
+    const pascal = toPascalCase(name);
+    return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+function toTitleCase(name) {
+    return name
+        .split('-')
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(' ');
+}
+function copyDirRecursive(src, dest, replacements, name) {
+    fs.mkdirSync(dest, { recursive: true });
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        // Skip node_modules, dist, .turbo, etc.
+        if (['node_modules', 'dist', '.turbo', 'tsconfig.tsbuildinfo'].includes(entry.name)) {
+            continue;
+        }
+        if (entry.isDirectory()) {
+            copyDirRecursive(srcPath, destPath, replacements, name);
+        }
+        else {
+            let content = fs.readFileSync(srcPath, 'utf-8');
+            // Apply replacements
+            for (const [search, replace] of replacements) {
+                content = content.replaceAll(search, replace);
+            }
+            // Rename file if necessary
+            let finalDestName = entry.name;
+            if (entry.name === 'template-client.tsx') {
+                finalDestName = `${name}-client.tsx`;
+            }
+            const finalDestPath = path.join(dest, finalDestName);
+            fs.writeFileSync(finalDestPath, content, 'utf-8');
+        }
+    }
+}
+export async function create(name) {
+    // Validate name
+    if (!SLUG_PREFIX_PATTERN.test(name)) {
+        console.error(`❌ Invalid name "${name}". Must be lowercase kebab-case (e.g. "invoice-tracker").`);
+        process.exit(1);
+    }
+    const paths = resolveWorkspacePaths();
+    const targetDir = installDirForKind(paths, 'micro-app', name);
+    const targetRelPath = installRelPath('micro-app', name);
+    const templateDir = path.join(paths.packagesDir, 'template-micro-app');
+    // Check template exists
+    if (!fs.existsSync(templateDir)) {
+        console.error(`❌ Template not found at ${templateDir}`);
+        process.exit(1);
+    }
+    // Check target doesn't already exist
+    if (fs.existsSync(targetDir)) {
+        console.error(`❌ Directory already exists: ${targetDir}`);
+        process.exit(1);
+    }
+    const slugPrefix = toSlugPrefix(name);
+    const pascalName = toPascalCase(name);
+    const camelName = toCamelCase(name);
+    const titleName = toTitleCase(name);
+    const npmName = `@doubledigit/${name}`;
+    const collisionResult = validateNoNameCollision(allInstallRoots(paths), name);
+    if (!collisionResult.valid) {
+        for (const error of collisionResult.errors) {
+            console.error(`❌ ${error}`);
+        }
+        process.exit(1);
+    }
+    const slugResult = validateSlugPrefix(allScanRoots(paths), slugPrefix, name);
+    if (!slugResult.valid) {
+        for (const error of slugResult.errors) {
+            console.error(`❌ ${error}`);
+        }
+        process.exit(1);
+    }
+    console.log(`\n📦 Creating micro-app: ${name}`);
+    console.log(`   Slug prefix: ${slugPrefix}`);
+    console.log(`   Package: ${npmName}`);
+    console.log(`   Directory: ${targetRelPath}\n`);
+    // Replacements map (template tokens → actual values)
+    const replacements = new Map([
+        // Package name
+        ['@doubledigit/template-micro-app', npmName],
+        // DDApp key
+        ['template-micro-app', name],
+        // Slug prefix (tp- → new prefix)
+        ['tp-', `${slugPrefix}-`],
+        // PascalCase identifiers
+        ['TemplateClient', `${pascalName}Client`],
+        ['Template App', titleName],
+        ['Template', pascalName],
+        // camelCase identifiers
+        ['templateMicroApp', `${camelName}MicroApp`],
+        ['templateCollections', `${camelName}Collections`],
+        ['templateManifest', `${camelName}Manifest`],
+        ['templateApiHandler', `${camelName}ApiHandler`],
+        // Description
+        ['Template for scaffolding new Payload Micro-Apps', `${titleName} micro-app`],
+        // File names inside imports
+        ['template-client', `${name}-client`],
+        // Static strings
+        ["'/template'", `'/${name}'`],
+        ['Template Micro-App', `${titleName} App`],
+    ]);
+    // 1. Copy template (ensure parent dir exists for extensions/ layout)
+    fs.mkdirSync(path.dirname(targetDir), { recursive: true });
+    copyDirRecursive(templateDir, targetDir, replacements, name);
+    // 1b. Rewrite tsconfig relative paths for the new installation depth
+    rewriteExtensionTsconfig(targetDir, paths.root);
+    // 2. Fix package.json in target
+    const targetPkgPath = path.join(targetDir, 'package.json');
+    if (fs.existsSync(targetPkgPath)) {
+        const pkg = JSON.parse(fs.readFileSync(targetPkgPath, 'utf-8'));
+        pkg.name = npmName;
+        pkg.ddapp = true;
+        pkg.version = '0.1.0';
+        pkg.private = true;
+        pkg.description = `${titleName} micro-app`;
+        // Remove publishConfig if present (template has it)
+        delete pkg.publishConfig;
+        fs.writeFileSync(targetPkgPath, JSON.stringify(pkg, null, 2) + '\n', 'utf-8');
+    }
+    // 3. Add dependency to main-app/package.json
+    const mainPkg = JSON.parse(fs.readFileSync(paths.mainAppPackageJsonPath, 'utf-8'));
+    if (!mainPkg.dependencies)
+        mainPkg.dependencies = {};
+    mainPkg.dependencies[npmName] = 'workspace:*';
+    // Sort dependencies alphabetically
+    mainPkg.dependencies = Object.fromEntries(Object.entries(mainPkg.dependencies).sort(([a], [b]) => a.localeCompare(b)));
+    fs.writeFileSync(paths.mainAppPackageJsonPath, JSON.stringify(mainPkg, null, 2) + '\n', 'utf-8');
+    // 3b. Add TS path mappings
+    const baseTsConfigPath = path.join(paths.root, 'tsconfig.base.json');
+    if (fs.existsSync(baseTsConfigPath)) {
+        const tsconfig = JSON.parse(fs.readFileSync(baseTsConfigPath, 'utf-8'));
+        if (!tsconfig.compilerOptions)
+            tsconfig.compilerOptions = {};
+        if (!tsconfig.compilerOptions.paths)
+            tsconfig.compilerOptions.paths = {};
+        tsconfig.compilerOptions.paths[npmName] = [`${targetRelPath}/src/index.tsx`];
+        tsconfig.compilerOptions.paths[`${npmName}/*`] = [`${targetRelPath}/src/*`];
+        fs.writeFileSync(baseTsConfigPath, JSON.stringify(tsconfig, null, 2) + '\n', 'utf-8');
+    }
+    const mainTsConfigPath = path.join(paths.packagesDir, '../apps/main-app/tsconfig.json');
+    if (fs.existsSync(mainTsConfigPath)) {
+        const tsconfig = JSON.parse(fs.readFileSync(mainTsConfigPath, 'utf-8'));
+        if (!tsconfig.compilerOptions)
+            tsconfig.compilerOptions = {};
+        if (!tsconfig.compilerOptions.paths)
+            tsconfig.compilerOptions.paths = {};
+        tsconfig.compilerOptions.paths[npmName] = [`../../${targetRelPath}/src/index.tsx`];
+        tsconfig.compilerOptions.paths[`${npmName}/*`] = [`../../${targetRelPath}/src/*`];
+        fs.writeFileSync(mainTsConfigPath, JSON.stringify(tsconfig, null, 2) + '\n', 'utf-8');
+    }
+    // 4. Add entry to dd-apps.config.json
+    const config = readConfig(paths.configPath);
+    if (!config.apps)
+        config.apps = {};
+    config.apps[name] = true;
+    writeConfig(paths.configPath, config);
+    // 5. Run sync
+    await sync();
+    // 6. Run pnpm install
+    console.log('\n📦 Running pnpm install...');
+    try {
+        execSync('pnpm install', { cwd: paths.root, stdio: 'inherit' });
+    }
+    catch {
+        console.warn('⚠ pnpm install failed. Run it manually.');
+    }
+    console.log(`
+✅ Micro-app "${name}" created successfully!
+
+Next steps:
+  1. Edit ${targetRelPath}/src/micro-app/index.tsx to define your routes, widgets, and API entrypoints
+  2. Edit ${targetRelPath}/src/collections to define your collections
+  3. Run: pnpm db:migrate:create
+  4. Run: pnpm db:migrate
+  5. Run: pnpm payload:generate-types:main
+  6. Run: pnpm dev
+`);
+}

package/dist/commands/db.d.ts

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

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

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

package/dist/commands/db.js

@@ -0,0 +1,64 @@
+import { resolveWorkspacePaths } from '../paths.js';
+import { applyRuntimeDatabaseUrl, captureCommand, checkDatabaseReachability, inspectLocalEnv, parseDatabaseUrl, resolveDatabasePreference, databaseRuntimeToEnvOptions, ensureDatabaseReady, ensureLocalEnv, runChecked, } from '../lib/onboarding.js';
+async function dbStatus() {
+    const paths = resolveWorkspacePaths();
+    const envInspection = inspectLocalEnv(paths);
+    const databasePreference = resolveDatabasePreference(envInspection.env);
+    const databaseMode = databasePreference.mode;
+    const databaseUrl = databasePreference.databaseUrl;
+    if (!databaseUrl) {
+        console.error('Error: no database configuration is available. Run `pnpm dd onboard` first.');
+        process.exit(1);
+    }
+    const info = parseDatabaseUrl(databaseUrl);
+    const reachable = await checkDatabaseReachability(databaseUrl);
+    console.log('\n🗄️ Database status\n');
+    console.log(`Mode: ${databaseMode}`);
+    console.log(`Host: ${info.host}`);
+    console.log(`Port: ${info.port}`);
+    console.log(`Database: ${info.database}`);
+    console.log(`Reachable: ${reachable ? 'yes' : 'no'}`);
+    const migrationStatus = captureCommand('pnpm', ['db:migrate:status'], paths.root);
+    console.log('\nMigration status:\n');
+    console.log(migrationStatus.output || 'Unavailable');
+    if (!reachable || !migrationStatus.ok) {
+        process.exitCode = 1;
+    }
+}
+async function dbMigrate() {
+    const paths = resolveWorkspacePaths();
+    const runtime = await ensureDatabaseReady(paths, {
+        yes: true,
+        allowDockerFallback: true,
+    });
+    applyRuntimeDatabaseUrl(ensureLocalEnv(paths, databaseRuntimeToEnvOptions(runtime)).env, runtime);
+    runChecked('pnpm', ['db:migrate'], paths.root, 'Migration run');
+    console.log('✔ Migrations applied');
+}
+const HELP = `
+dd db — Database helpers
+
+Subcommands:
+  status      Show database connectivity and migration status
+  migrate     Apply committed migrations
+`;
+export async function db(args) {
+    const subcommand = args[0];
+    switch (subcommand) {
+        case 'status':
+            await dbStatus();
+            break;
+        case 'migrate':
+            await dbMigrate();
+            break;
+        case '--help':
+        case '-h':
+        case undefined:
+            console.log(HELP);
+            break;
+        default:
+            console.error(`Unknown db subcommand: ${subcommand}`);
+            console.log(HELP);
+            process.exit(1);
+    }
+}

package/dist/commands/disable.d.ts

@@ -0,0 +1,5 @@
+/**
+ * dd disable <name> — Disable a micro-app in dd-apps.config.json and run sync.
+ */
+export declare function disable(name: string): Promise<void>;
+//# sourceMappingURL=disable.d.ts.map

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

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

package/dist/commands/disable.js

@@ -0,0 +1,29 @@
+/**
+ * dd disable <name> — Disable a micro-app in dd-apps.config.json and run sync.
+ */
+import { resolveWorkspacePaths } from '../paths.js';
+import { readConfig, writeConfig } from '../config.js';
+import { scanWorkspace } from '../scanner.js';
+import { sync } from './sync.js';
+export async function disable(name) {
+    const paths = resolveWorkspacePaths();
+    const { microApps: allApps, payloadPlugins } = scanWorkspace(paths);
+    const app = allApps.find((a) => a.key === name);
+    if (!app) {
+        const plugin = payloadPlugins.find((p) => p.key === name);
+        if (plugin) {
+            console.error(`❌ "${name}" is a payload plugin — payload plugins are always-on and cannot be enabled or disabled.`);
+            process.exit(1);
+        }
+        console.error(`❌ Micro-app "${name}" not found in workspace.`);
+        console.error(`   Available: ${allApps.map((a) => a.key).join(', ')}`);
+        process.exit(1);
+    }
+    const config = readConfig(paths.configPath);
+    if (!config.apps)
+        config.apps = {};
+    config.apps[name] = false;
+    writeConfig(paths.configPath, config);
+    console.log(`❌ Disabled "${name}" in dd-apps.config.json`);
+    await sync();
+}

package/dist/commands/doctor.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../src/commands/doctor.ts"],"names":[],"mappings":"AAsBA,wBAAsB,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAmG5C"}

package/dist/commands/doctor.js

@@ -0,0 +1,88 @@
+import fs from 'node:fs';
+import { resolveWorkspacePaths } from '../paths.js';
+import { captureCommand, checkDatabaseReachability, commandExists, dockerAvailable, getGeneratedTypesPath, probeEmbeddedPostgresSupport, inspectLocalEnv, resolveDatabasePreference, requiredEnvKeysMissing, trimOutput, } from '../lib/onboarding.js';
+export async function doctor() {
+    const paths = resolveWorkspacePaths();
+    const checks = [];
+    const nodeOk = commandExists('node');
+    checks.push({
+        label: 'Node.js',
+        ok: nodeOk,
+        detail: nodeOk ? process.version : 'Install Node.js 20+.',
+    });
+    const pnpmResult = captureCommand('pnpm', ['--version'], paths.root);
+    checks.push({
+        label: 'pnpm',
+        ok: pnpmResult.ok,
+        detail: pnpmResult.ok ? pnpmResult.output.trim() : 'Install pnpm 9+ with corepack.',
+    });
+    const envInspection = inspectLocalEnv(paths);
+    const missingKeys = requiredEnvKeysMissing(envInspection.env);
+    const databasePreference = resolveDatabasePreference(envInspection.env);
+    const databaseMode = databasePreference.mode;
+    checks.push({
+        label: '.env',
+        ok: envInspection.exists && missingKeys.length === 0,
+        detail: missingKeys.length === 0
+            ? envInspection.exists
+                ? `present at ${envInspection.envPath.replace(`${paths.root}/`, '')}`
+                : 'Missing apps/main-app/.env.'
+            : `Missing keys: ${missingKeys.join(', ')}`,
+    });
+    checks.push({
+        label: 'Database mode',
+        ok: true,
+        detail: databaseMode,
+    });
+    const dbReachable = databasePreference.databaseUrl
+        ? await checkDatabaseReachability(databasePreference.databaseUrl)
+        : false;
+    const embeddedSupport = databaseMode === 'embedded'
+        ? await probeEmbeddedPostgresSupport()
+        : { supported: true };
+    checks.push({
+        label: 'Database reachability',
+        ok: databaseMode === 'embedded' ? embeddedSupport.supported : dbReachable,
+        detail: databaseMode === 'embedded'
+            ? embeddedSupport.supported
+                ? dbReachable
+                    ? 'Embedded PostgreSQL is reachable.'
+                    : 'Embedded PostgreSQL is not running yet. `pnpm dev` or `dd run` will start it automatically.'
+                : embeddedSupport.reason || 'Embedded PostgreSQL is not supported on this host.'
+            : dbReachable
+                ? 'PostgreSQL is reachable from DATABASE_URL.'
+                : dockerAvailable()
+                    ? 'Database is not reachable yet. Run `pnpm dd onboard` or start Docker/Postgres manually.'
+                    : 'Database is not reachable. Start PostgreSQL or update DATABASE_URL.',
+    });
+    const migrationStatus = captureCommand('pnpm', ['db:migrate:status'], paths.root);
+    checks.push({
+        label: 'Migration status',
+        ok: migrationStatus.ok,
+        detail: migrationStatus.ok
+            ? trimOutput(migrationStatus.output)
+            : trimOutput(migrationStatus.output) || 'Could not read migration status.',
+    });
+    const generatedTypesPath = getGeneratedTypesPath(paths);
+    const generatedTypesExists = fs.existsSync(generatedTypesPath);
+    checks.push({
+        label: 'Generated Payload types',
+        ok: generatedTypesExists,
+        detail: generatedTypesExists
+            ? 'packages/shared/src/types/payload-types.ts exists.'
+            : 'Run `pnpm payload:generate-types:main`.',
+    });
+    console.log('\n🩺 Double Digit doctor\n');
+    for (const check of checks) {
+        console.log(`${check.ok ? '✔' : '✘'} ${check.label}`);
+        console.log(`  ${check.detail}`);
+    }
+    const failed = checks.filter((check) => !check.ok);
+    if (failed.length > 0) {
+        console.log('\nDoctor found issues. Recommended next step:\n');
+        console.log('  pnpm dd onboard\n');
+        process.exitCode = 1;
+        return;
+    }
+    console.log('\nAll checks passed.\n');
+}

package/dist/commands/enable.d.ts

@@ -0,0 +1,5 @@
+/**
+ * dd enable <name> — Enable a micro-app in dd-apps.config.json and run sync.
+ */
+export declare function enable(name: string): Promise<void>;
+//# sourceMappingURL=enable.d.ts.map

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

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

package/dist/commands/enable.js

@@ -0,0 +1,29 @@
+/**
+ * dd enable <name> — Enable a micro-app in dd-apps.config.json and run sync.
+ */
+import { resolveWorkspacePaths } from '../paths.js';
+import { readConfig, writeConfig } from '../config.js';
+import { scanWorkspace } from '../scanner.js';
+import { sync } from './sync.js';
+export async function enable(name) {
+    const paths = resolveWorkspacePaths();
+    const { microApps: allApps, payloadPlugins } = scanWorkspace(paths);
+    const app = allApps.find((a) => a.key === name);
+    if (!app) {
+        const plugin = payloadPlugins.find((p) => p.key === name);
+        if (plugin) {
+            console.error(`❌ "${name}" is a payload plugin — payload plugins are always-on and cannot be enabled or disabled.`);
+            process.exit(1);
+        }
+        console.error(`❌ Micro-app "${name}" not found in workspace.`);
+        console.error(`   Available: ${allApps.map((a) => a.key).join(', ')}`);
+        process.exit(1);
+    }
+    const config = readConfig(paths.configPath);
+    if (!config.apps)
+        config.apps = {};
+    config.apps[name] = true;
+    writeConfig(paths.configPath, config);
+    console.log(`✅ Enabled "${name}" in dd-apps.config.json`);
+    await sync();
+}

package/dist/commands/info.d.ts

@@ -0,0 +1,8 @@
+/**
+ * dd info <name> — Show detailed info about an installed extension.
+ *
+ * Reads from the lock file and cross-references with marketplace cache
+ * if the extension was installed from a marketplace.
+ */
+export declare function info(name: string): Promise<void>;
+//# sourceMappingURL=info.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"info.d.ts","sourceRoot":"","sources":["../../src/commands/info.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AASH,wBAAsB,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA8EtD"}

package/dist/commands/info.js

@@ -0,0 +1,84 @@
+/**
+ * dd info <name> — Show detailed info about an installed extension.
+ *
+ * Reads from the lock file and cross-references with marketplace cache
+ * if the extension was installed from a marketplace.
+ */
+import { resolveWorkspacePaths } from '../paths.js';
+import { readLockFile } from '../lib/lock-file.js';
+import { readCachedMarketplace, readKnownMarketplaces, } from '../lib/marketplace.js';
+export async function info(name) {
+    const paths = resolveWorkspacePaths();
+    const lock = readLockFile(paths.lockFilePath);
+    const entry = lock.apps[name];
+    if (!entry) {
+        console.error(`Error: "${name}" is not installed (not found in lock file).`);
+        process.exit(1);
+    }
+    console.log(`\n📦 ${name}\n`);
+    console.log(`  Kind:             ${entry.kind ?? 'unknown'}`);
+    console.log(`  Source:           ${entry.source}`);
+    console.log(`  Resolved source:  ${entry.resolvedSource}`);
+    if (entry.ref) {
+        console.log(`  Ref:              ${entry.ref}`);
+    }
+    if (entry.sha) {
+        console.log(`  SHA:              ${entry.sha}`);
+    }
+    if (entry.marketplaceVersion) {
+        console.log(`  Marketplace ver:  ${entry.marketplaceVersion}`);
+    }
+    if (entry.npmName) {
+        console.log(`  npm name:         ${entry.npmName}`);
+    }
+    console.log(`  Content hash:     ${entry.contentHash}`);
+    console.log(`  Install path:     ${entry.installPath ?? 'unknown'}`);
+    console.log(`  Install strategy: ${entry.installStrategy ?? 'unknown'}`);
+    console.log(`  Installed at:     ${entry.installedAt}`);
+    console.log(`  Updated at:       ${entry.updatedAt}`);
+    // Cross-reference with marketplace cache
+    if (entry.marketplace) {
+        console.log(`\n  Marketplace:      ${entry.marketplace}`);
+        const known = readKnownMarketplaces(paths.root);
+        const mpEntry = known.marketplaces[entry.marketplace];
+        if (mpEntry) {
+            console.log(`  Marketplace src:  ${mpEntry.source}`);
+            if (mpEntry.cachedAt) {
+                console.log(`  Catalog cached:   ${mpEntry.cachedAt}`);
+            }
+        }
+        const cached = readCachedMarketplace(paths.root, entry.marketplace);
+        if (cached) {
+            const ext = cached.manifest.extensions.find((e) => e.name === name);
+            if (ext) {
+                console.log(`\n  Marketplace entry:`);
+                if (ext.description) {
+                    console.log(`    Description:    ${ext.description}`);
+                }
+                if (ext.version) {
+                    console.log(`    Version:        ${ext.version}`);
+                }
+                if (ext.author) {
+                    console.log(`    Author:         ${ext.author}`);
+                }
+                console.log(`    Verified:       ${ext.verified ? 'yes' : 'no'}`);
+                if (ext.tags.length > 0) {
+                    console.log(`    Tags:           ${ext.tags.join(', ')}`);
+                }
+                if (ext.source.sha) {
+                    console.log(`    Latest SHA:     ${ext.source.sha}`);
+                }
+                if (ext.source.ref) {
+                    console.log(`    Latest ref:     ${ext.source.ref}`);
+                }
+            }
+            else {
+                console.log(`  ⚠ Extension not found in current marketplace catalog`);
+            }
+        }
+        else {
+            console.log(`  ⚠ Marketplace catalog not cached — run: dd marketplace update ${entry.marketplace}`);
+        }
+    }
+    console.log('');
+}

package/dist/commands/list.d.ts

@@ -0,0 +1,5 @@
+/**
+ * dd list — Show all discovered micro-apps with their enabled/disabled status.
+ */
+export declare function list(): Promise<void>;
+//# sourceMappingURL=list.d.ts.map

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

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

package/dist/commands/list.js

@@ -0,0 +1,44 @@
+/**
+ * dd list — Show all discovered micro-apps with their enabled/disabled status.
+ */
+import { resolveWorkspacePaths } from '../paths.js';
+import { readConfig, isEntryEnabled } from '../config.js';
+import { scanWorkspace } from '../scanner.js';
+export async function list() {
+    const paths = resolveWorkspacePaths();
+    const config = readConfig(paths.configPath);
+    const { microApps: allApps, payloadPlugins } = scanWorkspace(paths);
+    if (allApps.length === 0 && payloadPlugins.length === 0) {
+        console.log('No extensions found. Add "ddapp": true or "ddPackageType": "payload-plugin" to a package.json to register one.');
+        return;
+    }
+    // Apply DD_APPS env var override for display
+    const envApps = process.env.DD_APPS;
+    const whitelist = envApps
+        ? new Set(envApps.split(',').map((s) => s.trim()).filter(Boolean))
+        : null;
+    if (allApps.length > 0) {
+        console.log(`\nMicro-Apps (${allApps.length} discovered):\n`);
+        for (const app of allApps) {
+            let status;
+            if (whitelist) {
+                status = whitelist.has(app.key) ? '✅' : '❌ (DD_APPS override)';
+            }
+            else if (config.apps && !isEntryEnabled(config.apps[app.key])) {
+                status = '❌ (disabled in config)';
+            }
+            else {
+                status = '✅';
+            }
+            console.log(`  ${status}  ${app.key.padEnd(20)} ${app.npmName}`);
+        }
+        console.log('');
+    }
+    if (payloadPlugins.length > 0) {
+        console.log(`Payload Plugins (${payloadPlugins.length} discovered):\n`);
+        for (const plugin of payloadPlugins) {
+            console.log(`  🔌 always-on  ${plugin.key.padEnd(20)} ${plugin.npmName}`);
+        }
+        console.log('');
+    }
+}

package/dist/commands/marketplace.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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
+ */
+export declare function marketplace(args: string[]): Promise<void>;
+//# sourceMappingURL=marketplace.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"marketplace.d.ts","sourceRoot":"","sources":["../../src/commands/marketplace.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AA+NH,wBAAsB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CA8B/D"}