dev-prism 0.3.0 → 0.6.0

package/dist/chunk-W54CPPSK.js

@@ -0,0 +1,217 @@
+import {
+  extractPorts,
+  formatPortsTable
+} from "./chunk-LAOWFCQL.js";
+import {
+  generateEnvStub,
+  writeComposeFile
+} from "./chunk-JMKE3ZKI.js";
+import {
+  writeAppEnvFiles,
+  writeEnvFile
+} from "./chunk-SEKH4ZV6.js";
+import {
+  createWorktree,
+  generateDefaultBranchName,
+  removeWorktree
+} from "./chunk-3Q454U3I.js";
+import {
+  down,
+  logs,
+  up
+} from "./chunk-GBN67HYD.js";
+import {
+  getSessionsDir,
+  loadConfig
+} from "./chunk-25WQHUYW.js";
+import {
+  getPortMappings,
+  sessionExists
+} from "./chunk-JZ2VPQXP.js";
+
+// src/commands/create.ts
+import { existsSync, mkdirSync, copyFileSync, readFileSync, writeFileSync } from "fs";
+import { basename, join, resolve } 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);
+  const inPlace = options.inPlace ?? false;
+  const mode = options.mode || "docker";
+  let workingDir;
+  let branchName = "";
+  if (inPlace) {
+    workingDir = projectRoot;
+    console.log(chalk.blue(`Creating session in current directory (${mode} mode)...`));
+  } else {
+    branchName = options.branch || generateDefaultBranchName();
+    workingDir = resolve(sessionsDir, branchName);
+    console.log(chalk.blue(`Creating session (${mode} mode)...`));
+    console.log(chalk.gray(`Branch: ${branchName}`));
+    console.log(chalk.gray(`Directory: ${workingDir}`));
+  }
+  if (await sessionExists(workingDir)) {
+    console.error(chalk.red(`
+Error: Session already running in this directory.`));
+    console.error(chalk.gray(`Stop it first with: dev-prism stop`));
+    process.exit(1);
+  }
+  let profiles;
+  try {
+    if (!inPlace) {
+      if (!existsSync(sessionsDir)) {
+        mkdirSync(sessionsDir, { recursive: true });
+      }
+      console.log(chalk.blue("\nCreating git worktree..."));
+      await createWorktree(projectRoot, workingDir, branchName);
+      console.log(chalk.green(`  Created: ${workingDir}`));
+    }
+    const projectName = config.projectName ?? basename(projectRoot);
+    const services = [
+      { name: "postgres", internalPort: 5432 },
+      { name: "app", internalPort: 3e3 }
+    ];
+    console.log(chalk.blue("\nGenerating docker-compose.session.yml..."));
+    const composePath = writeComposeFile(workingDir, projectName, services);
+    console.log(chalk.green(`  Written: ${composePath}`));
+    console.log(chalk.blue("\nGenerating .env.session stub..."));
+    const envStub = generateEnvStub(workingDir, projectName);
+    const envPath = resolve(workingDir, ".env.session");
+    writeFileSync(envPath, envStub, "utf-8");
+    console.log(chalk.green(`  Written: ${envPath}`));
+    if (!inPlace) {
+      const envFilesToCopy = config.envFiles ?? [];
+      for (const envFile of envFilesToCopy) {
+        const srcPath = join(projectRoot, envFile);
+        const destPath = join(workingDir, envFile);
+        if (existsSync(srcPath)) {
+          copyFileSync(srcPath, destPath);
+          console.log(chalk.green(`  Copied: ${envFile}`));
+        }
+      }
+    }
+    console.log(chalk.blue("\nStarting Docker services..."));
+    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: workingDir, profiles, detach: true });
+    console.log(chalk.blue("Waiting for services to be ready..."));
+    await new Promise((resolve2) => setTimeout(resolve2, 3e3));
+    console.log(chalk.blue("\nDiscovering ports from containers..."));
+    const portMappings = await getPortMappings(workingDir);
+    const ports = extractPorts(portMappings);
+    console.log(chalk.gray("Discovered ports:"));
+    console.log(chalk.gray(formatPortsTable(ports)));
+    const finalEnvContent = writeEnvFile(workingDir, ports, projectName);
+    console.log(chalk.green(`  Updated: ${finalEnvContent}`));
+    const appEnvFiles = writeAppEnvFiles(config, workingDir, ports);
+    for (const file of appEnvFiles) {
+      console.log(chalk.green(`  Written: ${file}`));
+    }
+    if (!inPlace && ports.POSTGRES_PORT) {
+      const sessionDbUrl = `postgresql://postgres:postgres@localhost:${ports.POSTGRES_PORT}/postgres`;
+      const envFilesToCopy = config.envFiles ?? [];
+      for (const envFile of envFilesToCopy) {
+        const destPath = join(workingDir, envFile);
+        if (existsSync(destPath)) {
+          updateEnvDatabaseUrl(destPath, sessionDbUrl);
+          console.log(chalk.green(`  Updated DATABASE_URL in: ${envFile}`));
+        }
+      }
+    }
+    if (config.setup.length > 0) {
+      console.log(chalk.blue("\nRunning setup commands..."));
+      const setupEnv = {
+        ...process.env,
+        SESSION_DIR: workingDir
+      };
+      for (const [name, port] of Object.entries(ports)) {
+        setupEnv[name] = String(port);
+      }
+      if (ports.POSTGRES_PORT) {
+        setupEnv.DATABASE_URL = `postgresql://postgres:postgres@localhost:${ports.POSTGRES_PORT}/postgres`;
+      }
+      for (const cmd of config.setup) {
+        console.log(chalk.gray(`  Running: ${cmd}`));
+        const [command, ...args] = cmd.split(" ");
+        try {
+          await execa(command, args, {
+            cwd: workingDir,
+            stdio: "inherit",
+            env: setupEnv
+          });
+        } catch {
+          console.warn(chalk.yellow(`  Warning: Command failed: ${cmd}`));
+        }
+      }
+    }
+    console.log(chalk.green(`
+Session ready!`));
+    console.log(chalk.gray(`Directory: ${workingDir}`));
+    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("\nPorts:"));
+    for (const [name, port] of Object.entries(ports)) {
+      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: workingDir, 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 ${workingDir} && docker compose -f docker-compose.session.yml --env-file .env.session logs -f`
+            )
+          );
+        } else {
+          throw error;
+        }
+      }
+    }
+  } catch (error) {
+    console.error(chalk.red("Session creation failed. Cleaning up..."));
+    try {
+      await down({ cwd: workingDir });
+    } catch {
+    }
+    if (!inPlace && branchName) {
+      try {
+        await removeWorktree(projectRoot, workingDir, branchName);
+      } catch {
+      }
+    }
+    throw error;
+  }
+}
+
+export {
+  createSession
+};

package/dist/chunk-X2PXZRYU.js

@@ -0,0 +1,41 @@
+import {
+  loadConfig
+} from "./chunk-25WQHUYW.js";
+import {
+  getSession
+} from "./chunk-DQER5GNG.js";
+
+// src/commands/stop.ts
+import { existsSync, unlinkSync } from "fs";
+import { resolve } from "path";
+import chalk from "chalk";
+import { execa } from "execa";
+async function stopSession(workingDir) {
+  const session = await getSession(workingDir);
+  if (!session) {
+    console.error(chalk.red(`Error: No session found in directory: ${workingDir}`));
+    process.exit(1);
+  }
+  console.log(chalk.blue(`Stopping session in ${workingDir}...`));
+  const config = await loadConfig(workingDir);
+  const allApps = config.apps ?? [];
+  const composeArgs = ["compose", "-f", "docker-compose.session.yml"];
+  const envPath = resolve(workingDir, ".env.session");
+  if (existsSync(envPath)) {
+    composeArgs.push("--env-file", ".env.session");
+  }
+  for (const profile of allApps) {
+    composeArgs.push("--profile", profile);
+  }
+  composeArgs.push("stop");
+  await execa("docker", composeArgs, { cwd: workingDir, stdio: "inherit" });
+  if (existsSync(envPath)) {
+    unlinkSync(envPath);
+    console.log(chalk.gray(`Deleted: ${envPath}`));
+  }
+  console.log(chalk.green("Session stopped."));
+}
+
+export {
+  stopSession
+};

package/dist/chunk-X6FHBEAS.js

@@ -0,0 +1,200 @@
+import {
+  writeAppEnvFiles,
+  writeEnvFile
+} from "./chunk-J36LRUXM.js";
+import {
+  calculatePorts,
+  formatPortsTable
+} from "./chunk-3ATDGV4Y.js";
+import {
+  createWorktree,
+  findNextSessionId,
+  generateDefaultBranchName,
+  removeWorktree
+} from "./chunk-FKTFCSU7.js";
+import {
+  down,
+  logs,
+  up
+} from "./chunk-GBN67HYD.js";
+import {
+  getSessionDir,
+  getSessionsDir,
+  loadConfig
+} from "./chunk-25WQHUYW.js";
+import {
+  SessionStore
+} from "./chunk-6YMQTISJ.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);
+  const store = new SessionStore();
+  try {
+    if (!sessionId) {
+      sessionId = findNextSessionId(store.getUsedSessionIds(projectRoot));
+      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}`));
+        }
+      }
+    }
+    store.remove(projectRoot, sessionId);
+    try {
+      store.insert({
+        sessionId,
+        projectRoot,
+        sessionDir,
+        branch: inPlace ? "" : branchName,
+        mode,
+        inPlace
+      });
+    } catch (dbErr) {
+      console.error(chalk.red("Failed to record session in database. Cleaning up..."));
+      try {
+        await down({ cwd: sessionDir });
+      } catch {
+      }
+      if (!inPlace) {
+        try {
+          await removeWorktree(projectRoot, sessionDir, branchName);
+        } catch {
+        }
+      }
+      throw dbErr;
+    }
+    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("\nPorts:"));
+    for (const [name, port] of Object.entries(ports)) {
+      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;
+        }
+      }
+    }
+  } finally {
+    store.close();
+  }
+}
+
+export {
+  createSession
+};

