@chriscode/devmux 1.2.0 → 1.3.1

package/dist/{chunk-FVUGZCQ3.js → chunk-ALENFKSX.js}

@@ -1,27 +1,8 @@
 import {
-  BUILTIN_PATTERN_SETS,
-  DedupeCache,
-  clearQueue,
-  computeContentHash,
-  createRingBuffer,
-  ensureOutputDir,
-  getPendingEvents,
-  getQueuePath,
-  isStackTraceLine,
-  matchPatterns,
-  readQueue,
-  resolvePatterns,
-  startWatcher,
-  updateEventStatus,
-  writeEvent
-} from "./chunk-JDD6USSA.js";
-import {
-  __export
-} from "./chunk-MLKGABMK.js";
-
-// src/config/loader.ts
-import { readFileSync, existsSync } from "fs";
-import { resolve, dirname } from "path";
+  __esm,
+  __export,
+  init_esm_shims
+} from "./chunk-66UOCF5R.js";
 
 // src/utils/worktree.ts
 import { execSync } from "child_process";
@@ -54,6 +35,12 @@ function resolveInstanceId() {
   }
   return "";
 }
+var init_worktree = __esm({
+  "src/utils/worktree.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
 
 // src/utils/port.ts
 function calculatePortOffset(instanceId) {
@@ -68,13 +55,24 @@ function calculatePortOffset(instanceId) {
 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 CONFIG_NAMES = [
-  "devmux.config.json",
-  ".devmuxrc.json",
-  ".devmuxrc"
-];
+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);
@@ -174,6 +172,20 @@ function getResolvedPort(config, serviceName) {
   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 = {};
@@ -185,6 +197,7 @@ __export(driver_exports, {
   newSession: () => newSession,
   setRemainOnExit: () => setRemainOnExit
 });
+init_esm_shims();
 import { execSync as execSync2, spawn } from "child_process";
 function hasSession(sessionName) {
   try {
@@ -252,23 +265,24 @@ __export(checkers_exports, {
   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((resolve3) => {
+  return new Promise((resolve2) => {
     const socket = createConnection({ port, host });
     socket.setTimeout(1e3);
     socket.on("connect", () => {
       socket.destroy();
-      resolve3(true);
+      resolve2(true);
     });
     socket.on("timeout", () => {
       socket.destroy();
-      resolve3(false);
+      resolve2(false);
     });
     socket.on("error", () => {
       socket.destroy();
-      resolve3(false);
+      resolve2(false);
     });
   });
 }
@@ -323,7 +337,95 @@ function getHealthPort(health) {
 }
 
 // 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}`);
@@ -414,7 +516,7 @@ async function getAllStatus(config) {
   }
   return statuses;
 }
-function stopService(config, serviceName, options = {}) {
+async function stopService(config, serviceName, options = {}) {
   const service = config.services[serviceName];
   if (!service) {
     throw new Error(`Unknown service: ${serviceName}`);
@@ -437,21 +539,18 @@ function stopService(config, serviceName, options = {}) {
       }
     }
     for (const port of [...new Set(ports)]) {
-      try {
-        const pids = execSync4(`lsof -ti :${port}`, { encoding: "utf-8" }).trim();
-        if (pids) {
-          execSync4(`kill -9 ${pids.split("\n").join(" ")}`, { stdio: "pipe" });
-          log(`   \u2514\u2500 Killed process(es) on port ${port}`);
-        }
-      } catch {
+      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`);
 }
-function stopAllServices(config, options = {}) {
+async function stopAllServices(config, options = {}) {
   for (const serviceName of Object.keys(config.services)) {
-    stopService(config, serviceName, options);
+    await stopService(config, serviceName, options);
   }
 }
 async function restartService(config, serviceName, options = {}) {
@@ -472,7 +571,7 @@ function attachService(config, serviceName) {
   attachSession(sessionName);
 }
 function sleep(ms) {
-  return new Promise((resolve3) => setTimeout(resolve3, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 function resolveHealthCheck(health, resolvedPort) {
   if (!health) return void 0;
@@ -511,330 +610,22 @@ function buildServiceEnv(config, serviceName, userEnv) {
   return env;
 }
 
-// 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 sessionName = getSessionName(config, serviceName);
-    const wasHealthy = await checkHealth(service.health, sessionName);
-    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 existsSync2 } from "fs";
-import { resolve as resolve2, relative } from "path";
-function loadTurboConfig(root) {
-  const turboPath = resolve2(root, "turbo.json");
-  if (!existsSync2(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 (!existsSync2(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 (existsSync2(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 (existsSync2(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}`
-        };
-      }
-    }
-  }
-  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");
-}
-
-// src/watch/manager.ts
-import { execSync as execSync5 } from "child_process";
-import { dirname as dirname2, join as join2 } from "path";
-import { fileURLToPath } from "url";
-function getWatcherCliPath() {
-  const thisFileDir = dirname2(fileURLToPath(import.meta.url));
-  if (thisFileDir.endsWith("watch")) {
-    return join2(thisFileDir, "watcher-cli.js");
-  }
-  return join2(thisFileDir, "watch", "watcher-cli.js");
-}
-function getWatchConfig(config) {
-  return config.watch;
-}
-function getServiceWatchConfig(config, serviceName) {
-  return config.services[serviceName]?.watch;
-}
-function isWatchEnabled(config, serviceName) {
-  const globalWatch = getWatchConfig(config);
-  const serviceWatch = getServiceWatchConfig(config, serviceName);
-  if (serviceWatch?.enabled !== void 0) {
-    return serviceWatch.enabled;
-  }
-  return globalWatch?.enabled ?? false;
-}
-function isPipeActive(sessionName) {
-  try {
-    const output = execSync5(`tmux show-options -t "${sessionName}" -p pipe-command 2>/dev/null || true`, {
-      encoding: "utf-8"
-    });
-    return output.includes("watcher-cli");
-  } catch {
-    return false;
-  }
-}
-function getWatcherStatus(config, serviceName) {
-  const sessionName = getSessionName(config, serviceName);
-  const hasSession2 = hasSession(sessionName);
-  return {
-    service: serviceName,
-    sessionName,
-    pipeActive: hasSession2 && isPipeActive(sessionName)
-  };
-}
-function getAllWatcherStatuses(config) {
-  return Object.keys(config.services).map((serviceName) => getWatcherStatus(config, serviceName));
-}
-function startWatcher2(config, serviceName, options = {}) {
-  const sessionName = getSessionName(config, serviceName);
-  const log = options.quiet ? () => {
-  } : console.log;
-  if (!hasSession(sessionName)) {
-    log(`\u274C Service ${serviceName} is not running (no tmux session: ${sessionName})`);
-    return false;
-  }
-  if (isPipeActive(sessionName)) {
-    log(`\u2705 Watcher already active for ${serviceName}`);
-    return true;
-  }
-  const globalWatch = getWatchConfig(config);
-  const serviceWatch = getServiceWatchConfig(config, serviceName);
-  const patterns = resolvePatterns(globalWatch, serviceWatch);
-  if (patterns.length === 0) {
-    log(`\u26A0\uFE0F No patterns configured for ${serviceName}`);
-    return false;
-  }
-  const outputDir = globalWatch?.outputDir ?? `${process.env.HOME}/.opencode/triggers`;
-  const dedupeWindowMs = globalWatch?.dedupeWindowMs ?? 5e3;
-  const contextLines = globalWatch?.contextLines ?? 20;
-  const patternsJson = JSON.stringify(patterns).replace(/"/g, '\\"');
-  const watcherCliPath = getWatcherCliPath();
-  const cmd = [
-    `node "${watcherCliPath}"`,
-    `--service=${serviceName}`,
-    `--project=${config.project}`,
-    `--session=${sessionName}`,
-    `--output=${outputDir}`,
-    `--dedupe=${dedupeWindowMs}`,
-    `--context=${contextLines}`,
-    `--patterns="${patternsJson}"`
-  ].join(" ");
-  try {
-    execSync5(`tmux pipe-pane -t "${sessionName}" '${cmd}'`, { stdio: "pipe" });
-    log(`\u{1F441}\uFE0F Started watching ${serviceName}`);
-    return true;
-  } catch (e) {
-    log(`\u274C Failed to start watcher for ${serviceName}: ${e}`);
-    return false;
-  }
-}
-function stopWatcher(config, serviceName, options = {}) {
-  const sessionName = getSessionName(config, serviceName);
-  const log = options.quiet ? () => {
-  } : console.log;
-  if (!hasSession(sessionName)) {
-    log(`\u26A0\uFE0F Service ${serviceName} is not running`);
-    return false;
-  }
-  if (!isPipeActive(sessionName)) {
-    log(`\u26A0\uFE0F Watcher not active for ${serviceName}`);
-    return false;
-  }
-  try {
-    execSync5(`tmux pipe-pane -t "${sessionName}"`, { stdio: "pipe" });
-    log(`\u{1F6D1} Stopped watching ${serviceName}`);
-    return true;
-  } catch (e) {
-    log(`\u274C Failed to stop watcher for ${serviceName}: ${e}`);
-    return false;
-  }
-}
-function startAllWatchers(config, options = {}) {
-  for (const serviceName of Object.keys(config.services)) {
-    if (isWatchEnabled(config, serviceName)) {
-      startWatcher2(config, serviceName, options);
-    }
-  }
-}
-function stopAllWatchers(config, options = {}) {
-  for (const serviceName of Object.keys(config.services)) {
-    const status = getWatcherStatus(config, serviceName);
-    if (status.pipeActive) {
-      stopWatcher(config, serviceName, options);
-    }
-  }
-}
-
-// src/watch/index.ts
-var watch_exports = {};
-__export(watch_exports, {
-  BUILTIN_PATTERN_SETS: () => BUILTIN_PATTERN_SETS,
-  DedupeCache: () => DedupeCache,
-  clearQueue: () => clearQueue,
-  computeContentHash: () => computeContentHash,
-  createRingBuffer: () => createRingBuffer,
-  ensureOutputDir: () => ensureOutputDir,
-  getAllWatcherStatuses: () => getAllWatcherStatuses,
-  getPendingEvents: () => getPendingEvents,
-  getQueuePath: () => getQueuePath,
-  getWatcherStatus: () => getWatcherStatus,
-  isStackTraceLine: () => isStackTraceLine,
-  matchPatterns: () => matchPatterns,
-  readQueue: () => readQueue,
-  resolvePatterns: () => resolvePatterns,
-  startAllWatchers: () => startAllWatchers,
-  startServiceWatcher: () => startWatcher2,
-  startWatcher: () => startWatcher,
-  stopAllWatchers: () => stopAllWatchers,
-  stopServiceWatcher: () => stopWatcher,
-  updateEventStatus: () => updateEventStatus,
-  writeEvent: () => writeEvent
-});
-
 export {
   loadConfig,
   getSessionName,
   getServiceCwd,
+  loader_exports,
+  init_loader,
+  hasSession,
   driver_exports,
+  checkHealth,
   checkers_exports,
+  getProcessOnPort,
   ensureService,
   getStatus,
   getAllStatus,
   stopService,
   stopAllServices,
   restartService,
-  attachService,
-  runWithServices,
-  discoverFromTurbo,
-  formatDiscoveredConfig,
-  getAllWatcherStatuses,
-  startWatcher2 as startWatcher,
-  stopWatcher,
-  startAllWatchers,
-  stopAllWatchers,
-  watch_exports
+  attachService
 };