@chriscode/devmux 1.0.0

package/bin/devmux.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../dist/cli.js";

package/dist/chunk-7JJYYMUP.js

@@ -0,0 +1,542 @@
+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
+};

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,162 @@
+#!/usr/bin/env node
+import {
+  attachService,
+  discoverFromTurbo,
+  ensureService,
+  formatDiscoveredConfig,
+  getAllStatus,
+  loadConfig,
+  runWithServices,
+  stopAllServices,
+  stopService
+} from "./chunk-7JJYYMUP.js";
+
+// src/cli.ts
+import { defineCommand, runMain } from "citty";
+var ensure = defineCommand({
+  meta: { name: "ensure", description: "Ensure a service is running (idempotent)" },
+  args: {
+    service: { type: "positional", description: "Service name", required: true },
+    timeout: { type: "string", description: "Startup timeout in seconds" }
+  },
+  async run({ args }) {
+    const config = loadConfig();
+    await ensureService(config, args.service, {
+      timeout: args.timeout ? parseInt(args.timeout) : void 0
+    });
+  }
+});
+var status = defineCommand({
+  meta: { name: "status", description: "Show status of all services" },
+  args: {
+    json: { type: "boolean", description: "Output as JSON" }
+  },
+  async run({ args }) {
+    const config = loadConfig();
+    const statuses = await getAllStatus(config);
+    if (args.json) {
+      console.log(JSON.stringify(statuses, null, 2));
+      return;
+    }
+    console.log("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+    console.log("       Service Status");
+    console.log("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+    console.log("");
+    for (const s of statuses) {
+      const icon = s.healthy ? "\u2705" : "\u274C";
+      const portInfo = s.port ? ` (port ${s.port})` : "";
+      console.log(`${icon} ${s.name}${portInfo}: ${s.healthy ? "Running" : "Not running"}`);
+      if (s.tmuxSession) {
+        console.log(`   \u2514\u2500 tmux: ${s.tmuxSession}`);
+      } else if (s.healthy) {
+        console.log(`   \u2514\u2500 (running outside tmux)`);
+      }
+      console.log("");
+    }
+  }
+});
+var stop = defineCommand({
+  meta: { name: "stop", description: "Stop a service or all services" },
+  args: {
+    service: { type: "positional", description: "Service name or 'all'" },
+    force: { type: "boolean", description: "Also kill processes on ports" }
+  },
+  run({ args }) {
+    const config = loadConfig();
+    const serviceName = args.service ?? "all";
+    if (serviceName === "all") {
+      stopAllServices(config, { killPorts: args.force });
+    } else {
+      stopService(config, serviceName, { killPorts: args.force });
+    }
+  }
+});
+var attach = defineCommand({
+  meta: { name: "attach", description: "Attach to a service's tmux session" },
+  args: {
+    service: { type: "positional", description: "Service name", required: true }
+  },
+  run({ args }) {
+    const config = loadConfig();
+    attachService(config, args.service);
+  }
+});
+var run = defineCommand({
+  meta: { name: "run", description: "Run a command with services, cleanup on exit" },
+  args: {
+    with: { type: "string", description: "Comma-separated services to ensure", required: true },
+    "no-stop": { type: "boolean", description: "Don't stop services on exit" },
+    _: { type: "positional", description: "Command to run" }
+  },
+  async run({ args }) {
+    const config = loadConfig();
+    const services = args.with.split(",").map((s) => s.trim());
+    const command = args._;
+    if (!command || command.length === 0) {
+      console.error("\u274C No command specified");
+      process.exit(1);
+    }
+    const exitCode = await runWithServices(config, command, {
+      services,
+      stopOnExit: !args["no-stop"]
+    });
+    process.exit(exitCode);
+  }
+});
+var discover = defineCommand({
+  meta: { name: "discover", description: "Discover services from turbo.json" },
+  args: {
+    source: { type: "positional", description: "Source to discover from (turbo)", default: "turbo" }
+  },
+  run({ args }) {
+    if (args.source !== "turbo") {
+      console.error(`\u274C Unknown source: ${args.source}. Supported: turbo`);
+      process.exit(1);
+    }
+    const discovered = discoverFromTurbo(process.cwd());
+    if (!discovered) {
+      console.error("\u274C No services discovered. Make sure turbo.json exists with persistent tasks.");
+      process.exit(1);
+    }
+    console.log(formatDiscoveredConfig(discovered));
+    console.log("");
+    console.log("Save this as devmux.config.json and update the health checks.");
+  }
+});
+var init = defineCommand({
+  meta: { name: "init", description: "Initialize devmux config" },
+  run() {
+    const template = {
+      version: 1,
+      project: "my-project",
+      services: {
+        api: {
+          cwd: "api",
+          command: "pnpm dev",
+          health: { type: "port", port: 8787 }
+        }
+      }
+    };
+    console.log("# devmux.config.json template");
+    console.log(JSON.stringify(template, null, 2));
+    console.log("");
+    console.log("Save this as devmux.config.json in your project root.");
+  }
+});
+var main = defineCommand({
+  meta: {
+    name: "devmux",
+    version: "0.1.0",
+    description: "tmux-based service management for monorepos"
+  },
+  subCommands: {
+    ensure,
+    status,
+    stop,
+    attach,
+    run,
+    discover,
+    init
+  }
+});
+runMain(main);

package/dist/index.d.ts

@@ -0,0 +1,107 @@
+type HealthCheckType = {
+    type: "port";
+    port: number;
+    host?: string;
+} | {
+    type: "http";
+    url: string;
+    expectStatus?: number;
+} | {
+    type: "none";
+};
+interface ServiceDefinition {
+    cwd: string;
+    command: string;
+    health: HealthCheckType;
+    sessionName?: string;
+    env?: Record<string, string>;
+    stopPorts?: number[];
+}
+interface DevMuxConfig {
+    version: 1;
+    project: string;
+    sessionPrefix?: string;
+    defaults?: {
+        startupTimeoutSeconds?: number;
+        remainOnExit?: boolean;
+    };
+    services: Record<string, ServiceDefinition>;
+}
+interface ResolvedConfig extends DevMuxConfig {
+    configRoot: string;
+    resolvedSessionPrefix: string;
+}
+interface ServiceStatus {
+    name: string;
+    healthy: boolean;
+    tmuxSession: string | null;
+    port?: number;
+    managedByDevmux: boolean;
+}
+
+declare function loadConfig(startDir?: string): ResolvedConfig;
+declare function getSessionName(config: ResolvedConfig, serviceName: string): string;
+declare function getServiceCwd(config: ResolvedConfig, serviceName: string): string;
+
+interface EnsureResult {
+    serviceName: string;
+    startedByUs: boolean;
+    sessionName: string;
+}
+declare function ensureService(config: ResolvedConfig, serviceName: string, options?: {
+    timeout?: number;
+    quiet?: boolean;
+}): Promise<EnsureResult>;
+declare function getStatus(config: ResolvedConfig, serviceName: string): Promise<ServiceStatus>;
+declare function getAllStatus(config: ResolvedConfig): Promise<ServiceStatus[]>;
+declare function stopService(config: ResolvedConfig, serviceName: string, options?: {
+    killPorts?: boolean;
+    quiet?: boolean;
+}): void;
+declare function stopAllServices(config: ResolvedConfig, options?: {
+    killPorts?: boolean;
+    quiet?: boolean;
+}): void;
+declare function attachService(config: ResolvedConfig, serviceName: string): void;
+
+interface RunOptions {
+    services: string[];
+    stopOnExit?: boolean;
+    quiet?: boolean;
+}
+declare function runWithServices(config: ResolvedConfig, command: string[], options: RunOptions): Promise<number>;
+
+declare function discoverFromTurbo(root: string): Partial<DevMuxConfig> | null;
+declare function formatDiscoveredConfig(config: Partial<DevMuxConfig>): string;
+
+declare function hasSession(sessionName: string): boolean;
+declare function listSessions(prefix?: string): string[];
+declare function newSession(sessionName: string, cwd: string, command: string, env?: Record<string, string>): void;
+declare function setRemainOnExit(sessionName: string, value: boolean): void;
+declare function killSession(sessionName: string): void;
+declare function attachSession(sessionName: string): void;
+
+declare const driver_attachSession: typeof attachSession;
+declare const driver_hasSession: typeof hasSession;
+declare const driver_killSession: typeof killSession;
+declare const driver_listSessions: typeof listSessions;
+declare const driver_newSession: typeof newSession;
+declare const driver_setRemainOnExit: typeof setRemainOnExit;
+declare namespace driver {
+  export { driver_attachSession as attachSession, driver_hasSession as hasSession, driver_killSession as killSession, driver_listSessions as listSessions, driver_newSession as newSession, driver_setRemainOnExit as setRemainOnExit };
+}
+
+declare function checkPort(port: number, host?: string): Promise<boolean>;
+declare function checkHttp(url: string, expectStatus?: number): Promise<boolean>;
+declare function checkHealth(health: HealthCheckType): Promise<boolean>;
+declare function getHealthPort(health: HealthCheckType): number | undefined;
+
+declare const checkers_checkHealth: typeof checkHealth;
+declare const checkers_checkHttp: typeof checkHttp;
+declare const checkers_checkPort: typeof checkPort;
+declare const checkers_getHealthPort: typeof getHealthPort;
+declare namespace checkers {
+  export { checkers_checkHealth as checkHealth, checkers_checkHttp as checkHttp, checkers_checkPort as checkPort, checkers_getHealthPort as getHealthPort };
+}
+
+export { type DevMuxConfig, type EnsureResult, type HealthCheckType, type ResolvedConfig, type RunOptions, type ServiceDefinition, type ServiceStatus, attachService, discoverFromTurbo, ensureService, formatDiscoveredConfig, getAllStatus, getServiceCwd, getSessionName, getStatus, checkers as health, loadConfig, runWithServices, stopAllServices, stopService, driver as tmux };

package/dist/index.js

@@ -0,0 +1,32 @@
+import {
+  attachService,
+  checkers_exports,
+  discoverFromTurbo,
+  driver_exports,
+  ensureService,
+  formatDiscoveredConfig,
+  getAllStatus,
+  getServiceCwd,
+  getSessionName,
+  getStatus,
+  loadConfig,
+  runWithServices,
+  stopAllServices,
+  stopService
+} from "./chunk-7JJYYMUP.js";
+export {
+  attachService,
+  discoverFromTurbo,
+  ensureService,
+  formatDiscoveredConfig,
+  getAllStatus,
+  getServiceCwd,
+  getSessionName,
+  getStatus,
+  checkers_exports as health,
+  loadConfig,
+  runWithServices,
+  stopAllServices,
+  stopService,
+  driver_exports as tmux
+};

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@chriscode/devmux",
+  "version": "1.0.0",
+  "description": "tmux-based service management for monorepos with human-agent shared awareness",
+  "type": "module",
+  "bin": {
+    "devmux": "./bin/devmux.js"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "prepublishOnly": "pnpm build",
+    "type-check": "tsc --noEmit",
+    "test": "echo 'No tests yet' && exit 0"
+  },
+  "keywords": [
+    "tmux",
+    "monorepo",
+    "dev",
+    "services",
+    "turbo",
+    "agent",
+    "opencode",
+    "claude",
+    "ai"
+  ],
+  "author": "Chris Hasson",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hassoncs/devmux.git",
+    "directory": "devmux-cli"
+  },
+  "bugs": {
+    "url": "https://github.com/hassoncs/devmux/issues"
+  },
+  "homepage": "https://github.com/hassoncs/devmux#readme",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "citty": "^0.1.6"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0"
+  },
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}