package/dist/chunk-YSO3IDZZ.js

@@ -0,0 +1,40 @@
+import {
+  getSession
+} from "./chunk-DQER5GNG.js";
+
+// src/commands/info.ts
+import chalk from "chalk";
+async function showInfo(cwd) {
+  const session = await getSession(cwd);
+  if (!session) {
+    console.log(chalk.yellow("No session running in this directory."));
+    console.log(chalk.gray("Run `dev-prism create --in-place` to create a session here."));
+    process.exit(1);
+  }
+  console.log(chalk.blue(`
+Session`));
+  console.log(chalk.gray(`Directory: ${session.workingDir}`));
+  console.log(
+    session.running ? chalk.green("Status: running") : chalk.yellow("Status: stopped")
+  );
+  if (session.containers.length > 0) {
+    console.log(chalk.gray(`
+Containers (${session.containers.length}):`));
+    for (const container of session.containers) {
+      const serviceName = container.labels["dev-prism.service"] || container.name;
+      const state = container.state === "running" ? chalk.green("\u25CF") : chalk.gray("\u25CB");
+      console.log(`  ${state} ${serviceName}`);
+    }
+  }
+  if (session.ports.length > 0) {
+    console.log(chalk.gray("\nPorts:"));
+    for (const port of session.ports) {
+      console.log(chalk.cyan(`  ${port.service}: http://localhost:${port.externalPort}`));
+    }
+  }
+  console.log("");
+}
+
+export {
+  showInfo
+};

