@chriscode/devmux 1.0.0 → 1.2.0

package/dist/chunk-7JJYYMUP.js

@@ -1,542 +0,0 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/config/loader.ts
-import { readFileSync, existsSync } from "fs";
-import { resolve, dirname } from "path";
-var CONFIG_NAMES = [
-  "devmux.config.json",
-  ".devmuxrc.json",
-  ".devmuxrc"
-];
-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}`;
-  return {
-    ...config,
-    configRoot,
-    resolvedSessionPrefix
-  };
-}
-function getSessionName(config, serviceName) {
-  const service = config.services[serviceName];
-  if (service?.sessionName) {
-    return service.sessionName;
-  }
-  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);
-}
-
-// src/tmux/driver.ts
-var driver_exports = {};
-__export(driver_exports, {
-  attachSession: () => attachSession,
-  hasSession: () => hasSession,
-  killSession: () => killSession,
-  listSessions: () => listSessions,
-  newSession: () => newSession,
-  setRemainOnExit: () => setRemainOnExit
-});
-import { execSync, spawn } from "child_process";
-function hasSession(sessionName) {
-  try {
-    execSync(`tmux has-session -t ${sessionName}`, {
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function listSessions(prefix) {
-  try {
-    const output = execSync("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(" ") + " " : "";
-  execSync(
-    `tmux new-session -d -s "${sessionName}" -c "${cwd}" "${envPrefix}${command}"`,
-    { stdio: ["pipe", "pipe", "pipe"] }
-  );
-}
-function setRemainOnExit(sessionName, value) {
-  try {
-    execSync(
-      `tmux set-option -t "${sessionName}" remain-on-exit ${value ? "on" : "off"}`,
-      { stdio: ["pipe", "pipe", "pipe"] }
-    );
-  } catch {
-  }
-}
-function killSession(sessionName) {
-  try {
-    execSync(`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,
-  getHealthPort: () => getHealthPort
-});
-import { createConnection } from "net";
-function checkPort(port, host = "127.0.0.1") {
-  return new Promise((resolve3) => {
-    const socket = createConnection({ port, host });
-    socket.setTimeout(1e3);
-    socket.on("connect", () => {
-      socket.destroy();
-      resolve3(true);
-    });
-    socket.on("timeout", () => {
-      socket.destroy();
-      resolve3(false);
-    });
-    socket.on("error", () => {
-      socket.destroy();
-      resolve3(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;
-  }
-}
-async function checkHealth(health) {
-  switch (health.type) {
-    case "port":
-      return checkPort(health.port, health.host);
-    case "http":
-      return checkHttp(health.url, health.expectStatus);
-    case "none":
-      return false;
-  }
-}
-function getHealthPort(health) {
-  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
-import { execSync as execSync2 } from "child_process";
-
-// src/utils/lock.ts
-import { mkdirSync, rmdirSync, existsSync as existsSync2 } from "fs";
-import { tmpdir } from "os";
-import { join } from "path";
-function acquireLock(name) {
-  const lockDir = join(tmpdir(), `${name}.lock`);
-  try {
-    mkdirSync(lockDir);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function releaseLock(name) {
-  const lockDir = join(tmpdir(), `${name}.lock`);
-  try {
-    rmdirSync(lockDir);
-  } catch {
-  }
-}
-
-// src/core/service.ts
-async function ensureService(config, serviceName, options = {}) {
-  const service = config.services[serviceName];
-  if (!service) {
-    throw new Error(`Unknown service: ${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 isHealthy = await checkHealth(service.health);
-  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)`);
-    }
-    return { serviceName, startedByUs: false, sessionName };
-  }
-  if (!acquireLock(sessionName)) {
-    log(`\u23F3 Another process is starting ${serviceName}, waiting...`);
-    for (let i = 0; i < 10; i++) {
-      await sleep(1e3);
-      if (await checkHealth(service.health)) {
-        log(`\u2705 ${serviceName} now running`);
-        return { serviceName, startedByUs: false, sessionName };
-      }
-    }
-    throw new Error(`${serviceName} failed to start (locked by another process)`);
-  }
-  try {
-    if (hasSession(sessionName)) {
-      log(`\u{1F504} Cleaning up stale session: ${sessionName}`);
-      killSession(sessionName);
-    }
-    log(`\u{1F680} Starting ${serviceName} in tmux session: ${sessionName}`);
-    newSession(sessionName, cwd, service.command, service.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(service.health)) {
-        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`);
-  } finally {
-    releaseLock(sessionName);
-  }
-}
-async function getStatus(config, serviceName) {
-  const service = config.services[serviceName];
-  if (!service) {
-    throw new Error(`Unknown service: ${serviceName}`);
-  }
-  const sessionName = getSessionName(config, serviceName);
-  const healthy = await checkHealth(service.health);
-  const hasTmux = hasSession(sessionName);
-  return {
-    name: serviceName,
-    healthy,
-    tmuxSession: hasTmux ? sessionName : null,
-    port: getHealthPort(service.health),
-    managedByDevmux: hasTmux
-  };
-}
-async function getAllStatus(config) {
-  const statuses = [];
-  for (const serviceName of Object.keys(config.services)) {
-    statuses.push(await getStatus(config, serviceName));
-  }
-  return statuses;
-}
-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 ports = service.stopPorts ?? [];
-    const healthPort = getHealthPort(service.health);
-    if (healthPort) ports.push(healthPort);
-    for (const port of [...new Set(ports)]) {
-      try {
-        const pids = execSync2(`lsof -ti :${port}`, { encoding: "utf-8" }).trim();
-        if (pids) {
-          execSync2(`kill -9 ${pids.split("\n").join(" ")}`, { stdio: "pipe" });
-          log(`   \u2514\u2500 Killed process(es) on port ${port}`);
-        }
-      } catch {
-      }
-    }
-  }
-  log(`\u2705 ${serviceName} stopped`);
-}
-function stopAllServices(config, options = {}) {
-  for (const serviceName of Object.keys(config.services)) {
-    stopService(config, serviceName, options);
-  }
-}
-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((resolve3) => setTimeout(resolve3, ms));
-}
-
-// src/core/run.ts
-import { spawn as spawn2 } from "child_process";
-async function runWithServices(config, command, options) {
-  const { services, stopOnExit = true, quiet = false } = options;
-  const log = quiet ? () => {
-  } : console.log;
-  const startedByUs = [];
-  for (const serviceName of services) {
-    const service = config.services[serviceName];
-    if (!service) {
-      console.error(`\u274C Unknown service: ${serviceName}`);
-      process.exit(1);
-    }
-    const wasHealthy = await checkHealth(service.health);
-    if (wasHealthy) {
-      log(`\u2705 ${serviceName} already running (will keep on exit)`);
-    } else {
-      const result = await ensureService(config, serviceName, { quiet });
-      if (result.startedByUs) {
-        startedByUs.push(result);
-        log(`   (will stop on Ctrl+C)`);
-      }
-    }
-  }
-  log("");
-  const cleanup = () => {
-    if (stopOnExit && startedByUs.length > 0) {
-      log("");
-      log("\u{1F9F9} Cleaning up services we started...");
-      for (const result of startedByUs) {
-        stopService(config, result.serviceName, { killPorts: true, quiet: true });
-        log(`   \u2514\u2500 Stopped ${result.serviceName}`);
-      }
-    }
-  };
-  process.on("SIGINT", () => {
-    cleanup();
-    process.exit(130);
-  });
-  process.on("SIGTERM", () => {
-    cleanup();
-    process.exit(143);
-  });
-  process.on("exit", cleanup);
-  const [cmd, ...args] = command;
-  const child = spawn2(cmd, args, {
-    stdio: "inherit",
-    shell: true
-  });
-  return new Promise((resolve3) => {
-    child.on("close", (code) => {
-      resolve3(code ?? 0);
-    });
-    child.on("error", (err) => {
-      console.error(`Failed to run command: ${err.message}`);
-      resolve3(1);
-    });
-  });
-}
-
-// src/discovery/turbo.ts
-import { readFileSync as readFileSync2, existsSync as existsSync3 } from "fs";
-import { resolve as resolve2, relative } from "path";
-function loadTurboConfig(root) {
-  const turboPath = resolve2(root, "turbo.json");
-  if (!existsSync3(turboPath)) return null;
-  try {
-    return JSON.parse(readFileSync2(turboPath, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function getPersistentTasks(turbo) {
-  const tasks = turbo.tasks ?? turbo.pipeline ?? {};
-  return Object.entries(tasks).filter(([_, task]) => task.persistent).map(([name]) => name.replace(/^\/\/#/, ""));
-}
-function findWorkspacePackages(root) {
-  const packages = [];
-  const rootPkg = resolve2(root, "package.json");
-  if (!existsSync3(rootPkg)) return packages;
-  try {
-    const pkg = JSON.parse(
-      readFileSync2(rootPkg, "utf-8")
-    );
-    const workspaces = pkg.workspaces ?? [];
-    for (const pattern of workspaces) {
-      const cleanPattern = pattern.replace(/\/\*$/, "");
-      const pkgPath = resolve2(root, cleanPattern, "package.json");
-      if (existsSync3(pkgPath)) {
-        const subPkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
-        packages.push({
-          name: subPkg.name ?? cleanPattern,
-          path: relative(root, resolve2(root, cleanPattern)) || ".",
-          scripts: Object.keys(subPkg.scripts ?? {})
-        });
-      }
-    }
-    for (const subdir of ["app", "api", "web", "packages", "apps"]) {
-      const pkgPath = resolve2(root, subdir, "package.json");
-      if (existsSync3(pkgPath) && !packages.some((p) => p.path === subdir)) {
-        const subPkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
-        packages.push({
-          name: subPkg.name ?? subdir,
-          path: subdir,
-          scripts: Object.keys(subPkg.scripts ?? {})
-        });
-      }
-    }
-  } catch {
-  }
-  return packages;
-}
-function discoverFromTurbo(root) {
-  const turbo = loadTurboConfig(root);
-  if (!turbo) return null;
-  const persistentTasks = getPersistentTasks(turbo);
-  if (persistentTasks.length === 0) return null;
-  const packages = findWorkspacePackages(root);
-  const services = {};
-  for (const pkg of packages) {
-    for (const task of persistentTasks) {
-      if (pkg.scripts.includes(task)) {
-        const serviceName = pkg.path === "." ? task : `${pkg.path.replace(/\//g, "-")}-${task}`;
-        services[serviceName] = {
-          cwd: pkg.path,
-          command: `pnpm ${task}`,
-          health: { type: "none" }
-        };
-      }
-    }
-  }
-  if (Object.keys(services).length === 0) return null;
-  return {
-    version: 1,
-    project: "my-project",
-    services
-  };
-}
-function formatDiscoveredConfig(config) {
-  const lines = [
-    "# Discovered from turbo.json",
-    "# Review and update:",
-    "#   1. Set 'project' name",
-    "#   2. Add health checks (port or http) for each service",
-    "#   3. Remove services you don't want to manage",
-    "",
-    JSON.stringify(config, null, 2)
-  ];
-  return lines.join("\n");
-}
-
-export {
-  loadConfig,
-  getSessionName,
-  getServiceCwd,
-  driver_exports,
-  checkers_exports,
-  ensureService,
-  getStatus,
-  getAllStatus,
-  stopService,
-  stopAllServices,
-  attachService,
-  runWithServices,
-  discoverFromTurbo,
-  formatDiscoveredConfig
-};