@vendian/cli 0.0.15 → 0.0.17

package/cli-wrapper.mjs

@@ -36675,21 +36675,27 @@ async function forwardToPythonVendian(args, { env: env3 = process.env, platform:
   recordForwardedDocsCommand(args, code, { env: env3, platform: platform2 });
   process.exitCode = code;
 }
-async function preparePythonVendianInvocation(args, { env: env3 = process.env, platform: platform2 = process.platform } = {}) {
+async function preparePythonVendianInvocation(args, { env: env3 = process.env, platform: platform2 = process.platform, onProgress = null } = {}) {
   const venvPath = managedVenvPath(env3, platform2);
   const vendianPath = venvVendian(venvPath, platform2);
+  reportProgress(onProgress, "Checking managed Python runtime");
   if (!fs8.existsSync(vendianPath)) {
     throw new Error("Vendian is not set up yet. Run `vendian login` first.");
   }
   const loadedConfig = loadConfig(env3, platform2);
   const requiresPackageAccess = commandNeedsPackageAccess(args);
+  if (requiresPackageAccess) {
+    reportProgress(onProgress, "Refreshing package access");
+  }
   const refreshed = requiresPackageAccess ? await refreshPackageAccessFromCloudAuth({ config: loadedConfig, env: env3, platform: platform2 }) : { config: loadedConfig };
-  maybeAutoUpdateManagedEnv({ env: env3, platform: platform2, venvPath });
+  maybeAutoUpdateManagedEnv({ env: env3, platform: platform2, venvPath, onProgress });
   const config = refreshed.config;
+  reportProgress(onProgress, "Preparing package indexes");
   const registry = registryConfig(config, env3, platform2);
   if (requiresPackageAccess && !registry.token) {
     throw new Error("Package access is missing. Run `vendian login` or `vendian update` before starting local agents.");
   }
+  reportProgress(onProgress, "Launching local serve daemon");
   return {
     command: vendianPath,
     args,
@@ -36738,7 +36744,8 @@ function maybeAutoUpdateManagedEnv({
   save = saveConfig,
   installPackages = installVendianPackages,
   refreshDocs = refreshAgentDocsWorkspaces,
-  now = Date.now()
+  now = Date.now(),
+  onProgress = null
 } = {}) {
   if (env3.VENDIAN_SKIP_AUTO_UPDATE === "1") {
     return false;
@@ -36760,10 +36767,13 @@ function maybeAutoUpdateManagedEnv({
     if (log) {
       console.error("[vendian] Checking managed CLI/runtime updates...");
     }
+    reportProgress(onProgress, "Installing managed CLI/runtime updates");
     installPackages({ pythonPath, venvPath, config, env: env3, platform: platform2 });
     const next = { ...config, lastManagedUpdateAt: new Date(now).toISOString() };
     save(next, env3, platform2);
+    reportProgress(onProgress, "Refreshing generated agent docs");
     refreshDocs({ config: next, venvPath, env: env3, platform: platform2 });
+    reportProgress(onProgress, "Managed CLI/runtime ready");
     return true;
   } catch (error) {
     const message = error && typeof error.message === "string" ? error.message : String(error);
@@ -36773,13 +36783,18 @@ function maybeAutoUpdateManagedEnv({
     return false;
   }
 }
+function reportProgress(onProgress, message) {
+  if (typeof onProgress === "function") {
+    onProgress(message);
+  }
+}
 
 // src/tui.js
 import fs12 from "node:fs";
 import readlinePromises from "node:readline/promises";
 
 // src/version.js
-var CLI_VERSION = true ? "0.0.15" : process.env.npm_package_version || "0.0.0-dev";
+var CLI_VERSION = true ? "0.0.17" : process.env.npm_package_version || "0.0.0-dev";
 
 // src/npm-update.js
 var NPM_CHECK_INTERVAL_MS = 30 * 60 * 1e3;
@@ -37153,11 +37168,12 @@ function serveProcessExitMessage({ stderr = "", code = 0, signal = "" } = {}) {
   if (/unrecognized arguments:\s*--event-stream/i.test(text)) {
     return "Managed Vendian runtime is too old for the local serve dashboard. Run `vendian update`, then start Serve Agents again.";
   }
+  const detail = textTail(text);
   if (code && code !== 0) {
-    return `Local serve exited with code ${code}. Toggle details for stderr.`;
+    return `Local serve exited with code ${code}${detail ? `: ${detail}` : ""}`;
   }
   if (signal && signal !== "SIGINT" && signal !== "SIGTERM") {
-    return `Local serve exited from ${signal}. Toggle details for stderr.`;
+    return `Local serve exited from ${signal}${detail ? `: ${detail}` : ""}`;
   }
   return "";
 }
@@ -37181,8 +37197,43 @@ function applyServeEvent(state, event) {
       activity: "Daemon registered"
     };
   }
+  if (event.type === "agent_prepare_plan") {
+    const agentCount = Number(event.agentCount || 0);
+    const environmentCount = Number(event.environmentCount || 0);
+    return {
+      ...next,
+      activity: `Preparing ${agentCount} agent${agentCount === 1 ? "" : "s"} across ${environmentCount} dependency set${environmentCount === 1 ? "" : "s"}`
+    };
+  }
   if (event.type === "agent_prepare_started") {
-    return { ...next, activity: `Preparing ${agentLabel(event)}` };
+    const relativePath = agentLabel(event);
+    const timestamp = event.timestamp || (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      ...next,
+      agentLogs: appendAgentLog(state.agentLogs, event),
+      agentRunState: setAgentRunState(state.agentRunState, relativePath, {
+        status: "preparing",
+        lastEventAt: timestamp,
+        progressMessage: "Preparing agent"
+      }),
+      activity: `Preparing ${relativePath}`
+    };
+  }
+  if (event.type === "agent_prepare_progress") {
+    const relativePath = agentLabel(event);
+    const timestamp = event.timestamp || (/* @__PURE__ */ new Date()).toISOString();
+    const message = stringValue(event.message || event.stage || "Preparing agent");
+    return {
+      ...next,
+      agentLogs: appendAgentLog(state.agentLogs, event),
+      agentRunState: setAgentRunState(state.agentRunState, relativePath, {
+        status: "preparing",
+        lastEventAt: timestamp,
+        progressStage: stringValue(event.stage),
+        progressMessage: message
+      }),
+      activity: `${relativePath}: ${message}`
+    };
   }
   if (event.type === "agent_prepare_completed") {
     const isError = event.status === "error";
@@ -37196,10 +37247,16 @@ function applyServeEvent(state, event) {
       lastEventAt: event.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
       disabledReason: stringValue(event.disabledReason || event.warning || "System dependency not met"),
       resolutionHints: Array.isArray(event.resolutionHints) ? event.resolutionHints : []
-    }) : state.agentRunState;
+    }) : setAgentRunState(state.agentRunState, agentLabel(event), {
+      status: "ready",
+      lastEventAt: event.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+      progressMessage: null,
+      progressStage: null
+    });
     const activityLabel = isError ? `${agentLabel(event)} needs setup` : isDisabled ? `${agentLabel(event)} disabled (deps not met locally)` : `${agentLabel(event)} ready`;
     return {
       ...next,
+      agentLogs: appendAgentLog(state.agentLogs, event),
       activity: activityLabel,
       agentRunState: runState,
       errors: isError && event.error ? appendError(state.errors, agentLabel(event), event.error) : state.errors
@@ -37296,6 +37353,22 @@ function applyServeEvent(state, event) {
       jobsRun: Number(event.jobsRun ?? state.jobsRun)
     };
   }
+  if (event.type === "process_exit" || event.type === "daemon_exit") {
+    const timestamp = event.timestamp || (/* @__PURE__ */ new Date()).toISOString();
+    const message = stringValue(event.message || processExitMessage(event));
+    const relativePath = stringValue(event.relativePath || "");
+    const runState = failRunningAgents(state.agentRunState, message, timestamp, relativePath);
+    return {
+      ...next,
+      stopped: true,
+      connected: false,
+      currentJob: null,
+      activity: "Process exited",
+      agentLogs: appendProcessExitAgentLogs(state.agentLogs, event, state.agentRunState, relativePath),
+      agentRunState: runState,
+      errors: appendError(state.errors, "Local daemon", message)
+    };
+  }
   if (event.type === "run_log") {
     const entry = serveEventAgentLogEntry(event);
     const nextRunState = entry && entry.entry.eventType === "completion" ? setAgentRunState(state.agentRunState, entry.relativePath, {
@@ -37498,6 +37571,49 @@ function serveEventAgentLogEntry(event) {
       }
     };
   }
+  if (type === "agent_prepare_started" || type === "agent_prepare_progress" || type === "agent_prepare_completed") {
+    const success = type === "agent_prepare_completed" ? event.status !== "error" : null;
+    return {
+      relativePath,
+      entry: {
+        timestamp,
+        runId: "",
+        eventType: type,
+        level: event.status === "error" ? "error" : "info",
+        message: agentPrepareLogMessage(event),
+        stepId: stringValue(event.stage || type),
+        current: null,
+        total: null,
+        success,
+        error: event.error ?? null,
+        jobType: null
+      }
+    };
+  }
+  if (type === "process_exit" || type === "daemon_exit") {
+    const message = stringValue(event.message || processExitMessage(event));
+    return {
+      relativePath,
+      entry: {
+        timestamp,
+        runId: stringValue(event.runId || event.sessionId || "daemon"),
+        eventType: type,
+        level: "error",
+        message,
+        stepId: null,
+        current: null,
+        total: null,
+        success: false,
+        error: {
+          message,
+          code: event.code ?? null,
+          signal: event.signal ?? null,
+          stderrTail: event.stderrTail ?? null
+        },
+        jobType: event.jobType ? stringValue(event.jobType) : null
+      }
+    };
+  }
   return null;
 }
 function agentRuntimeStatus(agent, agentRunState = {}) {
@@ -37507,6 +37623,9 @@ function agentRuntimeStatus(agent, agentRunState = {}) {
   if (run2?.status === "running") {
     return { status: "running", label: "running", run: run2 };
   }
+  if (run2?.status === "preparing") {
+    return { status: "preparing", label: "preparing", run: run2 };
+  }
   if (run2?.status === "error" || inventoryStatus === "error") {
     return { status: "error", label: "error", run: run2 };
   }
@@ -37540,6 +37659,46 @@ function setAgentRunState(agentRunState, relativePath, patch) {
     }
   };
 }
+function failRunningAgents(agentRunState, message, timestamp, relativePath = "") {
+  let next = agentRunState || {};
+  for (const [path8, run2] of Object.entries(agentRunState || {})) {
+    if (run2?.status !== "running") continue;
+    next = setAgentRunState(next, path8, {
+      status: "error",
+      completedAt: timestamp,
+      lastEventAt: timestamp,
+      errorMessage: message
+    });
+  }
+  if (relativePath) {
+    next = setAgentRunState(next, relativePath, {
+      status: "error",
+      completedAt: timestamp,
+      lastEventAt: timestamp,
+      errorMessage: message
+    });
+  }
+  return next;
+}
+function appendProcessExitAgentLogs(agentLogs, event, agentRunState, relativePath = "") {
+  const paths = /* @__PURE__ */ new Set();
+  if (relativePath) {
+    paths.add(relativePath);
+  }
+  for (const [path8, run2] of Object.entries(agentRunState || {})) {
+    if (run2?.status === "running") {
+      paths.add(path8);
+    }
+  }
+  if (paths.size === 0) {
+    return appendAgentLog(agentLogs, event);
+  }
+  let next = agentLogs || {};
+  for (const path8 of paths) {
+    next = appendAgentLog(next, { ...event, relativePath: path8 });
+  }
+  return next;
+}
 function reconcileInventoryRunState(agentRunState, agents, timestamp) {
   let next = agentRunState || {};
   for (const agent of agents || []) {
@@ -37612,6 +37771,30 @@ function jobLabel(event) {
 function stringValue(value) {
   return value == null ? "" : String(value);
 }
+function processExitMessage(event) {
+  if (event?.code && Number(event.code) !== 0) {
+    return `Agent serve exited with code ${event.code}`;
+  }
+  if (event?.signal) {
+    return `Agent serve exited from ${event.signal}`;
+  }
+  return "Agent serve exited";
+}
+function agentPrepareLogMessage(event) {
+  if (event.type === "agent_prepare_started") {
+    return "Preparing agent";
+  }
+  if (event.type === "agent_prepare_completed") {
+    if (event.status === "error") return stringValue(event.error || event.errorMessage || "Agent setup failed");
+    if (event.status === "disabled") return stringValue(event.warning || event.disabledReason || "Agent disabled locally");
+    return "Agent ready";
+  }
+  return stringValue(event.message || event.stage || "Preparing agent");
+}
+function textTail(value, limit = 800) {
+  const text = String(value || "").trim().replace(/\s+/g, " ");
+  return text.length > limit ? text.slice(-limit) : text;
+}
 function formatSeconds(value) {
   const numeric = Number(value);
   return Number.isFinite(numeric) ? `${numeric.toFixed(1)}s` : "";
@@ -37623,9 +37806,10 @@ async function spawnLocalServeEventStream({
   agentsDir = "./agents",
   collectionId = "",
   env: env3 = process.env,
-  platform: platform2 = process.platform
+  platform: platform2 = process.platform,
+  onProgress = null
 } = {}) {
-  const invocation = await preparePythonVendianInvocation(buildLocalServeEventStreamArgs({ agentsDir, collectionId }), { env: env3, platform: platform2 });
+  const invocation = await preparePythonVendianInvocation(buildLocalServeEventStreamArgs({ agentsDir, collectionId }), { env: env3, platform: platform2, onProgress });
   return spawn2(invocation.command, invocation.args, {
     env: invocation.env,
     stdio: ["ignore", "pipe", "pipe"],
@@ -38447,6 +38631,7 @@ function ServeScreen({ env: env3, platform: platform2, input, onBack, onState, o
     setStarted(true);
     setStartupError("");
     try {
+      setState((current) => ({ ...current, activity: "Loading previous agent logs" }));
       const logStore = createServeLogStore({ agentsDir: serveRoot, collectionId, env: env3, platform: platform2 });
       const historicalLogs = logStore.load();
       if (historicalLogs.length > 0) {
@@ -38462,7 +38647,17 @@ function ServeScreen({ env: env3, platform: platform2, input, onBack, onState, o
           };
         });
       }
-      const nextChild = await spawnLocalServeEventStream({ agentsDir: serveRoot, collectionId, env: env3, platform: platform2 });
+      setState((current) => ({ ...current, activity: "Preparing managed runtime" }));
+      const nextChild = await spawnLocalServeEventStream({
+        agentsDir: serveRoot,
+        collectionId,
+        env: env3,
+        platform: platform2,
+        onProgress: (message) => {
+          setState((current) => ({ ...current, activity: message || "Preparing managed runtime" }));
+        }
+      });
+      setState((current) => ({ ...current, activity: "Waiting for daemon events" }));
       setChild(nextChild);
       attachServeChild(nextChild, setState, setStartupError, ({ message } = {}) => {
         setState((current) => current.stopped ? current : { ...current, stopped: true, activity: message ? "Runtime update required" : "Process exited" });
@@ -38721,6 +38916,7 @@ function DisabledAgentsFooter({ agents, agentRunState = {} }) {
 }
 function runtimeStatusColor(status) {
   if (status === "running") return colors.accent;
+  if (status === "preparing") return colors.brand;
   if (status === "ready" || status === "completed") return colors.success;
   if (status === "disabled") return colors.warning;
   if (status === "error") return colors.error;
@@ -38728,6 +38924,7 @@ function runtimeStatusColor(status) {
 }
 function runtimeStatusIcon(status) {
   if (status === "running") return fig.arrow;
+  if (status === "preparing") return fig.dotEmpty;
   if (status === "ready" || status === "completed") return fig.dot;
   if (status === "disabled") return fig.warning;
   if (status === "error") return fig.cross;
@@ -39210,13 +39407,44 @@ function attachServeChild(child, setState, setStartupError, onExit, logStore = n
   });
   child.on("error", (error) => setStartupError(errorMessage2(error)));
   child.on("exit", (code, signal) => {
-    try {
-      logStore?.compact();
-    } catch {
-    }
     const message = serveProcessExitMessage({ stderr: stderrChunks.join("\n"), code, signal });
     if (message) {
       setStartupError(message);
+      setState((current) => {
+        const currentJob = current?.currentJob || {};
+        const event = {
+          type: "process_exit",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          code,
+          signal,
+          message,
+          stderrTail: stderrChunks.join("\n").slice(-2e3),
+          relativePath: currentJob.relativePath || currentJob.localPath || currentJob.path || "",
+          runId: currentJob.runId || currentJob.deployRequestId || currentJob.testRunId || "",
+          sessionId: currentJob.sessionId || "",
+          jobType: currentJob.jobType || ""
+        };
+        try {
+          const runningPaths = Object.entries(current?.agentRunState || {}).filter(([, run2]) => run2?.status === "running").map(([path8]) => path8).filter(Boolean);
+          const paths = new Set(runningPaths);
+          if (event.relativePath) {
+            paths.add(event.relativePath);
+          }
+          if (paths.size === 0) {
+            logStore?.append(event);
+          } else {
+            for (const relativePath of paths) {
+              logStore?.append({ ...event, relativePath });
+            }
+          }
+        } catch {
+        }
+        return applyServeEvent(current, event);
+      });
+    }
+    try {
+      logStore?.compact();
+    } catch {
     }
     onExit({ code, signal, message });
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vendian/cli",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "description": "Public Vendian CLI bootstrapper and launcher",
   "license": "UNLICENSED",
   "private": false,