dev-prism 0.1.0 → 0.2.0

package/README.md

@@ -1,5 +1,9 @@
 # dev-prism
 
+<p align="center">
+  <img src="banner.png" alt="dev-prism - One codebase, many parallel sessions" width="600">
+</p>
+
 A minimal CLI tool for managing isolated parallel development sessions. Enables multiple Claude Code (or human developer) sessions to work on the same repo simultaneously with complete isolation.
 
 ## Philosophy
@@ -85,36 +89,50 @@ With base port 47000:
 
 | Service        | Session 001 | Session 002 | Session 003 |
 |----------------|-------------|-------------|-------------|
-| CONVAS_APP_PORT| 47100       | 47200       | 47300       |
-| CONVAS_WEB_PORT| 47101       | 47201       | 47301       |
+| APP_PORT       | 47100       | 47200       | 47300       |
+| WEB_PORT       | 47101       | 47201       | 47301       |
 | POSTGRES_PORT  | 47110       | 47210       | 47310       |
 | MAILPIT_SMTP   | 47111       | 47211       | 47311       |
 | MAILPIT_WEB    | 47112       | 47212       | 47312       |
 
 ## Configuration
 
-### session.config.mjs (minimal)
+### session.config.mjs
 
 ```javascript
 export default {
+  // Required
   portBase: 47000,
   sessionsDir: '../my-project-sessions',
 
   // Port offsets - become env vars for docker-compose
+  // Formula: portBase + (sessionId * 100) + offset
   ports: {
-    POSTGRES_PORT: 10,
-    REDIS_PORT: 11,
-    APP_PORT: 0,
+    APP_PORT: 0,        // 47100, 47200, 47300...
+    WEB_PORT: 1,        // 47101, 47201, 47301...
+    POSTGRES_PORT: 10,  // 47110, 47210, 47310...
+    REDIS_PORT: 11,     // 47111, 47211, 47311...
   },
 
-  // Optional: app-specific env for CLI commands from host
+  // Docker Compose profiles for app containers (used in docker mode)
+  // These match service names with `profiles: ["app-name"]` in docker-compose
+  apps: ['app', 'web'],
+
+  // .env files to copy to session worktree (DATABASE_URL auto-updated)
+  envFiles: [
+    'apps/my-app/.env',
+    'packages/db/.env',
+  ],
+
+  // Commands to run after session creation
+  setup: ['pnpm install', 'pnpm db:push'],
+
+  // Optional: app-specific env for CLI commands from host (native mode)
   appEnv: {
     'apps/my-app': {
       DATABASE_URL: 'postgresql://postgres:postgres@localhost:${POSTGRES_PORT}/postgres',
     },
   },
-
-  setup: ['pnpm install', 'pnpm db:push'],
 };
 ```
 
@@ -179,7 +197,7 @@ SESSION_ID=001
 POSTGRES_PORT=47110
 MAILPIT_SMTP_PORT=47111
 MAILPIT_WEB_PORT=47112
