memoire-ai 0.3.2 → 0.3.4

package/dist/setup-wizard.js

@@ -1,5 +1,5 @@
-import { spawn, execFileSync } from 'node:child_process';
-import { existsSync, writeFileSync, mkdirSync } from 'node:fs';
+import { spawn } from 'node:child_process';
+import { existsSync, writeFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { homedir, platform } from 'node:os';
@@ -10,16 +10,11 @@ import { init, install } from './configure.js';
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
-const CLOUD_API_URL = 'https://api.memoire.dev';
+const CLOUD_API_URL = 'http://esprit-prod-alb-1025392673.us-east-1.elb.amazonaws.com';
 const DEFAULT_API_PORT = 3100;
 const DEFAULT_DASHBOARD_PORT = 4310;
-/** Agent IDs that have working install() / init() support in configure.ts. */
-const INSTALL_READY_AGENTS = ['cursor', 'claude', 'codex', 'amp'];
-/** All agents we show in the wizard (detected even if no install logic yet). */
-const ALL_WIZARD_AGENTS = [
-    'cursor', 'claude', 'codex', 'amp', 'windsurf',
-    'opencode', 'zed', 'aider', 'continue', 'cline', 'copilot', 'trae', 'void',
-];
+/** Agent IDs that have working install() / init() support. */
+const SUPPORTED_AGENTS = ['cursor', 'claude', 'codex', 'amp'];
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -83,149 +78,6 @@ function cancelAndExit(value, message = 'Setup cancelled.') {
     return false;
 }
 // ---------------------------------------------------------------------------
-// Local infrastructure helpers
-// ---------------------------------------------------------------------------
-const MEMOIRE_REPO = 'https://github.com/esprit-cli/Memoire.git';
-const MEMOIRE_DOCKER_IMAGE = 'ghcr.io/esprit-cli/memoire';
-function runCmd(cmd, args, opts) {
-    return execFileSync(cmd, args, {
-        cwd: opts?.cwd,
-        env: { ...process.env, ...(opts?.env ?? {}) },
-        encoding: 'utf-8',
-        stdio: ['pipe', 'pipe', 'pipe'],
-        timeout: 300_000,
-    }).trim();
-}
-/** Clone the Memoire repo, install deps, build, and return the root path. */
-async function cloneAndBuild(s, isJson) {
-    const installDir = join(homedir(), '.memoire', 'server');
-    if (existsSync(join(installDir, 'apps', 'api', 'dist', 'index.js'))) {
-        if (!isJson)
-            p.log.info('Memoire server already installed, pulling latest...');
-        try {
-            runCmd('git', ['pull', '--ff-only'], { cwd: installDir });
-        }
-        catch {
-            // Pull failed — that's OK, use what we have
-        }
-    }
-    else {
-        if (!isJson)
-            s.start('Cloning Memoire repository...');
-        mkdirSync(join(homedir(), '.memoire'), { recursive: true });
-        runCmd('git', ['clone', '--depth', '1', MEMOIRE_REPO, installDir]);
-        if (!isJson)
-            s.stop('Repository cloned');
-    }
-    // Install deps
-    if (!isJson)
-        s.start('Installing dependencies (this may take a minute)...');
-    runCmd('pnpm', ['install', '--frozen-lockfile'], { cwd: installDir });
-    if (!isJson)
-        s.stop('Dependencies installed');
-    // Build
-    if (!isJson)
-        s.start('Building Memoire...');
-    runCmd('pnpm', ['--filter', '@memoire-ai/shared', 'build'], { cwd: installDir });
-    runCmd('pnpm', ['--filter', '@memoire-ai/sdk', 'build'], { cwd: installDir });
-    runCmd('pnpm', ['--filter', '@memoire-ai/api', 'build'], { cwd: installDir });
-    runCmd('pnpm', ['--filter', '@memoire-ai/dashboard', 'build'], { cwd: installDir });
-    if (!isJson)
-        s.stop('Build complete');
-    return installDir;
-}
-/** Start Memoire via Docker Compose. */
-async function startWithDocker(s, isJson, dbUrl, dbUrlDirect, apiPort, dashboardPort, openaiKey, anthropicKey) {
-    const installDir = join(homedir(), '.memoire', 'server');
-    // We need the docker-compose.yml from the repo
-    if (!existsSync(join(installDir, 'docker-compose.yml'))) {
-        if (!isJson)
-            s.start('Downloading Memoire Docker config...');
-        mkdirSync(join(homedir(), '.memoire'), { recursive: true });
-        runCmd('git', ['clone', '--depth', '1', MEMOIRE_REPO, installDir]);
-        if (!isJson)
-            s.stop('Docker config ready');
-    }
-    // Write .env for Docker Compose
-    const envLines = [
-        `DATABASE_URL=${dbUrl}`,
-        `DATABASE_URL_DIRECT=${dbUrlDirect}`,
-        `API_PORT=${apiPort}`,
-        `DASHBOARD_PORT=${dashboardPort}`,
-    ];
-    if (openaiKey)
-        envLines.push(`OPENAI_API_KEY=${openaiKey}`);
-    if (anthropicKey)
-        envLines.push(`ANTHROPIC_API_KEY=${anthropicKey}`);
-    writeFileSync(join(installDir, '.env'), envLines.join('\n') + '\n');
-    if (!isJson)
-        s.start('Starting Memoire with Docker Compose...');
-    runCmd('docker', ['compose', 'up', '-d'], { cwd: installDir });
-    if (!isJson)
-        s.stop('Docker containers started');
-    return { memoireRoot: installDir, started: true };
-}
-/** Start API + push schema from a local monorepo clone. */
-async function startFromSource(s, isJson, memoireRoot, dbUrl, dbUrlDirect, apiPort, openaiKey, anthropicKey) {
-    const apiDir = join(memoireRoot, 'apps', 'api');
-    // Write .env
-    const envLines = [
-        `DATABASE_URL="${dbUrl}"`,
-        `DATABASE_URL_DIRECT="${dbUrlDirect}"`,
-        `PORT=${apiPort}`,
-    ];
-    if (openaiKey)
-        envLines.push(`OPENAI_API_KEY="${openaiKey}"`);
-    if (anthropicKey)
-        envLines.push(`ANTHROPIC_API_KEY="${anthropicKey}"`);
-    writeFileSync(join(apiDir, '.env'), envLines.join('\n') + '\n');
-    // Push schema
-    if (!isJson)
-        s.start('Pushing database schema...');
-    try {
-        runCmd('npx', ['drizzle-kit', 'push', '--force'], {
-            cwd: apiDir,
-            env: { DATABASE_URL_DIRECT: dbUrlDirect },
-        });
-        if (!isJson)
-            s.stop('Schema pushed');
-    }
-    catch (err) {
-        if (!isJson)
-            s.stop('Schema push failed — you may need to run it manually');
-    }
-    // Start API
-    if (!isJson)
-        s.start('Starting API server...');
-    const env = {
-        ...process.env,
-        DATABASE_URL: dbUrl,
-        PORT: String(apiPort),
-    };
-    if (openaiKey)
-        env.OPENAI_API_KEY = openaiKey;
-    if (anthropicKey)
-        env.ANTHROPIC_API_KEY = anthropicKey;
-    const child = spawn('node', ['dist/index.js'], {
-        cwd: apiDir,
-        detached: true,
-        stdio: 'ignore',
-        env,
-    });
-    child.unref();
-    // Wait for health
-    for (let i = 0; i < 15; i++) {
-        await new Promise((resolve) => setTimeout(resolve, 1000));
-        if (await checkApiHealth(`http://localhost:${apiPort}`)) {
-            if (!isJson)
-                s.stop(`API running at http://localhost:${apiPort}`);
-            return;
-        }
-    }
-    if (!isJson)
-        s.stop('API started (health check timed out — may still be loading)');
-}
-// ---------------------------------------------------------------------------
 // Main wizard
 // ---------------------------------------------------------------------------
 export async function runSetupWizard(flags = {}) {
@@ -244,7 +96,7 @@ export async function runSetupWizard(flags = {}) {
     const allAgents = await detectAllAgents();
     if (!isJson)
         s.stop('System scan complete');
-    const detectedAgents = allAgents.filter((a) => a.detected);
+    const detectedAgents = allAgents.filter((a) => a.detected && SUPPORTED_AGENTS.includes(a.id));
     if (!isJson) {
         const lines = [
             `Platform:  ${systemInfo.platform} / ${systemInfo.arch}`,
@@ -257,101 +109,53 @@ export async function runSetupWizard(flags = {}) {
         p.note(lines.join('\n'), 'System Information');
     }
     // -----------------------------------------------------------------------
-    // Phase 2: API connection
+    // Phase 2: Hosting mode
     // -----------------------------------------------------------------------
-    let apiUrl;
-    let isCloud = false;
-    let needsLocalStart = false;
-    if (flags.apiUrl) {
-        // Explicit URL provided — use it directly
-        apiUrl = flags.apiUrl;
-        isCloud = apiUrl === CLOUD_API_URL;
-    }
-    else if (flags.cloud) {
-        apiUrl = CLOUD_API_URL;
-        isCloud = true;
+    let isCloud;
+    if (flags.cloud !== undefined) {
+        isCloud = flags.cloud;
+    }
+    else if (flags.apiUrl) {
+        isCloud = flags.apiUrl === CLOUD_API_URL;
     }
     else if (isNonInteractive) {
-        // Default to localhost in non-interactive
-        apiUrl = `http://localhost:${flags.apiPort ?? DEFAULT_API_PORT}`;
+        isCloud = true;
     }
     else {
-        const apiChoice = await p.select({
-            message: 'Where is your Memoire API?',
+        const mode = await p.select({
+            message: 'How would you like to host Memoire?',
             options: [
-                {
-                    value: 'localhost',
-                    label: 'Run locally',
-                    hint: `starts API on localhost:${flags.apiPort ?? DEFAULT_API_PORT} — uses your Supabase DB`,
-                },
-                {
-                    value: 'custom',
-                    label: 'Custom URL',
-                    hint: 'connect to an API already running somewhere',
-                },
-                {
-                    value: 'cloud',
-                    label: 'Memoire Cloud',
-                    hint: 'api.memoire.dev — coming soon',
-                },
+                { value: 'cloud', label: 'Memoire Cloud', hint: 'Fastest — no infrastructure to manage' },
+                { value: 'self-host', label: 'Self-hosted', hint: 'Your own database and servers' },
             ],
         });
-        cancelAndExit(apiChoice);
-        if (apiChoice === 'cloud') {
-            apiUrl = CLOUD_API_URL;
-            isCloud = true;
-        }
-        else if (apiChoice === 'custom') {
-            const urlInput = await p.text({
-                message: 'API URL:',
-                placeholder: 'https://your-api.example.com',
-                validate: (v) => {
-                    if (!v?.startsWith('http://') && !v?.startsWith('https://'))
-                        return 'Must be an HTTP(S) URL';
-                },
-            });
-            cancelAndExit(urlInput);
-            apiUrl = urlInput.replace(/\/$/, '');
-        }
-        else {
-            // localhost
-            apiUrl = `http://localhost:${flags.apiPort ?? DEFAULT_API_PORT}`;
-            needsLocalStart = true;
-        }
+        cancelAndExit(mode);
+        isCloud = mode === 'cloud';
     }
-    // -----------------------------------------------------------------------
-    // Phase 3: Database URL (needed for localhost + custom without running API)
-    // -----------------------------------------------------------------------
-    let dbUrl = flags.dbUrl;
-    let dbUrlDirect = flags.dbUrlDirect;
-    // Check if the API is already reachable — if so, skip DB prompt
-    const apiAlreadyRunning = await checkApiHealth(apiUrl);
+    let apiUrl;
     if (isCloud) {
-        if (!isJson) {
-            if (apiAlreadyRunning) {
-                p.log.success(`Memoire Cloud is reachable at ${apiUrl}`);
-            }
-            else {
-                p.log.warn('Memoire Cloud (api.memoire.dev) is coming soon. Your agent configs will be ready when it launches.');
-            }
-        }
+        apiUrl = flags.apiUrl ?? CLOUD_API_URL;
+        if (!isJson)
+            p.log.info(`Using Memoire Cloud at ${apiUrl}`);
     }
-    else if (!apiAlreadyRunning && !flags.skipStart) {
-        // API not running — we need DB credentials to start it
-        needsLocalStart = true;
+    else {
+        // ------------------------------------------------------------------
+        // Phase 3: Database URL (self-host only)
+        // ------------------------------------------------------------------
+        apiUrl = flags.apiUrl ?? `http://localhost:${flags.apiPort ?? DEFAULT_API_PORT}`;
+        let dbUrl = flags.dbUrl;
+        let dbUrlDirect = flags.dbUrlDirect;
         if (!dbUrl) {
             if (isNonInteractive) {
-                p.log.error('API is not reachable and --db-url was not provided.');
+                p.log.error('Self-hosted mode requires --db-url in non-interactive mode.');
                 process.exit(1);
             }
-            p.note('Memoire needs a PostgreSQL database (Supabase recommended).\n' +
-                'Get a free one at supabase.com/dashboard → Settings → Database → Connection string.', 'Database Setup');
             const dbInput = await p.text({
-                message: 'Database URL (transaction pooler, port 6543):',
-                placeholder: 'postgresql://postgres.xxx:PASSWORD@aws-0-us-west-2.pooler.supabase.com:6543/postgres',
+                message: 'PostgreSQL connection string (pooler / transaction mode):',
+                placeholder: 'postgresql://user:pass@host:6543/memoire',
                 validate: (v) => {
                     if (!v?.startsWith('postgresql://') && !v?.startsWith('postgres://')) {
-                        return 'Must be a PostgreSQL connection string';
+                        return 'Must be a valid PostgreSQL connection string';
                     }
                 },
             });
@@ -361,9 +165,9 @@ export async function runSetupWizard(flags = {}) {
         if (!dbUrlDirect) {
             if (!isNonInteractive) {
                 const directInput = await p.text({
-                    message: 'Direct URL for migrations (port 5432):',
-                    placeholder: dbUrl.replace(':6543/', ':5432/'),
-                    defaultValue: dbUrl.replace(':6543/', ':5432/'),
+                    message: 'Direct database URL (for migrations, optional):',
+                    placeholder: dbUrl,
+                    defaultValue: dbUrl,
                 });
                 cancelAndExit(directInput);
                 dbUrlDirect = directInput || dbUrl;
@@ -372,19 +176,16 @@ export async function runSetupWizard(flags = {}) {
                 dbUrlDirect = dbUrl;
             }
         }
+        // Store for later use in .env writing
+        flags._resolvedDbUrl = dbUrl;
+        flags._resolvedDbUrlDirect = dbUrlDirect;
     }
-    else if (apiAlreadyRunning && !isJson) {
-        p.log.success(`API already running at ${apiUrl}`);
-    }
-    // Store resolved DB URLs for later phases
-    flags._resolvedDbUrl = dbUrl;
-    flags._resolvedDbUrlDirect = dbUrlDirect;
     // -----------------------------------------------------------------------
     // Phase 4: Optional API keys
     // -----------------------------------------------------------------------
     let openaiKey = flags.openaiKey;
     let anthropicKey = flags.anthropicKey;
-    if (needsLocalStart && !isNonInteractive) {
+    if (!isCloud && !isNonInteractive) {
         if (!openaiKey) {
             const wantOpenai = await p.confirm({
                 message: 'Add an OpenAI API key? (used for embeddings)',
@@ -432,38 +233,30 @@ export async function runSetupWizard(flags = {}) {
         selectedAgentIds = flags.agents
             .split(',')
             .map((a) => a.trim())
-            .filter((id) => ALL_WIZARD_AGENTS.includes(id));
+            .filter((id) => SUPPORTED_AGENTS.includes(id));
     }
     else if (isNonInteractive) {
-        // In non-interactive mode, auto-select all detected agents that we can install
-        selectedAgentIds = detectedAgents
-            .filter((a) => INSTALL_READY_AGENTS.includes(a.id))
-            .map((a) => a.id);
+        selectedAgentIds = detectedAgents.map((a) => a.id);
         if (selectedAgentIds.length === 0) {
-            p.log.error('No configurable agents detected. Use --agents to specify agents in non-interactive mode.');
+            p.log.error('No supported agents detected. Use --agents to specify agents in non-interactive mode.');
             process.exit(1);
         }
     }
     else {
-        // Show all wizard agents — mark which are detected and which have full install support
-        const wizardAgents = allAgents.filter((a) => ALL_WIZARD_AGENTS.includes(a.id));
-        if (wizardAgents.length === 0) {
-            p.log.warn('No agents found. Please install an AI coding agent first.');
+        const supportedDetected = allAgents.filter((a) => SUPPORTED_AGENTS.includes(a.id));
+        if (supportedDetected.length === 0) {
+            p.log.warn('No supported agents detected. Please install Cursor, Claude Code, Codex, or Amp first.');
             process.exit(1);
         }
-        const agentChoices = wizardAgents.map((a) => {
-            const hasInstall = INSTALL_READY_AGENTS.includes(a.id);
-            let hint = a.detected ? 'detected' : 'not found';
-            if (a.detected && !hasInstall)
-                hint = 'detected — MCP setup coming soon';
-            return { value: a.id, label: a.name, hint };
-        });
+        const agentChoices = supportedDetected.map((a) => ({
+            value: a.id,
+            label: a.name,
+            hint: a.detected ? 'detected' : 'not found',
+        }));
         const chosen = await p.multiselect({
             message: 'Which agents should Memoire connect to?',
             options: agentChoices,
-            initialValues: detectedAgents
-                .filter((a) => INSTALL_READY_AGENTS.includes(a.id))
-                .map((a) => a.id),
+            initialValues: detectedAgents.map((a) => a.id),
             required: true,
         });
         cancelAndExit(chosen);
@@ -477,45 +270,124 @@ export async function runSetupWizard(flags = {}) {
         p.log.info(`Selected agents: ${selectedAgentIds.join(', ')}`);
     }
     // -----------------------------------------------------------------------
-    // Phase 6: Workspace info
+    // Phase 6: Workspace info (or invite code for cloud join)
     // -----------------------------------------------------------------------
     let orgName = flags.orgName;
     let projectName = flags.projectName;
-    if (!isNonInteractive) {
-        if (!orgName) {
-            const org = await p.text({
-                message: 'Organization name:',
-                placeholder: 'My Team',
+    let joinInviteCode = flags.inviteCode;
+    if (isCloud && !isNonInteractive && !joinInviteCode && !flags.inviteToken) {
+        const joinOrCreate = await p.select({
+            message: 'How would you like to get started?',
+            options: [
+                { value: 'join', label: 'Join an existing workspace (I have an invite code)' },
+                { value: 'create', label: 'Create a new workspace' },
+            ],
+        });
+        cancelAndExit(joinOrCreate);
+        if (joinOrCreate === 'join') {
+            const code = await p.text({
+                message: 'Enter your invite code:',
+                placeholder: 'ABCD-1234',
                 validate: (v) => {
                     if (!v?.trim())
-                        return 'Organization name is required';
+                        return 'Invite code is required';
                 },
             });
-            cancelAndExit(org);
-            orgName = org;
+            cancelAndExit(code);
+            joinInviteCode = code;
         }
-        if (!projectName) {
-            const proj = await p.text({
-                message: 'Project name:',
-                placeholder: 'my-project',
-                validate: (v) => {
-                    if (!v?.trim())
-                        return 'Project name is required';
-                },
-            });
-            cancelAndExit(proj);
-            projectName = proj;
+    }
+    if (!joinInviteCode && !flags.inviteToken) {
+        if (!isNonInteractive) {
+            if (!orgName) {
+                const org = await p.text({
+                    message: 'Organization name:',
+                    placeholder: 'My Team',
+                    validate: (v) => {
+                        if (!v?.trim())
+                            return 'Organization name is required';
+                    },
+                });
+                cancelAndExit(org);
+                orgName = org;
+            }
+            if (!projectName) {
+                const proj = await p.text({
+                    message: 'Project name:',
+                    placeholder: 'my-project',
+                    validate: (v) => {
+                        if (!v?.trim())
+                            return 'Project name is required';
+                    },
+                });
+                cancelAndExit(proj);
+                projectName = proj;
+            }
         }
     }
     // -----------------------------------------------------------------------
-    // Phase 7+8: Infrastructure setup (self-host only)
-    // Set up database, start API server — via Docker or clone+build
+    // Phase 7: Write .env and push DB schema (self-host only)
     // -----------------------------------------------------------------------
-    let apiReachable = apiAlreadyRunning;
-    if (apiAlreadyRunning || isCloud || flags.skipStart) {
-        // API is already up, or we're in cloud/skip mode — nothing to start
+    if (!isCloud) {
+        const memoireRoot = findMemoireRoot();
+        if (memoireRoot) {
+            const apiDir = join(memoireRoot, 'apps', 'api');
+            const envPath = join(apiDir, '.env');
+            const dbUrl = flags._resolvedDbUrl;
+            const dbUrlDirect = flags._resolvedDbUrlDirect;
+            const envLines = [
+                `DATABASE_URL="${dbUrl}"`,
+                `DATABASE_URL_DIRECT="${dbUrlDirect}"`,
+                `PORT=${flags.apiPort ?? DEFAULT_API_PORT}`,
+            ];
+            if (openaiKey)
+                envLines.push(`OPENAI_API_KEY="${openaiKey}"`);
+            if (anthropicKey)
+                envLines.push(`ANTHROPIC_API_KEY="${anthropicKey}"`);
+            writeFileSync(envPath, envLines.join('\n') + '\n');
+            if (!isJson)
+                p.log.success(`Environment file written to ${envPath}`);
+            // Push database schema
+            if (!isJson)
+                s.start('Pushing database schema...');
+            try {
+                const { execFileSync } = await import('node:child_process');
+                execFileSync('npx', ['drizzle-kit', 'push', '--force'], {
+                    cwd: apiDir,
+                    stdio: 'pipe',
+                    env: { ...process.env, DATABASE_URL_DIRECT: dbUrlDirect },
+                });
+                if (!isJson)
+                    s.stop('Database schema pushed');
+            }
+            catch (err) {
+                if (!isJson)
+                    s.stop('Failed to push database schema');
+                p.log.warn(`Could not push schema: ${err instanceof Error ? err.message : 'unknown error'}. You may need to run "npx drizzle-kit push --force" manually in apps/api.`);
+            }
+        }
+        else {
+            p.log.warn('Could not locate Memoire monorepo root. Skipping .env and schema push.');
+        }
     }
-    else if (needsLocalStart && dbUrl) {
+    // -----------------------------------------------------------------------
+    // Phase 8: Start API server (self-host only)
+    // -----------------------------------------------------------------------
+    let apiReachable = false;
+    if (isCloud) {
+        if (!isJson)
+            s.start('Checking Memoire Cloud...');
+        apiReachable = await checkApiHealth(apiUrl);
+        if (!isJson) {
+            if (apiReachable) {
+                s.stop('Memoire Cloud is reachable');
+            }
+            else {
+                s.stop('Memoire Cloud is not reachable — proceeding anyway');
+            }
+        }
+    }
+    else if (!flags.skipStart) {
         const apiPort = flags.apiPort ?? DEFAULT_API_PORT;
         const portFree = await isPortAvailable(apiPort);
         if (!portFree) {
@@ -524,80 +396,37 @@ export async function runSetupWizard(flags = {}) {
             apiReachable = await checkApiHealth(apiUrl);
         }
         else {
-            // API is not running — we need to start it
-            const dbUrl = flags._resolvedDbUrl;
-            const dbUrlDirect = flags._resolvedDbUrlDirect;
-            // Check if we're already in the monorepo
-            let memoireRoot = findMemoireRoot();
+            const memoireRoot = findMemoireRoot();
             if (memoireRoot) {
-                // We're in the monorepo — use it directly
                 if (!isJson)
-                    p.log.info('Found Memoire source — starting from local build');
-                await startFromSource(s, isJson, memoireRoot, dbUrl, dbUrlDirect, apiPort, openaiKey, anthropicKey);
-                apiReachable = await checkApiHealth(apiUrl);
-            }
-            else if (!isNonInteractive) {
-                // Not in monorepo — ask how to start
-                const startMethod = await p.select({
-                    message: 'How should Memoire run locally?',
-                    options: [
-                        ...(systemInfo.hasDocker
-                            ? [{ value: 'docker', label: 'Docker Compose', hint: 'recommended — fastest' }]
-                            : []),
-                        ...(systemInfo.hasPnpm
-                            ? [{ value: 'clone', label: 'Clone & build from source', hint: `installs to ~/.memoire/server` }]
-                            : []),
-                        { value: 'skip', label: 'Skip — I\'ll start the API myself', hint: 'manual setup' },
-                    ],
+                    s.start('Starting API server...');
+                const apiDir = join(memoireRoot, 'apps', 'api');
+                const child = spawn('node', ['dist/index.js'], {
+                    cwd: apiDir,
+                    detached: true,
+                    stdio: 'ignore',
+                    env: { ...process.env, PORT: String(apiPort) },
                 });
-                cancelAndExit(startMethod);
-                if (startMethod === 'docker') {
-                    const result = await startWithDocker(s, isJson, dbUrl, dbUrlDirect, apiPort, flags.dashboardPort ?? DEFAULT_DASHBOARD_PORT, openaiKey, anthropicKey);
-                    memoireRoot = result.memoireRoot;
-                    // Wait for API health via Docker
-                    if (!isJson)
-                        s.start('Waiting for API to be ready...');
-                    for (let i = 0; i < 30; i++) {
-                        await new Promise((r) => setTimeout(r, 2000));
-                        apiReachable = await checkApiHealth(apiUrl);
-                        if (apiReachable)
-                            break;
-                    }
-                    if (!isJson) {
-                        if (apiReachable)
-                            s.stop('API is healthy');
-                        else
-                            s.stop('API may still be starting — Docker containers are running');
-                    }
-                }
-                else if (startMethod === 'clone') {
-                    memoireRoot = await cloneAndBuild(s, isJson);
-                    await startFromSource(s, isJson, memoireRoot, dbUrl, dbUrlDirect, apiPort, openaiKey, anthropicKey);
+                child.unref();
+                // Wait briefly for the server to start
+                for (let i = 0; i < 10; i++) {
+                    await new Promise((resolve) => setTimeout(resolve, 1000));
                     apiReachable = await checkApiHealth(apiUrl);
+                    if (apiReachable)
+                        break;
                 }
-                else {
-                    if (!isJson)
-                        p.log.info(`Start the API manually, then run: npx memoire-ai setup --api-url http://localhost:${apiPort}`);
+                if (!isJson) {
+                    if (apiReachable) {
+                        s.stop(`API server running on port ${apiPort}`);
+                    }
+                    else {
+                        s.stop('API server may still be starting');
+                        p.log.warn('Could not verify API health. Continuing anyway.');
+                    }
                 }
             }
             else {
-                // Non-interactive + no monorepo — try Docker, then clone
-                if (systemInfo.hasDocker) {
-                    const dbUrl = flags._resolvedDbUrl;
-                    const dbUrlDirect = flags._resolvedDbUrlDirect;
-                    await startWithDocker(s, isJson, dbUrl, dbUrlDirect, apiPort, flags.dashboardPort ?? DEFAULT_DASHBOARD_PORT, openaiKey, anthropicKey);
-                    for (let i = 0; i < 30; i++) {
-                        await new Promise((r) => setTimeout(r, 2000));
-                        apiReachable = await checkApiHealth(apiUrl);
-                        if (apiReachable)
-                            break;
-                    }
-                }
-                else if (systemInfo.hasPnpm) {
-                    memoireRoot = await cloneAndBuild(s, isJson);
-                    await startFromSource(s, isJson, memoireRoot, dbUrl, dbUrlDirect, apiPort, openaiKey, anthropicKey);
-                    apiReachable = await checkApiHealth(apiUrl);
-                }
+                p.log.warn('Could not locate Memoire monorepo root. Skipping API start.');
             }
         }
     }
@@ -662,6 +491,7 @@ export async function runSetupWizard(flags = {}) {
             apiUrl,
             setupToken: flags.setupToken,
             inviteToken: flags.inviteToken,
+            inviteCode: joinInviteCode ?? flags.inviteCode,
             orgName,
             orgSlug: flags.orgSlug,
             projectName,
@@ -681,43 +511,10 @@ export async function runSetupWizard(flags = {}) {
                 s.stop('Workspace bootstrapped');
         }
         catch (err) {
-            const msg = err instanceof Error ? err.message : 'unknown error';
-            // If bootstrap is disabled (workspace already exists), fall back to existing config
-            if (msg.includes('Bootstrap is disabled') || msg.includes('403')) {
-                if (!isJson)
-                    s.stop('Workspace already exists');
-                if (existingConfig?.api_key && existingConfig?.org_id) {
-                    if (!isJson)
-                        p.log.info('Using existing workspace credentials.');
-                    bootstrapResult = {
-                        org_id: existingConfig.org_id,
-                        project_id: existingConfig.project_id ?? '',
-                        token: existingConfig.api_key,
-                        user_id: existingConfig.user_id ?? '',
-                    };
-                    // Install for the first agent
-                    await install({
-                        client: firstAgent,
-                        apiKey: bootstrapResult.token,
-                        apiUrl,
-                        orgId: bootstrapResult.org_id,
-                        projectId: bootstrapResult.project_id || undefined,
-                        userName: flags.userName,
-                        userEmail: flags.userEmail,
-                    });
-                }
-                else {
-                    if (!isJson)
-                        p.log.error('Workspace exists but no local credentials found. Run `npx memoire-ai login` to authenticate.');
-                    process.exit(1);
-                }
-            }
-            else {
-                if (!isJson)
-                    s.stop('Bootstrap failed');
-                p.log.error(`Failed to bootstrap workspace: ${msg}`);
-                process.exit(1);
-            }
+            if (!isJson)
+                s.stop('Bootstrap failed');
+            p.log.error(`Failed to bootstrap workspace: ${err instanceof Error ? err.message : 'unknown error'}`);
+            process.exit(1);
         }
     }
     // -----------------------------------------------------------------------
@@ -750,10 +547,9 @@ export async function runSetupWizard(flags = {}) {
     }
     // -----------------------------------------------------------------------
     // Phase 11: Start dashboard (self-host only)
-    // Docker users already have dashboard running from docker compose up.
     // -----------------------------------------------------------------------
     let dashboardUrl = null;
-    if (!isCloud && !flags.skipStart && apiReachable) {
+    if (!isCloud && !flags.skipStart) {
         const dashPort = flags.dashboardPort ?? DEFAULT_DASHBOARD_PORT;
         const dashPortFree = await isPortAvailable(dashPort);
         if (!dashPortFree) {
@@ -762,34 +558,23 @@ export async function runSetupWizard(flags = {}) {
                 p.log.info(`Dashboard already running at ${dashboardUrl}`);
         }
         else {
-            // Try to start dashboard from local source
-            const memoireRoot = findMemoireRoot() ?? join(homedir(), '.memoire', 'server');
-            const dashboardBuild = join(memoireRoot, 'apps', 'dashboard', 'dist', 'server.js');
-            if (existsSync(dashboardBuild)) {
+            const memoireRoot = findMemoireRoot();
+            if (memoireRoot) {
                 if (!isJson)
                     s.start('Starting dashboard...');
-                const child = spawn('node', [dashboardBuild], {
-                    cwd: join(memoireRoot, 'apps', 'dashboard'),
+                const configPath = join(homedir(), '.memoire', 'config.json');
+                const child = spawn('npx', ['memoire', 'dashboard', '--port', String(dashPort), '--config-path', configPath], {
+                    cwd: memoireRoot,
                     detached: true,
                     stdio: 'ignore',
-                    env: {
-                        ...process.env,
-                        MEMOIRE_API_URL: apiUrl,
-                        MEMOIRE_DASHBOARD_DEFAULT_API_URL: apiUrl,
-                        PORT: String(dashPort),
-                        NODE_ENV: 'production',
-                    },
                 });
                 child.unref();
                 dashboardUrl = `http://localhost:${dashPort}`;
-                await new Promise((resolve) => setTimeout(resolve, 3000));
+                // Wait briefly for dashboard to start
+                await new Promise((resolve) => setTimeout(resolve, 2000));
                 if (!isJson)
                     s.stop(`Dashboard starting at ${dashboardUrl}`);
             }
-            else {
-                if (!isJson)
-                    p.log.info('Dashboard not built — run `pnpm --filter @memoire-ai/dashboard build` to enable it');
-            }
         }
     }
     else if (isCloud) {