dev-prism 0.4.0 → 0.7.0

package/dist/{chunk-7YGOMAJG.js → chunk-3CIXBEXK.js}

@@ -4,31 +4,29 @@ import { join } from "path";
 import chalk from "chalk";
 var SKILL_CONTENT = `---
 allowed-tools: Bash(dev-prism *)
-description: Manage isolated development sessions (create, list, start, stop, destroy)
+description: Manage isolated development sessions (create, destroy, list, env, with-env)
 ---
 
 # Dev Session Manager
 
-Manage isolated parallel development sessions using git worktrees and Docker.
+Manage isolated parallel development sessions with port allocation and env injection.
 
 ## Parse Intent from: $ARGUMENTS
 
 - "create" / "new" -> dev-prism create
 - "list" / "status" -> dev-prism list
-- "start <id>" -> dev-prism start <id>
-- "stop <id>" -> dev-prism stop <id>
-- "destroy <id>" -> dev-prism destroy <id>
-- "logs <id>" -> dev-prism logs <id>
-- "stop all" -> dev-prism stop-all
+- "info" -> dev-prism info
+- "destroy" -> dev-prism destroy
+- "env" -> dev-prism env
 - "prune" -> dev-prism prune
 
 ## Commands
 
-Run from the project root (where session.config.mjs exists).
+Run from the project root (where prism.config.mjs exists).
 
 After running commands, explain:
 1. What happened
-2. Relevant ports/paths
+2. Relevant ports/env vars
 3. Next steps
 
 Warn before destructive operations (destroy, prune).
@@ -36,33 +34,29 @@ Warn before destructive operations (destroy, prune).
 var CLAUDE_MD_SECTION = `
 ## Dev Sessions
 
