create-memory-soda 0.2.0 → 0.4.0

package/README.md

@@ -1,37 +1,39 @@
 # create-memory-soda
 
 Scaffold a self-hosted [Memory Soda](https://github.com/alagappan17/memory-soda)
-instance — API, dashboard, SDK, and a Postgres to point them at.
+instance — API, dashboard, and a Postgres to point them at.
 
 ```bash
 npm create memory-soda@latest
 ```
 
-It asks for a folder name, a Gemini API key, your Postgres connection string,
-which ports to use, and the dashboard admin login. Then it clones the repo,
-writes `.env`, installs dependencies, creates the database if it is missing,
-and verifies pgvector is available. Clone and install run behind a spinner;
-pass `--verbose` to stream their full output instead.
+The installer checks each requirement before asking you to use it, creates
+what it can, and ends with a checklist of anything it could not do for you.
+
+1. **Preflight** — Node 20+ and git. Missing? Prints the install command for
+   your OS and stops. Nothing is written.
+2. **Folder** — `memory-soda` by default.
+3. **Postgres** — bring your own URL, let it start `pgvector/pgvector:pg16` in
+   Docker (offered when Docker is running), or skip.
+4. **Database check** — connects, offers to create a missing database,
+   confirms pgvector and enables the extension. Failures name the fix and let
+   you retry, paste another URL, or skip.
+5. **Gemini key** — checked live. Blank allowed; goes on the checklist.
+6. **Ports** — checked for use. Dashboard login starts as `admin` /
+   `open-sesame`; change it after signing in.
+7. **Clone, `.env`, `npm ci`, migrations** — migrations run now if the database
+   passed.
+
+Then:
 
 ```bash
 cd memory-soda
 npm run dev
 ```
 
-First boot applies migrations, creates your admin user, and prints an API key
-once. Dashboard on :3000, API on :3004.
-
-## Postgres
-
-You bring the server; the installer creates the database. It asks for a
-`DATABASE_URL`, probes the host and port while you are still at the prompt, and
-after install connects for real. A missing database is created for you (the
-role in the URL needs `CREATEDB`). Anything else — server down, bad password,
-no pgvector — names the fix and lets you retry without starting over.
-
-The role in the URL needs permission to `CREATE EXTENSION vector` — the first
-migration creates the extension. On most installations that means a superuser.
+Sign in to the dashboard (:3000) to create an API key. `npm run update` pulls
+and reinstalls later. Pass `--verbose` to stream clone/install output.
 
 ## Requirements
 
-Node 20+, git, and a Postgres 14+ with the pgvector extension available.
+Node 20+, git. Postgres 14+ with pgvector, or Docker.

package/index.js

@@ -1,16 +1,18 @@
 #!/usr/bin/env node
 import { spawn, execFileSync } from 'node:child_process';
-import { existsSync, readdirSync, writeFileSync, rmSync, realpathSync } from 'node:fs';
-import { resolve, basename, join } from 'node:path';
-import { createRequire } from 'node:module';
+import { existsSync, readdirSync, writeFileSync, realpathSync } from 'node:fs';
+import { resolve, basename } from 'node:path';
 import { connect } from 'node:net';
-import { exit } from 'node:process';
+import { exit, platform } from 'node:process';
 import { pathToFileURL } from 'node:url';
+import { randomBytes } from 'node:crypto';
 import * as p from '@clack/prompts';
 import chalk from 'chalk';
+import pg from 'pg';
 
 const REPO = 'https://github.com/alagappan17/memory-soda.git';
 const DEFAULT_DB = 'postgresql://localhost:5432/memory_db';
+const DOCKER_IMAGE = 'pgvector/pgvector:pg16';
 const VERBOSE = process.argv.includes('--verbose');
 
 function die(msg) {
@@ -27,7 +29,11 @@ function guard(value) {
 /** Run a command quietly, returning stdout — or null if it failed or is missing. */
 function tryRun(cmd, args, opts = {}) {
   try {
-    return execFileSync(cmd, args, { encoding: 'utf8', stdio: 'pipe', ...opts });
+    return execFileSync(cmd, args, {
+      encoding: 'utf8',
+      stdio: 'pipe',
+      ...opts,
+    });
   } catch {
     return null;
   }
@@ -63,7 +69,11 @@ function runWithSpinner(title, cmd, args, { cwd } = {}) {
       if (code === 0) return s.stop(title) ?? done();
       s.stop(`${title} — failed`, 1);
       p.log.error(log.trim().split('\n').slice(-20).join('\n'));
-      fail(new Error(`${cmd} ${args.join(' ')} exited with ${code}. Re-run with --verbose for the full log.`));
+      fail(
+        new Error(
+          `${cmd} ${args.join(' ')} exited with ${code}. Re-run with --verbose for the full log.`,
+        ),
+      );
     });
   });
 }
