dev-prism 0.6.0 → 0.7.0

package/dist/chunk-DTE5YQMI.js

@@ -1,41 +0,0 @@
-import {
-  listActiveSessions
-} from "./chunk-DQER5GNG.js";
-
-// src/commands/stop-all.ts
-import { existsSync, unlinkSync } from "fs";
-import { resolve } from "path";
-import chalk from "chalk";
-import { execa } from "execa";
-async function stopAllSessions() {
-  const sessions = await listActiveSessions();
-  if (sessions.length === 0) {
-    console.log(chalk.gray("No active sessions found."));
-    return;
-  }
-  console.log(chalk.blue(`Stopping ${sessions.length} session(s)...
-`));
-  for (const session of sessions) {
-    console.log(chalk.gray(`  Stopping session in ${session.workingDir}...`));
-    try {
-      await execa(
-        "docker",
-        ["compose", "-f", "docker-compose.session.yml", "--env-file", ".env.session", "stop"],
-        { cwd: session.workingDir, stdio: "pipe" }
-      );
-      const envPath = resolve(session.workingDir, ".env.session");
-      if (existsSync(envPath)) {
-        unlinkSync(envPath);
-      }
-      console.log(chalk.green(`  Stopped: ${session.workingDir}`));
-    } catch {
-      console.log(chalk.yellow(`  Warning: Could not stop session in ${session.workingDir}`));
-    }
-  }
-  console.log(chalk.green(`
-Stopped ${sessions.length} session(s).`));
-}
-
-export {
-  stopAllSessions
-};

package/dist/chunk-EXRHG5KQ.js

@@ -1,60 +0,0 @@
-import {
-  isRunning
-} from "./chunk-GBN67HYD.js";
-import {
-  SessionStore
-} from "./chunk-ZKHNUDSL.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() {
-  const store = new SessionStore();
-  let sessions;
-  try {
-    sessions = store.listAll();
-  } 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, projectRoot: session.project_root });
-      }
-    }
-  }
-  if (runningSessions.length === 0) {
-    console.log(chalk.gray("No running sessions found."));
-    return;
-  }
-  console.log(chalk.blue(`Stopping ${runningSessions.length} running session(s)...
-`));
-  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", "stop"],
-        { cwd: session.path, stdio: "inherit" }
-      );
-      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-FKTFCSU7.js