-Isolated parallel development sessions using git worktrees and Docker.
+Port allocator, env injector, and worktree manager for parallel development.
 
 ### Commands
 \`\`\`bash
-dev-prism create [id]      # Create session (auto-assigns ID)
-dev-prism list             # Show all sessions with status
-dev-prism start <id>       # Start stopped session
-dev-prism stop <id>        # Stop session (preserves data)
-dev-prism stop-all         # Stop all running sessions
-dev-prism destroy <id>     # Remove session completely
-dev-prism logs <id>        # Stream Docker logs
-dev-prism prune            # Remove stopped sessions
+dev-prism create [--branch <name>] [--in-place]  # Allocate ports + optional worktree
+dev-prism destroy [--all]                         # Deallocate ports + remove worktree
+dev-prism list                                    # List sessions from SQLite
+dev-prism info                                    # Show session ports/env for cwd
+dev-prism with-env -- <command>                   # Inject env + exec command
+dev-prism with-env <app> -- <command>             # Inject app-specific env + exec
+dev-prism env [--write <path>] [--app <name>]     # Print/write env vars
+dev-prism prune [-y]                              # Remove orphaned sessions
 \`\`\`
 
 ### Port Allocation
-Port = 47000 + (sessionId \xD7 100) + offset
-
-| Service | Offset | Session 001 |
-|---------|--------|-------------|
-| APP     | 0      | 47100       |
-| WEB     | 1      | 47101       |
-| POSTGRES| 10     | 47110       |
+Ports are allocated dynamically using \`get-port\` and stored in SQLite.
+Each service gets a unique port. Use \`dev-prism info\` to see allocated ports.
 
 ### AI Notes
-- In sessions, use DATABASE_URL from \`.env.session\`
-- Run \`dev-prism list\` to discover ports
-- Commands run from project root, not session worktrees
+- Use \`dev-prism with-env -- <cmd>\` to run commands with session env injected
+- \`with-env\` is a no-op outside a session \u2014 safe to use unconditionally
+- Use \`dev-prism env\` to see all env vars for the current session
+- Docker is not managed by dev-prism \u2014 users manage their own compose files
 `;
 async function installClaude(projectRoot, options) {
   const skillDir = join(projectRoot, ".claude", "commands");

package/dist/chunk-AHC6CD7F.js

@@ -0,0 +1,92 @@
+import {
+  removeWorktree
+} from "./chunk-NJAITOCG.js";
+import {
+  getSessionsDir,
+  loadConfig
+} from "./chunk-TSNFAXVQ.js";
+import {
+  deleteDbSession,
+  findProjectRoot,
+  getDbSession,
+  listDbSessions,
+  openDatabase
+} from "./chunk-IWZN6P6M.js";
+
+// src/commands/destroy.ts
+import { existsSync } from "fs";
+import chalk from "chalk";
+async function destroySession(workingDir, options) {
+  let projectRoot;
+  try {
+    projectRoot = findProjectRoot(workingDir);
+  } catch {
+    console.error(chalk.red("Error: Could not find prism.config.mjs"));
+    process.exit(1);
+  }
+  const db = openDatabase();
+  try {
+    if (options.all) {
+      console.log(chalk.blue("Destroying all sessions..."));
+      const sessions = listDbSessions(db);
+      if (sessions.length === 0) {
+        console.log(chalk.gray("No sessions found."));
+        return;
+      }
+      const config2 = await loadConfig(projectRoot);
+      const sessionsDir2 = getSessionsDir(config2, projectRoot);
+      for (const session2 of sessions) {
+        await destroySingleSession(
+          db,
+          projectRoot,
+          sessionsDir2,
+          session2.id,
+          session2.branch
+        );
+      }
+      console.log(chalk.green(`
+Destroyed ${sessions.length} session(s).`));
+      return;
+    }
+    const session = getDbSession(db, workingDir);
+    if (!session) {
+      console.error(
+        chalk.red(`Error: No session found for ${workingDir}`)
+      );
+      process.exit(1);
+    }
+    const config = await loadConfig(projectRoot);
+    const sessionsDir = getSessionsDir(config, projectRoot);
+    await destroySingleSession(
+      db,
+      projectRoot,
+      sessionsDir,
+      session.id,
+      session.branch
+    );
+    console.log(chalk.green("\nSession destroyed."));
+  } finally {
+    db.close();
+  }
+}
+async function destroySingleSession(db, projectRoot, sessionsDir, sessionId, branch) {
+  console.log(chalk.blue(`
+Destroying session in ${sessionId}...`));
+  deleteDbSession(db, sessionId);
+  console.log(chalk.gray("  Removed from database."));
+  if (branch && sessionId.startsWith(sessionsDir) && existsSync(sessionId)) {
+    console.log(chalk.gray("  Removing git worktree..."));
+    try {
+      await removeWorktree(projectRoot, sessionId, branch);
+    } catch (error) {
+      console.warn(
+        chalk.yellow(`  Warning: Could not remove worktree: ${error}`)
+      );
+    }
+  }
+  console.log(chalk.green("  Session destroyed."));
+}
+
+export {
+  destroySession
+};

package/dist/chunk-FQTS57VO.js

@@ -0,0 +1,64 @@
+import {
+  deleteDbSession,
+  listDbSessions,
+  openDatabase
+} from "./chunk-IWZN6P6M.js";
+
+// src/commands/prune.ts
+import { existsSync } from "fs";
+import { createInterface } from "readline";
+import chalk from "chalk";
+async function pruneSessions(options) {
+  const db = openDatabase();
+  try {
+    const sessions = listDbSessions(db);
+    const orphaned = sessions.filter((s) => !existsSync(s.id));
+    if (orphaned.length === 0) {
+      console.log(chalk.gray("No orphaned sessions to prune."));
+      return;
+    }
+    console.log(
+      chalk.yellow(
+        `
+Found ${orphaned.length} orphaned session(s) to prune:`
+      )
+    );
+    for (const session of orphaned) {
+      console.log(chalk.gray(`  - ${session.id}`));
+    }
+    console.log("");
+    if (!options.yes) {
+      const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      const answer = await new Promise((resolve) => {
+        rl.question(
+          chalk.red("Remove these orphaned sessions from the database? [y/N] "),
+          resolve
+        );
+      });
+      rl.close();
+      if (answer.toLowerCase() !== "y" && answer.toLowerCase() !== "yes") {
+        console.log(chalk.gray("Cancelled."));
+        return;
+      }
+    }
+    console.log(chalk.blue("\nPruning orphaned sessions...\n"));
+    for (const session of orphaned) {
+      console.log(chalk.gray(`  Removing ${session.id}...`));
+      deleteDbSession(db, session.id);
+      console.log(chalk.green(`  Removed.`));
+    }
+    console.log(
+      chalk.green(`
+Pruned ${orphaned.length} orphaned session(s).`)
+    );
+  } finally {
+    db.close();
+  }
+}
+
+export {
+  pruneSessions
+};

package/dist/chunk-GWQPK7MZ.js

@@ -0,0 +1,50 @@
+// src/lib/env.ts
+import { createHash } from "crypto";
+import { basename } from "path";
+function renderTemplate(template, ports) {
+  const result = {};
+  for (const [key, value] of Object.entries(template)) {
+    let rendered = value;
+    for (const [serviceName, portValue] of Object.entries(ports)) {
+      rendered = rendered.replace(
+        new RegExp(`\\$\\{${serviceName}\\}`, "g"),
+        String(portValue)
+      );
+    }
+    result[key] = rendered;
+  }
+  return result;
+}
+function buildSessionEnv(config, workingDir, allocations, appName) {
+  const ports = {};
+  for (const alloc of allocations) {
+    ports[alloc.service] = alloc.port;
+  }
+  const env = {};
+  env.COMPOSE_PROJECT_NAME = getComposeProjectName(
+    workingDir,
+    config.projectName
+  );
+  if (config.env) {
+    Object.assign(env, renderTemplate(config.env, ports));
+  }
+  if (appName && config.apps?.[appName]) {
+    Object.assign(env, renderTemplate(config.apps[appName], ports));
+  }
+  return env;
+}
+function formatEnvFile(env) {
+  return Object.entries(env).map(([key, value]) => `${key}=${value}`).join("\n") + "\n";
+}
+function getComposeProjectName(workingDir, projectName) {
+  const name = projectName ?? basename(workingDir);
+  const dirHash = createHash("md5").update(workingDir).digest("hex").substring(0, 8);
+  return `${name}-${dirHash}`;
+}
+
+export {
+  renderTemplate,
+  buildSessionEnv,
+  formatEnvFile,
+  getComposeProjectName
+};

package/dist/chunk-HDGBJGIH.js

@@ -0,0 +1,55 @@
+import {
+  buildSessionEnv,
+  formatEnvFile
+} from "./chunk-GWQPK7MZ.js";
+import {
+  loadConfig
+} from "./chunk-TSNFAXVQ.js";
+import {
+  findProjectRoot,
+  getDbSession,
+  getPortAllocations,
+  openDatabase
+} from "./chunk-IWZN6P6M.js";
+
+// src/commands/env.ts
+import { writeFileSync } from "fs";
+import { resolve } from "path";
+import chalk from "chalk";
+async function showEnv(options) {
+  const cwd = process.cwd();
+  let projectRoot;
+  try {
+    projectRoot = findProjectRoot(cwd);
+  } catch {
+    console.error(chalk.red("Error: Could not find prism.config.mjs"));
+    process.exit(1);
+  }
+  const db = openDatabase();
+  try {
+    const session = getDbSession(db, cwd);
+    if (!session) {
+      console.error(chalk.red("Error: No session found for this directory."));
+      console.error(
+        chalk.gray("Run `dev-prism create --in-place` to create a session here.")
+      );
+      process.exit(1);
+    }
+    const ports = getPortAllocations(db, session.id);
+    const config = await loadConfig(projectRoot);
+    const env = buildSessionEnv(config, cwd, ports, options.app);
+    if (options.write) {
+      const filePath = resolve(cwd, options.write);
+      writeFileSync(filePath, formatEnvFile(env), "utf-8");
+      console.error(chalk.green(`Written: ${filePath}`));
+    } else {
+      process.stdout.write(formatEnvFile(env));
+    }
+  } finally {
+    db.close();
+  }
+}
+
+export {
+  showEnv
+};

package/dist/chunk-ILICQAU7.js

@@ -0,0 +1,60 @@
+import {
+  buildSessionEnv
+} from "./chunk-GWQPK7MZ.js";
+import {
+  loadConfig
+} from "./chunk-TSNFAXVQ.js";
+import {
+  findProjectRoot,
+  getDbSession,
+  getPortAllocations,
+  openDatabase
+} from "./chunk-IWZN6P6M.js";
+
+// src/commands/with-env.ts
+import { execa } from "execa";
+async function withEnv(command, appName) {
+  if (command.length === 0) {
+    console.error("Usage: dev-prism with-env [app] -- <command>");
+    process.exit(1);
+  }
+  const cwd = process.cwd();
+  let sessionEnv = {};
+  try {
+    const projectRoot = findProjectRoot(cwd);
+    const db = openDatabase();
+    try {
+      const session = getDbSession(db, cwd);
+      if (session) {
+        const ports = getPortAllocations(db, session.id);
+        const config = await loadConfig(projectRoot);
+        sessionEnv = buildSessionEnv(config, cwd, ports, appName);
+      }
+    } finally {
+      db.close();
+    }
+  } catch {
+  }
+  const [cmd, ...args] = command;
+  const merged = {
+    ...process.env,
+    ...sessionEnv
+  };
+  try {
+    const result = await execa(cmd, args, {
+      stdio: "inherit",
+      env: merged,
+      reject: false
+    });
+    if (result.exitCode !== void 0 && result.exitCode !== 0) {
+      process.exit(result.exitCode);
+    }
+  } catch (error) {
+    console.error(error.message);
+    process.exit(1);
+  }
+}
+
+export {
+  withEnv
+};

package/dist/chunk-IWZN6P6M.js

@@ -0,0 +1,155 @@
+// src/lib/db.ts
+import Database from "better-sqlite3";
+import getPort from "get-port";
+import { existsSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { dirname, join, resolve } from "path";
+var SCHEMA = `
+CREATE TABLE IF NOT EXISTS sessions (
+  id         TEXT PRIMARY KEY,
+  branch     TEXT,
+  created_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS port_allocations (
+  session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+  service    TEXT NOT NULL,
+  port       INTEGER NOT NULL UNIQUE,
+  PRIMARY KEY (session_id, service)
+);
+
+CREATE TABLE IF NOT EXISTS reservations (
+  port       INTEGER PRIMARY KEY,
+  reason     TEXT,
+  created_at TEXT NOT NULL
+);
+`;
+function openDatabase() {
+  const dbDir = join(homedir(), ".dev-prism");
+  if (!existsSync(dbDir)) {
+    mkdirSync(dbDir, { recursive: true });
+  }
+  const db = new Database(join(dbDir, "sessions.db"));
+  db.pragma("journal_mode = WAL");
+  db.pragma("busy_timeout = 5000");
+  db.pragma("foreign_keys = ON");
+  db.exec(SCHEMA);
+  return db;
+}
+function findProjectRoot(startDir) {
+  let dir = resolve(startDir);
+  while (true) {
+    if (existsSync(join(dir, "prism.config.mjs")) || existsSync(join(dir, "prism.config.js"))) {
+      return dir;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) {
+      throw new Error(
+        "Could not find prism.config.mjs in any parent directory"
+      );
+    }
+    dir = parent;
+  }
+}
+function createDbSession(db, session) {
+  db.prepare(
+    "INSERT INTO sessions (id, branch, created_at) VALUES (?, ?, ?)"
+  ).run(session.id, session.branch, session.created_at);
+}
+function deleteDbSession(db, sessionId) {
+  db.prepare("DELETE FROM sessions WHERE id = ?").run(sessionId);
+}
+function getDbSession(db, sessionId) {
+  return db.prepare("SELECT id, branch, created_at FROM sessions WHERE id = ?").get(sessionId);
+}
+function listDbSessions(db) {
+  return db.prepare("SELECT id, branch, created_at FROM sessions ORDER BY created_at").all();
+}
+function getPortAllocations(db, sessionId) {
+  return db.prepare(
+    "SELECT session_id, service, port FROM port_allocations WHERE session_id = ?"
+  ).all(sessionId);
+}
+function getAllocatedPorts(db) {
+  return db.prepare("SELECT port FROM port_allocations").all().map((r) => r.port);
+}
+function getReservedPorts(db) {
+  return db.prepare("SELECT port FROM reservations").all().map((r) => r.port);
+}
+function reservePort(db, port, reason) {
+  db.prepare(
+    "INSERT INTO reservations (port, reason, created_at) VALUES (?, ?, ?)"
+  ).run(port, reason ?? null, (/* @__PURE__ */ new Date()).toISOString());
+}
+function unreservePort(db, port) {
+  db.prepare("DELETE FROM reservations WHERE port = ?").run(port);
+}
+async function allocatePorts(db, sessionId, services) {
+  if (services.length === 0) return [];
+  const excludePorts = /* @__PURE__ */ new Set([
+    ...getAllocatedPorts(db),
+    ...getReservedPorts(db)
+  ]);
+  const allocations = [];
+  for (const name of services) {
+    const port = await getPort({ exclude: [...excludePorts] });
+    excludePorts.add(port);
+    allocations.push({
+      session_id: sessionId,
+      service: name,
+      port
+    });
+  }
+  const insert = db.prepare(
+    "INSERT INTO port_allocations (session_id, service, port) VALUES (?, ?, ?)"
+  );
+  try {
+    const insertAll = db.transaction(() => {
+      for (const alloc of allocations) {
+        insert.run(alloc.session_id, alloc.service, alloc.port);
+      }
+    });
+    insertAll();
+  } catch (err) {
+    if (err.code === "SQLITE_CONSTRAINT_UNIQUE") {
+      const retryExclude = /* @__PURE__ */ new Set([
+        ...getAllocatedPorts(db),
+        ...getReservedPorts(db)
+      ]);
+      const retryAllocations = [];
+      for (const name of services) {
+        const port = await getPort({ exclude: [...retryExclude] });
+        retryExclude.add(port);
+        retryAllocations.push({
+          session_id: sessionId,
+          service: name,
+          port
+        });
+      }
+      const insertAllRetry = db.transaction(() => {
+        for (const alloc of retryAllocations) {
+          insert.run(alloc.session_id, alloc.service, alloc.port);
+        }
+      });
+      insertAllRetry();
+      return retryAllocations;
+    }
+    throw err;
+  }
+  return allocations;
+}
+
+export {
+  openDatabase,
+  findProjectRoot,
+  createDbSession,
+  deleteDbSession,
+  getDbSession,
+  listDbSessions,
+  getPortAllocations,
+  getAllocatedPorts,
+  getReservedPorts,
+  reservePort,
+  unreservePort,
+  allocatePorts
+};

package/dist/chunk-KP56QH72.js

@@ -0,0 +1,133 @@
+import {
+  createWorktree,
+  generateDefaultBranchName,
+  removeWorktree
+} from "./chunk-NJAITOCG.js";
+import {
+  buildSessionEnv
+} from "./chunk-GWQPK7MZ.js";
+import {
+  getSessionsDir,
+  loadConfig
+} from "./chunk-TSNFAXVQ.js";
+import {
+  allocatePorts,
+  createDbSession,
+  getDbSession,
+  openDatabase
+} from "./chunk-IWZN6P6M.js";
+
+// src/commands/create.ts
+import { existsSync, mkdirSync } from "fs";
+import { resolve } from "path";
+import chalk from "chalk";
+import { execa } from "execa";
+async function createSession(projectRoot, options) {
+  const config = await loadConfig(projectRoot);
+  const sessionsDir = getSessionsDir(config, projectRoot);
+  const inPlace = options.inPlace ?? false;
+  let workingDir;
+  let branchName = "";
+  if (inPlace) {
+    workingDir = projectRoot;
+    console.log(chalk.blue("Creating session in current directory..."));
+  } else {
+    branchName = options.branch || generateDefaultBranchName();
+    workingDir = resolve(sessionsDir, branchName);
+    console.log(chalk.blue("Creating session..."));
+    console.log(chalk.gray(`Branch: ${branchName}`));
+    console.log(chalk.gray(`Directory: ${workingDir}`));
+  }
+  const db = openDatabase();
+  try {
+    if (getDbSession(db, workingDir)) {
+      console.error(chalk.red("Error: Session already exists for this directory."));
+      console.error(chalk.gray("Destroy it first with: dev-prism destroy"));
+      process.exit(1);
+    }
+    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}`));
+    }
+    createDbSession(db, {
+      id: workingDir,
+      branch: branchName || null,
+      created_at: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    console.log(chalk.blue("\nAllocating ports..."));
+    const allocations = await allocatePorts(db, workingDir, config.ports);
+    if (allocations.length > 0) {
+      console.log(chalk.gray("Allocated ports:"));
+      for (const alloc of allocations) {
+        console.log(
+          chalk.cyan(`  ${alloc.service}: ${alloc.port}`)
+        );
+      }
+    }
+    if (config.setup.length > 0) {
+      console.log(chalk.blue("\nRunning setup commands..."));
+      const sessionEnv = buildSessionEnv(config, workingDir, allocations);
+      const setupEnv = {
+        ...process.env,
+        ...sessionEnv
+      };
+      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("\nSession ready!"));
+    console.log(chalk.gray(`Directory: ${workingDir}`));
+    if (allocations.length > 0) {
+      console.log(chalk.gray("\nPorts:"));
+      for (const alloc of allocations) {
+        console.log(
+          chalk.cyan(`  ${alloc.service}: http://localhost:${alloc.port}`)
+        );
+      }
+    }
+    console.log(chalk.gray("\nUsage:"));
+    console.log(
+      chalk.gray("  dev-prism with-env -- docker compose up -d")
+    );
+    console.log(
+      chalk.gray("  dev-prism with-env -- pnpm dev")
+    );
+    console.log(
+      chalk.gray("  dev-prism env                # show env vars")
+    );
+  } catch (error) {
+    console.error(chalk.red("Session creation failed. Cleaning up..."));
+    try {
+      const { deleteDbSession } = await import("./lib/db.js");
+      deleteDbSession(db, workingDir);
+    } catch {
+    }
+    if (!inPlace && branchName) {
+      try {
+        await removeWorktree(projectRoot, workingDir, branchName);
+      } catch {
+      }
+    }
+    throw error;
+  } finally {
+    db.close();
+  }
+}
+
+export {
+  createSession
+};