@@ -73,8 +83,8 @@ function runWithSpinner(title, cmd, args, { cwd } = {}) {
  * explicitly — everything else stays on the defaults baked into config.ts, so
  * this file does not drift every time a new option is added there.
  */
-export function renderEnv({ databaseUrl, geminiKey, adminUser, adminPassword, apiPort, dashboardPort }) {
-  const lines = [
+export function renderEnv({ databaseUrl, geminiKey, apiPort, dashboardPort }) {
+  return [
     '# Generated by create-memory-soda.',
     '# Full reference: https://github.com/alagappan17/memory-soda',
     '',
@@ -91,15 +101,11 @@ export function renderEnv({ databaseUrl, geminiKey, adminUser, adminPassword, ap
     `CORS_ORIGIN=http://localhost:${dashboardPort}`,
     `VITE_API_URL=http://localhost:${apiPort}`,
     '',
-    '# Dashboard login, created once on first boot.',
-    `ADMIN_USERNAME=${adminUser}`,
-  ];
-  // An unset ADMIN_PASSWORD makes the API generate one and print it once. That
-  // is a better default than writing a weak chosen password to disk, so a blank
-  // answer omits the key entirely rather than writing an empty one.
-  if (adminPassword) lines.push(`ADMIN_PASSWORD=${adminPassword}`);
-  lines.push('');
-  return lines.join('\n');
+    '# Dashboard login. Defaults to admin / open-sesame — change it in the dashboard after first sign-in.',
+    '# ADMIN_USERNAME=admin',
+    '# ADMIN_PASSWORD=open-sesame',
+    '',
+  ].join('\n');
 }
 
 /** True if the path is safe to scaffold into: missing, or an empty directory. */
@@ -137,62 +143,82 @@ function isReachable({ host, port }, timeout = 2000) {
   });
 }
 
-function loadPg(target) {
-  const require = createRequire(pathToFileURL(join(target, 'package.json')));
-  return require('pg').Client;
-}
+const dbName = (databaseUrl) =>
+  decodeURIComponent(new URL(databaseUrl).pathname.slice(1));
 
 /** Create the database named in the URL by connecting to the maintenance db on the same server. */
-async function createDatabase(target, databaseUrl) {
-  const Client = loadPg(target);
+async function createDatabase(databaseUrl) {
   const url = new URL(databaseUrl);
-  const db = decodeURIComponent(url.pathname.slice(1));
   url.pathname = '/postgres';
-  const client = new Client({ connectionString: url.href });
+  const client = new pg.Client({ connectionString: url.href });
   try {
     await client.connect();
-    await client.query(`CREATE DATABASE "${db.replaceAll('"', '""')}"`);
+    await client.query(
+      `CREATE DATABASE "${dbName(databaseUrl).replaceAll('"', '""')}"`,
+    );
   } finally {
     await client.end().catch(() => {});
   }
 }
 
+/** OS-specific hint for a pgvector install, matched to the server's major version. */
+function pgvectorHint(serverMajor) {
+  if (platform === 'darwin') return 'brew install pgvector';
+  if (platform === 'linux')
+    return `sudo apt install postgresql-${serverMajor}-pgvector`;
+  return 'see https://github.com/pgvector/pgvector#installation';
+}
+
 /**
- * Connect for real and confirm pgvector is installable, using the `pg` copy
- * inside the freshly installed project so the installer needs no database
- * driver of its own. Returns null on success, or an operator-readable problem.
+ * Connect for real, confirm pgvector is installable, and enable it. Returns
+ * null on success, or an operator-readable { problem, fix, ...flags }.
  */
-export async function checkDatabase(target, databaseUrl) {
-  let Client;
-  try {
-    Client = loadPg(target);
-  } catch {
-    return { skipped: 'could not load pg from the new project' };
-  }
-
-  const client = new Client({ connectionString: databaseUrl });
+export async function checkDatabase(databaseUrl) {
+  const addr = parsePostgresUrl(databaseUrl) ?? { host: '?', port: '?' };
+  const client = new pg.Client({ connectionString: databaseUrl });
   try {
     await client.connect();
-    const { rows } = await client.query("SELECT 1 FROM pg_available_extensions WHERE name = 'vector'");
+    const { rows } = await client.query(
+      "SELECT 1 FROM pg_available_extensions WHERE name = 'vector'",
+    );
     if (rows.length === 0) {
+      const major = (
+        await client.query('SHOW server_version')
+      ).rows[0].server_version.split('.')[0];
       return {
         problem: 'pgvector is not available on this server',
-        fix: 'Install it — brew install pgvector, or apt install postgresql-16-pgvector — then retry.',
+        fix: `${pgvectorHint(major)}, restart Postgres, then retry. Or let the installer start a Docker Postgres that has it.`,
       };
     }
+    try {
+      await client.query('CREATE EXTENSION IF NOT EXISTS vector');
+    } catch (err) {
+      // Not fatal: the first migration retries this. Surface it as a to-do
+      // rather than blocking, since it usually just needs a superuser once.
+      if (err.code === '42501') return { extensionTodo: dbName(databaseUrl) };
+      throw err;
+    }
     return null;
   } catch (err) {
     if (err.code === '3D000') {
-      const db = decodeURIComponent(new URL(databaseUrl).pathname.slice(1));
-      return { problem: `database "${db}" does not exist`, fix: `createdb ${db}`, missingDb: db };
+      return {
+        problem: `database "${dbName(databaseUrl)}" does not exist`,
+        missingDb: dbName(databaseUrl),
+      };
     }
     if (err.code === '28P01' || err.code === '28000') {
-      return { problem: 'authentication failed', fix: 'Check the user and password in the URL.' };
+      return {
+        problem: 'authentication failed',
+        fix: 'Check the user and password in the URL.',
+      };
     }
-    if (err.code === 'ECONNREFUSED') {
+    if (err.code === 'ECONNREFUSED' || err.code === 'ENOTFOUND') {
       return {
-        problem: 'nothing is accepting connections at that host and port',
-        fix: 'Start Postgres — brew services start postgresql, or pg_ctl start.',
+        problem: `nothing is accepting connections at ${addr.host}:${addr.port}`,
+        fix:
+          platform === 'darwin'
+            ? 'brew services start postgresql@16 (or start your Postgres however you installed it).'
+            : 'sudo systemctl start postgresql (or start your Postgres however you installed it).',
       };
     }
     return { problem: err.message, fix: null };
@@ -201,119 +227,335 @@ export async function checkDatabase(target, databaseUrl) {
   }
 }
 
+/** Start a pgvector-enabled Postgres in Docker. Returns the DATABASE_URL, or throws. */
+async function startDockerPostgres() {
+  const password = randomBytes(12).toString('hex');
+  const name = 'memory-soda-pg';
+  // A stale container from a previous run would fail the `run` with a name
+  // clash; removing it is safe because it only ever held this installer's data.
+  tryRun('docker', ['rm', '-f', name]);
+  await runWithSpinner(
+    `Starting Postgres in Docker (${DOCKER_IMAGE})`,
+    'docker',
+    [
+      'run',
+      '-d',
+      '--name',
+      name,
+      '--restart',
+      'unless-stopped',
+      '-e',
+      `POSTGRES_PASSWORD=${password}`,
+      '-e',
+      'POSTGRES_DB=memory_db',
+      '-p',
+      '5432:5432',
+      DOCKER_IMAGE,
+    ],
+  );
+  const addr = { host: 'localhost', port: 5432 };
+  // Postgres takes a moment to accept connections after the container is up.
+  for (let i = 0; i < 20 && !(await isReachable(addr, 500)); i++)
+    await new Promise((r) => setTimeout(r, 500));
+  return `postgresql://postgres:${password}@localhost:5432/memory_db`;
+}
+
+/** A cheap live check that the Gemini key is accepted. null = ok, string = why not. */
+export async function checkGeminiKey(key) {
+  try {
+    const res = await fetch(
+      'https://generativelanguage.googleapis.com/v1beta/models?pageSize=1',
+      {
+        headers: { 'x-goog-api-key': key },
+        signal: AbortSignal.timeout(8000),
+      },
+    );
+    if (res.ok) return null;
+    if (res.status === 400 || res.status === 403)
+      return 'Gemini rejected that key.';
+    return `Gemini answered ${res.status}.`;
+  } catch {
+    return 'could not reach Gemini (offline?)';
+  }
+}
+
 const validPort = (v) => {
   if (!v) return; // blank takes the default
   const n = Number(v);
-  if (!Number.isInteger(n) || n < 1 || n > 65535) return 'Enter a port between 1 and 65535.';
+  if (!Number.isInteger(n) || n < 1 || n > 65535)
+    return 'Enter a port between 1 and 65535.';
 };
 
+async function askPort(message, defaultValue) {
+  for (;;) {
+    const port = Number(
+      guard(
+        await p.text({
+          message,
+          placeholder: defaultValue,
+          defaultValue,
+          validate: validPort,
+        }),
+      ),
+    );
+    if (!(await isReachable({ host: '127.0.0.1', port }, 300))) return port;
+    p.log.warn(`Port ${port} is already in use.`);
+  }
+}
+
 async function main() {
+  // ── 0. Preflight: check and tell, never install. System packages are the
+  // user's call; we only ever run things inside the folder we create.
   if (Number(process.versions.node.split('.')[0]) < 20) {
-    die(`Node 20 or newer is required — you are on ${process.versions.node}.`);
+    die(
+      `Node 20 or newer is required — you are on ${process.versions.node}.\n  ` +
+        (tryRun('nvm', ['--version'])
+          ? 'nvm install 22 && nvm use 22'
+          : 'https://nodejs.org or brew install node') +
+        '\n  then re-run: npm create memory-soda@latest',
+    );
+  }
+  if (!tryRun('git', ['--version'])) {
+    die(
+      'git is required but was not found.\n  ' +
+        (platform === 'darwin'
+          ? 'xcode-select --install'
+          : 'sudo apt install git') +
+        '\n  then re-run: npm create memory-soda@latest',
+    );
   }
-  if (!tryRun('git', ['--version'])) die('git is required but was not found.');
+  const hasDocker = Boolean(tryRun('docker', ['info']));
 
-  console.log();
-  p.intro(`${chalk.bgCyan.black(' Memory Soda ')} ${chalk.dim('self-hosted memory for AI agents')}`);
+  p.intro(chalk.bold('create-memory-soda'));
+  const todo = []; // things the user must do themselves before the app runs
 
-  const dirArg = process.argv.slice(2).find((a) => !a.startsWith('-'));
+  // ── 1. Folder
   const dirName =
-    dirArg ||
+    process.argv.slice(2).find((a) => !a.startsWith('-')) ??
     guard(
       await p.text({
-        message: 'Where should we create your project?',
+        message: 'Project folder',
         placeholder: 'memory-soda',
         defaultValue: 'memory-soda',
         validate: (v) =>
-          isUsableTarget(resolve(process.cwd(), v || 'memory-soda')) ? undefined : 'That folder exists and is not empty.',
+          isUsableTarget(resolve(process.cwd(), v || 'memory-soda'))
+            ? undefined
+            : 'That folder exists and is not empty.',
       }),
     );
   const target = resolve(process.cwd(), dirName);
-  if (!isUsableTarget(target)) die(`${target} already exists and is not empty.`);
+  if (!isUsableTarget(target))
+    die(`${target} already exists and is not empty.`);
 
-  const geminiKey = guard(
-    await p.password({
-      message: `Gemini API key ${chalk.dim('(aistudio.google.com — required for the memory layer, leave blank to add to .env later)')}`,
-      mask: '•',
-    }),
-  ) ?? '';
-  if (!geminiKey) p.log.warn('No key given. Memory extraction and search will not work until GOOGLE_GENERATIVE_AI_API_KEY is set in .env.');
-
-  let databaseUrl = guard(
-    await p.text({
-      message: `Postgres URL ${chalk.dim('(bring your own — pgvector must be installed; the database itself is created for you)')}`,
-      placeholder: DEFAULT_DB,
-      defaultValue: DEFAULT_DB,
-      validate: (v) => (v && !parsePostgresUrl(v) ? 'Expected a postgres:// URL.' : undefined),
+  // ── 2 + 3. Postgres: where is it, then verify it until it works or is skipped.
+  let databaseUrl = DEFAULT_DB;
+  let dbReady = false;
+  const where = guard(
+    await p.select({
+      message: 'Where is Postgres?',
+      options: [
+        {
+          value: 'own',
+          label: 'I have one',
+          hint: 'you give the URL; pgvector must be installed on it',
+        },
+        ...(hasDocker
+          ? [
+              {
+                value: 'docker',
+                label: 'Start one in Docker for me',
+                hint: DOCKER_IMAGE,
+              },
+            ]
+          : []),
+        {
+          value: 'skip',
+          label: 'Skip',
+          hint: 'set DATABASE_URL in .env yourself later',
+        },
+      ],
     }),
   );
-  const addr = parsePostgresUrl(databaseUrl);
-  if (addr && !(await isReachable(addr))) {
-    // Only a warning: the server may legitimately be starting, or firewalled
-    // from here but reachable from wherever the app will actually run.
-    p.log.warn(`Nothing is listening on ${addr.host}:${addr.port} right now — checked again after install.`);
+  if (where === 'docker') {
+    try {
+      databaseUrl = await startDockerPostgres();
+    } catch (err) {
+      p.log.error(err.message);
+    }
+  } else if (where === 'own') {
+    databaseUrl = guard(
+      await p.text({
+        message: 'Postgres URL',
+        placeholder: DEFAULT_DB,
+        defaultValue: DEFAULT_DB,
+        validate: (v) =>
+          v && !parsePostgresUrl(v) ? 'Expected a postgres:// URL.' : undefined,
+      }),
+    );
+  }
+  if (where !== 'skip') {
+    for (;;) {
+      // A clack spinner cannot be restarted once stopped (its timer leaks and
+      // the process never exits), so every phase gets a fresh one.
+      let s = p.spinner();
+      s.start('Checking the database');
+      let result = await checkDatabase(databaseUrl);
+      if (result?.missingDb) {
+        s.stop(`Database "${result.missingDb}" does not exist`);
+        if (
+          !guard(
+            await p.confirm({
+              message: `Create database "${result.missingDb}"?`,
+              initialValue: true,
+            }),
+          )
+        ) {
+          todo.push(`createdb ${result.missingDb}`);
+          break;
+        }
+        s = p.spinner();
+        s.start(`Creating database ${result.missingDb}`);
+        try {
+          await createDatabase(databaseUrl);
+          result = await checkDatabase(databaseUrl);
+        } catch (err) {
+          result = {
+            problem: `could not create database "${result.missingDb}": ${err.message}`,
+            fix: `createdb ${result.missingDb}  (as a role with CREATEDB)`,
+          };
+        }
+      }
+      if (result === null) {
+        s.stop('Database ready — connected, pgvector enabled');
+        dbReady = true;
+        break;
+      }
+      if (result.extensionTodo) {
+        s.stop('Database connected, but this role cannot enable pgvector', 1);
+        todo.push(
+          `psql -d ${result.extensionTodo} -c "CREATE EXTENSION vector"   (run as a Postgres superuser)`,
+        );
+        break;
+      }
+      s.stop(`Database: ${result.problem}`, 1);
+      if (result.fix) p.log.info(result.fix);
+      const retry =
+        guard(
+          await p.text({
+            message:
+              'Fix it and press enter to retry, paste a new DATABASE_URL, or type s to skip',
+            placeholder: 'enter to retry',
+          }),
+        ) ?? '';
+      if (retry.toLowerCase() === 's') break;
+      if (retry) databaseUrl = retry;
+    }
+  }
+  if (!dbReady && todo.length === 0) {
+    todo.push(
+      `Point DATABASE_URL in .env at a Postgres with pgvector, and create the database (createdb ${dbName(databaseUrl)})`,
+    );
   }
 
-  const apiPort = Number(guard(await p.text({ message: 'API port', placeholder: '3004', defaultValue: '3004', validate: validPort })));
-  const dashboardPort = Number(
-    guard(await p.text({ message: 'Dashboard port', placeholder: '3000', defaultValue: '3000', validate: validPort })),
-  );
-  const adminUser = guard(await p.text({ message: 'Dashboard admin username', placeholder: 'admin', defaultValue: 'admin' }));
-  const adminPassword =
-    guard(await p.password({ message: `Dashboard admin password ${chalk.dim('(leave blank to generate one at first boot)')}`, mask: '•' })) ?? '';
-
-  await runWithSpinner(`Cloning into ${chalk.bold(dirName)}`, 'git', ['clone', '--depth', '1', REPO, target]);
-  rmSync(resolve(target, '.git'), { recursive: true, force: true });
-
-  const writeEnv = () =>
-    writeFileSync(resolve(target, '.env'), renderEnv({ databaseUrl, geminiKey, adminUser, adminPassword, apiPort, dashboardPort }));
-  writeEnv();
-  p.log.success('Wrote .env');
-
-  await runWithSpinner('Installing dependencies', 'npm', ['ci', '--no-audit', '--no-fund'], { cwd: target });
-
-  // Now that pg exists in the project, check the database for real. Looping
-  // here beats failing at first boot: the fix is usually one command away and
-  // the answer is still in front of the user.
+  // ── 4. Gemini
+  let geminiKey = '';
   for (;;) {
+    geminiKey =
+      guard(
+        await p.password({
+          message: `Gemini API key ${chalk.dim('(aistudio.google.com — leave blank to add later)')}`,
+          mask: '•',
+        }),
+      ) ?? '';
+    if (!geminiKey) break;
     const s = p.spinner();
-    s.start('Checking the database');
-    let result = await checkDatabase(target, databaseUrl);
-    if (result?.missingDb) {
-      s.message(`Creating database ${result.missingDb}`);
-      try {
-        await createDatabase(target, databaseUrl);
-        result = await checkDatabase(target, databaseUrl);
-      } catch (err) {
-        result = { problem: `could not create database "${result.missingDb}": ${err.message}`, fix: result.fix };
-      }
-    }
-    if (result === null) {
-      s.stop('Database ready — connected, pgvector available');
+    s.start('Checking the key');
+    const problem = await checkGeminiKey(geminiKey);
+    if (!problem) {
+      s.stop('Gemini key accepted');
       break;
     }
-    if (result.skipped) {
-      s.stop(`Database check skipped — ${result.skipped}`, 1);
+    s.stop(problem, 1);
+    if (
+      guard(
+        await p.confirm({ message: 'Keep it anyway?', initialValue: false }),
+      )
+    )
       break;
+  }
+  if (!geminiKey)
+    todo.push(
+      'Set GOOGLE_GENERATIVE_AI_API_KEY in .env — the API refuses to start without it',
+    );
+
+  // ── 5. Ports
+  const apiPort = await askPort('API port', '3004');
+  const dashboardPort = await askPort('Dashboard port', '3000');
+  // ── 7. Install
+  await runWithSpinner(`Cloning into ${chalk.bold(dirName)}`, 'git', [
+    'clone',
+    '--depth',
+    '1',
+    REPO,
+    target,
+  ]);
+  writeFileSync(
+    resolve(target, '.env'),
+    renderEnv({
+      databaseUrl,
+      geminiKey,
+      apiPort,
+      dashboardPort,
+    }),
+  );
+  p.log.success('Wrote .env');
+  await runWithSpinner(
+    'Installing dependencies',
+    'npm',
+    ['ci', '--no-audit', '--no-fund'],
+    { cwd: target },
+  );
+
+  let migrated = false;
+  if (dbReady) {
+    try {
+      await runWithSpinner(
+        'Applying migrations',
+        'npm',
+        ['run', 'db:migrate'],
+        { cwd: target },
+      );
+      migrated = true;
+    } catch {
+      todo.push(
+        'npm run db:migrate   (failed during install — see the log above)',
+      );
     }
-    s.stop(`Database: ${result.problem}`, 1);
-    if (result.fix) p.log.info(result.fix);
-    const retry = guard(
-      await p.text({
-        message: 'Fix it and press enter to retry, paste a new DATABASE_URL, or type s to skip',
-        placeholder: 'enter to retry',
-      }),
-    ) ?? '';
-    if (retry.toLowerCase() === 's') {
-      p.log.warn('Skipped — the API will fail on boot until this is resolved.');
-      break;
-    }
-    if (retry) {
-      databaseUrl = retry;
-      writeEnv();
-    }
+  } else {
+    todo.push('npm run db:migrate   (once the database is ready)');
   }
 
+  // ── 8. Summary
+  const tick = (ok, text) =>
+    `${ok ? chalk.green('✓') : chalk.yellow('✗')} ${text}`;
+  p.note(
+    [
+      tick(
+        dbReady,
+        dbReady
+          ? `Postgres  ${databaseUrl.replace(/:[^:@/]+@/, ':•••@')}`
+          : 'Postgres  not verified',
+      ),
+      tick(
+        Boolean(geminiKey),
+        geminiKey ? 'Gemini key set' : 'Gemini key missing',
+      ),
+      tick(migrated, migrated ? 'Migrations applied' : 'Migrations pending'),
+    ].join('\n'),
+    'Status',
+  );
+  if (todo.length)
+    p.note(todo.map((t, i) => `${i + 1}. ${t}`).join('\n'), 'Before you run');
   p.note(
     [
       `cd ${dirName}`,
@@ -321,14 +563,16 @@ async function main() {
       '',
       `Dashboard  ${chalk.underline(`http://localhost:${dashboardPort}`)}`,
       `API        ${chalk.underline(`http://localhost:${apiPort}`)}`,
-      `Login      ${adminUser} / ${adminPassword ? 'the password you chose' : 'password printed at first boot'}`,
+      `Login      ${chalk.bold('admin')} / ${chalk.bold('open-sesame')}  ${chalk.dim('← change it under Settings after signing in')}`,
       '',
-      'First boot applies migrations and prints your API key once.',
-      ...(geminiKey ? [] : ['Set GOOGLE_GENERATIVE_AI_API_KEY in .env before starting.']),
+      'Then sign in, create an API key, and: npm install @memory-soda/sdk',
     ].join('\n'),
-    'Next steps',
+    'Run',
   );
-  p.outro(`${chalk.bold(basename(target))} is ready.`);
+  p.outro(
+    `Thanks for trying Memory Soda — ${chalk.bold(basename(target))} is ready.`,
+  );
+  exit(0);
 }
 
 /**
@@ -339,7 +583,9 @@ async function main() {
 function isEntryPoint() {
   if (!process.argv[1]) return false;
   try {
-    return import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href;
+    return (
+      import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href
+    );
   } catch {
     return false;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-memory-soda",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Scaffold a self-hosted Memory Soda instance — API, dashboard, and Postgres",
   "keywords": [
     "ai",
@@ -37,6 +37,7 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.7.0",
-    "chalk": "^5.6.2"
+    "chalk": "^5.6.2",
+    "pg": "^8.23.0"
   }
 }