@@ -1,78 +0,0 @@
-// src/lib/worktree.ts
-import { existsSync, rmSync } from "fs";
-import { execa } from "execa";
-async function branchExists(projectRoot, branchName) {
-  try {
-    await execa("git", ["rev-parse", "--verify", branchName], {
-      cwd: projectRoot,
-      stdio: "pipe"
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function findNextSessionId(usedIds) {
-  for (let i = 1; i <= 999; i++) {
-    const sessionId = String(i).padStart(3, "0");
-    if (!usedIds.has(sessionId)) {
-      return sessionId;
-    }
-  }
-  throw new Error("No available session IDs (001-999 all in use)");
-}
-function generateDefaultBranchName(sessionId) {
-  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  return `session/${today}/${sessionId}`;
-}
-async function createWorktree(projectRoot, sessionDir, branchName) {
-  if (existsSync(sessionDir)) {
-    try {
-      await execa("git", ["worktree", "remove", "--force", sessionDir], {
-        cwd: projectRoot,
-        stdio: "pipe"
-      });
-    } catch {
-      rmSync(sessionDir, { recursive: true, force: true });
-    }
-  }
-  const exists = await branchExists(projectRoot, branchName);
-  if (exists) {
-    await execa("git", ["worktree", "add", sessionDir, branchName], {
-      cwd: projectRoot,
-      stdio: "inherit"
-    });
-  } else {
-    await execa("git", ["worktree", "add", sessionDir, "-b", branchName, "HEAD"], {
-      cwd: projectRoot,
-      stdio: "inherit"
-    });
-  }
-}
-async function removeWorktree(projectRoot, sessionDir, branchName) {
-  if (existsSync(sessionDir)) {
-    try {
-      await execa("git", ["worktree", "remove", "--force", sessionDir], {
-        cwd: projectRoot,
-        stdio: "inherit"
-      });
-    } catch {
-      rmSync(sessionDir, { recursive: true, force: true });
-    }
-  }
-  try {
-    await execa("git", ["branch", "-D", branchName], {
-      cwd: projectRoot,
-      stdio: "pipe"
-      // Don't show output, branch might not exist
-    });
-  } catch {
-  }
-}
-
-export {
-  findNextSessionId,
-  generateDefaultBranchName,
-  createWorktree,
-  removeWorktree
-};

package/dist/chunk-GBN67HYD.js

@@ -1,57 +0,0 @@
-// 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-GKXXK2ZH.js

@@ -1,203 +0,0 @@
-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);
-    }
-    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..."));
-      let profiles2;
-      if (mode === "docker") {
-        const allApps = config.apps ?? [];
-        const excludeApps = options.without ?? [];
-        profiles2 = allApps.filter((app) => !excludeApps.includes(app));
-        if (excludeApps.length > 0) {
-          console.log(chalk.gray(`  Excluding apps: ${excludeApps.join(", ")}`));
-        }
-      }
-      await up({ cwd: sessionDir, profiles: profiles2 });
-      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-GWDGC2OE.js

@@ -1,116 +0,0 @@
-// src/lib/worktree.ts
-import { existsSync, rmSync } from "fs";
-import { execa } from "execa";
-async function branchExists(projectRoot, branchName) {
-  try {
-    await execa("git", ["rev-parse", "--verify", branchName], {
-      cwd: projectRoot,
-      stdio: "pipe"
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function findNextSessionId(projectRoot, sessionsDir) {
-  const sessions = await getSessionWorktrees(projectRoot);
-  const usedIds = new Set(sessions.map((s) => parseInt(s.sessionId, 10)));
-  for (let i = 1; i <= 999; i++) {
-    if (!usedIds.has(i)) {
-      const sessionId = String(i).padStart(3, "0");
-      if (sessionsDir) {
-        const sessionDir = `${sessionsDir}/session-${sessionId}`;
-        if (existsSync(sessionDir)) {
-          continue;
-        }
-      }
-      return sessionId;
-    }
-  }
-  throw new Error("No available session IDs (001-999 all in use)");
-}
-function generateDefaultBranchName(sessionId) {
-  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  return `session/${today}/${sessionId}`;
-}
-async function createWorktree(projectRoot, sessionDir, branchName) {
-  if (existsSync(sessionDir)) {
-    throw new Error(`Session directory already exists: ${sessionDir}`);
-  }
-  const exists = await branchExists(projectRoot, branchName);
-  if (exists) {
-    await execa("git", ["worktree", "add", sessionDir, branchName], {
-      cwd: projectRoot,
-      stdio: "inherit"
-    });
-  } else {
-    await execa("git", ["worktree", "add", sessionDir, "-b", branchName, "HEAD"], {
-      cwd: projectRoot,
-      stdio: "inherit"
-    });
-  }
-}
-async function removeWorktree(projectRoot, sessionDir, branchName) {
-  if (existsSync(sessionDir)) {
-    try {
-      await execa("git", ["worktree", "remove", "--force", sessionDir], {
-        cwd: projectRoot,
-        stdio: "inherit"
-      });
-    } catch {
-      rmSync(sessionDir, { recursive: true, force: true });
-    }
-  }
-  try {
-    await execa("git", ["branch", "-D", branchName], {
-      cwd: projectRoot,
-      stdio: "pipe"
-      // Don't show output, branch might not exist
-    });
-  } catch {
-  }
-}
-async function listWorktrees(projectRoot) {
-  const { stdout } = await execa("git", ["worktree", "list", "--porcelain"], {
-    cwd: projectRoot
-  });
-  const worktrees = [];
-  let current = null;
-  for (const line of stdout.split("\n")) {
-    if (line.startsWith("worktree ")) {
-      if (current) {
-        worktrees.push(current);
-      }
-      current = { path: line.replace("worktree ", ""), branch: "", commit: "" };
-    } else if (line.startsWith("HEAD ") && current) {
-      current.commit = line.replace("HEAD ", "");
-    } else if (line.startsWith("branch ") && current) {
-      current.branch = line.replace("branch refs/heads/", "");
-    }
-  }
-  if (current) {
-    worktrees.push(current);
-  }
-  return worktrees;
-}
-async function getSessionWorktrees(projectRoot) {
-  const worktrees = await listWorktrees(projectRoot);
-  const sessionPattern = /\/session-(\d{3})$/;
-  return worktrees.filter((wt) => sessionPattern.test(wt.path)).map((wt) => {
-    const match = wt.path.match(sessionPattern);
-    return {
-      sessionId: match[1],
-      path: wt.path,
-      branch: wt.branch
-    };
-  });
-}
-
-export {
-  findNextSessionId,
-  generateDefaultBranchName,
-  createWorktree,
-  removeWorktree,
-  listWorktrees,
-  getSessionWorktrees
-};

package/dist/chunk-H3L73URT.js

@@ -1,65 +0,0 @@
-// src/lib/compose.ts
-import { writeFileSync } from "fs";
-import { resolve } from "path";
-import { createHash } from "crypto";
-function generateComposeFile(workingDir, projectName, services) {
-  const createdAt = (/* @__PURE__ */ new Date()).toISOString();
-  const dirHash = createHash("md5").update(workingDir).digest("hex").substring(0, 8);
-  const composeProjectName = `${projectName}-${dirHash}`;
-  const lines = [
-    "# Auto-generated by dev-prism - DO NOT EDIT",
-    'version: "3.8"',
-    "",
-    "x-dev-prism-labels: &dev-prism-labels",
-    '  dev-prism.managed: "true"',
-    `  dev-prism.working_dir: "${workingDir}"`,
-    `  dev-prism.session_id: "${workingDir}"`,
-    `  dev-prism.created_at: "${createdAt}"`,
-    "",
-    "services:"
-  ];
-  for (const service of services) {
-    lines.push(`  ${service.name}:`);
-    lines.push(`    extends:`);
-    lines.push(`      file: docker-compose.yml`);
-    lines.push(`      service: ${service.name}`);
-    lines.push(`    ports:`);
-    lines.push(`      - "0:${service.internalPort}"  # Random host port`);
-    lines.push(`    labels:`);
-    lines.push(`      <<: *dev-prism-labels`);
-    lines.push(`      dev-prism.service: "${service.name}"`);
-    lines.push(`      dev-prism.internal_port: "${service.internalPort}"`);
-    lines.push(``);
-  }
-  lines.unshift(`# Compose project name: ${composeProjectName}`);
-  lines.unshift("");
-  return lines.join("\n");
-}
-function writeComposeFile(workingDir, projectName, services) {
-  const content = generateComposeFile(workingDir, projectName, services);
-  const filePath = resolve(workingDir, "docker-compose.session.yml");
-  writeFileSync(filePath, content, "utf-8");
-  return filePath;
-}
-function generateEnvStub(workingDir, projectName) {
-  const composeProjectName = getComposeProjectName(workingDir, projectName);
-  const lines = [
-    "# Auto-generated by dev-prism",
-    `COMPOSE_PROJECT_NAME=${composeProjectName}`,
-    `SESSION_DIR=${workingDir}`,
-    "",
-    "# Ports will be added after containers start"
-  ];
-  return lines.join("\n") + "\n";
-}
-function getComposeProjectName(workingDir, projectName) {
-  const dirHash = createHash("md5").update(workingDir).digest("hex").substring(0, 8);
-  return `${projectName}-${dirHash}`;
-}
-
-export {
-  generateComposeFile,
-  writeComposeFile,
-  generateEnvStub,
-  getComposeProjectName
-};