@doubledigit/cli 0.1.0 → 0.2.1

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 doubledigital
+Copyright (c) 2026 doubledigit
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -0,0 +1,102 @@
+# @doubledigit/cli
+
+CLI for Double Digit local setup, project bootstrapping, extension management, and database workflows.
+
+Double Digit is a pluggable Next.js/Payload developer control plane. The CLI is the supported command surface for creating a new Double Digit project and managing an existing local workspace.
+
+## Usage
+
+Run the published package directly:
+
+```bash
+npx @doubledigit/cli init my-project
+pnpm dlx @doubledigit/cli init my-project
+```
+
+Inside a Double Digit project, use the repo-local shortcut:
+
+```bash
+pnpm dd doctor
+pnpm dd onboard
+pnpm dd run
+```
+
+If installed globally, the binary is available as `dd`:
+
+```bash
+dd doctor
+dd onboard
+dd run
+```
+
+## Requirements
+
+- Node.js 20 or newer
+- pnpm 9 or newer
+
+Enable pnpm through Corepack when needed:
+
+```bash
+corepack enable
+```
+
+## Core Commands
+
+```bash
+dd init <project-name>      # scaffold a new Double Digit project
+dd doctor                   # check local prerequisites and project health
+dd onboard                  # prepare env, dependencies, DB, migrations, and types
+dd run                      # bootstrap the runtime DB and start the app
+dd db status                # inspect migration state
+dd db migrate               # run migrations
+dd db create <target> <name> # create a migration for shared or micro-app schema
+dd add <source>             # install an extension
+dd sync                     # regenerate workspace registries
+dd list                     # list discovered micro-apps
+dd enable <name>            # enable a micro-app
+dd disable <name>           # disable a micro-app
+dd remove <name>            # remove a micro-app package and wiring
+dd reconcile                # detect registry, lock file, and package drift
+dd marketplace <subcommand> # manage marketplace registrations
+dd browse                   # browse marketplace extensions
+```
+
+`add` is also available as `install`, and `remove` is also available as `uninstall`.
+
+## New Project Bootstrap
+
+```bash
+npx @doubledigit/cli init my-project --yes
+cd my-project
+pnpm dd run
+```
+
+Useful `init` options:
+
+- `--yes` skips prompts and uses defaults.
+- `--run` bootstraps and starts the app after scaffolding.
+- `--skip-install` skips dependency installation.
+- `--no-git` removes the cloned `.git` directory from the generated project.
+
+## Existing Project Setup
+
+Use `onboard` for setup-only work:
+
+```bash
+pnpm dd onboard
+```
+
+Use `run` when you want the CLI to prepare the runtime database and then start the app:
+
+```bash
+pnpm dd run
+```
+
+Leave `DATABASE_URL` empty in `apps/main-app/.env` to use the default CLI-managed embedded PostgreSQL flow. Provide `DATABASE_URL` through the environment or `.env` when using your own PostgreSQL instance.
+
+## Links
+
+- Repository: https://github.com/crystalphantom/double-digit
+- Issues: https://github.com/crystalphantom/double-digit/issues
+- Getting started: https://github.com/crystalphantom/double-digit/blob/main/docs/getting-started.md
+- Architecture: https://github.com/crystalphantom/double-digit/blob/main/docs/architecture.md

package/dist/codegen.d.ts

@@ -5,8 +5,12 @@
  * that the Next.js bundler can tree-shake and analyze.
  */
 import type { DiscoveredApp, DiscoveredPayloadPlugin } from './scanner.js';
-export declare function generateMicroAppsModule(enabledApps: DiscoveredApp[]): string;
+export declare function generateMicroAppsModule(outputPath: string, enabledApps: DiscoveredApp[]): string;
 export declare function writeMicroAppsModule(outputPath: string, enabledApps: DiscoveredApp[]): void;
