dev-prism 0.3.0 → 0.4.0

package/dist/chunk-H4HPDIY3.js

@@ -0,0 +1,95 @@
+// src/lib/store.ts
+import Database from "better-sqlite3";
+import { existsSync, mkdirSync } from "fs";
+import { dirname, join } from "path";
+import { homedir } from "os";
+var SCHEMA = `
+CREATE TABLE IF NOT EXISTS sessions (
+  id            INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id    TEXT NOT NULL,
+  project_root  TEXT NOT NULL,
+  session_dir   TEXT NOT NULL,
+  branch        TEXT NOT NULL DEFAULT '',
+  mode          TEXT NOT NULL DEFAULT 'docker',
+  in_place      INTEGER NOT NULL DEFAULT 0,
+  created_at    TEXT NOT NULL DEFAULT (datetime('now')),
+  destroyed_at  TEXT,
+  UNIQUE(session_id, project_root)
+);
+`;
+function defaultDbPath() {
+  return join(homedir(), ".dev-prism", "sessions.db");
+}
+var SessionStore = class {
+  db;
+  constructor(dbPath) {
+    const path = dbPath ?? defaultDbPath();
+    if (path !== ":memory:") {
+      const dir = dirname(path);
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+    }
+    this.db = new Database(path);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("busy_timeout = 3000");
+    this.db.exec(SCHEMA);
+  }
+  insert(row) {
+    const stmt = this.db.prepare(`
+      INSERT INTO sessions (session_id, project_root, session_dir, branch, mode, in_place)
+      VALUES (@session_id, @project_root, @session_dir, @branch, @mode, @in_place)
+    `);
+    const info = stmt.run({
+      session_id: row.sessionId,
+      project_root: row.projectRoot,
+      session_dir: row.sessionDir,
+      branch: row.branch ?? "",
+      mode: row.mode ?? "docker",
+      in_place: row.inPlace ? 1 : 0
+    });
+    return this.db.prepare("SELECT * FROM sessions WHERE id = ?").get(info.lastInsertRowid);
+  }
+  /**
+   * Atomically remove any old destroyed row and insert a new one.
+   * Uses a transaction so the UNIQUE constraint prevents concurrent creates
+   * from claiming the same session ID.
+   */
+  reserve(row) {
+    return this.db.transaction(() => {
+      this.remove(row.projectRoot, row.sessionId);
+      return this.insert(row);
+    })();
+  }
+  listByProject(projectRoot) {
+    return this.db.prepare("SELECT * FROM sessions WHERE project_root = ? AND destroyed_at IS NULL ORDER BY session_id").all(projectRoot);
+  }
+  listAll() {
+    return this.db.prepare("SELECT * FROM sessions WHERE destroyed_at IS NULL ORDER BY project_root, session_id").all();
+  }
+  findSession(projectRoot, sessionId) {
+    return this.db.prepare("SELECT * FROM sessions WHERE project_root = ? AND session_id = ? AND destroyed_at IS NULL").get(projectRoot, sessionId);
+  }
+  findByDir(sessionDir) {
+    return this.db.prepare("SELECT * FROM sessions WHERE session_dir = ? AND destroyed_at IS NULL").get(sessionDir);
+  }
+  getUsedSessionIds(projectRoot) {
+    const rows = this.db.prepare("SELECT session_id FROM sessions WHERE project_root = ? AND destroyed_at IS NULL").all(projectRoot);
+    return new Set(rows.map((r) => r.session_id));
+  }
+  markDestroyed(projectRoot, sessionId) {
+    const info = this.db.prepare("UPDATE sessions SET destroyed_at = datetime('now') WHERE project_root = ? AND session_id = ? AND destroyed_at IS NULL").run(projectRoot, sessionId);
+    return info.changes > 0;
+  }
+  remove(projectRoot, sessionId) {
+    const info = this.db.prepare("DELETE FROM sessions WHERE project_root = ? AND session_id = ?").run(projectRoot, sessionId);
+    return info.changes > 0;
+  }
+  close() {
+    this.db.close();
+  }
+};
+
+export {
+  SessionStore
+};

package/dist/chunk-KZJE62TK.js

