@chriscode/devmux 1.2.0 → 1.3.1

package/dist/{chunk-JDD6USSA.js → chunk-32R7KDZB.js}

@@ -1,9 +1,15 @@
+import {
+  init_esm_shims
+} from "./chunk-66UOCF5R.js";
+
 // src/watch/queue.ts
+init_esm_shims();
 import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, statSync } from "fs";
 import { join } from "path";
 import { randomUUID } from "crypto";
 
 // src/watch/deduper.ts
+init_esm_shims();
 import { createHash } from "crypto";
 function computeContentHash(service, patternName, content) {
   const normalized = content.replace(/\d{4}-\d{2}-\d{2}T[\d:.]+Z?/g, "TIMESTAMP").replace(/\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2}/g, "TIMESTAMP").replace(/:\d+:\d+/g, ":LINE:COL").replace(/0x[0-9a-f]+/gi, "0xADDR").replace(/\b\d{5,}\b/g, "NUM");
@@ -156,9 +162,11 @@ function updateEventStatus(eventId, status, outputDir = DEFAULT_OUTPUT_DIR) {
 }
 
 // src/watch/watcher.ts
+init_esm_shims();
 import { createInterface } from "readline";
 
 // src/watch/patterns.ts
+init_esm_shims();
 var BUILTIN_PATTERN_SETS = {
   node: [
     { name: "unhandled-rejection", regex: "UnhandledPromiseRejection|unhandledRejection", severity: "critical", extractStackTrace: true },

package/dist/chunk-66UOCF5R.js

@@ -0,0 +1,36 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../node_modules/.pnpm/tsup@8.5.1_postcss@8.5.6_typescript@5.9.3_yaml@2.8.2/node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "../node_modules/.pnpm/tsup@8.5.1_postcss@8.5.6_typescript@5.9.3_yaml@2.8.2/node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+export {
+  __esm,
+  __export,
+  __toCommonJS,
+  init_esm_shims
+};

package/dist/chunk-6EU6ODXX.js

@@ -0,0 +1,372 @@
+import {
+  BUILTIN_PATTERN_SETS,
+  DedupeCache,
+  clearQueue,
+  computeContentHash,
+  createRingBuffer,
+  ensureOutputDir,
+  getPendingEvents,
+  getQueuePath,
+  isStackTraceLine,
+  matchPatterns,
+  readQueue,
+  resolvePatterns,
+  startWatcher,
+  updateEventStatus,
+  writeEvent
+} from "./chunk-32R7KDZB.js";
+import {
+  checkHealth,
+  ensureService,
+  getSessionName,
+  hasSession,
+  init_loader,
+  stopService
+} from "./chunk-ALENFKSX.js";
+import {
+  __export,
+  init_esm_shims
+} from "./chunk-66UOCF5R.js";
+
+// src/core/run.ts
+init_esm_shims();
+init_loader();
+import { spawn } from "child_process";
+function resolveDashboardConfig(config, override) {
+  if (override === false) return { enabled: false, port: 9e3 };
+  const opt = config.defaults?.dashboard;
+  if (override === true || opt === true) return { enabled: true, port: 9e3 };
+  if (opt && typeof opt === "object") return { enabled: true, port: opt.port ?? 9e3 };
+  return { enabled: false, port: 9e3 };
+}
+async function runWithServices(config, command, options) {
+  const { services, stopOnExit = true, quiet = false } = options;
+  const log = quiet ? () => {
+  } : console.log;
+  const startedByUs = [];
+  let dashboardServer;
+  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)`);
+      }
+    }
+  }
+  const dashboardConfig = resolveDashboardConfig(config, options.dashboard);
+  if (dashboardConfig.enabled) {
+    try {
+      const { startDashboard } = await import("./dashboard-3GHLOSV3.js");
+      dashboardServer = startDashboard({ port: dashboardConfig.port, open: true });
+    } catch (err) {
+      log(`\u26A0\uFE0F  Dashboard failed to start: ${err instanceof Error ? err.message : err}`);
+    }
+  }
+  log("");
+  const cleanup = () => {
+    if (dashboardServer) {
+      dashboardServer.close();
+      dashboardServer = void 0;
+    }
+    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 = spawn(cmd, args, {
+    stdio: "inherit",
+    shell: true
+  });
+  return new Promise((resolve2) => {
+    child.on("close", (code) => {
+      resolve2(code ?? 0);
+    });
+    child.on("error", (err) => {
+      console.error(`Failed to run command: ${err.message}`);
+      resolve2(1);
+    });
+  });
+}
+
+// src/discovery/turbo.ts
+init_esm_shims();
+import { readFileSync, existsSync } from "fs";
+import { resolve, relative } from "path";
+function loadTurboConfig(root) {
+  const turboPath = resolve(root, "turbo.json");
+  if (!existsSync(turboPath)) return null;
+  try {
+    return JSON.parse(readFileSync(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 = resolve(root, "package.json");
+  if (!existsSync(rootPkg)) return packages;
+  try {
+    const pkg = JSON.parse(
+      readFileSync(rootPkg, "utf-8")
+    );
+    const workspaces = pkg.workspaces ?? [];
+    for (const pattern of workspaces) {
+      const cleanPattern = pattern.replace(/\/\*$/, "");
+      const pkgPath = resolve(root, cleanPattern, "package.json");
+      if (existsSync(pkgPath)) {
+        const subPkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        packages.push({
+          name: subPkg.name ?? cleanPattern,
+          path: relative(root, resolve(root, cleanPattern)) || ".",
+          scripts: Object.keys(subPkg.scripts ?? {})
+        });
+      }
+    }
+    for (const subdir of ["app", "api", "web", "packages", "apps"]) {
+      const pkgPath = resolve(root, subdir, "package.json");
+      if (existsSync(pkgPath) && !packages.some((p) => p.path === subdir)) {
+        const subPkg = JSON.parse(readFileSync(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
+init_esm_shims();
+init_loader();
+import { execSync } from "child_process";
+import { dirname, join as join2 } from "path";
+import { fileURLToPath } from "url";
+function getWatcherCliPath() {
+  const thisFileDir = dirname(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 = execSync(`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 {
+    execSync(`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 {
+    execSync(`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
+});
+init_esm_shims();
+
+export {
+  runWithServices,
+  discoverFromTurbo,
+  formatDiscoveredConfig,
+  getAllWatcherStatuses,
+  startWatcher2 as startWatcher,
+  stopWatcher,
+  startAllWatchers,
+  stopAllWatchers,
+  watch_exports
+};