package/dist/chunk-YY5DA35Z.js

@@ -0,0 +1,40 @@
+import {
+  loadConfig
+} from "./chunk-25WQHUYW.js";
+import {
+  up
+} from "./chunk-GBN67HYD.js";
+import {
+  SessionStore
+} from "./chunk-ZKHNUDSL.js";
+
+// src/commands/start.ts
+import chalk from "chalk";
+async function startSession(sessionId, options) {
+  const store = new SessionStore();
+  let sessionDir;
+  let projectRoot;
+  try {
+    const session = store.findSession(sessionId);
+    if (!session) {
+      console.error(chalk.red(`Error: Session ${sessionId} not found.`));
+      process.exit(1);
+    }
+    sessionDir = session.session_dir;
+    projectRoot = session.project_root;
+  } finally {
+    store.close();
+  }
+  const config = await loadConfig(projectRoot);
+  let profiles;
+  if (options.mode === "docker") {
+    const allApps = config.apps ?? [];
+    const excludeApps = options.without ?? [];
+    profiles = allApps.filter((app) => !excludeApps.includes(app));
+  }
+  await up({ cwd: sessionDir, profiles });
+}
+
+export {
+  startSession
+};

package/dist/chunk-Z2ISJMLW.js

@@ -0,0 +1,92 @@
+import {
+  removeWorktree
+} from "./chunk-3Q454U3I.js";
+import {
+  down
+} from "./chunk-GBN67HYD.js";
+import {
+  getSessionsDir,
+  loadConfig
+} from "./chunk-25WQHUYW.js";
+import {
+  listActiveSessions
+} from "./chunk-DQER5GNG.js";
+
+// src/commands/prune.ts
+import { existsSync, readdirSync, statSync } from "fs";
+import { resolve, basename, join } from "path";
+import { createInterface } from "readline";
+import chalk from "chalk";
+async function pruneSessions(options) {
+  const runningSessions = await listActiveSessions();
+  const runningDirs = new Set(runningSessions.map((s) => s.workingDir));
+  const projectRoot = process.cwd();
+  const config = await loadConfig(projectRoot);
+  const sessionsDir = getSessionsDir(config, projectRoot);
+  if (!existsSync(sessionsDir)) {
+    console.log(chalk.gray("No sessions directory found."));
+    return;
+  }
+  const sessionDirs = readdirSync(sessionsDir).map((name) => join(sessionsDir, name)).filter((path) => {
+    try {
+      return statSync(path).isDirectory();
+    } catch {
+      return false;
+    }
+  });
+  const stoppedSessions = sessionDirs.filter((dir) => !runningDirs.has(dir));
+  if (stoppedSessions.length === 0) {
+    console.log(chalk.gray("No stopped sessions to prune."));
+    return;
+  }
+  console.log(chalk.yellow(`
+Found ${stoppedSessions.length} stopped session(s) to prune:`));
+  for (const sessionDir of stoppedSessions) {
+    const dirName = basename(sessionDir);
+    console.log(chalk.gray(`  - ${dirName}`));
+  }
+  console.log("");
+  if (!options.yes) {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    const answer = await new Promise((resolve2) => {
+      rl.question(
+        chalk.red(
+          "Are you sure you want to delete these sessions? This cannot be undone. [y/N] "
+        ),
+        resolve2
+      );
+    });
+    rl.close();
+    if (answer.toLowerCase() !== "y" && answer.toLowerCase() !== "yes") {
+      console.log(chalk.gray("Cancelled."));
+      return;
+    }
+  }
+  console.log(chalk.blue("\nPruning stopped sessions...\n"));
+  for (const sessionDir of stoppedSessions) {
+    const dirName = basename(sessionDir);
+    console.log(chalk.gray(`  Removing ${dirName}...`));
+    try {
+      const envFile = resolve(sessionDir, ".env.session");
+      if (existsSync(envFile)) {
+        try {
+          await down({ cwd: sessionDir });
+        } catch {
+        }
+      }
+      await removeWorktree(projectRoot, sessionDir, dirName);
+      console.log(chalk.green(`  Removed ${dirName}`));
+    } catch {
+      console.log(chalk.yellow(`  Warning: Could not fully remove ${dirName}`));
+    }
+  }
+  console.log(chalk.green(`
+Pruned ${stoppedSessions.length} session(s).`));
+}
+
+export {
+  pruneSessions
+};