@@ -0,0 +1,203 @@
+import {
+  writeAppEnvFiles,
+  writeEnvFile
+} from "./chunk-J36LRUXM.js";
+import {
+  calculatePorts,
+  formatPortsTable
+} from "./chunk-3ATDGV4Y.js";
+import {
+  createWorktree,
+  findNextSessionId,
+  generateDefaultBranchName,
+  removeWorktree
+} from "./chunk-Y3GR6XK7.js";
+import {
+  down,
+  logs,
+  up
+} from "./chunk-GBN67HYD.js";
+import {
+  getSessionDir,
+  getSessionsDir,
+  loadConfig
+} from "./chunk-25WQHUYW.js";
+import {
+  SessionStore
+} from "./chunk-H4HPDIY3.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)));
+    const sessionDir = inPlace ? projectRoot : getSessionDir(config, projectRoot, sessionId);
+    try {
+      store.reserve({
+        sessionId,
+        projectRoot,
+        sessionDir,
+        branch: inPlace ? "" : branchName,
+        mode,
+        inPlace
+      });
+    } catch {
+      console.error(chalk.red(`Error: Session ${sessionId} is already being created by another process.`));
+      process.exit(1);
+    }
+    let profiles;
+    try {
+      if (inPlace) {
+        console.log(chalk.blue("\nUsing current directory (in-place mode)..."));
+        console.log(chalk.green(`  Directory: ${sessionDir}`));
+      } else {
+        if (!existsSync(sessionsDir)) {
+          mkdirSync(sessionsDir, { recursive: true });
+        }
+        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..."));
+      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}`));
+          }
+        }
+      }
+    } catch (error) {
+      console.error(chalk.red("Session creation failed. Cleaning up..."));
+      store.remove(projectRoot, sessionId);
+      try {
+        await down({ cwd: sessionDir });
+      } catch {
+      }
+      if (!inPlace) {
+        try {
+          await removeWorktree(projectRoot, sessionDir, branchName);
+        } catch {
+        }
+      }
+      throw error;
+    }
+    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-LNIOSGC4.js

@@ -0,0 +1,78 @@
+import {
+  removeWorktree
+} from "./chunk-FKTFCSU7.js";
+import {
+  down
+} from "./chunk-GBN67HYD.js";
+import {
+  loadConfig
+} from "./chunk-25WQHUYW.js";
+import {
+  SessionStore
+} from "./chunk-6YMQTISJ.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 store = new SessionStore();
+  try {
+    if (options.all) {
+      console.log(chalk.blue("Destroying all sessions..."));
+      const sessions = store.listByProject(projectRoot);
+      if (sessions.length === 0) {
+        console.log(chalk.gray("No sessions found."));
+        return;
+      }
+      for (const session2 of sessions) {
+        await destroySingleSession(projectRoot, session2.session_id, session2.session_dir, session2.branch, session2.in_place === 1);
+        store.markDestroyed(projectRoot, session2.session_id);
+      }
+      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 = store.findSession(projectRoot, sessionId);
+    if (!session) {
+      console.error(chalk.red(`Error: Session ${sessionId} not found.`));
+      process.exit(1);
+    }
+    await destroySingleSession(projectRoot, sessionId, session.session_dir, session.branch, session.in_place === 1);
+    store.markDestroyed(projectRoot, sessionId);
+    console.log(chalk.green(`
+Session ${sessionId} destroyed.`));
+  } finally {
+    store.close();
+  }
+}
+async function destroySingleSession(projectRoot, sessionId, sessionDir, branchName, inPlace) {
+  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 {
+    }
+  }
+  if (!inPlace) {
+    console.log(chalk.gray("  Removing git worktree..."));
+    await removeWorktree(projectRoot, sessionDir, branchName);
+  }
+  console.log(chalk.green(`  Session ${sessionId} destroyed.`));
+}
+
+export {
+  destroySession
+};

package/dist/chunk-NNVP5F6I.js

@@ -0,0 +1,77 @@
+import {
+  calculatePorts
+} from "./chunk-3ATDGV4Y.js";
+import {
+  isRunning
+} from "./chunk-GBN67HYD.js";
+import {
+  loadConfig
+} from "./chunk-25WQHUYW.js";
+import {
+  SessionStore
+} from "./chunk-H4HPDIY3.js";
+
+// src/commands/list.ts
+import { existsSync } from "fs";
+import { resolve } from "path";
+import chalk from "chalk";
+async function listSessions(projectRoot, options) {
+  const showAll = options?.all ?? false;
+  const config = await loadConfig(projectRoot);
+  const store = new SessionStore();
+  let sessions;
+  try {
+    const projectSessions = store.listByProject(projectRoot);
+    if (showAll || projectSessions.length === 0) {
+      sessions = store.listAll();
+    } else {
+      sessions = projectSessions;
+    }
+  } finally {
+    store.close();
+  }
+  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 sessionConfig = await loadConfig(session.project_root).catch(() => config);
+    const status = await getSessionStatus(session.session_id, session.session_dir, session.branch, sessionConfig);
+    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)) {
+    console.log(chalk.cyan(`    ${name}: http://localhost:${port}`));
+  }
+  console.log("");
+}
+
+export {
+  listSessions
+};

package/dist/chunk-OL25TBYX.js

