npm - vibora - Versions diffs - 4.5.2 → 4.6.0 - Mend

vibora 4.5.2 → 4.6.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/README.md +10 -1
package/bin/vibora.js +69 -1
package/dist/assets/index-CVgbBi7w.css +1 -0
package/dist/assets/{index-rvVpMwsP.js → index-D9hu2Hyr.js} +89 -89
package/dist/index.html +2 -2
package/package.json +1 -1
package/server/index.js +235 -28
package/dist/assets/index-DujV-tJ5.css +0 -1

package/dist/index.html CHANGED Viewed

@@ -5,8 +5,8 @@
     <link rel="icon" type="image/jpeg" href="/logo-dark.jpg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Vibora</title>
-    <script type="module" crossorigin src="/assets/index-rvVpMwsP.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-DujV-tJ5.css">
+    <script type="module" crossorigin src="/assets/index-D9hu2Hyr.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-CVgbBi7w.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "vibora",
-  "version": "4.5.2",
+  "version": "4.6.0",
   "description": "The Vibe Engineer's Cockpit",
   "license": "PolyForm-Shield-1.0.0",
   "repository": {

package/server/index.js CHANGED Viewed

@@ -152493,6 +152493,212 @@ app13.get("/dependencies", (c) => {
 });
 var system_default = app13;
+// server/routes/exec.ts
+import { spawn as spawn3 } from "child_process";
+import { randomUUID } from "crypto";
+import * as os6 from "os";
+var DEFAULT_TIMEOUT = 30000;
+var START_MARKER = `<<VIBORA_CMD_START_${randomUUID().slice(0, 8)}>>`;
+var END_MARKER_PREFIX = `<<VIBORA_CMD_END_${randomUUID().slice(0, 8)}:`;
+var sessions = new Map;
+function createSession(cwd, name) {
+  const id = randomUUID();
+  const initialCwd = cwd || os6.homedir();
+  const proc2 = spawn3("/bin/bash", ["--norc", "--noprofile"], {
+    cwd: initialCwd,
+    env: { ...process.env, TERM: "dumb" },
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  const session = {
+    id,
+    name,
+    process: proc2,
+    cwd: initialCwd,
+    outputBuffer: "",
+    stderrBuffer: "",
+    pendingResolve: null,
+    pendingReject: null,
+    createdAt: new Date,
+    lastUsedAt: new Date
+  };
+  proc2.stdout?.on("data", (data) => {
+    session.outputBuffer += data.toString();
+    checkForCompletion(session);
+  });
+  proc2.stderr?.on("data", (data) => {
+    session.stderrBuffer += data.toString();
+  });
+  proc2.on("error", (err) => {
+    if (session.pendingReject) {
+      session.pendingReject(err);
+      session.pendingResolve = null;
+      session.pendingReject = null;
+    }
+  });
+  proc2.on("exit", () => {
+    sessions.delete(id);
+    if (session.pendingReject) {
+      session.pendingReject(new Error("Shell process exited unexpectedly"));
+      session.pendingResolve = null;
+      session.pendingReject = null;
+    }
+  });
+  sessions.set(id, session);
+  return session;
+}
+function checkForCompletion(session) {
+  if (!session.pendingResolve)
+    return;
+  const endMarkerRegex = new RegExp(`${END_MARKER_PREFIX.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(\\d+)>>`);
+  const match3 = session.outputBuffer.match(endMarkerRegex);
+  if (match3) {
+    const exitCode = parseInt(match3[1], 10);
+    const startIdx = session.outputBuffer.indexOf(START_MARKER);
+    const endIdx = session.outputBuffer.indexOf(match3[0]);
+    let stdout = "";
+    if (startIdx !== -1 && endIdx > startIdx) {
+      stdout = session.outputBuffer.slice(startIdx + START_MARKER.length + 1, endIdx);
+      if (stdout.endsWith(`
+`)) {
+        stdout = stdout.slice(0, -1);
+      }
+    }
+    const stderr = session.stderrBuffer;
+    session.outputBuffer = "";
+    session.stderrBuffer = "";
+    const resolve4 = session.pendingResolve;
+    session.pendingResolve = null;
+    session.pendingReject = null;
+    resolve4({ stdout, stderr, exitCode });
+  }
+}
+function destroySession(id) {
+  const session = sessions.get(id);
+  if (!session)
+    return false;
+  try {
+    session.process.kill();
+  } catch {}
+  sessions.delete(id);
+  return true;
+}
+async function executeCommand(session, command, timeout) {
+  return new Promise((resolve4, reject) => {
+    session.lastUsedAt = new Date;
+    session.outputBuffer = "";
+    session.stderrBuffer = "";
+    session.pendingResolve = resolve4;
+    session.pendingReject = reject;
+    const wrappedCommand = `echo "${START_MARKER}"; ${command}; echo "${END_MARKER_PREFIX}$?>>"
+`;
+    const timeoutId = setTimeout(() => {
+      session.pendingResolve = null;
+      session.pendingReject = null;
+      reject(new Error("Command timed out"));
+    }, timeout);
+    const originalResolve = resolve4;
+    session.pendingResolve = (result) => {
+      clearTimeout(timeoutId);
+      originalResolve(result);
+    };
+    session.process.stdin?.write(wrappedCommand);
+  });
+}
+async function updateSessionCwd(session) {
+  try {
+    const result = await executeCommand(session, "pwd", 5000);
+    if (result.exitCode === 0 && result.stdout.trim()) {
+      session.cwd = result.stdout.trim();
+    }
+  } catch {}
+}
+var app14 = new Hono2;
+app14.post("/", async (c) => {
+  try {
+    const body = await c.req.json();
+    const { command, sessionId, cwd, timeout = DEFAULT_TIMEOUT, name } = body;
+    if (!command) {
+      return c.json({ error: "command is required" }, 400);
+    }
+    let session;
+    if (sessionId) {
+      const existing = sessions.get(sessionId);
+      if (!existing) {
+        return c.json({ error: `Session ${sessionId} not found` }, 404);
+      }
+      session = existing;
+    } else {
+      session = createSession(cwd, name);
+    }
+    try {
+      const result = await executeCommand(session, command, timeout);
+      await updateSessionCwd(session);
+      const response = {
+        sessionId: session.id,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        exitCode: result.exitCode,
+        timedOut: false
+      };
+      return c.json(response);
+    } catch (err) {
+      if (err instanceof Error && err.message === "Command timed out") {
+        const response = {
+          sessionId: session.id,
+          stdout: session.outputBuffer,
+          stderr: session.stderrBuffer,
+          exitCode: null,
+          timedOut: true
+        };
+        return c.json(response);
+      }
+      throw err;
+    }
+  } catch (err) {
+    return c.json({ error: err instanceof Error ? err.message : "Failed to execute command" }, 500);
+  }
+});
+app14.get("/sessions", (c) => {
+  const sessionList = [];
+  for (const [id, session] of sessions) {
+    sessionList.push({
+      id,
+      name: session.name,
+      cwd: session.cwd,
+      createdAt: session.createdAt.toISOString(),
+      lastUsedAt: session.lastUsedAt.toISOString()
+    });
+  }
+  return c.json(sessionList);
+});
+app14.patch("/sessions/:id", async (c) => {
+  const id = c.req.param("id");
+  const session = sessions.get(id);
+  if (!session) {
+    return c.json({ error: `Session ${id} not found` }, 404);
+  }
+  const body = await c.req.json();
+  if (body.name !== undefined) {
+    session.name = body.name;
+  }
+  return c.json({
+    id: session.id,
+    name: session.name,
+    cwd: session.cwd,
+    createdAt: session.createdAt.toISOString(),
+    lastUsedAt: session.lastUsedAt.toISOString()
+  });
+});
+app14.delete("/sessions/:id", (c) => {
+  const id = c.req.param("id");
+  const destroyed = destroySession(id);
+  if (!destroyed) {
+    return c.json({ error: `Session ${id} not found` }, 404);
+  }
+  return c.json({ success: true });
+});
+var exec_default = app14;
 // server/app.ts
 function getDistPath() {
   if (process.env.VIBORA_PACKAGE_ROOT) {
@@ -152501,35 +152707,36 @@ function getDistPath() {
   return join15(process.cwd(), "dist");
 }
 function createApp() {
-  const app14 = new Hono2;
-  app14.use("*", logger());
-  app14.use("*", cors({
+  const app15 = new Hono2;
+  app15.use("*", logger());
+  app15.use("*", cors({
     origin: "*",
     allowMethods: ["GET", "POST", "PATCH", "PUT", "DELETE", "OPTIONS"],
     allowHeaders: ["Content-Type"]
   }));
-  app14.route("/health", health_default);
-  app14.route("/api/tasks", tasks_default);
-  app14.route("/api/git", git_default);
-  app14.route("/api/fs", filesystem_default);
-  app14.route("/api/config", config_default);
-  app14.route("/api/uploads", uploads_default);
-  app14.route("/api/worktrees", worktrees_default);
-  app14.route("/api/terminal-view-state", terminal_view_state_default);
-  app14.route("/api/repositories", repositories_default);
-  app14.route("/api/copier", copier_default);
-  app14.route("/api/linear", linear_default);
-  app14.route("/api/github", github_default);
-  app14.route("/api/monitoring", monitoringRoutes);
-  app14.route("/api/system", system_default);
-  app14.post("/api/logs", async (c) => {
+  app15.route("/health", health_default);
+  app15.route("/api/tasks", tasks_default);
+  app15.route("/api/git", git_default);
+  app15.route("/api/fs", filesystem_default);
+  app15.route("/api/config", config_default);
+  app15.route("/api/uploads", uploads_default);
+  app15.route("/api/worktrees", worktrees_default);
+  app15.route("/api/terminal-view-state", terminal_view_state_default);
+  app15.route("/api/repositories", repositories_default);
+  app15.route("/api/copier", copier_default);
+  app15.route("/api/linear", linear_default);
+  app15.route("/api/github", github_default);
+  app15.route("/api/monitoring", monitoringRoutes);
+  app15.route("/api/system", system_default);
+  app15.route("/api/exec", exec_default);
+  app15.post("/api/logs", async (c) => {
     const { entries } = await c.req.json();
     for (const entry of entries) {
       writeEntry(entry);
     }
     return c.json({ ok: true });
   });
-  app14.post("/api/debug", async (c) => {
+  app15.post("/api/debug", async (c) => {
     const body = await c.req.json();
     const entry = {
       ts: new Date().toISOString(),
@@ -152566,14 +152773,14 @@ function createApp() {
         headers: { "Content-Type": mimeTypes2[ext2 || ""] || "application/octet-stream" }
       });
     };
-    app14.get("/assets/*", async (c) => {
+    app15.get("/assets/*", async (c) => {
       const assetPath = join15(distPath, c.req.path);
       if (existsSync13(assetPath)) {
         return serveFile(assetPath);
       }
       return c.notFound();
     });
-    app14.get("/sounds/*", async (c) => {
+    app15.get("/sounds/*", async (c) => {
       const soundPath = join15(distPath, c.req.path);
       if (existsSync13(soundPath)) {
         return serveFile(soundPath);
@@ -152582,7 +152789,7 @@ function createApp() {
     });
     const staticFiles = ["vibora-icon.png", "vibora-logo.jpeg", "vite.svg", "logo-dark.jpg", "logo-light.jpg", "goat.jpeg"];
     for (const file of staticFiles) {
-      app14.get(`/${file}`, async () => {
+      app15.get(`/${file}`, async () => {
         const filePath = join15(distPath, file);
         if (existsSync13(filePath)) {
           return serveFile(filePath);
@@ -152590,7 +152797,7 @@ function createApp() {
         return new Response("Not Found", { status: 404 });
       });
     }
-    app14.get("*", async (c, next) => {
+    app15.get("*", async (c, next) => {
       const path9 = c.req.path;
       if (path9.startsWith("/api/") || path9.startsWith("/ws/") || path9 === "/health") {
         return next();
@@ -152599,7 +152806,7 @@ function createApp() {
       return c.html(html);
     });
   }
-  return app14;
+  return app15;
 }
 // server/services/pr-monitor.ts
@@ -152702,11 +152909,11 @@ setBroadcastDestroyed((terminalId) => {
     payload: { terminalId }
   });
 });
-var app14 = createApp();
-var { injectWebSocket, upgradeWebSocket } = createNodeWebSocket({ app: app14 });
-app14.get("/ws/terminal", upgradeWebSocket(() => terminalWebSocketHandlers));
+var app15 = createApp();
+var { injectWebSocket, upgradeWebSocket } = createNodeWebSocket({ app: app15 });
+app15.get("/ws/terminal", upgradeWebSocket(() => terminalWebSocketHandlers));
 var server = serve({
-  fetch: app14.fetch,
+  fetch: app15.fetch,
   port: PORT,
   hostname: HOST
 }, (info) => {