vent-hq 0.5.1 → 0.5.2

package/dist/index.mjs

@@ -131,14 +131,24 @@ async function apiFetch(path3, apiKey, options = {}) {
 }
 
 // src/lib/sse.ts
+function log(msg) {
+  const ts = (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
+  const line = `[vent:sse ${ts}] ${msg}
+`;
+  process.stderr.write(line);
+}
 async function* streamRunEvents(runId, apiKey, signal) {
   const url = `${API_BASE}/runs/${runId}/stream`;
+  log(`connecting to ${url}`);
   const res = await fetch(url, {
     headers: { Authorization: `Bearer ${apiKey}` },
     signal
   });
+  log(`response: status=${res.status} content-type=${res.headers.get("content-type")}`);
   if (!res.ok) {
-    throw new Error(`SSE stream failed (${res.status}): ${await res.text()}`);
+    const body = await res.text();
+    log(`error body: ${body}`);
+    throw new Error(`SSE stream failed (${res.status}): ${body}`);
   }
   if (!res.body) {
     throw new Error("SSE stream returned no body");
@@ -146,28 +156,48 @@ async function* streamRunEvents(runId, apiKey, signal) {
   const reader = res.body.getReader();
   const decoder = new TextDecoder();
   let buffer = "";
+  let chunkCount = 0;
+  let eventCount = 0;
   try {
     while (true) {
       const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
+      if (done) {
+        log(`stream done after ${chunkCount} chunks, ${eventCount} events`);
+        break;
+      }
+      chunkCount++;
+      const chunk = decoder.decode(value, { stream: true });
+      buffer += chunk;
+      if (chunkCount <= 3 || chunkCount % 10 === 0) {
+        log(`chunk #${chunkCount} (${chunk.length} bytes) buffer=${buffer.length} bytes`);
+      }
       const lines = buffer.split("\n");
       buffer = lines.pop();
       for (const line of lines) {
         if (line.startsWith("data: ")) {
+          const raw = line.slice(6);
           try {
-            const event = JSON.parse(line.slice(6));
+            const event = JSON.parse(raw);
+            eventCount++;
+            log(`parsed event #${eventCount}: type=${event.event_type}`);
             yield event;
             if (event.event_type === "run_complete") {
+              log("run_complete received \u2014 closing stream");
               return;
             }
           } catch {
+            log(`malformed JSON: ${raw.slice(0, 200)}`);
+          }
+        } else if (line.startsWith(": ")) {
+          if (chunkCount <= 3) {
+            log(`heartbeat: "${line}"`);
           }
         }
       }
     }
   } finally {
     reader.releaseLock();
+    log("reader released");
   }
 }
 
@@ -511,19 +541,31 @@ function printSuccess(message) {
 }
 
 // src/commands/run.ts
+function log2(msg) {
+  const ts = (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
+  const line = `[vent ${ts}] ${msg}
+`;
+  process.stdout.write(line);
+  process.stderr.write(line);
+}
 async function runCommand(args) {
+  log2(`start args=${JSON.stringify({ file: args.file, test: args.test, json: args.json, submit: args.submit })}`);
   const apiKey = args.apiKey ?? await loadApiKey();
   if (!apiKey) {
     printError("No API key found. Set VENT_API_KEY, run `npx vent-hq login`, or pass --api-key.");
     return 2;
   }
+  log2(`api-key resolved (${apiKey.slice(0, 8)}\u2026)`);
   let config;
   try {
     if (args.file) {
+      log2(`reading config file: ${args.file}`);
       const raw = await fs2.readFile(args.file, "utf-8");
       config = JSON.parse(raw);
+      log2(`config parsed \u2014 keys: ${Object.keys(config).join(", ")}`);
     } else if (args.config) {
       config = JSON.parse(args.config);
+      log2("config parsed from --config flag");
     } else {
       printError("Provide --config '{...}' or -f <file>.");
       return 2;
@@ -552,12 +594,15 @@ async function runCommand(args) {
       return 2;
     }
     cfg2.conversation_tests = match;
+    log2(`filtered to test: ${args.test}`);
   }
   const cfg = config;
   if (cfg.connection?.start_command) {
     const freePort = await findFreePort();
     cfg.connection.agent_port = freePort;
+    log2(`auto-port assigned: ${freePort}`);
   }
+  log2("submitting run to API\u2026");
   printInfo("Submitting run\u2026");
   let submitResult;
   try {
@@ -565,16 +610,20 @@ async function runCommand(args) {
       method: "POST",
       body: JSON.stringify({ config })
     });
+    log2(`API response status: ${res.status}`);
     submitResult = await res.json();
   } catch (err) {
+    log2(`submit error: ${err.message}`);
     printError(`Submit failed: ${err.message}`);
     return 2;
   }
   const { run_id } = submitResult;
   if (!run_id) {
+    log2(`no run_id in response: ${JSON.stringify(submitResult)}`);
     printError("Server returned no run_id. Response: " + JSON.stringify(submitResult));
     return 2;
   }
+  log2(`run created: ${run_id} status=${submitResult.status} has_relay=${!!submitResult.relay_config}`);
   printInfo(`Run ${run_id} created.`);
   if (args.submit) {
     if (submitResult.relay_config) {
@@ -594,56 +643,74 @@ async function runCommand(args) {
   }
   let relay = null;
   if (submitResult.relay_config) {
+    log2(`starting relay \u2014 agent_port=${submitResult.relay_config.agent_port} start_command="${submitResult.relay_config.start_command}" health=${submitResult.relay_config.health_endpoint}`);
     printInfo("Starting relay for local agent\u2026");
     try {
       relay = await startRelay(submitResult.relay_config);
+      log2("relay connected, agent healthy, run activated");
       printInfo("Relay connected, agent started.");
     } catch (err) {
+      log2(`relay error: ${err.message}`);
       printError(`Relay failed: ${err.message}`);
       return 2;
     }
   }
+  log2(`connecting to SSE stream for run ${run_id}\u2026`);
   printInfo(`Streaming results for run ${run_id}\u2026`);
   const abortController = new AbortController();
   let exitCode = 0;
   const testResults = [];
   let runCompleteData = null;
   const onSignal = () => {
+    log2("received SIGINT/SIGTERM \u2014 aborting stream");
     abortController.abort();
   };
   process.on("SIGINT", onSignal);
   process.on("SIGTERM", onSignal);
   try {
+    let eventCount = 0;
     for await (const event of streamRunEvents(run_id, apiKey, abortController.signal)) {
+      eventCount++;
+      const meta = event.metadata_json ?? {};
+      log2(`event #${eventCount}: type=${event.event_type} meta_keys=[${Object.keys(meta).join(",")}] message="${event.message ?? ""}"`);
       printEvent(event, args.json);
       if (event.event_type === "test_completed") {
         testResults.push(event);
+        log2(`test_completed: name=${meta.test_name} status=${meta.status} duration=${meta.duration_ms}ms completed=${meta.completed}/${meta.total}`);
       }
       if (event.event_type === "run_complete") {
-        const meta = event.metadata_json ?? {};
         runCompleteData = meta;
         const status = meta.status;
         exitCode = status === "pass" ? 0 : 1;
+        log2(`run_complete: status=${status} exitCode=${exitCode}`);
       }
     }
+    log2(`SSE stream ended \u2014 received ${eventCount} events total`);
   } catch (err) {
     if (err.name !== "AbortError") {
+      log2(`stream error: ${err.message}`);
       printError(`Stream error: ${err.message}`);
       exitCode = 2;
+    } else {
+      log2("stream aborted (user signal)");
     }
   } finally {
     process.off("SIGINT", onSignal);
     process.off("SIGTERM", onSignal);
     if (relay) {
+      log2("cleaning up relay\u2026");
       await relay.cleanup();
+      log2("relay cleaned up");
     }
   }
+  log2(`summary: testResults=${testResults.length} runComplete=${!!runCompleteData} exitCode=${exitCode}`);
   if (runCompleteData && testResults.length > 0) {
     printSummary(testResults, runCompleteData, run_id, args.json);
   } else if (testResults.length === 0 && exitCode !== 2) {
     process.stdout.write(`run_id: ${run_id} \u2014 no test results received
 `);
   }
+  log2(`exiting with code ${exitCode}`);
   return exitCode;
 }
 function findFreePort() {
@@ -6273,7 +6340,7 @@ async function main() {
     process.exit(0);
   }
   if (command === "--version" || command === "-v") {
-    const pkg = await import("./package-OFMTOIAB.mjs");
+    const pkg = await import("./package-QE6OAK7W.mjs");
     process.stdout.write(`vent-hq ${pkg.default.version}
 `);
     process.exit(0);

package/dist/package-QE6OAK7W.mjs

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+import "./chunk-U4M3XDTH.mjs";
+
+// package.json
+var package_default = {
+  name: "vent-hq",
+  version: "0.5.2",
+  type: "module",
+  description: "Vent CLI \u2014 CI/CD for voice AI agents",
+  bin: {
+    "vent-hq": "dist/index.mjs"
+  },
+  files: [
+    "dist"
+  ],
+  scripts: {
+    build: "node scripts/bundle.mjs",
+    clean: "rm -rf dist"
+  },
+  keywords: [
+    "vent",
+    "cli",
+    "voice",
+    "agent",
+    "testing",
+    "ci-cd"
+  ],
+  license: "MIT",
+  publishConfig: {
+    access: "public"
+  },
+  repository: {
+    type: "git",
+    url: "https://github.com/vent-hq/vent",
+    directory: "packages/cli"
+  },
+  homepage: "https://ventmcp.dev",
+  dependencies: {
+    "@clack/prompts": "^1.1.0",
+    ws: "^8.18.0"
+  },
+  devDependencies: {
+    "@types/ws": "^8.5.0",
+    "@vent/relay-client": "workspace:*",
+    "@vent/shared": "workspace:*",
+    esbuild: "^0.24.0"
+  }
+};
+export {
+  package_default as default
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vent-hq",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "type": "module",
   "description": "Vent CLI — CI/CD for voice AI agents",
   "bin": {