-CONVAS_APP_PORT=47100
+APP_PORT=47100
 ```
 
 ## Portability

package/bin/dev-prism.js

@@ -115,7 +115,7 @@ program
     const sessionDir = getSessionDir(config, projectRoot, sessionId);
     let profiles;
     if (options.mode === 'docker') {
-      const allApps = config.apps ?? ['app', 'web', 'widget'];
+      const allApps = config.apps ?? [];
       const excludeApps = options.without ?? [];
       profiles = allApps.filter((app) => !excludeApps.includes(app));
     }
@@ -157,7 +157,7 @@ program
     const sessionDir = getSessionDir(config, projectRoot, sessionId);
     let profileFlags = [];
     if (options.mode === 'docker') {
-      const allApps = config.apps ?? ['app', 'web', 'widget'];
+      const allApps = config.apps ?? [];
       const excludeApps = options.without ?? [];
       const profiles = allApps.filter((app) => !excludeApps.includes(app));
       profileFlags = profiles.flatMap((p) => ['--profile', p]);
@@ -216,10 +216,10 @@ program
     console.log(chalk.blue(`Stopping ${runningSessions.length} running session(s)...\n`));
 
     // Get all app profiles and service names to ensure we stop everything
-    const allApps = config.apps ?? ['app', 'web', 'widget'];
+    const allApps = config.apps ?? [];
     const profileFlags = allApps.flatMap((p) => ['--profile', p]);
     // Explicitly list all services to stop (infrastructure + apps)
-    const allServices = ['postgres', 'mailpit', 'convas-app', 'convas-web', 'convas-widget'];
+    const allServices = ['postgres', 'mailpit', ...allApps];
 
     const { execa } = await import('execa');
     for (const session of runningSessions) {

package/dist/chunk-35SHBLIZ.js

@@ -0,0 +1,69 @@
+import {
+  calculatePorts
+} from "./chunk-PJKUD2N2.js";
+import {
+  getSessionWorktrees
+} from "./chunk-GWDGC2OE.js";
+import {
+  loadConfig
+} from "./chunk-25WQHUYW.js";
+import {
+  isRunning
+} from "./chunk-GBN67HYD.js";
+
+// src/commands/list.ts
+import { existsSync } from "fs";
+import { resolve } from "path";
+import chalk from "chalk";
+async function listSessions(projectRoot) {
+  const config = await loadConfig(projectRoot);
+  const sessions = await getSessionWorktrees(projectRoot);
+  if (sessions.length === 0) {
+    console.log(chalk.gray("No active sessions found."));
+    console.log(chalk.gray("\nTo create a session:"));
+    console.log(chalk.cyan("  dev-prism create"));
+    return;
+  }
+  console.log(chalk.blue("Active Sessions:"));
+  console.log(chalk.gray("================\n"));
+  for (const session of sessions) {
+    const status = await getSessionStatus(session.sessionId, session.path, session.branch, config);
+    printSessionStatus(status);
+  }
+}
+async function getSessionStatus(sessionId, path, branch, config) {
+  const ports = calculatePorts(config, sessionId);
+  let running = false;
+  const envFile = resolve(path, ".env.session");
+  if (existsSync(envFile)) {
+    running = await isRunning({ cwd: path });
+  }
+  return {
+    sessionId,
+    path,
+    branch,
+    running,
+    ports
+  };
+}
+function printSessionStatus(status) {
+  const statusIcon = status.running ? chalk.green("\u25CF") : chalk.red("\u25CB");
+  const statusText = status.running ? chalk.green("running") : chalk.gray("stopped");
+  console.log(`${statusIcon} Session ${chalk.bold(status.sessionId)} ${statusText}`);
+  console.log(chalk.gray(`  Path: ${status.path}`));
+  console.log(chalk.gray(`  Branch: ${status.branch}`));
+  console.log(chalk.gray("  Ports:"));
+  for (const [name, port] of Object.entries(status.ports)) {
+    const isApp = name.includes("APP") || name.includes("WEB") || name.includes("WIDGET");
+    if (isApp) {
+      console.log(chalk.gray(`    ${name}: http://localhost:${port}`));
+    } else {
+      console.log(chalk.gray(`    ${name}: ${port}`));
+    }
+  }
+  console.log("");
+}
+
+export {
+  listSessions
+};

package/dist/chunk-5KDDYO6Y.js

