vibora 1.6.0 → 1.8.0

package/server/index.js

@@ -7667,6 +7667,7 @@ __export(exports_schema, {
   terminalViewState: () => terminalViewState,
   terminalTabs: () => terminalTabs,
   tasks: () => tasks,
+  systemMetrics: () => systemMetrics,
   repositories: () => repositories
 });
 var tasks = sqliteTable("tasks", {
@@ -7725,6 +7726,16 @@ var repositories = sqliteTable("repositories", {
   createdAt: text("created_at").notNull(),
   updatedAt: text("updated_at").notNull()
 });
+var systemMetrics = sqliteTable("system_metrics", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  timestamp: integer("timestamp").notNull(),
+  cpuPercent: real("cpu_percent").notNull(),
+  memoryUsedBytes: integer("memory_used_bytes").notNull(),
+  memoryTotalBytes: integer("memory_total_bytes").notNull(),
+  memoryCacheBytes: integer("memory_cache_bytes").notNull().default(0),
+  diskUsedBytes: integer("disk_used_bytes").notNull(),
+  diskTotalBytes: integer("disk_total_bytes").notNull()
+});
 
 // server/db/index.ts
 initializeViboraDirectories();
@@ -137940,9 +137951,9 @@ app2.delete("/bulk", async (c) => {
         continue;
       if (existing.worktreePath) {
         destroyTerminalsForWorktree(existing.worktreePath);
-      }
-      if (existing.worktreePath && existing.repoPath) {
-        deleteGitWorktree(existing.repoPath, existing.worktreePath);
+        if (body.deleteLinkedWorktrees && existing.repoPath) {
+          deleteGitWorktree(existing.repoPath, existing.worktreePath);
+        }
       }
       const columnTasks = db.select().from(tasks).where(eq(tasks.status, existing.status)).all();
       for (const t of columnTasks) {
@@ -137996,15 +138007,16 @@ app2.patch("/:id", async (c) => {
 });
 app2.delete("/:id", (c) => {
   const id = c.req.param("id");
+  const deleteLinkedWorktree = c.req.query("deleteLinkedWorktree") === "true";
   const existing = db.select().from(tasks).where(eq(tasks.id, id)).get();
   if (!existing) {
     return c.json({ error: "Task not found" }, 404);
   }
   if (existing.worktreePath) {
     destroyTerminalsForWorktree(existing.worktreePath);
-  }
-  if (existing.worktreePath && existing.repoPath) {
-    deleteGitWorktree(existing.repoPath, existing.worktreePath);
+    if (deleteLinkedWorktree && existing.repoPath) {
+      deleteGitWorktree(existing.repoPath, existing.worktreePath);
+    }
   }
   const columnTasks = db.select().from(tasks).where(eq(tasks.status, existing.status)).all();
   const now = new Date().toISOString();
@@ -139504,15 +139516,19 @@ app7.delete("/", async (c) => {
     await deleteWorktree(body.worktreePath, body.repoPath || linkedTask?.repoPath);
     let deletedTaskId;
     if (linkedTask) {
-      const columnTasks = db.select().from(tasks).where(eq(tasks.status, linkedTask.status)).all();
       const now = new Date().toISOString();
-      for (const t of columnTasks) {
-        if (t.position > linkedTask.position) {
-          db.update(tasks).set({ position: t.position - 1, updatedAt: now }).where(eq(tasks.id, t.id)).run();
+      if (body.deleteLinkedTask) {
+        const columnTasks = db.select().from(tasks).where(eq(tasks.status, linkedTask.status)).all();
+        for (const t of columnTasks) {
+          if (t.position > linkedTask.position) {
+            db.update(tasks).set({ position: t.position - 1, updatedAt: now }).where(eq(tasks.id, t.id)).run();
+          }
         }
+        db.delete(tasks).where(eq(tasks.id, linkedTask.id)).run();
+        deletedTaskId = linkedTask.id;
+      } else {
+        db.update(tasks).set({ worktreePath: null, updatedAt: now }).where(eq(tasks.id, linkedTask.id)).run();
       }
-      db.delete(tasks).where(eq(tasks.id, linkedTask.id)).run();
-      deletedTaskId = linkedTask.id;
     }
     return c.json({ success: true, path: body.worktreePath, deletedTaskId });
   } catch (err) {
@@ -143434,6 +143450,543 @@ app12.get("/check", async (c) => {
 });
 var auth_default = app12;
 
+// server/routes/monitoring.ts
+import { readdirSync as readdirSync7, readFileSync as readFileSync7, readlinkSync as readlinkSync2 } from "fs";
+import { execSync as execSync5 } from "child_process";
+
+// server/services/metrics-collector.ts
+import os5 from "os";
+import fs7 from "fs";
+import { execSync as execSync4 } from "child_process";
+var COLLECT_INTERVAL = 5000;
+var RETENTION_HOURS = 24;
+function getMemoryInfo() {
+  const total = os5.totalmem();
+  try {
+    const meminfo = fs7.readFileSync("/proc/meminfo", "utf-8");
+    const values = {};
+    for (const line of meminfo.split(`
+`)) {
+      const match3 = line.match(/^(\w+):\s+(\d+)\s+kB/);
+      if (match3) {
+        values[match3[1]] = parseInt(match3[2], 10) * 1024;
+      }
+    }
+    const memTotal = values["MemTotal"] || total;
+    const memFree = values["MemFree"] || 0;
+    const buffers = values["Buffers"] || 0;
+    const cached = values["Cached"] || 0;
+    const sReclaimable = values["SReclaimable"] || 0;
+    const shmem = values["Shmem"] || 0;
+    let cacheBuffers = buffers + cached + sReclaimable - shmem;
+    if (cacheBuffers < 0) {
+      cacheBuffers = 0;
+    }
+    const used = memTotal - memFree - buffers - cached - sReclaimable + shmem;
+    return {
+      total: memTotal,
+      used: Math.max(used, 0),
+      cache: cacheBuffers
+    };
+  } catch {
+    const free = os5.freemem();
+    return {
+      total,
+      used: total - free,
+      cache: 0
+    };
+  }
+}
+var intervalId = null;
+var previousCpu = null;
+function getCpuSnapshot() {
+  const cpus = os5.cpus();
+  let idle = 0;
+  let total = 0;
+  for (const cpu of cpus) {
+    idle += cpu.times.idle;
+    total += cpu.times.user + cpu.times.nice + cpu.times.sys + cpu.times.idle + cpu.times.irq;
+  }
+  return { idle, total };
+}
+function calculateCpuPercent() {
+  const current = getCpuSnapshot();
+  if (!previousCpu) {
+    previousCpu = current;
+    return 0;
+  }
+  const idleDiff = current.idle - previousCpu.idle;
+  const totalDiff = current.total - previousCpu.total;
+  previousCpu = current;
+  if (totalDiff === 0)
+    return 0;
+  const usedPercent = (totalDiff - idleDiff) / totalDiff * 100;
+  return Math.round(usedPercent * 100) / 100;
+}
+function getDiskUsage() {
+  try {
+    const output = execSync4("df -B1 / | tail -1", {
+      encoding: "utf-8",
+      timeout: 5000,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const parts = output.trim().split(/\s+/);
+    if (parts.length >= 4) {
+      const total = parseInt(parts[1], 10) || 0;
+      const used = parseInt(parts[2], 10) || 0;
+      return { used, total };
+    }
+  } catch (err) {
+    console.error("Failed to get disk usage:", err);
+  }
+  return { used: 0, total: 0 };
+}
+function collectMetrics() {
+  const timestamp = Math.floor(Date.now() / 1000);
+  const cpuPercent = calculateCpuPercent();
+  const memory = getMemoryInfo();
+  const disk = getDiskUsage();
+  db.insert(systemMetrics).values({
+    timestamp,
+    cpuPercent,
+    memoryUsedBytes: memory.used,
+    memoryTotalBytes: memory.total,
+    memoryCacheBytes: memory.cache,
+    diskUsedBytes: disk.used,
+    diskTotalBytes: disk.total
+  }).run();
+}
+function pruneOldMetrics() {
+  const cutoff = Math.floor(Date.now() / 1000) - RETENTION_HOURS * 60 * 60;
+  const result = db.delete(systemMetrics).where(lt(systemMetrics.timestamp, cutoff)).run();
+  if (result.changes > 0) {
+    console.log(`[MetricsCollector] Pruned ${result.changes} old metrics records`);
+  }
+}
+function startMetricsCollector() {
+  if (intervalId)
+    return;
+  console.log(`Metrics collector started (${COLLECT_INTERVAL / 1000}s interval)`);
+  previousCpu = getCpuSnapshot();
+  setTimeout(() => {
+    collectMetrics();
+  }, 1000);
+  intervalId = setInterval(() => {
+    collectMetrics();
+  }, COLLECT_INTERVAL);
+  setInterval(() => {
+    pruneOldMetrics();
+  }, 60 * 60 * 1000);
+  pruneOldMetrics();
+}
+function stopMetricsCollector() {
+  if (intervalId) {
+    clearInterval(intervalId);
+    intervalId = null;
+    console.log("Metrics collector stopped");
+  }
+}
+function getMetrics(windowSeconds) {
+  const cutoff = Math.floor(Date.now() / 1000) - windowSeconds;
+  const rows = db.select().from(systemMetrics).where(lt(systemMetrics.timestamp, cutoff) ? undefined : undefined).all().filter((r) => r.timestamp >= cutoff);
+  return rows.map((row) => ({
+    timestamp: row.timestamp,
+    cpuPercent: row.cpuPercent,
+    memoryUsedPercent: row.memoryTotalBytes > 0 ? row.memoryUsedBytes / row.memoryTotalBytes * 100 : 0,
+    memoryCachePercent: row.memoryTotalBytes > 0 ? row.memoryCacheBytes / row.memoryTotalBytes * 100 : 0,
+    diskUsedPercent: row.diskTotalBytes > 0 ? row.diskUsedBytes / row.diskTotalBytes * 100 : 0
+  }));
+}
+function getCurrentMetrics() {
+  const memory = getMemoryInfo();
+  const disk = getDiskUsage();
+  const latest = db.select().from(systemMetrics).orderBy(systemMetrics.timestamp).limit(1).all();
+  return {
+    cpu: latest.length > 0 ? latest[0].cpuPercent : 0,
+    memory: {
+      total: memory.total,
+      used: memory.used,
+      cache: memory.cache,
+      usedPercent: memory.total > 0 ? memory.used / memory.total * 100 : 0,
+      cachePercent: memory.total > 0 ? memory.cache / memory.total * 100 : 0
+    },
+    disk: {
+      total: disk.total,
+      used: disk.used,
+      usedPercent: disk.total > 0 ? disk.used / disk.total * 100 : 0,
+      path: "/"
+    }
+  };
+}
+
+// server/routes/monitoring.ts
+function parseWindow(window) {
+  const match3 = window.match(/^(\d+)(m|h)$/);
+  if (!match3)
+    return 3600;
+  const value = parseInt(match3[1], 10);
+  const unit = match3[2];
+  if (unit === "m")
+    return value * 60;
+  if (unit === "h")
+    return value * 3600;
+  return 3600;
+}
+function findAllClaudeProcesses() {
+  const claudeProcesses = [];
+  try {
+    const procDirs = readdirSync7("/proc").filter((d) => /^\d+$/.test(d));
+    for (const pidStr of procDirs) {
+      const pid = parseInt(pidStr, 10);
+      try {
+        const cmdline = readFileSync7(`/proc/${pid}/cmdline`, "utf-8");
+        if (/\bclaude\b/i.test(cmdline)) {
+          claudeProcesses.push({ pid, cmdline });
+        }
+      } catch {}
+    }
+  } catch {
+    try {
+      const result = execSync5("pgrep -f claude", { encoding: "utf-8" });
+      for (const line of result.trim().split(`
+`)) {
+        const pid = parseInt(line, 10);
+        if (!isNaN(pid)) {
+          try {
+            const cmdline = execSync5(`ps -p ${pid} -o args=`, { encoding: "utf-8" }).trim();
+            claudeProcesses.push({ pid, cmdline });
+          } catch {
+            claudeProcesses.push({ pid, cmdline: "claude" });
+          }
+        }
+      }
+    } catch {}
+  }
+  return claudeProcesses;
+}
+function getProcessCwd(pid) {
+  try {
+    return readlinkSync2(`/proc/${pid}/cwd`);
+  } catch {
+    try {
+      const result = execSync5(`lsof -p ${pid} -d cwd -Fn 2>/dev/null | grep ^n | cut -c2-`, {
+        encoding: "utf-8"
+      });
+      return result.trim() || "(unknown)";
+    } catch {
+      return "(unknown)";
+    }
+  }
+}
+function getProcessMemoryMB(pid) {
+  try {
+    const status = readFileSync7(`/proc/${pid}/status`, "utf-8");
+    const match3 = status.match(/VmRSS:\s+(\d+)\s+kB/);
+    return match3 ? parseInt(match3[1], 10) / 1024 : 0;
+  } catch {
+    try {
+      const result = execSync5(`ps -o rss= -p ${pid}`, { encoding: "utf-8" });
+      return parseInt(result.trim(), 10) / 1024;
+    } catch {
+      return 0;
+    }
+  }
+}
+function getProcessStartTime(pid) {
+  try {
+    const stat = readFileSync7(`/proc/${pid}/stat`, "utf-8");
+    const fields = stat.split(" ");
+    const starttime = parseInt(fields[21], 10);
+    const uptime = parseFloat(readFileSync7("/proc/uptime", "utf-8").split(" ")[0]);
+    const clockTicks = 100;
+    const bootTime = Math.floor(Date.now() / 1000) - uptime;
+    return Math.floor(bootTime + starttime / clockTicks);
+  } catch {
+    return null;
+  }
+}
+function getDescendantPids2(pid) {
+  const descendants = [];
+  try {
+    const result = execSync5(`ps --ppid ${pid} -o pid= 2>/dev/null || true`, { encoding: "utf-8" });
+    for (const line of result.trim().split(`
+`)) {
+      const childPid = parseInt(line.trim(), 10);
+      if (!isNaN(childPid)) {
+        descendants.push(childPid);
+        descendants.push(...getDescendantPids2(childPid));
+      }
+    }
+  } catch {}
+  return descendants;
+}
+var monitoringRoutes = new Hono2;
+monitoringRoutes.get("/claude-instances", (c) => {
+  const filter2 = c.req.query("filter") || "vibora";
+  const allClaudeProcesses = findAllClaudeProcesses();
+  const viboraManagedPids = new Map;
+  try {
+    const ptyManager2 = getPTYManager();
+    const terminals2 = ptyManager2.listTerminals();
+    const dtachService2 = getDtachService();
+    for (const terminal of terminals2) {
+      const socketPath = dtachService2.getSocketPath(terminal.id);
+      try {
+        const procDirs = readdirSync7("/proc").filter((d) => /^\d+$/.test(d));
+        for (const pidStr of procDirs) {
+          const pid = parseInt(pidStr, 10);
+          try {
+            const cmdline = readFileSync7(`/proc/${pid}/cmdline`, "utf-8");
+            if (cmdline.includes(socketPath)) {
+              const descendants = getDescendantPids2(pid);
+              for (const descendantPid of [...descendants, pid]) {
+                viboraManagedPids.set(descendantPid, {
+                  terminalId: terminal.id,
+                  terminalName: terminal.name,
+                  cwd: terminal.cwd
+                });
+              }
+            }
+          } catch {}
+        }
+      } catch {}
+    }
+  } catch {}
+  const allTasks = db.select().from(tasks).all();
+  const tasksByWorktree = new Map(allTasks.filter((t) => t.worktreePath).map((t) => [t.worktreePath, t]));
+  const instances = [];
+  for (const { pid } of allClaudeProcesses) {
+    const viboraInfo = viboraManagedPids.get(pid);
+    const isViboraManaged = !!viboraInfo;
+    if (filter2 === "vibora" && !isViboraManaged) {
+      continue;
+    }
+    const cwd = viboraInfo?.cwd || getProcessCwd(pid);
+    const ramMB = Math.round(getProcessMemoryMB(pid) * 10) / 10;
+    const startedAt = getProcessStartTime(pid);
+    let taskId = null;
+    let taskTitle = null;
+    let worktreePath = null;
+    if (viboraInfo) {
+      const task = tasksByWorktree.get(viboraInfo.cwd);
+      if (task) {
+        taskId = task.id;
+        taskTitle = task.title;
+        worktreePath = viboraInfo.cwd;
+      }
+    }
+    instances.push({
+      pid,
+      cwd,
+      ramMB,
+      startedAt,
+      terminalId: viboraInfo?.terminalId || null,
+      terminalName: viboraInfo?.terminalName || null,
+      taskId,
+      taskTitle,
+      worktreePath,
+      isViboraManaged
+    });
+  }
+  instances.sort((a, b) => {
+    if (a.isViboraManaged !== b.isViboraManaged) {
+      return a.isViboraManaged ? -1 : 1;
+    }
+    return b.ramMB - a.ramMB;
+  });
+  return c.json(instances);
+});
+monitoringRoutes.get("/system-metrics", (c) => {
+  const windowStr = c.req.query("window") || "1h";
+  const windowSeconds = parseWindow(windowStr);
+  const dataPoints = getMetrics(windowSeconds);
+  const current = getCurrentMetrics();
+  return c.json({
+    window: windowStr,
+    dataPoints,
+    current
+  });
+});
+monitoringRoutes.post("/claude-instances/:terminalId/kill", (c) => {
+  const terminalId = c.req.param("terminalId");
+  try {
+    const dtachService2 = getDtachService();
+    const killed = dtachService2.killClaudeInSession(terminalId);
+    return c.json({ success: true, killed });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return c.json({ error: message }, 500);
+  }
+});
+monitoringRoutes.post("/claude-instances/:pid/kill-pid", (c) => {
+  const pidStr = c.req.param("pid");
+  const pid = parseInt(pidStr, 10);
+  if (isNaN(pid)) {
+    return c.json({ error: "Invalid PID" }, 400);
+  }
+  try {
+    const cmdline = readFileSync7(`/proc/${pid}/cmdline`, "utf-8");
+    if (!/\bclaude\b/i.test(cmdline)) {
+      return c.json({ error: "Process is not a Claude instance" }, 400);
+    }
+    process.kill(pid, "SIGTERM");
+    return c.json({ success: true, killed: true });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return c.json({ error: message }, 500);
+  }
+});
+monitoringRoutes.get("/top-processes", (c) => {
+  const sortBy = c.req.query("sort") || "memory";
+  const limit = parseInt(c.req.query("limit") || "10", 10);
+  try {
+    const memTotal = parseInt(readFileSync7("/proc/meminfo", "utf-8").match(/MemTotal:\s+(\d+)/)?.[1] || "0", 10) * 1024;
+    const processes = [];
+    const procDirs = readdirSync7("/proc").filter((d) => /^\d+$/.test(d));
+    for (const pidStr of procDirs) {
+      const pid = parseInt(pidStr, 10);
+      try {
+        const status = readFileSync7(`/proc/${pid}/status`, "utf-8");
+        const nameMatch = status.match(/Name:\s+(.+)/);
+        const rssMatch = status.match(/VmRSS:\s+(\d+)\s+kB/);
+        if (!nameMatch || !rssMatch)
+          continue;
+        const name = nameMatch[1].trim();
+        const memoryKB = parseInt(rssMatch[1], 10);
+        const memoryMB = memoryKB / 1024;
+        const memoryPercent = memTotal > 0 ? memoryKB * 1024 / memTotal * 100 : 0;
+        let command = "";
+        try {
+          command = readFileSync7(`/proc/${pid}/cmdline`, "utf-8").replace(/\0/g, " ").trim().slice(0, 200);
+        } catch {
+          command = name;
+        }
+        const cpuPercent = 0;
+        processes.push({
+          pid,
+          name,
+          command,
+          cpuPercent: Math.round(cpuPercent * 10) / 10,
+          memoryMB: Math.round(memoryMB * 10) / 10,
+          memoryPercent: Math.round(memoryPercent * 10) / 10
+        });
+      } catch {
+        continue;
+      }
+    }
+    if (sortBy === "cpu") {
+      processes.sort((a, b) => b.cpuPercent - a.cpuPercent);
+    } else {
+      processes.sort((a, b) => b.memoryMB - a.memoryMB);
+    }
+    return c.json(processes.slice(0, limit));
+  } catch {
+    try {
+      const sortFlag = sortBy === "cpu" ? "-pcpu" : "-rss";
+      const result = execSync5(`ps -eo pid,comm,args,%cpu,rss --sort=${sortFlag} --no-headers | head -${limit + 1}`, { encoding: "utf-8", timeout: 5000 });
+      const memTotal = parseInt(execSync5("grep MemTotal /proc/meminfo", { encoding: "utf-8" }).match(/(\d+)/)?.[1] || "0", 10) * 1024;
+      const processes = [];
+      for (const line of result.trim().split(`
+`)) {
+        const match3 = line.match(/^\s*(\d+)\s+(\S+)\s+(.+?)\s+([\d.]+)\s+(\d+)\s*$/);
+        if (match3) {
+          const memoryKB = parseInt(match3[5], 10);
+          processes.push({
+            pid: parseInt(match3[1], 10),
+            name: match3[2],
+            command: match3[3].trim().slice(0, 200),
+            cpuPercent: parseFloat(match3[4]),
+            memoryMB: Math.round(memoryKB / 1024 * 10) / 10,
+            memoryPercent: memTotal > 0 ? Math.round(memoryKB * 1024 / memTotal * 1000) / 10 : 0
+          });
+        }
+      }
+      return c.json(processes);
+    } catch (fallbackErr) {
+      const message = fallbackErr instanceof Error ? fallbackErr.message : String(fallbackErr);
+      return c.json({ error: message }, 500);
+    }
+  }
+});
+monitoringRoutes.get("/docker-stats", (c) => {
+  try {
+    let result;
+    let runtime = "docker";
+    try {
+      result = execSync5('docker stats --no-stream --format "{{json .}}"', {
+        encoding: "utf-8",
+        timeout: 1e4,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    } catch {
+      try {
+        result = execSync5('podman stats --no-stream --format "{{json .}}"', {
+          encoding: "utf-8",
+          timeout: 1e4,
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        runtime = "podman";
+      } catch {
+        return c.json({ containers: [], available: false, runtime: null });
+      }
+    }
+    const containers = [];
+    for (const line of result.trim().split(`
+`)) {
+      if (!line.trim())
+        continue;
+      try {
+        const data = JSON.parse(line);
+        const cpuStr = data.CPUPerc || "0%";
+        const cpuPercent = parseFloat(cpuStr.replace("%", "")) || 0;
+        const memUsageStr = data.MemUsage || "0B / 0B";
+        const [usedStr, limitStr] = memUsageStr.split(" / ");
+        const parseMemory = (str) => {
+          const match3 = str.match(/([\d.]+)\s*(B|KB|KiB|MB|MiB|GB|GiB)/i);
+          if (!match3)
+            return 0;
+          const value = parseFloat(match3[1]);
+          const unit = match3[2].toLowerCase();
+          switch (unit) {
+            case "b":
+              return value / (1024 * 1024);
+            case "kb":
+            case "kib":
+              return value / 1024;
+            case "mb":
+            case "mib":
+              return value;
+            case "gb":
+            case "gib":
+              return value * 1024;
+            default:
+              return value;
+          }
+        };
+        const memoryMB = parseMemory(usedStr);
+        const memoryLimit = parseMemory(limitStr);
+        const memPercStr = data.MemPerc || "0%";
+        const memoryPercent = parseFloat(memPercStr.replace("%", "")) || 0;
+        containers.push({
+          id: (data.ID || data.Id || "").slice(0, 12),
+          name: data.Name || data.Names || "unknown",
+          cpuPercent: Math.round(cpuPercent * 10) / 10,
+          memoryMB: Math.round(memoryMB * 10) / 10,
+          memoryLimit: Math.round(memoryLimit * 10) / 10,
+          memoryPercent: Math.round(memoryPercent * 10) / 10
+        });
+      } catch {
+        continue;
+      }
+    }
+    containers.sort((a, b) => b.memoryMB - a.memoryMB);
+    return c.json({ containers, available: true, runtime });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return c.json({ error: message }, 500);
+  }
+});
+
 // server/app.ts
 function getDistPath() {
   if (process.env.VIBORA_PACKAGE_ROOT) {
@@ -143462,6 +144015,7 @@ function createApp() {
   app13.route("/api/linear", linear_default);
   app13.route("/api/github", github_default);
   app13.route("/api/auth", auth_default);
+  app13.route("/api/monitoring", monitoringRoutes);
   if (process.env.VIBORA_PACKAGE_ROOT) {
     const distPath = getDistPath();
     const serveFile = async (filePath) => {
@@ -143514,7 +144068,7 @@ function createApp() {
 }
 
 // server/services/pr-monitor.ts
-import { execSync as execSync4 } from "child_process";
+import { execSync as execSync6 } from "child_process";
 var POLL_INTERVAL = 60000;
 function parsePrUrl(url) {
   const match3 = url.match(/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)/);
@@ -143529,7 +144083,7 @@ function checkPrStatus(prUrl) {
     return null;
   }
   try {
-    const output = execSync4(`gh pr view ${parsed.number} --repo ${parsed.owner}/${parsed.repo} --json state,mergedAt`, { encoding: "utf-8", timeout: 1e4, stdio: ["pipe", "pipe", "pipe"] });
+    const output = execSync6(`gh pr view ${parsed.number} --repo ${parsed.owner}/${parsed.repo} --json state,mergedAt`, { encoding: "utf-8", timeout: 1e4, stdio: ["pipe", "pipe", "pipe"] });
     const data = JSON.parse(output);
     return {
       state: data.state,
@@ -143555,20 +144109,20 @@ async function pollPRs() {
     }
   }
 }
-var intervalId = null;
+var intervalId2 = null;
 function startPRMonitor() {
-  if (intervalId)
+  if (intervalId2)
     return;
   console.log("PR Monitor started (60s interval)");
   pollPRs().catch(console.error);
-  intervalId = setInterval(() => {
+  intervalId2 = setInterval(() => {
     pollPRs().catch(console.error);
   }, POLL_INTERVAL);
 }
 function stopPRMonitor() {
-  if (intervalId) {
-    clearInterval(intervalId);
-    intervalId = null;
+  if (intervalId2) {
+    clearInterval(intervalId2);
+    intervalId2 = null;
     console.log("PR Monitor stopped");
   }
 }
@@ -143611,10 +144165,12 @@ var server = serve({
 });
 injectWebSocket(server);
 startPRMonitor();
+startMetricsCollector();
 process.on("SIGINT", () => {
   console.log(`
 Shutting down (terminals will persist)...`);
   stopPRMonitor();
+  stopMetricsCollector();
   ptyManager2.detachAll();
   server.close();
   process.exit(0);
@@ -143623,6 +144179,7 @@ process.on("SIGTERM", () => {
   console.log(`
 Shutting down (terminals will persist)...`);
   stopPRMonitor();
+  stopMetricsCollector();
   ptyManager2.detachAll();
   server.close();
   process.exit(0);