@chriscode/devmux 1.0.0 → 1.2.0

package/dist/chunk-JDD6USSA.js

@@ -0,0 +1,311 @@
+// src/watch/queue.ts
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, statSync } from "fs";
+import { join } from "path";
+import { randomUUID } from "crypto";
+
+// src/watch/deduper.ts
+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");
+  return createHash("sha256").update(`${service}:${patternName}:${normalized}`).digest("hex").slice(0, 16);
+}
+function createRingBuffer(capacity) {
+  const buffer = [];
+  let writeIndex = 0;
+  let full = false;
+  return {
+    push(item) {
+      if (buffer.length < capacity) {
+        buffer.push(item);
+      } else {
+        buffer[writeIndex] = item;
+        full = true;
+      }
+      writeIndex = (writeIndex + 1) % capacity;
+    },
+    getAll() {
+      if (!full) return [...buffer];
+      const result = [];
+      for (let i = 0; i < capacity; i++) {
+        result.push(buffer[(writeIndex + i) % capacity]);
+      }
+      return result;
+    },
+    clear() {
+      buffer.length = 0;
+      writeIndex = 0;
+      full = false;
+    }
+  };
+}
+var DedupeCache = class {
+  cache = /* @__PURE__ */ new Map();
+  windowMs;
+  maxSize;
+  constructor(windowMs, maxSize = 1e3) {
+    this.windowMs = windowMs;
+    this.maxSize = maxSize;
+  }
+  isDuplicate(hash) {
+    const now = Date.now();
+    const lastSeen = this.cache.get(hash);
+    if (lastSeen && now - lastSeen < this.windowMs) {
+      this.cache.set(hash, now);
+      return true;
+    }
+    this.cache.set(hash, now);
+    this.cleanup(now);
+    return false;
+  }
+  cleanup(now) {
+    if (this.cache.size <= this.maxSize) return;
+    const cutoff = now - this.windowMs * 2;
+    for (const [hash, timestamp] of this.cache) {
+      if (timestamp < cutoff) {
+        this.cache.delete(hash);
+      }
+    }
+  }
+};
+
+// src/watch/queue.ts
+var DEFAULT_OUTPUT_DIR = join(process.env.HOME ?? "~", ".opencode", "triggers");
+var AUTO_PRUNE_THRESHOLD_BYTES = 50 * 1024 * 1024;
+var EVENTS_TO_KEEP_AFTER_PRUNE = 1e4;
+function ensureOutputDir(outputDir = DEFAULT_OUTPUT_DIR) {
+  if (!existsSync(outputDir)) {
+    mkdirSync(outputDir, { recursive: true });
+  }
+  return outputDir;
+}
+function getQueuePath(outputDir = DEFAULT_OUTPUT_DIR) {
+  return join(outputDir, "queue.jsonl");
+}
+function pruneQueueIfNeeded(outputDir = DEFAULT_OUTPUT_DIR) {
+  const queuePath = getQueuePath(outputDir);
+  if (!existsSync(queuePath)) {
+    return false;
+  }
+  const stats = statSync(queuePath);
+  if (stats.size < AUTO_PRUNE_THRESHOLD_BYTES) {
+    return false;
+  }
+  const content = readFileSync(queuePath, "utf-8");
+  const lines = content.trim().split("\n").filter(Boolean);
+  const linesToKeep = lines.slice(-EVENTS_TO_KEEP_AFTER_PRUNE);
+  writeFileSync(queuePath, linesToKeep.join("\n") + "\n");
+  return true;
+}
+function writeEvent(options, pattern, rawContent, context, stackTrace) {
+  const outputDir = ensureOutputDir(options.outputDir);
+  const queuePath = getQueuePath(outputDir);
+  const event = {
+    id: randomUUID(),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    source: `devmux:${options.service}`,
+    service: options.service,
+    project: options.project,
+    severity: pattern.severity,
+    pattern: pattern.name,
+    rawContent,
+    context,
+    stackTrace: stackTrace && stackTrace.length > 0 ? stackTrace : void 0,
+    status: "pending",
+    contentHash: computeContentHash(options.service, pattern.name, rawContent),
+    firstSeen: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  appendFileSync(queuePath, JSON.stringify(event) + "\n");
+  pruneQueueIfNeeded(outputDir);
+  return event;
+}
+function readQueue(outputDir = DEFAULT_OUTPUT_DIR) {
+  const queuePath = getQueuePath(outputDir);
+  if (!existsSync(queuePath)) {
+    return [];
+  }
+  const content = readFileSync(queuePath, "utf-8");
+  const lines = content.trim().split("\n").filter(Boolean);
+  return lines.map((line) => JSON.parse(line));
+}
+function getPendingEvents(outputDir = DEFAULT_OUTPUT_DIR) {
+  return readQueue(outputDir).filter((e) => e.status === "pending");
+}
+function clearQueue(outputDir = DEFAULT_OUTPUT_DIR) {
+  const queuePath = getQueuePath(outputDir);
+  if (existsSync(queuePath)) {
+    unlinkSync(queuePath);
+  }
+}
+function updateEventStatus(eventId, status, outputDir = DEFAULT_OUTPUT_DIR) {
+  const queuePath = getQueuePath(outputDir);
+  if (!existsSync(queuePath)) {
+    return false;
+  }
+  const events = readQueue(outputDir);
+  let found = false;
+  const updated = events.map((e) => {
+    if (e.id === eventId) {
+      found = true;
+      return { ...e, status };
+    }
+    return e;
+  });
+  if (!found) return false;
+  writeFileSync(queuePath, updated.map((e) => JSON.stringify(e)).join("\n") + "\n");
+  return true;
+}
+
+// src/watch/watcher.ts
+import { createInterface } from "readline";
+
+// src/watch/patterns.ts
+var BUILTIN_PATTERN_SETS = {
+  node: [
+    { name: "unhandled-rejection", regex: "UnhandledPromiseRejection|unhandledRejection", severity: "critical", extractStackTrace: true },
+    { name: "oom", regex: "out of memory|OutOfMemoryError|heap out of memory|ENOMEM|OOM killer", severity: "critical" },
+    { name: "type-error", regex: "TypeError:|ReferenceError:|SyntaxError:", severity: "error", extractStackTrace: true },
+    { name: "js-error", regex: "^Error:|^\\w*Error:|^\\s+at\\s+", severity: "error", extractStackTrace: true }
+  ],
+  web: [
+    { name: "http-5xx", regex: `HTTP/[\\d.]+["'\\s]+5\\d{2}|"(status|statusCode)":\\s*5\\d{2}`, severity: "error" },
+    { name: "http-4xx-important", regex: `HTTP/[\\d.]+["'\\s]+40[134]`, severity: "warning" }
+  ],
+  react: [
+    { name: "react-error", regex: "Uncaught Error:|Error: Minified React|Hydration failed", severity: "error", extractStackTrace: true }
+  ],
+  nextjs: [
+    { name: "webpack-error", regex: "^ERROR in|Module build failed|Failed to compile", severity: "error" },
+    { name: "hydration-error", regex: "Hydration failed|Text content does not match|There was an error while hydrating", severity: "error" }
+  ],
+  database: [
+    { name: "db-error", regex: "ECONNREFUSED|connection refused|Connection lost|\\bdeadlock\\b", severity: "error" }
+  ],
+  fatal: [
+    { name: "fatal", regex: "\\bFATAL\\b|\\bPANIC\\b|Segmentation fault|SIGKILL|SIGSEGV", severity: "critical" }
+  ],
+  python: [
+    { name: "exception", regex: "^Exception:|Traceback \\(most recent", severity: "error", extractStackTrace: true }
+  ]
+};
+var compiledPatterns = /* @__PURE__ */ new Map();
+function getCompiledRegex(pattern) {
+  const cached = compiledPatterns.get(pattern.regex);
+  if (cached) return cached;
+  const compiled = new RegExp(pattern.regex, "i");
+  compiledPatterns.set(pattern.regex, compiled);
+  return compiled;
+}
+function matchPatterns(line, patterns) {
+  for (const pattern of patterns) {
+    const regex = getCompiledRegex(pattern);
+    if (regex.test(line)) {
+      return { pattern, line };
+    }
+  }
+  return null;
+}
+function resolvePatterns(globalConfig, serviceConfig) {
+  const patterns = [];
+  const excludes = new Set(serviceConfig?.exclude ?? []);
+  const overrides = serviceConfig?.overrides ?? {};
+  for (const setName of serviceConfig?.include ?? []) {
+    const builtinSet = BUILTIN_PATTERN_SETS[setName];
+    const customSet = globalConfig?.patternSets?.[setName];
+    const set = builtinSet ?? customSet;
+    if (!set) continue;
+    for (const p of set) {
+      if (excludes.has(p.name)) continue;
+      patterns.push({
+        ...p,
+        severity: overrides[p.name] ?? p.severity
+      });
+    }
+  }
+  for (const p of serviceConfig?.patterns ?? []) {
+    patterns.push(p);
+  }
+  return patterns;
+}
+function isStackTraceLine(line) {
+  return /^\s+at\s+/.test(line) || /^\s+\.\.\.\s*\d+\s*more/.test(line);
+}
+
+// src/watch/watcher.ts
+function startWatcher(options) {
+  const contextBuffer = createRingBuffer(options.contextLines);
+  const dedupeCache = new DedupeCache(options.dedupeWindowMs);
+  let stackAccumulator = null;
+  const rl = createInterface({
+    input: process.stdin,
+    crlfDelay: Infinity
+  });
+  function flushStackTrace() {
+    if (!stackAccumulator) return;
+    if (stackAccumulator.timeout) {
+      clearTimeout(stackAccumulator.timeout);
+    }
+    const { match, context, lines } = stackAccumulator;
+    const stackTrace = lines.slice(1);
+    writeEvent(options, match.pattern, match.line, context, stackTrace);
+    console.error(`[devmux-watch] Captured ${match.pattern.severity}: ${match.pattern.name}`);
+    stackAccumulator = null;
+  }
+  rl.on("line", (line) => {
+    if (stackAccumulator) {
+      if (isStackTraceLine(line)) {
+        stackAccumulator.lines.push(line);
+        return;
+      }
+      flushStackTrace();
+    }
+    contextBuffer.push(line);
+    const match = matchPatterns(line, options.patterns);
+    if (!match) return;
+    const context = contextBuffer.getAll().slice(0, -1);
+    const hash = `${options.service}:${match.pattern.name}:${line}`;
+    if (dedupeCache.isDuplicate(hash)) {
+      return;
+    }
+    if (match.pattern.extractStackTrace) {
+      stackAccumulator = {
+        lines: [line],
+        match,
+        context,
+        timeout: setTimeout(flushStackTrace, 500)
+      };
+      return;
+    }
+    writeEvent(options, match.pattern, line, context);
+    console.error(`[devmux-watch] Captured ${match.pattern.severity}: ${match.pattern.name}`);
+  });
+  rl.on("close", () => {
+    flushStackTrace();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    flushStackTrace();
+    rl.close();
+  });
+  process.on("SIGINT", () => {
+    flushStackTrace();
+    rl.close();
+  });
+}
+
+export {
+  BUILTIN_PATTERN_SETS,
+  matchPatterns,
+  resolvePatterns,
+  isStackTraceLine,
+  computeContentHash,
+  createRingBuffer,
+  DedupeCache,
+  ensureOutputDir,
+  getQueuePath,
+  writeEvent,
+  readQueue,
+  getPendingEvents,
+  clearQueue,
+  updateEventStatus,
+  startWatcher
+};

package/dist/chunk-MLKGABMK.js

@@ -0,0 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};