@@ -0,0 +1,168 @@
+import {
+  calculatePorts,
+  formatPortsTable
+} from "./chunk-PJKUD2N2.js";
+import {
+  createWorktree,
+  findNextSessionId,
+  generateDefaultBranchName
+} from "./chunk-GWDGC2OE.js";
+import {
+  getSessionDir,
+  getSessionsDir,
+  loadConfig
+} from "./chunk-25WQHUYW.js";
+import {
+  logs,
+  up
+} from "./chunk-VR3QWHHB.js";
+import {
+  writeAppEnvFiles,
+  writeEnvFile
+} from "./chunk-LEHA65A7.js";
+
+// src/commands/create.ts
+import { existsSync, mkdirSync, copyFileSync, readFileSync, writeFileSync } from "fs";
+import { basename, join } from "path";
+import chalk from "chalk";
+import { execa } from "execa";
+function updateEnvDatabaseUrl(envPath, newDbUrl) {
+  if (!existsSync(envPath)) return;
+  let content = readFileSync(envPath, "utf-8");
+  if (content.includes("DATABASE_URL=")) {
+    content = content.replace(/^DATABASE_URL=.*/m, `DATABASE_URL=${newDbUrl}`);
+  } else {
+    content += `
+DATABASE_URL=${newDbUrl}
+`;
+  }
+  writeFileSync(envPath, content);
+}
+async function createSession(projectRoot, sessionId, options) {
+  const config = await loadConfig(projectRoot);
+  const sessionsDir = getSessionsDir(config, projectRoot);
+  if (!sessionId) {
+    sessionId = await findNextSessionId(projectRoot, sessionsDir);
+    console.log(chalk.gray(`Auto-assigned session ID: ${sessionId}`));
+  }
+  if (!/^\d{3}$/.test(sessionId)) {
+    console.error(chalk.red("Error: Session ID must be exactly 3 digits (001-999)"));
+    process.exit(1);
+  }
+  const inPlace = options.inPlace ?? false;
+  const branchName = options.branch || generateDefaultBranchName(sessionId);
+  const mode = options.mode || "docker";
+  console.log(chalk.blue(`Creating session ${sessionId} (${mode} mode${inPlace ? ", in-place" : ""})...`));
+  if (!inPlace) {
+    console.log(chalk.gray(`Branch: ${branchName}`));
+  }
+  const ports = calculatePorts(config, sessionId);
+  console.log(chalk.gray("\nPorts:"));
+  console.log(chalk.gray(formatPortsTable(ports)));
+  let sessionDir;
+  if (inPlace) {
+    sessionDir = projectRoot;
+    console.log(chalk.blue("\nUsing current directory (in-place mode)..."));
+    console.log(chalk.green(`  Directory: ${sessionDir}`));
+  } else {
+    if (!existsSync(sessionsDir)) {
+      mkdirSync(sessionsDir, { recursive: true });
+    }
+    sessionDir = getSessionDir(config, projectRoot, sessionId);
+    console.log(chalk.blue("\nCreating git worktree..."));
+    await createWorktree(projectRoot, sessionDir, branchName);
+    console.log(chalk.green(`  Created: ${sessionDir}`));
+    const sessionDbUrl = `postgresql://postgres:postgres@localhost:${ports.POSTGRES_PORT}/postgres`;
+    const envFilesToCopy = config.envFiles ?? [];
+    for (const envFile of envFilesToCopy) {
+      const srcPath = join(projectRoot, envFile);
+      const destPath = join(sessionDir, envFile);
+      if (existsSync(srcPath)) {
+        copyFileSync(srcPath, destPath);
+        updateEnvDatabaseUrl(destPath, sessionDbUrl);
+        console.log(chalk.green(`  Copied: ${envFile} (updated DATABASE_URL)`));
+      }
+    }
+  }
+  console.log(chalk.blue("\nGenerating .env.session..."));
+  const projectName = config.projectName ?? basename(projectRoot);
+  const envPath = writeEnvFile(sessionDir, sessionId, ports, projectName);
+  console.log(chalk.green(`  Written: ${envPath}`));
+  const appEnvFiles = writeAppEnvFiles(config, sessionDir, sessionId, ports);
+  for (const file of appEnvFiles) {
+    console.log(chalk.green(`  Written: ${file}`));
+  }
+  console.log(chalk.blue("\nStarting Docker services..."));
+  let profiles;
+  if (mode === "docker") {
+    const allApps = config.apps ?? [];
+    const excludeApps = options.without ?? [];
+    profiles = allApps.filter((app) => !excludeApps.includes(app));
+    if (excludeApps.length > 0) {
+      console.log(chalk.gray(`  Excluding apps: ${excludeApps.join(", ")}`));
+    }
+  }
+  await up({ cwd: sessionDir, profiles });
+  console.log(chalk.blue("Waiting for services to be ready..."));
+  await new Promise((resolve) => setTimeout(resolve, 3e3));
+  if (config.setup.length > 0) {
+    console.log(chalk.blue("\nRunning setup commands..."));
+    const setupEnv = {
+      ...process.env,
+      SESSION_ID: sessionId,
+      // Add DATABASE_URL for db commands
+      DATABASE_URL: `postgresql://postgres:postgres@localhost:${ports.POSTGRES_PORT}/postgres`
+    };
+    for (const [name, port] of Object.entries(ports)) {
+      setupEnv[name] = String(port);
+    }
+    for (const cmd of config.setup) {
+      console.log(chalk.gray(`  Running: ${cmd}`));
+      const [command, ...args] = cmd.split(" ");
+      try {
+        await execa(command, args, {
+          cwd: sessionDir,
+          stdio: "inherit",
+          env: setupEnv
+        });
+      } catch {
+        console.warn(chalk.yellow(`  Warning: Command failed: ${cmd}`));
+      }
+    }
+  }
+  console.log(chalk.green(`
+Session ${sessionId} ready!`));
+  console.log(chalk.gray(`Directory: ${sessionDir}`));
+  if (mode === "docker") {
+    console.log(chalk.gray("\nDocker mode - all services in containers."));
+    console.log(chalk.gray("View logs: docker compose -f docker-compose.session.yml logs -f"));
+  } else {
+    console.log(chalk.gray("\nNative mode - run apps with: pnpm dev"));
+  }
+  console.log(chalk.gray("\nURLs:"));
+  for (const [name, port] of Object.entries(ports)) {
+    if (name.includes("APP") || name.includes("WEB") || name.includes("WIDGET")) {
+      console.log(chalk.cyan(`  ${name}: http://localhost:${port}`));
+    }
+  }
+  if (options.detach === false) {
+    console.log(chalk.blue("\nStreaming logs (Ctrl+C to stop)..."));
+    console.log(chalk.gray("\u2500".repeat(60)));
+    try {
+      await logs({ cwd: sessionDir, profiles });
+    } catch (error) {
+      const execaError = error;
+      if (execaError.signal === "SIGINT") {
+        console.log(chalk.gray("\n\u2500".repeat(60)));
+        console.log(chalk.yellow("\nLog streaming stopped. Services are still running."));
+        console.log(chalk.gray(`Resume logs: cd ${sessionDir} && docker compose -f docker-compose.session.yml --env-file .env.session logs -f`));
+      } else {
+        throw error;
+      }
+    }
+  }
+}
+
+export {
+  createSession
+};