-export declare function generatePayloadPluginsModule(plugins: DiscoveredPayloadPlugin[]): string;
+export declare function generateMicroAppTranspilePackagesModule(apps: DiscoveredApp[]): string;
+export declare function writeMicroAppTranspilePackagesModule(outputPath: string, apps: DiscoveredApp[]): void;
+export declare function generatePayloadPluginsModule(outputPath: string, plugins: DiscoveredPayloadPlugin[]): string;
 export declare function writePayloadPluginsModule(outputPath: string, plugins: DiscoveredPayloadPlugin[]): void;
+export declare function generateScopedPayloadConfigModule(app: DiscoveredApp): string;
+export declare function writeScopedPayloadConfigs(configsDir: string, apps: DiscoveredApp[]): void;
 //# sourceMappingURL=codegen.d.ts.map

package/dist/codegen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"codegen.d.ts","sourceRoot":"","sources":["../src/codegen.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAQ3E,wBAAgB,uBAAuB,CACrC,WAAW,EAAE,aAAa,EAAE,GAC3B,MAAM,CAoER;AAED,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,aAAa,EAAE,GAC3B,IAAI,CAIN;AAID,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,uBAAuB,EAAE,GACjC,MAAM,CAwBR;AAED,wBAAgB,yBAAyB,CACvC,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,uBAAuB,EAAE,GACjC,IAAI,CAIN"}
+{"version":3,"file":"codegen.d.ts","sourceRoot":"","sources":["../src/codegen.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAe3E,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,aAAa,EAAE,GAC3B,MAAM,CAmER;AAED,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,aAAa,EAAE,GAC3B,IAAI,CAIN;AAED,wBAAgB,uCAAuC,CACrD,IAAI,EAAE,aAAa,EAAE,GACpB,MAAM,CAcR;AAED,wBAAgB,oCAAoC,CAClD,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,aAAa,EAAE,GACpB,IAAI,CAIN;AAID,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,uBAAuB,EAAE,GACjC,MAAM,CAuBR;AAED,wBAAgB,yBAAyB,CACvC,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,uBAAuB,EAAE,GACjC,IAAI,CAIN;AAID,wBAAgB,iCAAiC,CAAC,GAAG,EAAE,aAAa,GAAG,MAAM,CA6B5E;AAED,wBAAgB,yBAAyB,CACvC,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,aAAa,EAAE,GACpB,IAAI,CAuBN"}

package/dist/codegen.js

@@ -5,16 +5,22 @@
  * that the Next.js bundler can tree-shake and analyze.
  */
 import fs from 'node:fs';
+import path from 'node:path';
 const HEADER = `// ⚠️  AUTO-GENERATED by @doubledigit/cli sync
 // Do not edit manually. Run \`dd sync\` or \`npx @doubledigit/cli sync\` to regenerate.
-//
-// Generated at: {{TIMESTAMP}}
 `;
-export function generateMicroAppsModule(enabledApps) {
-    const timestamp = new Date().toISOString();
+function toImportSpecifier(outputPath, entryFile) {
+    const relativePath = path.relative(path.dirname(outputPath), entryFile);
+    const normalized = relativePath
+        .split(path.sep)
+        .join('/')
+        .replace(/\.(cts|mts|ts|tsx|js|jsx)$/, '');
+    return normalized.startsWith('.') ? normalized : `./${normalized}`;
+}
+export function generateMicroAppsModule(outputPath, enabledApps) {
     const lines = [];
     // Header
-    lines.push(HEADER.replace('{{TIMESTAMP}}', timestamp));
+    lines.push(HEADER);
     // Type + config imports
     lines.push("import type { DDApp } from '@doubledigit/micro-app-sdk';");
     lines.push("import { isAppEnabled } from '@doubledigit/micro-app-sdk';");
@@ -74,20 +80,37 @@ export function generateMicroAppsModule(enabledApps) {
     return lines.join('\n');
 }
 export function writeMicroAppsModule(outputPath, enabledApps) {
-    const content = generateMicroAppsModule(enabledApps);
-    fs.mkdirSync(fs.realpathSync(outputPath + '/..'), { recursive: true });
+    const content = generateMicroAppsModule(outputPath, enabledApps);
+    fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+    fs.writeFileSync(outputPath, content, 'utf-8');
+}
+export function generateMicroAppTranspilePackagesModule(apps) {
+    const lines = [];
+    lines.push(HEADER);
+    lines.push('// Packages statically imported by the generated micro-app registry.');
+    lines.push('// next.config.ts includes these in transpilePackages for source-first workspace dev.');
+    lines.push('export const microAppTranspilePackages = [');
+    for (const app of apps) {
+        lines.push(`  '${app.npmName}',`);
+    }
+    lines.push('] as const;');
+    lines.push('');
+    return lines.join('\n');
+}
+export function writeMicroAppTranspilePackagesModule(outputPath, apps) {
+    const content = generateMicroAppTranspilePackagesModule(apps);
+    fs.mkdirSync(path.dirname(outputPath), { recursive: true });
     fs.writeFileSync(outputPath, content, 'utf-8');
 }
 // ─── Payload Plugins codegen ───────────────────────────────────────────
-export function generatePayloadPluginsModule(plugins) {
-    const timestamp = new Date().toISOString();
+export function generatePayloadPluginsModule(outputPath, plugins) {
     const lines = [];
-    lines.push(HEADER.replace('{{TIMESTAMP}}', timestamp));
+    lines.push(HEADER);
     lines.push("import type { Plugin } from 'payload';");
     lines.push('');
     if (plugins.length > 0) {
         for (const plugin of plugins) {
-            lines.push(`import ${plugin.importName} from '${plugin.npmName}';`);
+            lines.push(`import ${plugin.importName} from '${toImportSpecifier(outputPath, plugin.entryFile)}';`);
         }
     }
     lines.push('');
@@ -101,7 +124,52 @@ export function generatePayloadPluginsModule(plugins) {
     return lines.join('\n');
 }
 export function writePayloadPluginsModule(outputPath, plugins) {
-    const content = generatePayloadPluginsModule(plugins);
-    fs.mkdirSync(fs.realpathSync(outputPath + '/..'), { recursive: true });
+    const content = generatePayloadPluginsModule(outputPath, plugins);
+    fs.mkdirSync(path.dirname(outputPath), { recursive: true });
     fs.writeFileSync(outputPath, content, 'utf-8');
 }
+// ─── Scoped Payload configs codegen ─────────────────────────────────────
+export function generateScopedPayloadConfigModule(app) {
+    const lines = [];
+    lines.push(HEADER);
+    lines.push("import path from 'node:path';");
+    lines.push('');
+    lines.push(`import ${app.importName}MicroApp from '${app.npmName}';`);
+    lines.push('');
+    lines.push("import { createScopedPayloadConfig } from './_factory';");
+    lines.push("import { getScopedMigrationTables } from './scoped-migration-tables';");
+    lines.push('');
+    lines.push(`export const scopedMigrationTables = getScopedMigrationTables(${app.importName}MicroApp);`);
+    lines.push('');
+    lines.push('export default createScopedPayloadConfig(');
+    lines.push(`  [${app.importName}MicroApp],`);
+    lines.push('  {');
+    lines.push('    migrationDir: path.resolve(');
+    lines.push('      process.cwd(),');
+    lines.push(`      '../../extensions/micro-apps/${app.key}/src/migrations',`);
+    lines.push('    ),');
+    lines.push('    mcp: false,');
+    lines.push('    tablesFilter: scopedMigrationTables,');
+    lines.push('  },');
+    lines.push(');');
+    lines.push('');
+    return lines.join('\n');
+}
+export function writeScopedPayloadConfigs(configsDir, apps) {
+    fs.mkdirSync(configsDir, { recursive: true });
+    const expectedConfigFiles = new Set(apps.map((app) => `${app.key}.config.ts`));
+    for (const app of apps) {
+        fs.writeFileSync(path.join(configsDir, `${app.key}.config.ts`), generateScopedPayloadConfigModule(app), 'utf-8');
+    }
+    for (const entry of fs.readdirSync(configsDir, { withFileTypes: true })) {
+        if (!entry.isFile())
+            continue;
+        if (!entry.name.endsWith('.config.ts'))
+            continue;
+        if (entry.name.startsWith('_') || entry.name === 'shared.config.ts')
+            continue;
+        if (expectedConfigFiles.has(entry.name))
+            continue;
+        fs.rmSync(path.join(configsDir, entry.name));
+    }
+}

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

@@ -1 +1 @@
-{"version":3,"file":"add.d.ts","sourceRoot":"","sources":["../../src/commands/add.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAymBH,wBAAsB,GAAG,CACvB,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GAC3C,OAAO,CAAC,IAAI,CAAC,CA4Ff"}
+{"version":3,"file":"add.d.ts","sourceRoot":"","sources":["../../src/commands/add.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAopBH,wBAAsB,GAAG,CACvB,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GAC3C,OAAO,CAAC,IAAI,CAAC,CA4Ff"}

package/dist/commands/add.js

@@ -107,6 +107,32 @@ function restoreSnapshots(snapshots) {
         }
     }
 }
+function snapshotDirectory(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+        return { path: dirPath, existed: false };
+    }
+    const backupRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'dd-add-configs-'));
+    const backupDir = path.join(backupRoot, 'payload-configs');
+    fs.cpSync(dirPath, backupDir, { recursive: true });
+    return { path: dirPath, existed: true, backupDir };
+}
+function restoreDirectorySnapshot(snapshot) {
+    if (fs.existsSync(snapshot.path)) {
+        fs.rmSync(snapshot.path, { recursive: true, force: true });
+    }
+    if (snapshot.existed && snapshot.backupDir) {
+        fs.mkdirSync(path.dirname(snapshot.path), { recursive: true });
+        fs.cpSync(snapshot.backupDir, snapshot.path, { recursive: true });
+    }
+}
+function cleanupDirectorySnapshot(snapshot) {
+    if (snapshot.backupDir) {
+        const backupRoot = path.dirname(snapshot.backupDir);
+        if (fs.existsSync(backupRoot)) {
+            fs.rmSync(backupRoot, { recursive: true, force: true });
+        }
+    }
+}
 // ---------------------------------------------------------------------------
 // npm source handler
 // ---------------------------------------------------------------------------
@@ -300,8 +326,10 @@ async function addFromGitHub(raw, options, marketplaceCtx) {
             paths.configPath,
             paths.lockFilePath,
             paths.microAppsOutputPath,
+            paths.microAppTranspilePackagesOutputPath,
             paths.payloadPluginsOutputPath,
         ]);
+        const payloadConfigsSnapshot = snapshotDirectory(paths.payloadConfigsDir);
         try {
             // Ensure parent directory exists (extensions/<kind>/ may not yet exist)
             fs.mkdirSync(path.dirname(targetDir), { recursive: true });
@@ -421,6 +449,7 @@ async function addFromGitHub(raw, options, marketplaceCtx) {
             console.error('   ✘ Install failed — rolling back workspace changes');
             try {
                 restoreSnapshots(rollbackSnapshots);
+                restoreDirectorySnapshot(payloadConfigsSnapshot);
                 if (fs.existsSync(targetDir)) {
                     fs.rmSync(targetDir, { recursive: true, force: true });
                 }
@@ -437,6 +466,9 @@ async function addFromGitHub(raw, options, marketplaceCtx) {
             }
             throw installErr;
         }
+        finally {
+            cleanupDirectorySnapshot(payloadConfigsSnapshot);
+        }
         for (const backup of backups) {
             if (fs.existsSync(backup.backupDir)) {
                 fs.rmSync(backup.backupDir, { recursive: true, force: true });
@@ -455,9 +487,10 @@ async function addFromGitHub(raw, options, marketplaceCtx) {
 
 Next steps:
   1. Review the installed code: ${targetRelPath}/
-  2. Run: pnpm db:migrate:create
-  3. Run: pnpm db:migrate
-  4. Run: pnpm dev
+  2. ${isPayloadPlugin ? 'Run: pnpm db:migrate:create:shared <migration-name>' : `Run: pnpm db:migrate:create:app ${appName} <migration-name>`}
+  3. ${isPayloadPlugin ? 'Run: pnpm db:migrate:shared' : `Run: pnpm db:migrate:app ${appName}`}
+  4. Run: pnpm payload:generate-types:main
+  5. Run: pnpm dev
 `);
     }
     finally {

package/dist/commands/create.js

@@ -210,8 +210,8 @@ export async function create(name) {
 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
+  3. Run: pnpm db:migrate:create:app ${name} <migration-name>
+  4. Run: pnpm db:migrate:app ${name}
   5. Run: pnpm payload:generate-types:main
   6. Run: pnpm dev
 `);

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

@@ -1 +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"}
+{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../../src/commands/db.ts"],"names":[],"mappings":"AA8EA,wBAAsB,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAuBtD"}

package/dist/commands/db.js

@@ -1,6 +1,7 @@
 import { resolveWorkspacePaths } from '../paths.js';
-import { applyRuntimeDatabaseUrl, captureCommand, checkDatabaseReachability, inspectLocalEnv, parseDatabaseUrl, resolveDatabasePreference, databaseRuntimeToEnvOptions, ensureDatabaseReady, ensureLocalEnv, runChecked, } from '../lib/onboarding.js';
-async function dbStatus() {
+import { applyRuntimeDatabaseUrl, checkDatabaseReachability, inspectLocalEnv, parseDatabaseUrl, resolveDatabasePreference, databaseRuntimeToEnvOptions, ensureDatabaseReady, ensureLocalEnv, } from '../lib/onboarding.js';
+import { runScopedMigrations } from '../lib/scoped-migrations.js';
+async function dbStatus(args) {
     const paths = resolveWorkspacePaths();
     const envInspection = inspectLocalEnv(paths);
     const databasePreference = resolveDatabasePreference(envInspection.env);
@@ -18,38 +19,50 @@ async function dbStatus() {
     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);
+    process.env.DATABASE_URL = databaseUrl;
     console.log('\nMigration status:\n');
-    console.log(migrationStatus.output || 'Unavailable');
-    if (!reachable || !migrationStatus.ok) {
+    runScopedMigrations(paths, 'status', args);
+    if (!reachable) {
         process.exitCode = 1;
     }
 }
-async function dbMigrate() {
+async function dbMigrate(args) {
     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');
+    runScopedMigrations(paths, 'migrate', args);
     console.log('✔ Migrations applied');
 }
+function dbCreate(args) {
+    runScopedMigrations(resolveWorkspacePaths(), 'create', args);
+}
 const HELP = `
 dd db — Database helpers
 
 Subcommands:
-  status      Show database connectivity and migration status
-  migrate     Apply committed migrations
+  status [target]            Show database connectivity and migration status
+  migrate [target]           Apply committed migrations
+  create [target] [name]     Create a scoped migration
+
+Targets:
+  --all        Shared migrations, then every micro-app config (default)
+  --shared     Shared migrations only
+  <micro-app>  One micro-app, for example meal-planner
 `;
 export async function db(args) {
     const subcommand = args[0];
     switch (subcommand) {
         case 'status':
-            await dbStatus();
+            await dbStatus(args.slice(1));
             break;
         case 'migrate':
-            await dbMigrate();
+            await dbMigrate(args.slice(1));
+            break;
+        case 'create':
+            dbCreate(args.slice(1));
             break;
         case '--help':
         case '-h':

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

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

package/dist/commands/doctor.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
+import os from 'node:os';
 import { resolveWorkspacePaths } from '../paths.js';
-import { captureCommand, checkDatabaseReachability, commandExists, dockerAvailable, getGeneratedTypesPath, probeEmbeddedPostgresSupport, inspectLocalEnv, resolveDatabasePreference, requiredEnvKeysMissing, trimOutput, } from '../lib/onboarding.js';
+import { captureCommand, checkDatabaseReachability, commandExists, DEFAULT_APP_URL, DEFAULT_EMBEDDED_POSTGRES_DATA_DIR, dockerAvailable, getGeneratedTypesPath, probeEmbeddedPostgresSupport, inspectLocalEnv, resolveDatabasePreference, requiredEnvKeysMissing, trimOutput, } from '../lib/onboarding.js';
 export async function doctor() {
     const paths = resolveWorkspacePaths();
     const checks = [];
@@ -29,10 +30,24 @@ export async function doctor() {
                 : 'Missing apps/main-app/.env.'
             : `Missing keys: ${missingKeys.join(', ')}`,
     });
+    const dbReasonLabels = {
+        'DATABASE_URL': 'via DATABASE_URL env var',
+        'apps/main-app/.env': 'via .env',
+        'DD_DATABASE_MODE': 'via DD_DATABASE_MODE',
+        'embedded-managed-url': 'auto-detected from database URL',
+        'no-database-url': 'default — no DATABASE_URL set',
+        'legacy-default': 'migrated from legacy default',
+    };
+    let dbModeDetail = `${databaseMode} (${dbReasonLabels[databasePreference.reason] || databasePreference.reason})`;
+    if (databaseMode === 'embedded') {
+        const dataDir = (envInspection.env.DD_EMBEDDED_POSTGRES_DATA_DIR?.trim() || DEFAULT_EMBEDDED_POSTGRES_DATA_DIR)
+            .replace(os.homedir(), '~');
+        dbModeDetail += `\n  Data dir: ${dataDir}`;
+    }
     checks.push({
         label: 'Database mode',
         ok: true,
-        detail: databaseMode,
+        detail: dbModeDetail,
     });
     const dbReachable = databasePreference.databaseUrl
         ? await checkDatabaseReachability(databasePreference.databaseUrl)
@@ -55,14 +70,23 @@ export async function doctor() {
                     ? '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.',
-    });
+    if (databaseMode === 'embedded' && embeddedSupport.supported && !dbReachable) {
+        checks.push({
+            label: 'Migration status',
+            ok: true,
+            detail: 'Skipped until embedded PostgreSQL starts. `pnpm dev` or `dd run` will start it automatically.',
+        });
+    }
+    else {
+        const migrationStatus = captureCommand('pnpm', ['db:migrate:status'], paths.root, databasePreference.databaseUrl ? { DATABASE_URL: databasePreference.databaseUrl } : {});
+        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({
@@ -72,6 +96,15 @@ export async function doctor() {
             ? 'packages/shared/src/types/payload-types.ts exists.'
             : 'Run `pnpm payload:generate-types:main`.',
     });
+    const appPort = envInspection.env.APP_PORT?.trim() || process.env.APP_PORT?.trim();
+    const appUrl = appPort ? `http://localhost:${appPort}` : DEFAULT_APP_URL;
+    checks.push({
+        label: 'App URL',
+        ok: true,
+        detail: appPort
+            ? `${appUrl} (APP_PORT override)`
+            : `${appUrl} (default — override with APP_PORT)`,
+    });
     console.log('\n🩺 Double Digit doctor\n');
     for (const check of checks) {
         console.log(`${check.ok ? '✔' : '✘'} ${check.label}`);
@@ -79,8 +112,9 @@ export async function doctor() {
     }
     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');
+        console.log('\nDoctor found issues. Recommended next steps:\n');
+        console.log('  pnpm dd onboard       # fix setup issues');
+        console.log('  pnpm dev              # then start the app\n');
         process.exitCode = 1;
         return;
     }

package/dist/commands/init.d.ts

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

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

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