@@ -0,0 +1,67 @@
+import {
+  isRunning
+} from "./chunk-GBN67HYD.js";
+import {
+  loadConfig
+} from "./chunk-25WQHUYW.js";
+import {
+  SessionStore
+} from "./chunk-H4HPDIY3.js";
+
+// src/commands/stop-all.ts
+import { existsSync } from "fs";
+import { resolve } from "path";
+import chalk from "chalk";
+import { execa } from "execa";
+async function stopAllSessions(projectRoot) {
+  const config = await loadConfig(projectRoot);
+  const store = new SessionStore();
+  let sessions;
+  try {
+    sessions = store.listByProject(projectRoot);
+  } finally {
+    store.close();
+  }
+  if (sessions.length === 0) {
+    console.log(chalk.gray("No sessions found."));
+    return;
+  }
+  const runningSessions = [];
+  for (const session of sessions) {
+    const envFile = resolve(session.session_dir, ".env.session");
+    if (existsSync(envFile)) {
+      const running = await isRunning({ cwd: session.session_dir });
+      if (running) {
+        runningSessions.push({ sessionId: session.session_id, path: session.session_dir });
+      }
+    }
+  }
+  if (runningSessions.length === 0) {
+    console.log(chalk.gray("No running sessions found."));
+    return;
+  }
+  console.log(chalk.blue(`Stopping ${runningSessions.length} running session(s)...
+`));
+  const allApps = config.apps ?? [];
+  const profileFlags = allApps.flatMap((p) => ["--profile", p]);
+  const allServices = ["postgres", "mailpit", ...allApps];
+  for (const session of runningSessions) {
+    console.log(chalk.gray(`  Stopping session ${session.sessionId}...`));
+    try {
+      await execa(
+        "docker",
+        ["compose", "-f", "docker-compose.session.yml", "--env-file", ".env.session", ...profileFlags, "stop", ...allServices],
+        { cwd: session.path, stdio: "pipe" }
+      );
+      console.log(chalk.green(`  Session ${session.sessionId} stopped.`));
+    } catch {
+      console.log(chalk.yellow(`  Warning: Could not stop session ${session.sessionId}`));
+    }
+  }
+  console.log(chalk.green(`
+Stopped ${runningSessions.length} session(s).`));
+}
+
+export {
+  stopAllSessions
+};

package/dist/chunk-RC2AUYZ7.js

@@ -0,0 +1,49 @@
+import {
+  loadConfig
+} from "./chunk-25WQHUYW.js";
+import {
+  SessionStore
+} from "./chunk-H4HPDIY3.js";
+
+// src/commands/logs.ts
+import chalk from "chalk";
+import { execa } from "execa";
+async function streamLogs(projectRoot, sessionId, options) {
+  const config = await loadConfig(projectRoot);
+  const store = new SessionStore();
+  let sessionDir;
+  try {
+    const session = store.findSession(projectRoot, sessionId);
+    if (!session) {
+      console.error(chalk.red(`Error: Session ${sessionId} not found.`));
+      process.exit(1);
+    }
+    sessionDir = session.session_dir;
+  } finally {
+    store.close();
+  }
+  let profileFlags = [];
+  if (options.mode === "docker") {
+    const allApps = config.apps ?? [];
+    const excludeApps = options.without ?? [];
+    const profiles = allApps.filter((app) => !excludeApps.includes(app));
+    profileFlags = profiles.flatMap((p) => ["--profile", p]);
+  }
+  const args = [
+    "compose",
+    "-f",
+    "docker-compose.session.yml",
+    "--env-file",
+    ".env.session",
+    ...profileFlags,
+    "logs",
+    "-f",
+    "--tail",
+    options.tail ?? "50"
+  ];
+  await execa("docker", args, { cwd: sessionDir, stdio: "inherit" });
+}
+
+export {
+  streamLogs
+};

package/dist/chunk-SUMJLXT7.js

@@ -0,0 +1,30 @@
+import {
+  SessionStore
+} from "./chunk-H4HPDIY3.js";
+
+// src/commands/stop.ts
+import chalk from "chalk";
+import { execa } from "execa";
+async function stopSession(projectRoot, sessionId) {
+  const store = new SessionStore();
+  let sessionDir;
+  try {
+    const session = store.findSession(projectRoot, sessionId);
+    if (!session) {
+      console.error(chalk.red(`Error: Session ${sessionId} not found.`));
+      process.exit(1);
+    }
+    sessionDir = session.session_dir;
+  } finally {
+    store.close();
+  }
+  await execa(
+    "docker",
+    ["compose", "-f", "docker-compose.session.yml", "--env-file", ".env.session", "stop"],
+    { cwd: sessionDir, stdio: "inherit" }
+  );
+}
+
+export {
+  stopSession
+};