@chriscode/devmux 1.0.0 → 1.2.0

package/dist/chunk-FVUGZCQ3.js

@@ -0,0 +1,840 @@
+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";
+
+// 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 "";
+}
+
+// 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);
+}
+
+// src/config/loader.ts
+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}`;
+  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);
+}
+
+// src/tmux/driver.ts
+var driver_exports = {};
+__export(driver_exports, {
+  attachSession: () => attachSession,
+  hasSession: () => hasSession,
+  killSession: () => killSession,
+  listSessions: () => listSessions,
+  newSession: () => newSession,
+  setRemainOnExit: () => setRemainOnExit
+});
+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
+});
+import { createConnection } from "net";
+import { execSync as execSync3 } from "child_process";
+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;
+  }
+}
+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
+import { execSync as execSync4 } from "child_process";
+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;
+}
+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)]) {
+      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 {
+      }
+    }
+  }
+  log(`\u2705 ${serviceName} stopped`);
+}
+function stopAllServices(config, options = {}) {
+  for (const serviceName of Object.keys(config.services)) {
+    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((resolve3) => setTimeout(resolve3, 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;
+}
+
+// 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,
+  driver_exports,
+  checkers_exports,
+  ensureService,
+  getStatus,
+  getAllStatus,
+  stopService,
+  stopAllServices,
+  restartService,
+  attachService,
+  runWithServices,
+  discoverFromTurbo,
+  formatDiscoveredConfig,
+  getAllWatcherStatuses,
+  startWatcher2 as startWatcher,
+  stopWatcher,
+  startAllWatchers,
+  stopAllWatchers,
+  watch_exports
+};