package/dist/cli.js

@@ -5,14 +5,28 @@ import {
   ensureService,
   formatDiscoveredConfig,
   getAllStatus,
+  getAllWatcherStatuses,
   loadConfig,
+  restartService,
   runWithServices,
+  startAllWatchers,
+  startWatcher,
   stopAllServices,
-  stopService
-} from "./chunk-7JJYYMUP.js";
+  stopAllWatchers,
+  stopService,
+  stopWatcher
+} from "./chunk-FVUGZCQ3.js";
+import {
+  clearQueue,
+  getPendingEvents
+} from "./chunk-JDD6USSA.js";
+import "./chunk-MLKGABMK.js";
 
 // src/cli.ts
 import { defineCommand, runMain } from "citty";
+import { mkdirSync, existsSync, cpSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
 var ensure = defineCommand({
   meta: { name: "ensure", description: "Ensure a service is running (idempotent)" },
   args: {
@@ -35,16 +49,20 @@ var status = defineCommand({
     const config = loadConfig();
     const statuses = await getAllStatus(config);
     if (args.json) {
-      console.log(JSON.stringify(statuses, null, 2));
+      console.log(JSON.stringify({ instanceId: config.instanceId || null, services: 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");
+    if (config.instanceId) {
+      console.log(`       Instance: ${config.instanceId}`);
+    }
     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})` : "";
+      const portDisplay = s.resolvedPort ?? s.port;
+      const portInfo = portDisplay ? ` (port ${portDisplay})` : "";
       console.log(`${icon} ${s.name}${portInfo}: ${s.healthy ? "Running" : "Not running"}`);
       if (s.tmuxSession) {
         console.log(`   \u2514\u2500 tmux: ${s.tmuxSession}`);
@@ -71,6 +89,34 @@ var stop = defineCommand({
     }
   }
 });
+var restart = defineCommand({
+  meta: { name: "restart", description: "Restart a service (stop + start)" },
+  args: {
+    service: { type: "positional", description: "Service name", required: true },
+    timeout: { type: "string", description: "Startup timeout in seconds" },
+    force: { type: "boolean", description: "Also kill processes on ports before restarting" }
+  },
+  async run({ args }) {
+    const config = loadConfig();
+    await restartService(config, args.service, {
+      timeout: args.timeout ? parseInt(args.timeout) : void 0,
+      killPorts: args.force
+    });
+  }
+});
+var start = defineCommand({
+  meta: { name: "start", description: "Start a service (alias for ensure)" },
+  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 attach = defineCommand({
   meta: { name: "attach", description: "Attach to a service's tmux session" },
   args: {
@@ -85,8 +131,7 @@ 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" }
+    "no-stop": { type: "boolean", description: "Don't stop services on exit" }
   },
   async run({ args }) {
     const config = loadConfig();
@@ -143,6 +188,177 @@ var init = defineCommand({
     console.log("Save this as devmux.config.json in your project root.");
   }
 });
+var installSkill = defineCommand({
+  meta: { name: "install-skill", description: "Install DevMux skills to .claude/skills" },
+  run() {
+    const __dirname2 = dirname(fileURLToPath(import.meta.url));
+    const skillDir = join(__dirname2, "skill");
+    const targetDir = join(process.cwd(), ".claude", "skills", "devmux");
+    try {
+      if (!existsSync(skillDir)) {
+        throw new Error(`Skill directory not found at ${skillDir}`);
+      }
+      mkdirSync(targetDir, { recursive: true });
+      cpSync(skillDir, targetDir, { recursive: true });
+      console.log(`\u2705 Installed DevMux skill to .claude/skills/devmux/`);
+    } catch (e) {
+      console.error("\u274C Failed to install skills:");
+      console.error(e);
+      process.exit(1);
+    }
+  }
+});
+var watchStart = defineCommand({
+  meta: { name: "start", description: "Start watching a service for errors" },
+  args: {
+    service: { type: "positional", description: "Service name (or 'all')" }
+  },
+  run({ args }) {
+    const config = loadConfig();
+    const serviceName = args.service;
+    if (!serviceName || serviceName === "all") {
+      startAllWatchers(config);
+    } else {
+      startWatcher(config, serviceName);
+    }
+  }
+});
+var watchStop = defineCommand({
+  meta: { name: "stop", description: "Stop watching a service" },
+  args: {
+    service: { type: "positional", description: "Service name (or 'all')" }
+  },
+  run({ args }) {
+    const config = loadConfig();
+    const serviceName = args.service;
+    if (!serviceName || serviceName === "all") {
+      stopAllWatchers(config);
+    } else {
+      stopWatcher(config, serviceName);
+    }
+  }
+});
+var watchStatus = defineCommand({
+  meta: { name: "status", description: "Show watcher status" },
+  args: {
+    json: { type: "boolean", description: "Output as JSON" }
+  },
+  run({ args }) {
+    const config = loadConfig();
+    const statuses = getAllWatcherStatuses(config);
+    if (args.json) {
+      console.log(JSON.stringify(statuses, null, 2));
+      return;
+    }
+    console.log("");
+    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("        Watcher 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.pipeActive ? "\u{1F441}\uFE0F" : "\u26AB";
+      console.log(`${icon} ${s.service}: ${s.pipeActive ? "Watching" : "Not watching"}`);
+      if (s.pipeActive) {
+        console.log(`   \u2514\u2500 session: ${s.sessionName}`);
+      }
+    }
+    console.log("");
+  }
+});
+var watchQueue = defineCommand({
+  meta: { name: "queue", description: "Show pending errors in queue" },
+  args: {
+    json: { type: "boolean", description: "Output as JSON" },
+    clear: { type: "boolean", description: "Clear the queue" }
+  },
+  run({ args }) {
+    if (args.clear) {
+      clearQueue();
+      console.log("\u2705 Queue cleared");
+      return;
+    }
+    const events = getPendingEvents();
+    if (args.json) {
+      console.log(JSON.stringify(events, null, 2));
+      return;
+    }
+    if (events.length === 0) {
+      console.log("No pending errors in queue.");
+      return;
+    }
+    console.log("");
+    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(`        Pending Errors (${events.length})`);
+    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 e of events) {
+      const severityIcon = e.severity === "critical" ? "\u{1F534}" : e.severity === "error" ? "\u{1F7E0}" : e.severity === "warning" ? "\u{1F7E1}" : "\u{1F535}";
+      console.log(`${severityIcon} [${e.service}] ${e.pattern}`);
+      console.log(`   ${e.rawContent.slice(0, 80)}${e.rawContent.length > 80 ? "..." : ""}`);
+      console.log(`   \u2514\u2500 ${e.firstSeen}`);
+      console.log("");
+    }
+  }
+});
+var watch = defineCommand({
+  meta: { name: "watch", description: "Manage error watchers for services" },
+  subCommands: {
+    start: watchStart,
+    stop: watchStop,
+    status: watchStatus,
+    queue: watchQueue
+  }
+});
+var telemetryStart = defineCommand({
+  meta: { name: "start", description: "Start the telemetry server" },
+  args: {
+    port: { type: "string", description: "Port to listen on (default: 9876)" },
+    host: { type: "string", description: "Host to bind to (default: 0.0.0.0)" }
+  },
+  async run({ args }) {
+    const { startServer } = await import("./server-manager-DO25DFFW.js");
+    startServer({
+      port: args.port ? parseInt(args.port) : void 0,
+      host: args.host
+    });
+  }
+});
+var telemetryStop = defineCommand({
+  meta: { name: "stop", description: "Stop the telemetry server" },
+  async run() {
+    const { stopServer } = await import("./server-manager-DO25DFFW.js");
+    stopServer();
+  }
+});
+var telemetryStatus = defineCommand({
+  meta: { name: "status", description: "Show telemetry server status" },
+  args: {
+    json: { type: "boolean", description: "Output as JSON" }
+  },
+  async run({ args }) {
+    const { getServerStatus } = await import("./server-manager-DO25DFFW.js");
+    const status2 = getServerStatus();
+    if (args.json) {
+      console.log(JSON.stringify(status2, null, 2));
+      return;
+    }
+    if (status2.running) {
+      console.log(`Telemetry Server: Running (PID: ${status2.pid})`);
+      console.log(`  Listening on: ws://${status2.host}:${status2.port}`);
+    } else {
+      console.log("Telemetry Server: Not running");
+      console.log("  Start with: devmux telemetry start");
+    }
+  }
+});
+var telemetry = defineCommand({
+  meta: { name: "telemetry", description: "Manage telemetry server for browser/app logs" },
+  subCommands: {
+    start: telemetryStart,
+    stop: telemetryStop,
+    status: telemetryStatus
+  }
+});
 var main = defineCommand({
   meta: {
     name: "devmux",
@@ -151,12 +367,17 @@ var main = defineCommand({
   },
   subCommands: {
     ensure,
+    start,
+    restart,
     status,
     stop,
     attach,
     run,
     discover,
-    init
+    init,
+    watch,
+    telemetry,
+    "install-skill": installSkill
   }
 });
 runMain(main);