package/dist/chunk-GBN67HYD.js

@@ -0,0 +1,57 @@
+// src/lib/docker.ts
+import { execa } from "execa";
+var COMPOSE_FILE = "docker-compose.session.yml";
+var ENV_FILE = ".env.session";
+async function compose(args, options) {
+  const profileFlags = options.profiles?.flatMap((p) => ["--profile", p]) ?? [];
+  const fullArgs = [
+    "compose",
+    "-f",
+    COMPOSE_FILE,
+    "--env-file",
+    ENV_FILE,
+    ...profileFlags,
+    ...args
+  ];
+  return execa("docker", fullArgs, {
+    cwd: options.cwd,
+    stdio: "inherit"
+  });
+}
+async function up(options) {
+  const detach = options.detach !== false;
+  const args = detach ? ["up", "-d", "--build"] : ["up", "--build"];
+  await compose(args, options);
+}
+async function logs(options) {
+  await compose(["logs", "-f", "--tail=50"], options);
+}
+async function down(options) {
+  await compose(["down", "-v"], options);
+}
+async function ps(options) {
+  const result = await execa(
+    "docker",
+    ["compose", "-f", COMPOSE_FILE, "--env-file", ENV_FILE, "ps", "--format", "json"],
+    { cwd: options.cwd, reject: false }
+  );
+  return result.stdout;
+}
+async function isRunning(options) {
+  try {
+    const output = await ps(options);
+    if (!output.trim()) return false;
+    const services = output.trim().split("\n").map((line) => JSON.parse(line));
+    return services.some((s) => s.State === "running");
+  } catch {
+    return false;
+  }
+}
+
+export {
+  up,
+  logs,
+  down,
+  ps,
+  isRunning
+};

package/dist/chunk-LDK6QMR6.js

@@ -0,0 +1,67 @@
+import {
+  getSessionWorktrees,
+  removeWorktree
+} from "./chunk-GWDGC2OE.js";
+import {
+  loadConfig
+} from "./chunk-25WQHUYW.js";
+import {
+  down
+} from "./chunk-GBN67HYD.js";
+
+// src/commands/destroy.ts
+import { existsSync } from "fs";
+import { resolve } from "path";
+import chalk from "chalk";
+async function destroySession(projectRoot, sessionId, options) {
+  const config = await loadConfig(projectRoot);
+  const sessions = await getSessionWorktrees(projectRoot);
+  if (options.all) {
+    console.log(chalk.blue("Destroying all sessions..."));
+    if (sessions.length === 0) {
+      console.log(chalk.gray("No sessions found."));
+      return;
+    }
+    for (const session2 of sessions) {
+      await destroySingleSession(projectRoot, session2.sessionId, session2.path, session2.branch);
+    }
+    console.log(chalk.green(`
+Destroyed ${sessions.length} session(s).`));
+    return;
+  }
+  if (!sessionId) {
+    console.error(chalk.red("Error: Session ID required. Use --all to destroy all sessions."));
+    process.exit(1);
+  }
+  if (!/^\d{3}$/.test(sessionId)) {
+    console.error(chalk.red("Error: Session ID must be exactly 3 digits (001-999)"));
+    process.exit(1);
+  }
+  const session = sessions.find((s) => s.sessionId === sessionId);
+  if (!session) {
+    console.error(chalk.red(`Error: Session ${sessionId} not found.`));
+    process.exit(1);
+  }
+  await destroySingleSession(projectRoot, sessionId, session.path, session.branch);
+  console.log(chalk.green(`
+Session ${sessionId} destroyed.`));
+}
+async function destroySingleSession(projectRoot, sessionId, sessionDir, branchName) {
+  console.log(chalk.blue(`
+Destroying session ${sessionId}...`));
+  const envFile = resolve(sessionDir, ".env.session");
+  if (existsSync(envFile)) {
+    console.log(chalk.gray("  Stopping Docker containers..."));
+    try {
+      await down({ cwd: sessionDir });
+    } catch {
+    }
+  }
+  console.log(chalk.gray("  Removing git worktree..."));
+  await removeWorktree(projectRoot, sessionDir, branchName);
+  console.log(chalk.green(`  Session ${sessionId} destroyed.`));
+}
+
+export {
+  destroySession
+};

