@chriscode/devmux 1.0.0 → 1.3.1

package/dist/chunk-32R7KDZB.js

@@ -0,0 +1,319 @@
+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");
+  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
+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 },
+    { 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-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
+};