vibora 1.6.0 → 1.7.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,15 @@ 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(),
+  diskUsedBytes: integer("disk_used_bytes").notNull(),
+  diskTotalBytes: integer("disk_total_bytes").notNull()
+});
 
 // server/db/index.ts
 initializeViboraDirectories();
@@ -137940,9 +137950,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 +138006,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 +139515,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 +143449,355 @@ 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 { execSync as execSync4 } from "child_process";
+var COLLECT_INTERVAL = 5000;
+var RETENTION_HOURS = 24;
+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 memoryTotal = os5.totalmem();
+  const memoryFree = os5.freemem();
+  const memoryUsed = memoryTotal - memoryFree;
+  const disk = getDiskUsage();
+  db.insert(systemMetrics).values({
+    timestamp,
+    cpuPercent,
+    memoryUsedBytes: memoryUsed,
+    memoryTotalBytes: memoryTotal,
+    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,
+    diskUsedPercent: row.diskTotalBytes > 0 ? row.diskUsedBytes / row.diskTotalBytes * 100 : 0
+  }));
+}
+function getCurrentMetrics() {
+  const memoryTotal = os5.totalmem();
+  const memoryFree = os5.freemem();
+  const memoryUsed = memoryTotal - memoryFree;
+  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: memoryTotal,
+      used: memoryUsed,
+      usedPercent: memoryUsed / memoryTotal * 100
+    },
+    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);
+  }
+});
+
 // server/app.ts
 function getDistPath() {
   if (process.env.VIBORA_PACKAGE_ROOT) {
@@ -143462,6 +143826,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 +143879,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 +143894,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 +143920,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 +143976,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 +143990,7 @@ process.on("SIGTERM", () => {
   console.log(`
 Shutting down (terminals will persist)...`);
   stopPRMonitor();
+  stopMetricsCollector();
   ptyManager2.detachAll();
   server.close();
   process.exit(0);