package/dist/chunk-PKC2ZED2.js

@@ -0,0 +1,168 @@
+import {
+  calculatePorts,
+  formatPortsTable
+} from "./chunk-PJKUD2N2.js";
+import {
+  createWorktree,
+  findNextSessionId,
+  generateDefaultBranchName
+} from "./chunk-GWDGC2OE.js";
+import {
+  getSessionDir,
+  getSessionsDir,
+  loadConfig
+} from "./chunk-25WQHUYW.js";
+import {
+  logs,
+  up
+} from "./chunk-VR3QWHHB.js";
+import {
+  writeAppEnvFiles,
+  writeEnvFile
+} from "./chunk-LEHA65A7.js";
+
+// src/commands/create.ts
+import { existsSync, mkdirSync, copyFileSync, readFileSync, writeFileSync } from "fs";
+import { basename, join } from "path";
+import chalk from "chalk";
+import { execa } from "execa";
+function updateEnvDatabaseUrl(envPath, newDbUrl) {
+  if (!existsSync(envPath)) return;
+  let content = readFileSync(envPath, "utf-8");
+  if (content.includes("DATABASE_URL=")) {
+    content = content.replace(/^DATABASE_URL=.*/m, `DATABASE_URL=${newDbUrl}`);
+  } else {
+    content += `
+DATABASE_URL=${newDbUrl}
+`;
+  }
+  writeFileSync(envPath, content);
+}
+async function createSession(projectRoot, sessionId, options) {
+  const config = await loadConfig(projectRoot);
+  const sessionsDir = getSessionsDir(config, projectRoot);
+  if (!sessionId) {
+    sessionId = await findNextSessionId(projectRoot, sessionsDir);
+    console.log(chalk.gray(`Auto-assigned session ID: ${sessionId}`));
+  }
+  if (!/^\d{3}$/.test(sessionId)) {
+    console.error(chalk.red("Error: Session ID must be exactly 3 digits (001-999)"));
+    process.exit(1);
+  }
+  const inPlace = options.inPlace ?? false;
+  const branchName = options.branch || generateDefaultBranchName(sessionId);
+  const mode = options.mode || "docker";
+  console.log(chalk.blue(`Creating session ${sessionId} (${mode} mode${inPlace ? ", in-place" : ""})...`));
+  if (!inPlace) {
+    console.log(chalk.gray(`Branch: ${branchName}`));
+  }
+  const ports = calculatePorts(config, sessionId);
+  console.log(chalk.gray("\nPorts:"));
+  console.log(chalk.gray(formatPortsTable(ports)));
+  let sessionDir;
+  if (inPlace) {
+    sessionDir = projectRoot;
+    console.log(chalk.blue("\nUsing current directory (in-place mode)..."));
+    console.log(chalk.green(`  Directory: ${sessionDir}`));
+  } else {
+    if (!existsSync(sessionsDir)) {
+      mkdirSync(sessionsDir, { recursive: true });
+    }
+    sessionDir = getSessionDir(config, projectRoot, sessionId);
+    console.log(chalk.blue("\nCreating git worktree..."));
+    await createWorktree(projectRoot, sessionDir, branchName);
+    console.log(chalk.green(`  Created: ${sessionDir}`));
+    const sessionDbUrl = `postgresql://postgres:postgres@localhost:${ports.POSTGRES_PORT}/postgres`;
+    const envFilesToCopy = config.envFiles ?? [];
+    for (const envFile of envFilesToCopy) {
+      const srcPath = join(projectRoot, envFile);
+      const destPath = join(sessionDir, envFile);
+      if (existsSync(srcPath)) {
+        copyFileSync(srcPath, destPath);
+        updateEnvDatabaseUrl(destPath, sessionDbUrl);
+        console.log(chalk.green(`  Copied: ${envFile} (updated DATABASE_URL)`));
+      }
+    }
+  }
+  console.log(chalk.blue("\nGenerating .env.session..."));
+  const projectName = config.projectName ?? basename(projectRoot);
+  const envPath = writeEnvFile(sessionDir, sessionId, ports, projectName);
+  console.log(chalk.green(`  Written: ${envPath}`));
+  const appEnvFiles = writeAppEnvFiles(config, sessionDir, sessionId, ports);
+  for (const file of appEnvFiles) {
+    console.log(chalk.green(`  Written: ${file}`));
+  }
+  console.log(chalk.blue("\nStarting Docker services..."));
+  let profiles;
+  if (mode === "docker") {
+    const allApps = config.apps ?? ["app", "web", "widget"];
+    const excludeApps = options.without ?? [];
+    profiles = allApps.filter((app) => !excludeApps.includes(app));
+    if (excludeApps.length > 0) {
+      console.log(chalk.gray(`  Excluding apps: ${excludeApps.join(", ")}`));
+    }
+  }
+  await up({ cwd: sessionDir, profiles });
+  console.log(chalk.blue("Waiting for services to be ready..."));
+  await new Promise((resolve) => setTimeout(resolve, 3e3));
+  if (config.setup.length > 0) {
+    console.log(chalk.blue("\nRunning setup commands..."));
+    const setupEnv = {
+      ...process.env,
+      SESSION_ID: sessionId,
+      // Add DATABASE_URL for db commands
+      DATABASE_URL: `postgresql://postgres:postgres@localhost:${ports.POSTGRES_PORT}/postgres`
+    };
+    for (const [name, port] of Object.entries(ports)) {
+      setupEnv[name] = String(port);
+    }
+    for (const cmd of config.setup) {
+      console.log(chalk.gray(`  Running: ${cmd}`));
+      const [command, ...args] = cmd.split(" ");
+      try {
+        await execa(command, args, {
+          cwd: sessionDir,
+          stdio: "inherit",
+          env: setupEnv
+        });
+      } catch {
+        console.warn(chalk.yellow(`  Warning: Command failed: ${cmd}`));
+      }
+    }
+  }
+  console.log(chalk.green(`
+Session ${sessionId} ready!`));
+  console.log(chalk.gray(`Directory: ${sessionDir}`));
+  if (mode === "docker") {
+    console.log(chalk.gray("\nDocker mode - all services in containers."));
+    console.log(chalk.gray("View logs: docker compose -f docker-compose.session.yml logs -f"));
+  } else {
+    console.log(chalk.gray("\nNative mode - run apps with: pnpm dev"));
+  }
+  console.log(chalk.gray("\nURLs:"));
+  for (const [name, port] of Object.entries(ports)) {
+    if (name.includes("APP") || name.includes("WEB") || name.includes("WIDGET")) {
+      console.log(chalk.cyan(`  ${name}: http://localhost:${port}`));
+    }
+  }
+  if (options.detach === false) {
+    console.log(chalk.blue("\nStreaming logs (Ctrl+C to stop)..."));
+    console.log(chalk.gray("\u2500".repeat(60)));
+    try {
+      await logs({ cwd: sessionDir, profiles });
+    } catch (error) {
+      const execaError = error;
+      if (execaError.signal === "SIGINT") {
+        console.log(chalk.gray("\n\u2500".repeat(60)));
+        console.log(chalk.yellow("\nLog streaming stopped. Services are still running."));
+        console.log(chalk.gray(`Resume logs: cd ${sessionDir} && docker compose -f docker-compose.session.yml --env-file .env.session logs -f`));
+      } else {
+        throw error;
+      }
+    }
+  }
+}
+
+export {
+  createSession
+};

