@vendian/cli 0.0.16 → 0.0.18

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.16" : process.env.npm_package_version || "0.0.0-dev";
+var CLI_VERSION = true ? "0.0.18" : process.env.npm_package_version || "0.0.0-dev";
 
 // src/npm-update.js
 var NPM_CHECK_INTERVAL_MS = 30 * 60 * 1e3;
@@ -37182,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: `Analyzing ${agentCount} agent${agentCount === 1 ? "" : "s"}: ${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";
@@ -37197,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
@@ -37515,6 +37571,25 @@ 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 {
@@ -37548,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 };
   }
@@ -37702,6 +37780,17 @@ function processExitMessage(event) {
   }
   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;
@@ -37717,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"],
@@ -38273,12 +38363,24 @@ function Header({ env: env3, platform: platform2, serveState, screen }) {
     serveState?.daemonId && h(StatusRow, {
       status: serveState.connected ? "ok" : "warning",
       label: "Daemon",
-      value: serveState.activity || "Running",
+      value: serveHeaderLabel(serveState),
       width: inner
     }),
     h(Text2, { color: colors.muted }, `${fig.bottomLeft}${fig.horizontal.repeat(inner)}${fig.bottomRight}`)
   );
 }
+function serveHeaderSnapshot(state) {
+  return {
+    connected: Boolean(state?.connected),
+    daemonId: String(state?.daemonId || ""),
+    stopped: Boolean(state?.stopped)
+  };
+}
+function serveHeaderLabel(state) {
+  if (state?.stopped) return "Stopped";
+  if (state?.connected) return "Running";
+  return "Starting";
+}
 function StatusRow({ status, label, value, width }) {
   const dotColor = status === "ok" ? colors.success : status === "warning" ? colors.warning : colors.error;
   const dot = status === "ok" ? fig.dot : status === "warning" ? fig.dot : fig.dot;
@@ -38460,8 +38562,15 @@ function ServeScreen({ env: env3, platform: platform2, input, onBack, onState, o
   const [startupError, setStartupError] = useState5("");
   const exitTimer = useRef2(null);
   const lastInterruptAt = useRef2(0);
+  const lastPublishedHeaderState = useRef2(null);
   useEffect6(() => {
-    onState(state);
+    const snapshot = serveHeaderSnapshot(state);
+    const previous = lastPublishedHeaderState.current;
+    if (previous && previous.daemonId === snapshot.daemonId && previous.connected === snapshot.connected && previous.stopped === snapshot.stopped) {
+      return;
+    }
+    lastPublishedHeaderState.current = snapshot;
+    onState(snapshot.daemonId ? snapshot : null);
   }, [state, onState]);
   useEffect6(() => () => {
     if (exitTimer.current) {
@@ -38541,6 +38650,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) {
@@ -38556,7 +38666,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" });
@@ -38815,6 +38935,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;
@@ -38822,6 +38943,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;
@@ -39276,6 +39398,7 @@ function attachServeChild(child, setState, setStartupError, onExit, logStore = n
     buffer += chunk;
     const lines = buffer.split(/\r?\n/);
     buffer = lines.pop() || "";
+    const events = [];
     for (const line of lines) {
       try {
         const event = parseServeEventLine(line);
@@ -39284,12 +39407,15 @@ function attachServeChild(child, setState, setStartupError, onExit, logStore = n
             logStore?.append(event);
           } catch {
           }
-          setState((current) => applyServeEvent(current, event));
+          events.push(event);
         }
       } catch (error) {
         setStartupError(`Invalid event stream payload: ${errorMessage2(error)}`);
       }
     }
+    if (events.length > 0) {
+      setState((current) => events.reduce((next, event) => applyServeEvent(next, event), current));
+    }
   });
   child.stderr.setEncoding("utf8");
   child.stderr.on("data", (chunk) => {

package/package.json

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