vibora 9.0.2 → 9.0.4

package/server/index.js

@@ -43652,8 +43652,8 @@ var logger = (fn = console.log) => {
 
 // server/app.ts
 import { readFile as readFile7 } from "fs/promises";
-import { join as join26 } from "path";
-import { existsSync as existsSync19 } from "fs";
+import { join as join27 } from "path";
+import { existsSync as existsSync20 } from "fs";
 
 // server/routes/health.ts
 var app = new Hono2;
@@ -181365,6 +181365,9 @@ app17.post("/caddy/stop", async (c) => {
 });
 var deployment_default = app17;
 
+// server/services/job-service.ts
+import { platform as platform3 } from "os";
+
 // server/services/systemd-timer.ts
 init_logger3();
 import { execSync as execSync8 } from "child_process";
@@ -181867,35 +181870,514 @@ function deleteTimer(name) {
   log2.jobs.info("Timer deleted", { name: timerName });
 }
 
+// server/services/launchd-service.ts
+init_logger3();
+import { execSync as execSync9 } from "child_process";
+import { homedir as homedir9, platform as platform2 } from "os";
+import { join as join25 } from "path";
+import { existsSync as existsSync18, readdirSync as readdirSync8 } from "fs";
+var USER_LAUNCH_AGENTS = join25(homedir9(), "Library/LaunchAgents");
+var GLOBAL_LAUNCH_AGENTS = "/Library/LaunchAgents";
+var GLOBAL_LAUNCH_DAEMONS = "/Library/LaunchDaemons";
+var launchdAvailable = null;
+function isLaunchdAvailable() {
+  if (launchdAvailable !== null) {
+    return launchdAvailable;
+  }
+  if (platform2() !== "darwin") {
+    launchdAvailable = false;
+    return false;
+  }
+  try {
+    execSync9("launchctl version", {
+      encoding: "utf-8",
+      timeout: 5000,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    launchdAvailable = true;
+    return true;
+  } catch {
+    launchdAvailable = false;
+    return false;
+  }
+}
+function parsePlist(plistPath) {
+  try {
+    const json = execSync9(`plutil -convert json -o - "${plistPath}"`, {
+      encoding: "utf-8",
+      timeout: 5000,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return JSON.parse(json);
+  } catch (err) {
+    log2.jobs.debug("Failed to parse plist", { plistPath, error: String(err) });
+    return null;
+  }
+}
+function parseLaunchctlList() {
+  const entries = new Map;
+  try {
+    const output = execSync9("launchctl list", {
+      encoding: "utf-8",
+      timeout: 1e4,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    for (const line of output.split(`
+`).slice(1)) {
+      const parts = line.trim().split(/\s+/);
+      if (parts.length >= 3) {
+        const [pidStr, statusStr, ...labelParts] = parts;
+        const label = labelParts.join(" ");
+        if (label) {
+          entries.set(label, {
+            pid: pidStr === "-" ? null : parseInt(pidStr, 10),
+            status: parseInt(statusStr, 10) || 0,
+            label
+          });
+        }
+      }
+    }
+  } catch (err) {
+    log2.jobs.error("Failed to run launchctl list", { error: String(err) });
+  }
+  return entries;
+}
+function formatCalendarInterval(ci) {
+  const parts = [];
+  if (ci.Weekday !== undefined) {
+    const days = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+    parts.push(days[ci.Weekday] || `Weekday ${ci.Weekday}`);
+  }
+  if (ci.Month !== undefined) {
+    const months = ["", "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+    parts.push(months[ci.Month] || `Month ${ci.Month}`);
+  }
+  if (ci.Day !== undefined) {
+    parts.push(`Day ${ci.Day}`);
+  }
+  const hour = ci.Hour ?? 0;
+  const minute = ci.Minute ?? 0;
+  const time2 = `${hour.toString().padStart(2, "0")}:${minute.toString().padStart(2, "0")}`;
+  if (parts.length === 0) {
+    return `Daily at ${time2}`;
+  }
+  return `${parts.join(" ")} at ${time2}`;
+}
+function formatSchedule(plist) {
+  if (plist.StartCalendarInterval) {
+    const intervals = Array.isArray(plist.StartCalendarInterval) ? plist.StartCalendarInterval : [plist.StartCalendarInterval];
+    if (intervals.length === 1) {
+      return formatCalendarInterval(intervals[0]);
+    }
+    return `${intervals.length} schedules`;
+  }
+  if (plist.StartInterval) {
+    const secs = plist.StartInterval;
+    if (secs < 60)
+      return `Every ${secs}s`;
+    if (secs < 3600)
+      return `Every ${Math.round(secs / 60)}m`;
+    if (secs < 86400)
+      return `Every ${Math.round(secs / 3600)}h`;
+    return `Every ${Math.round(secs / 86400)}d`;
+  }
+  if (plist.KeepAlive)
+    return "KeepAlive";
+  if (plist.RunAtLoad)
+    return "RunAtLoad";
+  return null;
+}
+function calculateNextRun(plist) {
+  if (!plist.StartCalendarInterval && !plist.StartInterval) {
+    return null;
+  }
+  const now = new Date;
+  if (plist.StartInterval) {
+    const nextRun = new Date(now.getTime() + plist.StartInterval * 1000);
+    return nextRun.toISOString();
+  }
+  if (plist.StartCalendarInterval) {
+    const intervals = Array.isArray(plist.StartCalendarInterval) ? plist.StartCalendarInterval : [plist.StartCalendarInterval];
+    let nextRun = null;
+    for (const ci of intervals) {
+      const candidate = new Date(now);
+      candidate.setHours(ci.Hour ?? 0);
+      candidate.setMinutes(ci.Minute ?? 0);
+      candidate.setSeconds(0);
+      candidate.setMilliseconds(0);
+      if (candidate <= now) {
+        if (ci.Weekday !== undefined) {
+          candidate.setDate(candidate.getDate() + 7);
+        } else if (ci.Day !== undefined) {
+          candidate.setMonth(candidate.getMonth() + 1);
+        } else {
+          candidate.setDate(candidate.getDate() + 1);
+        }
+      }
+      if (!nextRun || candidate < nextRun) {
+        nextRun = candidate;
+      }
+    }
+    return nextRun?.toISOString() ?? null;
+  }
+  return null;
+}
+function getCommand(plist) {
+  if (plist.ProgramArguments && plist.ProgramArguments.length > 0) {
+    return plist.ProgramArguments.join(" ");
+  }
+  if (plist.Program) {
+    return plist.Program;
+  }
+  return null;
+}
+function getJobState(entry) {
+  if (!entry) {
+    return "inactive";
+  }
+  if (entry.pid !== null && entry.pid > 0) {
+    return "active";
+  }
+  if (entry.status !== 0) {
+    return "failed";
+  }
+  return "waiting";
+}
+function getLastResult2(entry) {
+  if (!entry) {
+    return null;
+  }
+  if (entry.status === 0) {
+    return "success";
+  }
+  if (entry.status !== 0) {
+    return "failed";
+  }
+  return "unknown";
+}
+function scanPlistDirectory(dir, scope) {
+  const results = [];
+  if (!existsSync18(dir)) {
+    return results;
+  }
+  try {
+    const files = readdirSync8(dir);
+    for (const file of files) {
+      if (file.endsWith(".plist")) {
+        results.push({ path: join25(dir, file), scope });
+      }
+    }
+  } catch (err) {
+    log2.jobs.debug("Failed to scan directory", { dir, error: String(err) });
+  }
+  return results;
+}
+function listJobs(scope = "all") {
+  const jobs = [];
+  const launchctlStatus = parseLaunchctlList();
+  const plistFiles = [];
+  if (scope === "all" || scope === "user") {
+    plistFiles.push(...scanPlistDirectory(USER_LAUNCH_AGENTS, "user"));
+  }
+  if (scope === "all" || scope === "system") {
+    plistFiles.push(...scanPlistDirectory(GLOBAL_LAUNCH_AGENTS, "system"));
+    plistFiles.push(...scanPlistDirectory(GLOBAL_LAUNCH_DAEMONS, "system"));
+  }
+  for (const { path: path10, scope: jobScope } of plistFiles) {
+    const plist = parsePlist(path10);
+    if (!plist || !plist.Label) {
+      continue;
+    }
+    const entry = launchctlStatus.get(plist.Label);
+    const state = getJobState(entry);
+    const enabled = entry !== undefined && !plist.Disabled;
+    jobs.push({
+      name: plist.Label,
+      scope: jobScope,
+      description: null,
+      state,
+      enabled,
+      nextRun: calculateNextRun(plist),
+      lastRun: null,
+      lastResult: getLastResult2(entry),
+      schedule: formatSchedule(plist),
+      serviceName: plist.Label,
+      unitPath: path10
+    });
+  }
+  jobs.sort((a, b) => {
+    if (a.scope !== b.scope) {
+      return a.scope === "user" ? -1 : 1;
+    }
+    return a.name.localeCompare(b.name);
+  });
+  return jobs;
+}
+function getJob(name, scope) {
+  const directories = scope === "user" ? [USER_LAUNCH_AGENTS] : [GLOBAL_LAUNCH_AGENTS, GLOBAL_LAUNCH_DAEMONS];
+  let plistPath = null;
+  let plist = null;
+  for (const dir of directories) {
+    const candidates = [
+      join25(dir, `${name}.plist`)
+    ];
+    for (const candidate of candidates) {
+      if (existsSync18(candidate)) {
+        const parsed = parsePlist(candidate);
+        if (parsed?.Label === name) {
+          plistPath = candidate;
+          plist = parsed;
+          break;
+        }
+      }
+    }
+    if (plist)
+      break;
+    if (existsSync18(dir)) {
+      try {
+        const files = readdirSync8(dir);
+        for (const file of files) {
+          if (file.endsWith(".plist")) {
+            const path10 = join25(dir, file);
+            const parsed = parsePlist(path10);
+            if (parsed?.Label === name) {
+              plistPath = path10;
+              plist = parsed;
+              break;
+            }
+          }
+        }
+      } catch {}
+    }
+    if (plist)
+      break;
+  }
+  if (!plist || !plistPath) {
+    return null;
+  }
+  const launchctlStatus = parseLaunchctlList();
+  const entry = launchctlStatus.get(name);
+  const state = getJobState(entry);
+  const enabled = entry !== undefined && !plist.Disabled;
+  let plistContent = null;
+  try {
+    plistContent = execSync9(`cat "${plistPath}"`, {
+      encoding: "utf-8",
+      timeout: 5000,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch {}
+  return {
+    name,
+    scope,
+    description: null,
+    state,
+    enabled,
+    nextRun: calculateNextRun(plist),
+    lastRun: null,
+    lastResult: getLastResult2(entry),
+    schedule: formatSchedule(plist),
+    serviceName: name,
+    unitPath: plistPath,
+    timerContent: plistContent,
+    serviceContent: null,
+    command: getCommand(plist),
+    workingDirectory: plist.WorkingDirectory ?? null,
+    lastRunStart: null,
+    lastRunEnd: null,
+    lastRunDurationMs: null,
+    lastRunCpuTimeMs: null
+  };
+}
+function getJobLogs(name, scope, lines = 100) {
+  const job = getJob(name, scope);
+  if (!job) {
+    return [];
+  }
+  let processName = name;
+  if (job.command) {
+    const parts = job.command.split(/\s+/);
+    if (parts.length > 0) {
+      const executable = parts[0];
+      processName = executable.split("/").pop() || name;
+    }
+  }
+  try {
+    const cmd = `log show --predicate 'process == "${processName}" OR subsystem == "${name}"' --last 1h --style json 2>/dev/null | head -${lines * 20}`;
+    const output = execSync9(cmd, {
+      encoding: "utf-8",
+      timeout: 30000,
+      stdio: ["pipe", "pipe", "pipe"],
+      maxBuffer: 10 * 1024 * 1024
+    });
+    const entries = [];
+    try {
+      const parsed = JSON.parse(output);
+      if (Array.isArray(parsed)) {
+        for (const entry of parsed.slice(-lines)) {
+          entries.push({
+            timestamp: entry.timestamp || new Date().toISOString(),
+            message: entry.eventMessage || entry.message || "",
+            priority: mapLogLevel(entry.messageType)
+          });
+        }
+      }
+    } catch {
+      for (const line of output.split(`
+`)) {
+        if (!line.trim())
+          continue;
+        try {
+          const entry = JSON.parse(line);
+          entries.push({
+            timestamp: entry.timestamp || new Date().toISOString(),
+            message: entry.eventMessage || entry.message || "",
+            priority: mapLogLevel(entry.messageType)
+          });
+        } catch {}
+      }
+    }
+    return entries.slice(-lines);
+  } catch (err) {
+    log2.jobs.debug("Failed to get job logs", { name, error: String(err) });
+    const job2 = getJob(name, scope);
+    if (job2) {}
+    return [];
+  }
+}
+function mapLogLevel(messageType) {
+  switch (messageType) {
+    case "Error":
+    case "Fault":
+      return "error";
+    case "Warning":
+      return "warning";
+    default:
+      return "info";
+  }
+}
+
+// server/services/job-service.ts
+function getPlatform() {
+  if (platform3() === "darwin" && isLaunchdAvailable()) {
+    return "launchd";
+  }
+  if (platform3() === "linux" && isSystemdAvailable()) {
+    return "systemd";
+  }
+  return null;
+}
+function isJobsAvailable() {
+  return getPlatform() !== null;
+}
+function canCreateJobs() {
+  return getPlatform() === "systemd";
+}
+function listJobs2(scope = "all") {
+  const p = getPlatform();
+  if (p === "launchd") {
+    return listJobs(scope);
+  }
+  if (p === "systemd") {
+    return listTimers(scope);
+  }
+  return [];
+}
+function getJob2(name, scope) {
+  const p = getPlatform();
+  if (p === "launchd") {
+    return getJob(name, scope);
+  }
+  if (p === "systemd") {
+    return getTimer(name, scope);
+  }
+  return null;
+}
+function getJobLogs2(name, scope, lines = 100) {
+  const p = getPlatform();
+  if (p === "launchd") {
+    return getJobLogs(name, scope, lines);
+  }
+  if (p === "systemd") {
+    return getTimerLogs(name, scope, lines);
+  }
+  return [];
+}
+function enableJob(name, scope, enable) {
+  if (!canCreateJobs()) {
+    throw new Error("Job modification not supported on this platform");
+  }
+  enableTimer(name, scope, enable);
+}
+function startJob(name, scope) {
+  if (!canCreateJobs()) {
+    throw new Error("Job modification not supported on this platform");
+  }
+  startTimer(name, scope);
+}
+function stopJob(name, scope) {
+  if (!canCreateJobs()) {
+    throw new Error("Job modification not supported on this platform");
+  }
+  stopTimer(name, scope);
+}
+function runJobNow(name, scope) {
+  if (!canCreateJobs()) {
+    throw new Error("Job modification not supported on this platform");
+  }
+  runNow(name, scope);
+}
+function createJob(config) {
+  if (!canCreateJobs()) {
+    throw new Error("Job creation not supported on this platform");
+  }
+  createTimer(config);
+}
+function updateJob(name, updates) {
+  if (!canCreateJobs()) {
+    throw new Error("Job modification not supported on this platform");
+  }
+  updateTimer(name, updates);
+}
+function deleteJob(name) {
+  if (!canCreateJobs()) {
+    throw new Error("Job deletion not supported on this platform");
+  }
+  deleteTimer(name);
+}
+
 // server/routes/jobs.ts
 init_logger3();
 var app18 = new Hono2;
 app18.get("/available", (c) => {
-  const available = isSystemdAvailable();
-  return c.json({ available });
+  return c.json({
+    available: isJobsAvailable(),
+    canCreate: canCreateJobs(),
+    platform: getPlatform()
+  });
 });
 app18.get("/", (c) => {
   const scope = c.req.query("scope") || "all";
   try {
-    const timers = listTimers(scope);
-    return c.json(timers);
+    const jobs = listJobs2(scope);
+    return c.json(jobs);
   } catch (err) {
-    log2.jobs.error("Failed to list timers", { error: String(err) });
-    return c.json({ error: "Failed to list timers" }, 500);
+    log2.jobs.error("Failed to list jobs", { error: String(err) });
+    return c.json({ error: "Failed to list jobs" }, 500);
   }
 });
 app18.get("/:name", (c) => {
   const name = c.req.param("name");
   const scope = c.req.query("scope") || "user";
   try {
-    const timer = getTimer(name, scope);
-    if (!timer) {
-      return c.json({ error: "Timer not found" }, 404);
+    const job = getJob2(name, scope);
+    if (!job) {
+      return c.json({ error: "Job not found" }, 404);
     }
-    return c.json(timer);
+    return c.json(job);
   } catch (err) {
-    log2.jobs.error("Failed to get timer", { name, error: String(err) });
-    return c.json({ error: "Failed to get timer" }, 500);
+    log2.jobs.error("Failed to get job", { name, error: String(err) });
+    return c.json({ error: "Failed to get job" }, 500);
   }
 });
 app18.get("/:name/logs", (c) => {
@@ -181903,103 +182385,127 @@ app18.get("/:name/logs", (c) => {
   const scope = c.req.query("scope") || "user";
   const lines = parseInt(c.req.query("lines") || "100", 10);
   try {
-    const entries = getTimerLogs(name, scope, lines);
+    const entries = getJobLogs2(name, scope, lines);
     return c.json({ entries });
   } catch (err) {
-    log2.jobs.error("Failed to get timer logs", { name, error: String(err) });
-    return c.json({ error: "Failed to get timer logs" }, 500);
+    log2.jobs.error("Failed to get job logs", { name, error: String(err) });
+    return c.json({ error: "Failed to get job logs" }, 500);
   }
 });
 app18.post("/", async (c) => {
+  if (!canCreateJobs()) {
+    return c.json({ error: "Job creation not supported on this platform" }, 400);
+  }
   try {
     const body = await c.req.json();
     if (!body.name || !body.description || !body.schedule || !body.command) {
       return c.json({ error: "name, description, schedule, and command are required" }, 400);
     }
     if (!/^[a-zA-Z0-9_-]+$/.test(body.name)) {
-      return c.json({ error: "Timer name must contain only alphanumeric characters, hyphens, and underscores" }, 400);
+      return c.json({ error: "Job name must contain only alphanumeric characters, hyphens, and underscores" }, 400);
     }
-    createTimer(body);
+    createJob(body);
     return c.json({ success: true }, 201);
   } catch (err) {
-    log2.jobs.error("Failed to create timer", { error: String(err) });
-    return c.json({ error: err instanceof Error ? err.message : "Failed to create timer" }, 400);
+    log2.jobs.error("Failed to create job", { error: String(err) });
+    return c.json({ error: err instanceof Error ? err.message : "Failed to create job" }, 400);
   }
 });
 app18.patch("/:name", async (c) => {
+  if (!canCreateJobs()) {
+    return c.json({ error: "Job modification not supported on this platform" }, 400);
+  }
   const name = c.req.param("name");
   try {
     const body = await c.req.json();
-    updateTimer(name, body);
+    updateJob(name, body);
     return c.json({ success: true });
   } catch (err) {
-    log2.jobs.error("Failed to update timer", { name, error: String(err) });
-    return c.json({ error: err instanceof Error ? err.message : "Failed to update timer" }, 400);
+    log2.jobs.error("Failed to update job", { name, error: String(err) });
+    return c.json({ error: err instanceof Error ? err.message : "Failed to update job" }, 400);
   }
 });
 app18.delete("/:name", (c) => {
+  if (!canCreateJobs()) {
+    return c.json({ error: "Job deletion not supported on this platform" }, 400);
+  }
   const name = c.req.param("name");
   try {
-    deleteTimer(name);
+    deleteJob(name);
     return c.json({ success: true });
   } catch (err) {
-    log2.jobs.error("Failed to delete timer", { name, error: String(err) });
-    return c.json({ error: err instanceof Error ? err.message : "Failed to delete timer" }, 400);
+    log2.jobs.error("Failed to delete job", { name, error: String(err) });
+    return c.json({ error: err instanceof Error ? err.message : "Failed to delete job" }, 400);
   }
 });
 app18.post("/:name/enable", (c) => {
+  if (!canCreateJobs()) {
+    return c.json({ error: "Job modification not supported on this platform" }, 400);
+  }
   const name = c.req.param("name");
   const scope = c.req.query("scope") || "user";
   try {
-    enableTimer(name, scope, true);
+    enableJob(name, scope, true);
     return c.json({ success: true });
   } catch (err) {
-    log2.jobs.error("Failed to enable timer", { name, error: String(err) });
-    return c.json({ error: err instanceof Error ? err.message : "Failed to enable timer" }, 400);
+    log2.jobs.error("Failed to enable job", { name, error: String(err) });
+    return c.json({ error: err instanceof Error ? err.message : "Failed to enable job" }, 400);
   }
 });
 app18.post("/:name/disable", (c) => {
+  if (!canCreateJobs()) {
+    return c.json({ error: "Job modification not supported on this platform" }, 400);
+  }
   const name = c.req.param("name");
   const scope = c.req.query("scope") || "user";
   try {
-    enableTimer(name, scope, false);
+    enableJob(name, scope, false);
     return c.json({ success: true });
   } catch (err) {
-    log2.jobs.error("Failed to disable timer", { name, error: String(err) });
-    return c.json({ error: err instanceof Error ? err.message : "Failed to disable timer" }, 400);
+    log2.jobs.error("Failed to disable job", { name, error: String(err) });
+    return c.json({ error: err instanceof Error ? err.message : "Failed to disable job" }, 400);
   }
 });
 app18.post("/:name/start", (c) => {
+  if (!canCreateJobs()) {
+    return c.json({ error: "Job modification not supported on this platform" }, 400);
+  }
   const name = c.req.param("name");
   const scope = c.req.query("scope") || "user";
   try {
-    startTimer(name, scope);
+    startJob(name, scope);
     return c.json({ success: true });
   } catch (err) {
-    log2.jobs.error("Failed to start timer", { name, error: String(err) });
-    return c.json({ error: err instanceof Error ? err.message : "Failed to start timer" }, 400);
+    log2.jobs.error("Failed to start job", { name, error: String(err) });
+    return c.json({ error: err instanceof Error ? err.message : "Failed to start job" }, 400);
   }
 });
 app18.post("/:name/stop", (c) => {
+  if (!canCreateJobs()) {
+    return c.json({ error: "Job modification not supported on this platform" }, 400);
+  }
   const name = c.req.param("name");
   const scope = c.req.query("scope") || "user";
   try {
-    stopTimer(name, scope);
+    stopJob(name, scope);
     return c.json({ success: true });
   } catch (err) {
-    log2.jobs.error("Failed to stop timer", { name, error: String(err) });
-    return c.json({ error: err instanceof Error ? err.message : "Failed to stop timer" }, 400);
+    log2.jobs.error("Failed to stop job", { name, error: String(err) });
+    return c.json({ error: err instanceof Error ? err.message : "Failed to stop job" }, 400);
   }
 });
 app18.post("/:name/run", (c) => {
+  if (!canCreateJobs()) {
+    return c.json({ error: "Job modification not supported on this platform" }, 400);
+  }
   const name = c.req.param("name");
   const scope = c.req.query("scope") || "user";
   try {
-    runNow(name, scope);
+    runJobNow(name, scope);
     return c.json({ success: true });
   } catch (err) {
-    log2.jobs.error("Failed to run timer service", { name, error: String(err) });
-    return c.json({ error: err instanceof Error ? err.message : "Failed to run timer service" }, 400);
+    log2.jobs.error("Failed to run job service", { name, error: String(err) });
+    return c.json({ error: err instanceof Error ? err.message : "Failed to run job service" }, 400);
   }
 });
 var jobs_default = app18;
@@ -182145,9 +182651,9 @@ var opencode_default = app19;
 init_nanoid();
 init_db2();
 init_drizzle_orm();
-import { existsSync as existsSync18, rmSync as rmSync5 } from "fs";
-import { homedir as homedir9 } from "os";
-import { resolve as resolve5, join as join25 } from "path";
+import { existsSync as existsSync19, rmSync as rmSync5 } from "fs";
+import { homedir as homedir10 } from "os";
+import { resolve as resolve5, join as join26 } from "path";
 var app20 = new Hono2;
 function buildProjectWithDetails(project, repo, appRow, services, tab) {
   return {
@@ -182254,7 +182760,7 @@ app20.post("/", async (c) => {
       }
     } else if (body.path) {
       const repoPath = expandPath2(body.path);
-      if (!existsSync18(repoPath)) {
+      if (!existsSync19(repoPath)) {
         return c.json({ error: `Directory does not exist: ${repoPath}` }, 400);
       }
       const existing = db2.select().from(repositories).where(eq(repositories.path, repoPath)).get();
@@ -182277,16 +182783,16 @@ app20.post("/", async (c) => {
     } else if (body.url) {
       const { isGitUrl: isGitUrl2, extractRepoNameFromUrl: extractRepoNameFromUrl2 } = await Promise.resolve().then(() => exports_git_utils);
       const { getSettings: getSettings2 } = await Promise.resolve().then(() => (init_settings(), exports_settings));
-      const { execSync: execSync9 } = await import("child_process");
+      const { execSync: execSync10 } = await import("child_process");
       const { mkdirSync: mkdirSync7, rmSync: rmSync6 } = await import("fs");
-      const { homedir: homedir10 } = await import("os");
+      const { homedir: homedir11 } = await import("os");
       if (!isGitUrl2(body.url)) {
         return c.json({ error: "Invalid git URL format" }, 400);
       }
       const settings = getSettings2();
       let parentDir = body.targetDir?.trim() || settings.paths.defaultGitReposDir;
       parentDir = expandPath2(parentDir);
-      const home = homedir10();
+      const home = homedir11();
       if (resolve5(parentDir) === home) {
         return c.json({ error: "Cannot clone directly into home directory. Please specify a subdirectory." }, 400);
       }
@@ -182297,30 +182803,30 @@ app20.post("/", async (c) => {
       if (repoName.includes("/") || repoName.includes("\\")) {
         return c.json({ error: "Folder name cannot contain path separators" }, 400);
       }
-      const targetPath = join25(parentDir, repoName);
+      const targetPath = join26(parentDir, repoName);
       const resolvedParent = resolve5(parentDir);
       const resolvedTarget = resolve5(targetPath);
       if (!resolvedTarget.startsWith(resolvedParent + "/") && resolvedTarget !== resolvedParent) {
         return c.json({ error: "Invalid target path" }, 400);
       }
-      if (existsSync18(targetPath)) {
+      if (existsSync19(targetPath)) {
         return c.json({ error: `Directory already exists: ${targetPath}` }, 400);
       }
       const existingRepo = db2.select().from(repositories).where(eq(repositories.path, targetPath)).get();
       if (existingRepo) {
         return c.json({ error: "Repository with this path already exists in database" }, 400);
       }
-      if (!existsSync18(parentDir)) {
+      if (!existsSync19(parentDir)) {
         mkdirSync7(parentDir, { recursive: true });
       }
       try {
-        execSync9(`git clone "${body.url}" "${targetPath}"`, {
+        execSync10(`git clone "${body.url}" "${targetPath}"`, {
           encoding: "utf-8",
           stdio: "pipe",
           timeout: 120000
         });
       } catch (cloneErr) {
-        if (existsSync18(targetPath) && resolvedTarget.startsWith(resolvedParent + "/")) {
+        if (existsSync19(targetPath) && resolvedTarget.startsWith(resolvedParent + "/")) {
           rmSync6(targetPath, { recursive: true, force: true });
         }
         const errorMessage = cloneErr instanceof Error ? cloneErr.message : "Clone failed";
@@ -182427,7 +182933,7 @@ app20.delete("/:id", async (c) => {
   }
   let directoryDeleted = false;
   if (deleteDirectory && repoPath) {
-    const home = homedir9();
+    const home = homedir10();
     if (resolve5(repoPath) === home) {
       return c.json({ error: "Cannot delete home directory" }, 400);
     }
@@ -182435,9 +182941,9 @@ app20.delete("/:id", async (c) => {
     if (dangerousPaths.includes(resolve5(repoPath))) {
       return c.json({ error: "Cannot delete system directory" }, 400);
     }
-    if (existsSync18(repoPath)) {
-      const gitPath = join25(repoPath, ".git");
-      if (!existsSync18(gitPath)) {
+    if (existsSync19(repoPath)) {
+      const gitPath = join26(repoPath, ".git");
+      if (!existsSync19(gitPath)) {
         return c.json({ error: "Directory does not appear to be a git repository" }, 400);
       }
       try {
@@ -182587,12 +183093,12 @@ app20.delete("/:id/app", async (c) => {
 app20.post("/scan", async (c) => {
   try {
     const body = await c.req.json().catch(() => ({}));
-    const { existsSync: existsSync19, readdirSync: readdirSync8 } = await import("fs");
-    const { join: join26 } = await import("path");
+    const { existsSync: existsSync20, readdirSync: readdirSync9 } = await import("fs");
+    const { join: join27 } = await import("path");
     const { getSettings: getSettings2, expandPath: expandPath2 } = await Promise.resolve().then(() => (init_settings(), exports_settings));
     const settings = getSettings2();
     const directory = expandPath2(body.directory || settings.paths.defaultGitReposDir);
-    if (!existsSync19(directory)) {
+    if (!existsSync20(directory)) {
       return c.json({ error: `Directory does not exist: ${directory}` }, 400);
     }
     const allRepos = db2.select().from(repositories).all();
@@ -182600,15 +183106,15 @@ app20.post("/scan", async (c) => {
     const allProjects = db2.select().from(projects).all();
     const repoIdWithProject = new Set(allProjects.filter((p) => p.repositoryId).map((p) => p.repositoryId));
     const discovered = [];
-    const entries = readdirSync8(directory, { withFileTypes: true });
+    const entries = readdirSync9(directory, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
       if (entry.name.startsWith("."))
         continue;
-      const subPath = join26(directory, entry.name);
-      const gitPath = join26(subPath, ".git");
-      if (existsSync19(gitPath)) {
+      const subPath = join27(directory, entry.name);
+      const gitPath = join27(subPath, ".git");
+      if (existsSync20(gitPath)) {
         const existingRepo = repoPathMap.get(subPath);
         discovered.push({
           path: subPath,
@@ -182630,14 +183136,14 @@ app20.post("/bulk", async (c) => {
     if (!body.repositories || !Array.isArray(body.repositories) || body.repositories.length === 0) {
       return c.json({ error: "repositories array is required" }, 400);
     }
-    const { existsSync: existsSync19 } = await import("fs");
+    const { existsSync: existsSync20 } = await import("fs");
     const { expandPath: expandPath2 } = await Promise.resolve().then(() => (init_settings(), exports_settings));
     const now = new Date().toISOString();
     const createdProjects = [];
     let skipped = 0;
     for (const repoInput of body.repositories) {
       const repoPath = expandPath2(repoInput.path);
-      if (!existsSync19(repoPath)) {
+      if (!existsSync20(repoPath)) {
         skipped++;
         continue;
       }
@@ -182710,9 +183216,9 @@ var projects_default = app20;
 init_logger3();
 function getDistPath() {
   if (process.env.VIBORA_PACKAGE_ROOT) {
-    return join26(process.env.VIBORA_PACKAGE_ROOT, "dist");
+    return join27(process.env.VIBORA_PACKAGE_ROOT, "dist");
   }
-  return join26(process.cwd(), "dist");
+  return join27(process.cwd(), "dist");
 }
 function createApp() {
   const app21 = new Hono2;
@@ -182788,15 +183294,15 @@ function createApp() {
       });
     };
     app21.get("/assets/*", async (c) => {
-      const assetPath = join26(distPath, c.req.path);
-      if (existsSync19(assetPath)) {
+      const assetPath = join27(distPath, c.req.path);
+      if (existsSync20(assetPath)) {
         return serveFile(assetPath);
       }
       return c.notFound();
     });
     app21.get("/sounds/*", async (c) => {
-      const soundPath = join26(distPath, c.req.path);
-      if (existsSync19(soundPath)) {
+      const soundPath = join27(distPath, c.req.path);
+      if (existsSync20(soundPath)) {
         return serveFile(soundPath);
       }
       return c.notFound();
@@ -182804,8 +183310,8 @@ function createApp() {
     const staticFiles = ["vibora-icon.png", "vibora-logo.jpeg", "vite.svg", "logo.png", "goat.jpeg"];
     for (const file of staticFiles) {
       app21.get(`/${file}`, async () => {
-        const filePath = join26(distPath, file);
-        if (existsSync19(filePath)) {
+        const filePath = join27(distPath, file);
+        if (existsSync20(filePath)) {
           return serveFile(filePath);
         }
         return new Response("Not Found", { status: 404 });
@@ -182816,7 +183322,7 @@ function createApp() {
       if (path10.startsWith("/api/") || path10.startsWith("/ws/") || path10 === "/health") {
         return next();
       }
-      const html = await readFile7(join26(distPath, "index.html"), "utf-8");
+      const html = await readFile7(join27(distPath, "index.html"), "utf-8");
       return c.html(html);
     });
   }
@@ -182832,7 +183338,7 @@ init_settings();
 init_db2();
 init_schema();
 init_drizzle_orm();
-import { execSync as execSync9 } from "child_process";
+import { execSync as execSync10 } from "child_process";
 init_logger3();
 var POLL_INTERVAL = 60000;
 function parsePrUrl(url) {
@@ -182848,7 +183354,7 @@ function checkPrStatus(prUrl) {
     return null;
   }
   try {
-    const output = execSync9(`gh pr view ${parsed.number} --repo ${parsed.owner}/${parsed.repo} --json state,mergedAt`, { encoding: "utf-8", timeout: 1e4, stdio: ["pipe", "pipe", "pipe"] });
+    const output = execSync10(`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,