vibora 7.1.1 → 7.1.3

package/bin/vibora.js

@@ -32629,7 +32629,7 @@ function installUv() {
 var package_default = {
   name: "vibora",
   private: true,
-  version: "7.1.1",
+  version: "7.1.3",
   description: "Harness Attention. Orchestrate Agents. Ship.",
   license: "PolyForm-Shield-1.0.0",
   type: "module",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibora",
-  "version": "7.1.1",
+  "version": "7.1.3",
   "description": "Harness Attention. Orchestrate Agents. Ship.",
   "license": "PolyForm-Shield-1.0.0",
   "repository": {

package/server/index.js

@@ -9506,7 +9506,7 @@ var __classPrivateFieldSet = function(receiver, state, value, kind2, f) {
   }
 }, startsWithSchemeRegexp, isAbsoluteURL = (url) => {
   return startsWithSchemeRegexp.test(url);
-}, sleep2 = (ms) => new Promise((resolve5) => setTimeout(resolve5, ms)), validatePositiveInteger = (name, n) => {
+}, sleep2 = (ms) => new Promise((resolve6) => setTimeout(resolve6, ms)), validatePositiveInteger = (name, n) => {
   if (typeof n !== "number" || !Number.isInteger(n)) {
     throw new CloudflareError(`${name} must be an integer`);
   }
@@ -9571,8 +9571,8 @@ var init_core = __esm(() => {
   init();
   APIPromise = class APIPromise extends Promise {
     constructor(responsePromise, parseResponse = defaultParseResponse) {
-      super((resolve5) => {
-        resolve5(null);
+      super((resolve6) => {
+        resolve6(null);
       });
       this.responsePromise = responsePromise;
       this.parseResponse = parseResponse;
@@ -176605,17 +176605,15 @@ async function fetchDockerApiStats() {
     if (!listResponse.ok)
       return null;
     const containerList = await listResponse.json();
-    const containers = [];
-    for (const container of containerList) {
-      if (container.State !== "running")
-        continue;
+    const runningContainers = containerList.filter((c) => c.State === "running");
+    const statsPromises = runningContainers.map(async (container) => {
       try {
         const statsUrl = `http://localhost/containers/${container.Id}/stats?stream=false`;
         const statsResponse = await fetch(statsUrl, {
           unix: socketPath
         });
         if (!statsResponse.ok)
-          continue;
+          return null;
         const stats = await statsResponse.json();
         const cpuDelta = stats.cpu_stats.cpu_usage.total_usage - stats.precpu_stats.cpu_usage.total_usage;
         const systemDelta = stats.cpu_stats.system_cpu_usage - stats.precpu_stats.system_cpu_usage;
@@ -176625,18 +176623,20 @@ async function fetchDockerApiStats() {
         const memoryMB = memoryBytes / (1024 * 1024);
         const memoryLimitMB = memoryLimit / (1024 * 1024);
         const memoryPercent = memoryLimit > 0 ? memoryBytes / memoryLimit * 100 : 0;
-        containers.push({
+        return {
           id: container.Id.slice(0, 12),
           name: (container.Names[0] || "unknown").replace(/^\//, ""),
           cpuPercent: Math.round(cpuPercent * 10) / 10,
           memoryMB: Math.round(memoryMB * 10) / 10,
           memoryLimit: Math.round(memoryLimitMB * 10) / 10,
           memoryPercent: Math.round(memoryPercent * 10) / 10
-        });
+        };
       } catch {
-        continue;
+        return null;
       }
-    }
+    });
+    const results = await Promise.all(statsPromises);
+    const containers = results.filter((c) => c !== null);
     return containers;
   } catch {
     return null;
@@ -177308,6 +177308,60 @@ var nanoid = (size = 21) => {
 import { readFile as readFile2, access } from "fs/promises";
 import { join as join16 } from "path";
 init_logger2();
+
+// server/lib/env-expand.ts
+function expandEnvVar(str, env) {
+  const braceMatch = str.match(/^\$\{([A-Za-z_][A-Za-z0-9_]*)(?:(:?[-=])(.+))?\}$/);
+  if (braceMatch) {
+    const varName = braceMatch[1];
+    const operator = braceMatch[2];
+    const defaultValue = braceMatch[3];
+    if (env && varName in env) {
+      const value = env[varName];
+      if (operator?.startsWith(":") && value === "") {
+        return defaultValue ?? null;
+      }
+      return value;
+    }
+    if (defaultValue !== undefined) {
+      return defaultValue;
+    }
+    return null;
+  }
+  const simpleMatch = str.match(/^\$([A-Za-z_][A-Za-z0-9_]*)$/);
+  if (simpleMatch) {
+    const varName = simpleMatch[1];
+    if (env && varName in env) {
+      return env[varName];
+    }
+    return null;
+  }
+  return str;
+}
+function splitRespectingEnvVars(str, delimiter = ":") {
+  const parts = [];
+  let current = "";
+  let braceDepth = 0;
+  for (let i = 0;i < str.length; i++) {
+    const char = str[i];
+    if (char === "{" && i > 0 && str[i - 1] === "$") {
+      braceDepth++;
+      current += char;
+    } else if (char === "}" && braceDepth > 0) {
+      braceDepth--;
+      current += char;
+    } else if (char === delimiter && braceDepth === 0) {
+      parts.push(current);
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  parts.push(current);
+  return parts;
+}
+
+// server/services/compose-parser.ts
 var COMPOSE_FILE_NAMES = ["compose.yml", "compose.yaml", "docker-compose.yml", "docker-compose.yaml"];
 async function findComposeFile(repoPath) {
   for (const fileName of COMPOSE_FILE_NAMES) {
@@ -177319,8 +177373,23 @@ async function findComposeFile(repoPath) {
   }
   return null;
 }
+function parsePortValue(value) {
+  const expanded = expandEnvVar(value);
+  if (expanded === null) {
+    return null;
+  }
+  const port = parseInt(expanded, 10);
+  if (isNaN(port) || port <= 0 || port > 65535) {
+    return null;
+  }
+  return port;
+}
 function parsePort(port) {
   if (typeof port === "number") {
+    if (port <= 0 || port > 65535) {
+      log2.deploy.warn("Invalid port number", { port });
+      return null;
+    }
     return { container: port };
   }
   if (typeof port === "string") {
@@ -177333,28 +177402,34 @@ function parsePort(port) {
       protocol = "udp";
       portStr = port.slice(0, -4);
     }
-    if (portStr.includes(":")) {
-      const parts = portStr.split(":");
-      const containerPort = parseInt(parts[parts.length - 1], 10);
-      const hostPort = parseInt(parts[parts.length - 2], 10);
-      if (!isNaN(containerPort)) {
+    const parts = splitRespectingEnvVars(portStr);
+    if (parts.length >= 2) {
+      const containerPort = parsePortValue(parts[parts.length - 1]);
+      const hostPort = parsePortValue(parts[parts.length - 2]);
+      if (containerPort !== null) {
         return {
           container: containerPort,
-          host: isNaN(hostPort) ? undefined : hostPort,
+          host: hostPort ?? undefined,
           protocol
         };
       }
+      log2.deploy.warn("Could not parse port with env var reference", { port: portStr });
     } else {
-      const containerPort = parseInt(portStr, 10);
-      if (!isNaN(containerPort)) {
+      const containerPort = parsePortValue(portStr);
+      if (containerPort !== null) {
         return { container: containerPort, protocol };
       }
+      log2.deploy.warn("Could not parse port value", { port: portStr });
     }
   }
   if (typeof port === "object" && port !== null) {
     const portObj = port;
     const target = portObj.target ?? portObj.container_port;
     if (typeof target === "number") {
+      if (target <= 0 || target > 65535) {
+        log2.deploy.warn("Invalid port number in long syntax", { target });
+        return null;
+      }
       return {
         container: target,
         host: typeof portObj.published === "number" ? portObj.published : undefined,
@@ -177595,14 +177670,14 @@ async function runDocker(args, options = {}) {
 // server/services/docker-swarm.ts
 import { spawn as spawn5 } from "child_process";
 import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
-import { join as join17 } from "path";
+import { join as join17, resolve as resolve5, isAbsolute as isAbsolute2 } from "path";
 init_logger2();
 async function runDocker2(args, options = {}, onOutput) {
   if (options.signal?.aborted) {
     return { stdout: "", stderr: "Aborted", exitCode: -1, aborted: true };
   }
   log2.deploy.debug("Running docker command", { args, cwd: options.cwd });
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const proc2 = spawn5("docker", args, {
       cwd: options.cwd,
       env: {
@@ -177644,12 +177719,12 @@ async function runDocker2(args, options = {}, onOutput) {
     });
     proc2.on("close", (code) => {
       options.signal?.removeEventListener("abort", abortHandler);
-      resolve5({ stdout, stderr, exitCode: code ?? 0, aborted });
+      resolve6({ stdout, stderr, exitCode: code ?? 0, aborted });
     });
     proc2.on("error", (err) => {
       options.signal?.removeEventListener("abort", abortHandler);
       log2.deploy.error("Docker spawn error", { error: String(err) });
-      resolve5({ stdout, stderr, exitCode: 1, aborted });
+      resolve6({ stdout, stderr, exitCode: 1, aborted });
     });
   });
 }
@@ -177725,6 +177800,9 @@ async function generateSwarmComposeFile(cwd, composeFile, projectName, externalN
         });
         serviceConfig.depends_on = Object.keys(serviceConfig.depends_on);
       }
+      if (Array.isArray(serviceConfig.volumes)) {
+        serviceConfig.volumes = serviceConfig.volumes.map((vol) => resolveVolumeEntry(vol, cwd));
+      }
       const unsupportedFields = [
         "container_name",
         "links",
@@ -177972,7 +178050,55 @@ async function waitForServicesHealthy(stackName, timeoutMs = 300000, signal) {
   return { healthy: false, failedServices };
 }
 function sleep(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
+  return new Promise((r) => setTimeout(r, ms));
+}
+function resolveVolumePath(volumePath, basePath) {
+  const expanded = expandEnvVar(volumePath);
+  const pathToCheck = expanded ?? volumePath;
+  if (!pathToCheck.includes("/") && !pathToCheck.startsWith(".")) {
+    return volumePath;
+  }
+  if (expanded === null && volumePath.includes("${")) {
+    return volumePath;
+  }
+  if (isAbsolute2(pathToCheck)) {
+    return expanded ?? volumePath;
+  }
+  return resolve5(basePath, pathToCheck);
+}
+function resolveVolumeEntry(volume, basePath) {
+  if (typeof volume === "string") {
+    const parts = splitRespectingEnvVars(volume);
+    if (parts.length >= 2) {
+      const hostPath = parts[0];
+      const containerPath = parts[1];
+      const options = parts.slice(2).join(":");
+      const resolvedHost = resolveVolumePath(hostPath, basePath);
+      if (resolvedHost !== hostPath) {
+        log2.deploy.debug("Resolved relative volume path", {
+          original: hostPath,
+          resolved: resolvedHost
+        });
+      }
+      return options ? `${resolvedHost}:${containerPath}:${options}` : `${resolvedHost}:${containerPath}`;
+    }
+    return volume;
+  }
+  if (typeof volume === "object" && volume !== null) {
+    const vol = volume;
+    if (vol.type === "bind" && typeof vol.source === "string") {
+      const resolvedSource = resolveVolumePath(vol.source, basePath);
+      if (resolvedSource !== vol.source) {
+        log2.deploy.debug("Resolved relative volume path (long syntax)", {
+          original: vol.source,
+          resolved: resolvedSource
+        });
+        return { ...vol, source: resolvedSource };
+      }
+    }
+    return vol;
+  }
+  return volume;
 }
 async function addCloudflaredToStack(swarmFilePath, config) {
   try {
@@ -178522,17 +178648,17 @@ async function cancelDeployment(deploymentId) {
       log2.deploy.debug("Killing process", { deploymentId, pid: proc2.pid });
       try {
         proc2.kill("SIGTERM");
-        await new Promise((resolve5) => {
+        await new Promise((resolve6) => {
           const timeout = setTimeout(() => {
             if (!proc2.killed) {
               log2.deploy.debug("Force killing process", { deploymentId, pid: proc2.pid });
               proc2.kill("SIGKILL");
             }
-            resolve5();
+            resolve6();
           }, 3000);
           proc2.once("exit", () => {
             clearTimeout(timeout);
-            resolve5();
+            resolve6();
           });
         });
       } catch (err) {
@@ -178616,7 +178742,7 @@ function getProjectName(appId) {
   return `vibora-${appId.slice(0, 8).toLowerCase()}`;
 }
 async function getGitCommit(repoPath) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const proc2 = spawn6("git", ["log", "-1", "--format=%H%n%s"], { cwd: repoPath });
     let stdout = "";
     proc2.stdout.on("data", (data) => {
@@ -178624,18 +178750,18 @@ async function getGitCommit(repoPath) {
     });
     proc2.on("close", (code) => {
       if (code !== 0) {
-        resolve5(null);
+        resolve6(null);
       } else {
         const lines = stdout.trim().split(`
 `);
-        resolve5({
+        resolve6({
           hash: lines[0]?.slice(0, 7) ?? "",
           message: lines[1] ?? ""
         });
       }
     });
     proc2.on("error", () => {
-      resolve5(null);
+      resolve6(null);
     });
   });
 }
@@ -178756,8 +178882,13 @@ async function deployApp(appId, options = {}, onProgress) {
       where: eq(appServices.appId, appId)
     });
     for (const service of services) {
-      if (service.exposed && service.domain && !service.containerPort) {
-        throw new Error(`Service "${service.serviceName}" is exposed with domain "${service.domain}" but has no container port configured. ` + `Add a port mapping to your compose file or configure the container port in the service settings.`);
+      if (service.exposed && service.domain) {
+        if (!service.containerPort) {
+          throw new Error(`Service "${service.serviceName}" is exposed with domain "${service.domain}" but has no container port configured. ` + `Add a port mapping to your compose file or configure the container port in the service settings.`);
+        }
+        if (service.containerPort <= 0 || service.containerPort > 65535) {
+          throw new Error(`Service "${service.serviceName}" has invalid container port ${service.containerPort}. ` + `Port must be between 1 and 65535. Check your compose file port configuration.`);
+        }
       }
     }
     const serviceStatuses = await stackServices(projectName);
@@ -180189,11 +180320,11 @@ ensureLatestSettings();
 var PORT = getSettingByKey("port");
 var HOST = process.env.HOST || "localhost";
 async function checkPortAvailable(port, host) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const server = createServer();
-    server.once("error", () => resolve5(false));
+    server.once("error", () => resolve6(false));
     server.once("listening", () => {
-      server.close(() => resolve5(true));
+      server.close(() => resolve6(true));
     });
     server.listen(port, host);
   });