package/dist/chunk-PS76Q3HD.js

@@ -0,0 +1,168 @@
+import {
+  calculatePorts,
+  formatPortsTable
+} from "./chunk-PJKUD2N2.js";
+import {
+  createWorktree,
+  findNextSessionId,
+  generateDefaultBranchName
+} from "./chunk-GWDGC2OE.js";
+import {
+  getSessionDir,
+  getSessionsDir,
+  loadConfig
+} from "./chunk-25WQHUYW.js";
+import {
+  logs,
+  up
+} from "./chunk-GBN67HYD.js";
+import {
+  writeAppEnvFiles,
+  writeEnvFile
+} from "./chunk-LEHA65A7.js";
+
+// src/commands/create.ts
+import { existsSync, mkdirSync, copyFileSync, readFileSync, writeFileSync } from "fs";
+import { basename, join } from "path";
+import chalk from "chalk";
+import { execa } from "execa";
+function updateEnvDatabaseUrl(envPath, newDbUrl) {
+  if (!existsSync(envPath)) return;
+  let content = readFileSync(envPath, "utf-8");
+  if (content.includes("DATABASE_URL=")) {
+    content = content.replace(/^DATABASE_URL=.*/m, `DATABASE_URL=${newDbUrl}`);
+  } else {
+    content += `
+DATABASE_URL=${newDbUrl}
+`;
+  }
+  writeFileSync(envPath, content);
+}
+async function createSession(projectRoot, sessionId, options) {
+  const config = await loadConfig(projectRoot);
+  const sessionsDir = getSessionsDir(config, projectRoot);
+  if (!sessionId) {
+    sessionId = await findNextSessionId(projectRoot, sessionsDir);
+    console.log(chalk.gray(`Auto-assigned session ID: ${sessionId}`));
+  }
+  if (!/^\d{3}$/.test(sessionId)) {
+    console.error(chalk.red("Error: Session ID must be exactly 3 digits (001-999)"));
+    process.exit(1);
+  }
+  const inPlace = options.inPlace ?? false;
+  const branchName = options.branch || generateDefaultBranchName(sessionId);
+  const mode = options.mode || "docker";
+  console.log(chalk.blue(`Creating session ${sessionId} (${mode} mode${inPlace ? ", in-place" : ""})...`));
+  if (!inPlace) {
+    console.log(chalk.gray(`Branch: ${branchName}`));
+  }
+  const ports = calculatePorts(config, sessionId);
+  console.log(chalk.gray("\nPorts:"));
+  console.log(chalk.gray(formatPortsTable(ports)));
+  let sessionDir;
+  if (inPlace) {
+    sessionDir = projectRoot;
+    console.log(chalk.blue("\nUsing current directory (in-place mode)..."));
+    console.log(chalk.green(`  Directory: ${sessionDir}`));
+  } else {
+    if (!existsSync(sessionsDir)) {
+      mkdirSync(sessionsDir, { recursive: true });
+    }
+    sessionDir = getSessionDir(config, projectRoot, sessionId);
+    console.log(chalk.blue("\nCreating git worktree..."));
+    await createWorktree(projectRoot, sessionDir, branchName);
+    console.log(chalk.green(`  Created: ${sessionDir}`));
+    const sessionDbUrl = `postgresql://postgres:postgres@localhost:${ports.POSTGRES_PORT}/postgres`;
+    const envFilesToCopy = config.envFiles ?? [];
+    for (const envFile of envFilesToCopy) {
+      const srcPath = join(projectRoot, envFile);
+      const destPath = join(sessionDir, envFile);
+      if (existsSync(srcPath)) {
+        copyFileSync(srcPath, destPath);
+        updateEnvDatabaseUrl(destPath, sessionDbUrl);
+        console.log(chalk.green(`  Copied: ${envFile} (updated DATABASE_URL)`));
+      }
+    }
+  }
+  console.log(chalk.blue("\nGenerating .env.session..."));
+  const projectName = config.projectName ?? basename(projectRoot);
+  const envPath = writeEnvFile(sessionDir, sessionId, ports, projectName);
+  console.log(chalk.green(`  Written: ${envPath}`));
+  const appEnvFiles = writeAppEnvFiles(config, sessionDir, sessionId, ports);
+  for (const file of appEnvFiles) {
+    console.log(chalk.green(`  Written: ${file}`));
+  }
+  console.log(chalk.blue("\nStarting Docker services..."));
+  let profiles;
+  if (mode === "docker") {
+    const allApps = config.apps ?? [];
+    const excludeApps = options.without ?? [];
+    profiles = allApps.filter((app) => !excludeApps.includes(app));
+    if (excludeApps.length > 0) {
+      console.log(chalk.gray(`  Excluding apps: ${excludeApps.join(", ")}`));
+    }
+  }
+  await up({ cwd: sessionDir, profiles });
+  console.log(chalk.blue("Waiting for services to be ready..."));
+  await new Promise((resolve) => setTimeout(resolve, 3e3));
+  if (config.setup.length > 0) {
+    console.log(chalk.blue("\nRunning setup commands..."));
+    const setupEnv = {
+      ...process.env,
+      SESSION_ID: sessionId,
+      // Add DATABASE_URL for db commands
+      DATABASE_URL: `postgresql://postgres:postgres@localhost:${ports.POSTGRES_PORT}/postgres`
+    };
+    for (const [name, port] of Object.entries(ports)) {
+      setupEnv[name] = String(port);
+    }
+    for (const cmd of config.setup) {
+      console.log(chalk.gray(`  Running: ${cmd}`));
+      const [command, ...args] = cmd.split(" ");
+      try {
+        await execa(command, args, {
+          cwd: sessionDir,
+          stdio: "inherit",
+          env: setupEnv
+        });
+      } catch {
+        console.warn(chalk.yellow(`  Warning: Command failed: ${cmd}`));
+      }
+    }
+  }
+  console.log(chalk.green(`
+Session ${sessionId} ready!`));
+  console.log(chalk.gray(`Directory: ${sessionDir}`));
+  if (mode === "docker") {
+    console.log(chalk.gray("\nDocker mode - all services in containers."));
+    console.log(chalk.gray("View logs: docker compose -f docker-compose.session.yml logs -f"));
+  } else {
+    console.log(chalk.gray("\nNative mode - run apps with: pnpm dev"));
+  }
+  console.log(chalk.gray("\nURLs:"));
+  for (const [name, port] of Object.entries(ports)) {
+    if (name.includes("APP") || name.includes("WEB") || name.includes("WIDGET")) {
+      console.log(chalk.cyan(`  ${name}: http://localhost:${port}`));
+    }
+  }
+  if (options.detach === false) {
+    console.log(chalk.blue("\nStreaming logs (Ctrl+C to stop)..."));
+    console.log(chalk.gray("\u2500".repeat(60)));
+    try {
+      await logs({ cwd: sessionDir, profiles });
+    } catch (error) {
+      const execaError = error;
+      if (execaError.signal === "SIGINT") {
+        console.log(chalk.gray("\n\u2500".repeat(60)));
+        console.log(chalk.yellow("\nLog streaming stopped. Services are still running."));
+        console.log(chalk.gray(`Resume logs: cd ${sessionDir} && docker compose -f docker-compose.session.yml --env-file .env.session logs -f`));
+      } else {
+        throw error;
+      }
+    }
+  }
+}
+
+export {
+  createSession
+};

