@chriscode/devmux 1.0.0 → 1.3.1

package/dist/chunk-ALENFKSX.js

@@ -0,0 +1,631 @@
+import {
+  __esm,
+  __export,
+  init_esm_shims
+} from "./chunk-66UOCF5R.js";
+
+// src/utils/worktree.ts
+import { execSync } from "child_process";
+function detectWorktreeName() {
+  try {
+    const gitDir = execSync("git rev-parse --git-dir", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const worktreeMatch = gitDir.match(/\.git\/worktrees\/([^/]+)/);
+    if (worktreeMatch) {
+      return worktreeMatch[1];
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function sanitizeInstanceId(name) {
+  return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 30);
+}
+function resolveInstanceId() {
+  const envInstanceId = process.env.DEVMUX_INSTANCE_ID;
+  if (envInstanceId) {
+    return sanitizeInstanceId(envInstanceId);
+  }
+  const worktreeName = detectWorktreeName();
+  if (worktreeName) {
+    return sanitizeInstanceId(worktreeName);
+  }
+  return "";
+}
+var init_worktree = __esm({
+  "src/utils/worktree.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/utils/port.ts
+function calculatePortOffset(instanceId) {
+  if (!instanceId) return 0;
+  let hash = 0;
+  for (let i = 0; i < instanceId.length; i++) {
+    hash = (hash << 5) - hash + instanceId.charCodeAt(i);
+    hash = hash & hash;
+  }
+  return Math.abs(hash) % 999 + 1;
+}
+function resolvePort(basePort, instanceId) {
+  return basePort + calculatePortOffset(instanceId);
+}
+var init_port = __esm({
+  "src/utils/port.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/config/loader.ts
+var loader_exports = {};
+__export(loader_exports, {
+  getBasePort: () => getBasePort,
+  getResolvedPort: () => getResolvedPort,
+  getServiceCwd: () => getServiceCwd,
+  getSessionName: () => getSessionName,
+  loadConfig: () => loadConfig
+});
+import { readFileSync, existsSync } from "fs";
+import { resolve, dirname } from "path";
+function findConfigFile(startDir) {
+  let dir = resolve(startDir);
+  const root = dirname(dir);
+  while (dir !== root) {
+    for (const name of CONFIG_NAMES) {
+      const configPath = resolve(dir, name);
+      if (existsSync(configPath)) {
+        return configPath;
+      }
+    }
+    const pkgPath = resolve(dir, "package.json");
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        if (pkg.devmux) {
+          return pkgPath;
+        }
+      } catch {
+      }
+    }
+    dir = dirname(dir);
+  }
+  return null;
+}
+function loadConfigFromFile(configPath) {
+  const content = readFileSync(configPath, "utf-8");
+  if (configPath.endsWith("package.json")) {
+    const pkg = JSON.parse(content);
+    return pkg.devmux;
+  }
+  return JSON.parse(content);
+}
+function validateConfig(config) {
+  if (!config || typeof config !== "object") return false;
+  const c = config;
+  if (c.version !== 1) return false;
+  if (typeof c.project !== "string") return false;
+  if (!c.services || typeof c.services !== "object") return false;
+  return true;
+}
+function loadConfig(startDir = process.cwd()) {
+  const configPath = findConfigFile(startDir);
+  if (!configPath) {
+    throw new Error(
+      "No devmux config found. Create devmux.config.json or add 'devmux' to package.json"
+    );
+  }
+  const config = loadConfigFromFile(configPath);
+  if (!validateConfig(config)) {
+    throw new Error(`Invalid devmux config in ${configPath}`);
+  }
+  const configRoot = dirname(configPath);
+  const resolvedSessionPrefix = config.sessionPrefix ?? `omo-${config.project}`;
+  const instanceId = resolveInstanceId();
+  return {
+    ...config,
+    configRoot,
+    resolvedSessionPrefix,
+    instanceId
+  };
+}
+function getSessionName(config, serviceName) {
+  const service = config.services[serviceName];
+  if (service?.sessionName) {
+    return service.sessionName;
+  }
+  if (config.instanceId) {
+    return `${config.resolvedSessionPrefix}-${config.instanceId}-${serviceName}`;
+  }
+  return `${config.resolvedSessionPrefix}-${serviceName}`;
+}
+function getServiceCwd(config, serviceName) {
+  const service = config.services[serviceName];
+  if (!service) {
+    throw new Error(`Unknown service: ${serviceName}`);
+  }
+  return resolve(config.configRoot, service.cwd);
+}
+function getBasePort(health, explicitPort) {
+  if (explicitPort !== void 0) return explicitPort;
+  if (!health) return void 0;
+  if (health.type === "port") return health.port;
+  if (health.type === "http") {
+    try {
+      const url = new URL(health.url);
+      return parseInt(url.port) || (url.protocol === "https:" ? 443 : 80);
+    } catch {
+      return void 0;
+    }
+  }
+  return void 0;
+}
+function getResolvedPort(config, serviceName) {
+  const service = config.services[serviceName];
+  if (!service) return void 0;
+  const basePort = getBasePort(service.health, service.port);
+  if (basePort === void 0) return void 0;
+  return resolvePort(basePort, config.instanceId);
+}
+var CONFIG_NAMES;
+var init_loader = __esm({
+  "src/config/loader.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_worktree();
+    init_port();
+    CONFIG_NAMES = [
+      "devmux.config.json",
+      ".devmuxrc.json",
+      ".devmuxrc"
+    ];
+  }
+});
+
+// src/tmux/driver.ts
+var driver_exports = {};
+__export(driver_exports, {
+  attachSession: () => attachSession,
+  hasSession: () => hasSession,
+  killSession: () => killSession,
+  listSessions: () => listSessions,
+  newSession: () => newSession,
+  setRemainOnExit: () => setRemainOnExit
+});
+init_esm_shims();
+import { execSync as execSync2, spawn } from "child_process";
+function hasSession(sessionName) {
+  try {
+    execSync2(`tmux has-session -t ${sessionName}`, {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function listSessions(prefix) {
+  try {
+    const output = execSync2("tmux list-sessions -F #{session_name}", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const sessions = output.trim().split("\n").filter(Boolean);
+    if (prefix) {
+      return sessions.filter((s) => s.startsWith(prefix));
+    }
+    return sessions;
+  } catch {
+    return [];
+  }
+}
+function newSession(sessionName, cwd, command, env) {
+  const envPrefix = env ? Object.entries(env).map(([k, v]) => `${k}=${v}`).join(" ") + " " : "";
+  execSync2(
+    `tmux new-session -d -s "${sessionName}" -c "${cwd}" "${envPrefix}${command}"`,
+    { stdio: ["pipe", "pipe", "pipe"] }
+  );
+}
+function setRemainOnExit(sessionName, value) {
+  try {
+    execSync2(
+      `tmux set-option -t "${sessionName}" remain-on-exit ${value ? "on" : "off"}`,
+      { stdio: ["pipe", "pipe", "pipe"] }
+    );
+  } catch {
+  }
+}
+function killSession(sessionName) {
+  try {
+    execSync2(`tmux kill-session -t "${sessionName}"`, {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch {
+  }
+}
+function attachSession(sessionName) {
+  const child = spawn("tmux", ["attach", "-t", sessionName], {
+    stdio: "inherit"
+  });
+  child.on("error", () => {
+  });
+}
+
+// src/health/checkers.ts
+var checkers_exports = {};
+__export(checkers_exports, {
+  checkHealth: () => checkHealth,
+  checkHttp: () => checkHttp,
+  checkPort: () => checkPort,
+  checkTmuxPane: () => checkTmuxPane,
+  getHealthPort: () => getHealthPort
+});
+init_esm_shims();
+import { createConnection } from "net";
+import { execSync as execSync3 } from "child_process";
+function checkPort(port, host = "127.0.0.1") {
+  return new Promise((resolve2) => {
+    const socket = createConnection({ port, host });
+    socket.setTimeout(1e3);
+    socket.on("connect", () => {
+      socket.destroy();
+      resolve2(true);
+    });
+    socket.on("timeout", () => {
+      socket.destroy();
+      resolve2(false);
+    });
+    socket.on("error", () => {
+      socket.destroy();
+      resolve2(false);
+    });
+  });
+}
+async function checkHttp(url, expectStatus = 200) {
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (expectStatus === 200) {
+      return response.ok || response.status === 404;
+    }
+    return response.status === expectStatus;
+  } catch {
+    return false;
+  }
+}
+function checkTmuxPane(sessionName) {
+  try {
+    const output = execSync3(
+      `tmux list-panes -t "${sessionName}" -F "#{pane_dead}"`,
+      { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+    );
+    return output.trim() === "0";
+  } catch {
+    return false;
+  }
+}
+async function checkHealth(health, sessionName) {
+  if (!health) {
+    return checkTmuxPane(sessionName);
+  }
+  switch (health.type) {
+    case "port":
+      return checkPort(health.port, health.host);
+    case "http":
+      return checkHttp(health.url, health.expectStatus);
+  }
+}
+function getHealthPort(health) {
+  if (!health) return void 0;
+  if (health.type === "port") return health.port;
+  if (health.type === "http") {
+    try {
+      const url = new URL(health.url);
+      return parseInt(url.port) || (url.protocol === "https:" ? 443 : 80);
+    } catch {
+      return void 0;
+    }
+  }
+  return void 0;
+}
+
+// src/core/service.ts
+init_esm_shims();
+init_loader();
+
+// src/utils/process.ts
+init_esm_shims();
+import fkill from "fkill";
+import psList from "ps-list";
+import { execSync as execSync4 } from "child_process";
+async function getProcessOnPort(port) {
+  try {
+    if (process.platform === "win32") {
+      const output2 = execSync4(`netstat -ano | findstr :${port}`, { encoding: "utf-8" });
+      const lines = output2.trim().split("\n");
+      for (const line of lines) {
+        const parts = line.trim().split(/\s+/);
+        if (parts.length >= 5) {
+          const pid2 = parseInt(parts[4], 10);
+          if (!isNaN(pid2)) {
+            const proc = await getProcessInfo(pid2);
+            if (proc) return proc;
+          }
+        }
+      }
+      return null;
+    }
+    const output = execSync4(`lsof -ti :${port}`, { encoding: "utf-8" }).trim();
+    if (!output) return null;
+    const pid = parseInt(output.split("\n")[0], 10);
+    if (isNaN(pid)) return null;
+    return await getProcessInfo(pid);
+  } catch {
+    return null;
+  }
+}
+async function getProcessInfo(pid) {
+  try {
+    const processes = await psList();
+    const proc = processes.find((p) => p.pid === pid);
+    if (!proc) return null;
+    return {
+      pid: proc.pid,
+      name: proc.name,
+      cmd: proc.cmd
+    };
+  } catch {
+    return null;
+  }
+}
+async function killProcess(pid) {
+  try {
+    await fkill(pid, { force: true });
+  } catch {
+  }
+}
+async function getProcessesOnPort(port) {
+  const processes = [];
+  try {
+    if (process.platform === "win32") {
+      const output = execSync4(`netstat -ano | findstr :${port}`, { encoding: "utf-8" });
+      const lines = output.trim().split("\n");
+      const seenPids = /* @__PURE__ */ new Set();
+      for (const line of lines) {
+        const parts = line.trim().split(/\s+/);
+        if (parts.length >= 5) {
+          const pid = parseInt(parts[4], 10);
+          if (!isNaN(pid) && !seenPids.has(pid)) {
+            seenPids.add(pid);
+            const proc = await getProcessInfo(pid);
+            if (proc) processes.push(proc);
+          }
+        }
+      }
+    } else {
+      const output = execSync4(`lsof -ti :${port}`, { encoding: "utf-8" }).trim();
+      if (output) {
+        const pids = output.split("\n").map((p) => parseInt(p, 10)).filter((p) => !isNaN(p));
+        const uniquePids = [...new Set(pids)];
+        for (const pid of uniquePids) {
+          const proc = await getProcessInfo(pid);
+          if (proc) processes.push(proc);
+        }
+      }
+    }
+  } catch {
+  }
+  return processes;
+}
+
+// src/core/service.ts
+async function ensureService(config, serviceName, options = {}, _dependencyStack = /* @__PURE__ */ new Set()) {
+  if (_dependencyStack.has(serviceName)) {
+    throw new Error(`Circular dependency detected: ${Array.from(_dependencyStack).join(" -> ")} -> ${serviceName}`);
+  }
+  const service = config.services[serviceName];
+  if (!service) {
+    throw new Error(`Unknown service: ${serviceName}`);
+  }
+  if (service.dependsOn && service.dependsOn.length > 0) {
+    _dependencyStack.add(serviceName);
+    try {
+      if (!options.quiet) console.log(`Checking dependencies for ${serviceName}...`);
+      for (const dep of service.dependsOn) {
+        await ensureService(config, dep, options, _dependencyStack);
+      }
+    } finally {
+      _dependencyStack.delete(serviceName);
+    }
+  }
+  const sessionName = getSessionName(config, serviceName);
+  const cwd = getServiceCwd(config, serviceName);
+  const timeout = options.timeout ?? config.defaults?.startupTimeoutSeconds ?? 30;
+  const log = options.quiet ? () => {
+  } : console.log;
+  const resolvedPort = getResolvedPort(config, serviceName);
+  const resolvedHealth = resolveHealthCheck(service.health, resolvedPort);
+  const env = buildServiceEnv(config, serviceName, service.env);
+  const isHealthy = await checkHealth(resolvedHealth, sessionName);
+  if (isHealthy) {
+    const hasTmux = hasSession(sessionName);
+    log(`\u2705 ${serviceName} already running`);
+    if (hasTmux) {
+      log(`   \u2514\u2500 tmux session: ${sessionName}`);
+    } else {
+      log(`   \u2514\u2500 (running outside tmux)`);
+    }
+    if (resolvedPort && config.instanceId) {
+      log(`   \u2514\u2500 port: ${resolvedPort} (instance: ${config.instanceId})`);
+    }
+    return { serviceName, startedByUs: false, sessionName };
+  }
+  if (hasSession(sessionName)) {
+    log(`\u{1F504} Cleaning up stale session: ${sessionName}`);
+    killSession(sessionName);
+  }
+  log(`\u{1F680} Starting ${serviceName} in tmux session: ${sessionName}`);
+  if (resolvedPort && config.instanceId) {
+    log(`   \u2514\u2500 port: ${resolvedPort} (instance: ${config.instanceId})`);
+  }
+  newSession(sessionName, cwd, service.command, env);
+  const remainOnExit = config.defaults?.remainOnExit ?? true;
+  setRemainOnExit(sessionName, remainOnExit);
+  log(`\u23F3 Waiting for ${serviceName} to be ready...`);
+  for (let i = 0; i < timeout; i++) {
+    if (await checkHealth(resolvedHealth, sessionName)) {
+      log(`\u2705 ${serviceName} ready`);
+      log(`   \u2514\u2500 tmux session: ${sessionName}`);
+      return { serviceName, startedByUs: true, sessionName };
+    }
+    await sleep(1e3);
+  }
+  throw new Error(`${serviceName} failed to start within ${timeout}s`);
+}
+async function getStatus(config, serviceName) {
+  const service = config.services[serviceName];
+  if (!service) {
+    throw new Error(`Unknown service: ${serviceName}`);
+  }
+  const sessionName = getSessionName(config, serviceName);
+  const resolvedPort = getResolvedPort(config, serviceName);
+  const resolvedHealth = resolveHealthCheck(service.health, resolvedPort);
+  const healthy = await checkHealth(resolvedHealth, sessionName);
+  const hasTmux = hasSession(sessionName);
+  return {
+    name: serviceName,
+    healthy,
+    tmuxSession: hasTmux ? sessionName : null,
+    port: getHealthPort(service.health),
+    resolvedPort,
+    managedByDevmux: hasTmux,
+    instanceId: config.instanceId || void 0
+  };
+}
+async function getAllStatus(config) {
+  const statuses = [];
+  for (const serviceName of Object.keys(config.services)) {
+    statuses.push(await getStatus(config, serviceName));
+  }
+  return statuses;
+}
+async function stopService(config, serviceName, options = {}) {
+  const service = config.services[serviceName];
+  if (!service) {
+    throw new Error(`Unknown service: ${serviceName}`);
+  }
+  const sessionName = getSessionName(config, serviceName);
+  const log = options.quiet ? () => {
+  } : console.log;
+  log(`\u{1F6D1} Stopping ${serviceName}...`);
+  if (hasSession(sessionName)) {
+    killSession(sessionName);
+    log(`   \u2514\u2500 Killed tmux session: ${sessionName}`);
+  }
+  if (options.killPorts) {
+    const resolvedPort = getResolvedPort(config, serviceName);
+    const ports = [];
+    if (resolvedPort) ports.push(resolvedPort);
+    if (service.stopPorts) {
+      for (const p of service.stopPorts) {
+        ports.push(p);
+      }
+    }
+    for (const port of [...new Set(ports)]) {
+      const processes = await getProcessesOnPort(port);
+      for (const proc of processes) {
+        await killProcess(proc.pid);
+        log(`   \u2514\u2500 Killed process ${proc.name} (PID ${proc.pid}) on port ${port}`);
+      }
+    }
+  }
+  log(`\u2705 ${serviceName} stopped`);
+}
+async function stopAllServices(config, options = {}) {
+  for (const serviceName of Object.keys(config.services)) {
+    await stopService(config, serviceName, options);
+  }
+}
+async function restartService(config, serviceName, options = {}) {
+  stopService(config, serviceName, { killPorts: options.killPorts, quiet: options.quiet });
+  return ensureService(config, serviceName, { timeout: options.timeout, quiet: options.quiet });
+}
+function attachService(config, serviceName) {
+  const service = config.services[serviceName];
+  if (!service) {
+    throw new Error(`Unknown service: ${serviceName}`);
+  }
+  const sessionName = getSessionName(config, serviceName);
+  if (!hasSession(sessionName)) {
+    throw new Error(`No tmux session for ${serviceName}. Service may not be running or was started outside tmux.`);
+  }
+  console.log(`\u{1F4CE} Attaching to ${sessionName}...`);
+  console.log(`   (detach with Ctrl+B, then D)`);
+  attachSession(sessionName);
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+function resolveHealthCheck(health, resolvedPort) {
+  if (!health) return void 0;
+  if (resolvedPort === void 0) return health;
+  if (health.type === "port") {
+    return { ...health, port: resolvedPort };
+  }
+  if (health.type === "http") {
+    try {
+      const url = new URL(health.url);
+      url.port = String(resolvedPort);
+      return { ...health, url: url.toString() };
+    } catch {
+      return health;
+    }
+  }
+  return health;
+}
+function buildServiceEnv(config, serviceName, userEnv) {
+  const resolvedPort = getResolvedPort(config, serviceName);
+  const env = {};
+  if (resolvedPort !== void 0) {
+    env.PORT = String(resolvedPort);
+    env.DEVMUX_PORT = String(resolvedPort);
+  }
+  if (config.instanceId) {
+    env.DEVMUX_INSTANCE_ID = config.instanceId;
+  }
+  env.DEVMUX_SERVICE = serviceName;
+  env.DEVMUX_PROJECT = config.project;
+  if (userEnv) {
+    for (const [key, value] of Object.entries(userEnv)) {
+      env[key] = value.replace(/\{\{PORT\}\}/g, String(resolvedPort ?? "")).replace(/\{\{INSTANCE\}\}/g, config.instanceId).replace(/\{\{SERVICE\}\}/g, serviceName).replace(/\{\{PROJECT\}\}/g, config.project);
+    }
+  }
+  return env;
+}
+
+export {
+  loadConfig,
+  getSessionName,
+  getServiceCwd,
+  loader_exports,
+  init_loader,
+  hasSession,
+  driver_exports,
+  checkHealth,
+  checkers_exports,
+  getProcessOnPort,
+  ensureService,
+  getStatus,
+  getAllStatus,
+  stopService,
+  stopAllServices,
+  restartService,
+  attachService
+};