package/dist/commands/create.js

@@ -1,10 +1,10 @@
 import {
   createSession
-} from "../chunk-QSG5CXPX.js";
+} from "../chunk-PS76Q3HD.js";
 import "../chunk-PJKUD2N2.js";
 import "../chunk-GWDGC2OE.js";
 import "../chunk-25WQHUYW.js";
-import "../chunk-VR3QWHHB.js";
+import "../chunk-GBN67HYD.js";
 import "../chunk-LEHA65A7.js";
 export {
   createSession

package/dist/commands/destroy.js

@@ -1,9 +1,9 @@
 import {
   destroySession
-} from "../chunk-XUWQUDLT.js";
+} from "../chunk-LDK6QMR6.js";
 import "../chunk-GWDGC2OE.js";
 import "../chunk-25WQHUYW.js";
-import "../chunk-VR3QWHHB.js";
+import "../chunk-GBN67HYD.js";
 export {
   destroySession
 };

package/dist/commands/list.js

@@ -1,10 +1,10 @@
 import {
   listSessions
-} from "../chunk-SMFAL2VP.js";
+} from "../chunk-35SHBLIZ.js";
 import "../chunk-PJKUD2N2.js";
 import "../chunk-GWDGC2OE.js";
 import "../chunk-25WQHUYW.js";
-import "../chunk-VR3QWHHB.js";
+import "../chunk-GBN67HYD.js";
 export {
   listSessions
 };

package/dist/index.js

@@ -1,12 +1,12 @@
 import {
   createSession
-} from "./chunk-QSG5CXPX.js";
+} from "./chunk-PS76Q3HD.js";
 import {
   destroySession
-} from "./chunk-XUWQUDLT.js";
+} from "./chunk-LDK6QMR6.js";
 import {
   listSessions
-} from "./chunk-SMFAL2VP.js";
+} from "./chunk-35SHBLIZ.js";
 import {
   calculatePorts
 } from "./chunk-PJKUD2N2.js";
@@ -17,7 +17,7 @@ import {
 import {
   loadConfig
 } from "./chunk-25WQHUYW.js";
-import "./chunk-VR3QWHHB.js";
+import "./chunk-GBN67HYD.js";
 import "./chunk-LEHA65A7.js";
 export {
   calculatePorts,

package/dist/lib/config.d.ts

@@ -5,6 +5,7 @@ interface SessionConfig {
     ports: Record<string, number>;
     appEnv?: Record<string, Record<string, string>>;
     apps?: string[];
+    envFiles?: string[];
     setup: string[];
 }
 declare function loadConfig(projectRoot: string): Promise<SessionConfig>;

package/dist/lib/docker.js

@@ -4,7 +4,7 @@ import {
   logs,
   ps,
   up
-} from "../chunk-VR3QWHHB.js";
+} from "../chunk-GBN67HYD.js";
 export {
   down,
   isRunning,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dev-prism",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Minimal CLI for isolated parallel development sessions using git worktrees and Docker Compose",
   "type": "module",
   "license": "MIT",