@vellumai/cli 0.8.0 → 0.8.2

package/src/components/DefaultMainScreen.tsx

@@ -1,5 +1,4 @@
 import { spawn } from "child_process";
-import { randomUUID } from "crypto";
 import { basename } from "path";
 import {
   useCallback,
@@ -14,7 +13,6 @@ import { Box, render as inkRender, Text, useInput, useStdout } from "ink";
 import { removeAssistantEntry } from "../lib/assistant-config";
 
 import { SPECIES_CONFIG, type Species } from "../lib/constants";
-import { callDoctorDaemon, type ChatLogEntry } from "../lib/doctor-client";
 import { checkHealth } from "../lib/health-check";
 import { appendHistory, loadHistory } from "../lib/input-history";
 import { tuiLog } from "../lib/tui-log";
@@ -41,7 +39,6 @@ export const ANSI = {
 export const SLASH_COMMANDS = [
   "/btw",
   "/clear",
-  "/doctor",
   "/exit",
   "/help",
   "/q",
@@ -62,7 +59,7 @@ const HEADER_PREFIX_UNICODE = "── Vellum ";
 const HEADER_PREFIX_ASCII = "-- Vellum ";
 
 // Left panel structure: HEADER lines + art + FOOTER lines
-const LEFT_HEADER_LINES = 3; // spacer + heading + spacer
+const LEFT_HEADER_LINES = 4; // spacer + eyebrow + title + spacer
 const LEFT_FOOTER_LINES = 3; // spacer + runtimeUrl + dirName
 
 // Right panel structure
@@ -70,7 +67,7 @@ const TIPS = [
   "Send a message to start chatting",
   "Use /help to see available commands",
 ];
-const RIGHT_PANEL_INFO_SECTIONS = 3; // Assistant, Species, Status — each with heading + value
+const RIGHT_PANEL_INFO_SECTIONS = 3; // Assistant ID, Species, Status — each with heading + value
 const RIGHT_PANEL_SPACERS = 2; // top spacer + spacer between tips and info
 const RIGHT_PANEL_TIPS_HEADING = 1;
 const RIGHT_PANEL_LINE_COUNT =
@@ -103,7 +100,7 @@ const MIN_FEED_ROWS = 3;
 // Feed item height estimation
 const TOOL_CALL_CHROME_LINES = 2; // header (┌) + footer (└)
 const MESSAGE_SPACING = 1;
-const HELP_DISPLAY_HEIGHT = 8;
+const HELP_DISPLAY_HEIGHT = 7;
 
 interface ListMessagesResponse {
   messages: RuntimeMessage[];
@@ -333,6 +330,8 @@ interface SseEvent {
   allowedDomains?: string[];
   // message_complete fields
   source?: "main" | "aux";
+  // sync_changed fields
+  tags?: string[];
   [key: string]: unknown;
 }
 
@@ -666,6 +665,21 @@ function truncateValue(value: unknown, maxLen: number): string {
   return serialized;
 }
 
+function formatHeaderTitle(assistantName?: string): string {
+  const rawTitle = assistantName?.trim() || "Meet your Assistant!";
+  const title = rawTitle.replace(/\s+/g, " ");
+  const maxTitleLength = LEFT_PANEL_WIDTH - 2;
+  const displayTitle =
+    title.length > maxTitleLength
+      ? title.slice(0, maxTitleLength - 3) + "..."
+      : title;
+  return `  ${displayTitle}`;
+}
+
+function formatHeaderEyebrow(): string {
+  return "  Assistant";
+}
+
 interface ToolCallDisplayProps {
   tc: ToolCallInfo;
 }
@@ -732,10 +746,6 @@ function HelpDisplay(): ReactElement {
         {"  /btw <question>   "}
         <Text dimColor>Ask a side question while the assistant is working</Text>
       </Text>
-      <Text>
-        {"  /doctor [question] "}
-        <Text dimColor>Run diagnostics on the remote instance via SSH</Text>
-      </Text>
       <Text>
         {"  /retire           "}
         <Text dimColor>Retire the remote instance and exit</Text>
@@ -859,28 +869,33 @@ function stripAnsi(str: string): string {
 interface DefaultMainScreenProps {
   runtimeUrl: string;
   assistantId: string;
+  assistantName?: string;
   species: Species;
   healthStatus?: string;
 }
 
 interface StyledLine {
   text: string;
-  style: "heading" | "dim" | "normal";
+  style: "heading" | "dim" | "normal" | "eyebrow" | "title" | "art";
 }
 
 function CompactHeader({
+  assistantName,
   species,
   healthStatus,
   totalWidth,
 }: {
+  assistantName?: string;
   species: Species;
   healthStatus?: string;
   totalWidth: number;
 }): ReactElement {
-  const config = SPECIES_CONFIG[species];
   const accentColor = species === "openclaw" ? "red" : "magenta";
   const status = healthStatus ?? "checking...";
-  const label = ` ${config.hatchedEmoji} ${species} ${statusEmoji(status)} `;
+  const identity = assistantName?.trim() || species;
+  const compactIdentity =
+    identity.length > 18 ? `${identity.slice(0, 15)}...` : identity;
+  const label = ` ${compactIdentity} ${statusEmoji(status)} `;
   const prefix = "── Vellum";
   const suffix = "──";
   const fillLen = Math.max(
@@ -902,13 +917,13 @@ function CompactHeader({
 function DefaultMainScreen({
   runtimeUrl,
   assistantId,
+  assistantName,
   species,
   healthStatus,
 }: DefaultMainScreenProps): ReactElement {
   const cwd = process.cwd();
   const dirName = basename(cwd);
   const config = SPECIES_CONFIG[species];
-  const art = config.art;
   const accentColor = species === "openclaw" ? "red" : "magenta";
   const caps = getTerminalCapabilities();
   const headerPrefix = caps.unicodeSupported
@@ -924,6 +939,7 @@ function DefaultMainScreen({
   if (isCompact) {
     return (
       <CompactHeader
+        assistantName={assistantName}
         species={species}
         healthStatus={healthStatus}
         totalWidth={totalWidth}
@@ -931,16 +947,21 @@ function DefaultMainScreen({
     );
   }
 
+  const art = config.art;
   const rightPanelWidth = Math.max(1, totalWidth - LEFT_PANEL_WIDTH);
 
-  const leftLines = [
-    " ",
-    "    Meet your Assistant!",
-    " ",
-    ...art.map((l) => `  ${stripAnsi(l)}`),
-    " ",
-    `  ${runtimeUrl}`,
-    `  ~/${dirName}`,
+  const leftLines: StyledLine[] = [
+    { text: " ", style: "normal" },
+    { text: formatHeaderEyebrow(), style: "eyebrow" },
+    { text: formatHeaderTitle(assistantName), style: "title" },
+    { text: " ", style: "normal" },
+    ...art.map((line) => ({
+      text: `  ${stripAnsi(line)}`,
+      style: "art" as const,
+    })),
+    { text: " ", style: "normal" },
+    { text: `  ${runtimeUrl}`, style: "dim" },
+    { text: `  ~/${dirName}`, style: "dim" },
   ];
 
   const rightLines: StyledLine[] = [
@@ -948,7 +969,7 @@ function DefaultMainScreen({
     { text: "Tips for getting started", style: "heading" },
     ...TIPS.map((t) => ({ text: t, style: "normal" as const })),
     { text: " ", style: "normal" },
-    { text: "Assistant", style: "heading" },
+    { text: "Assistant ID", style: "heading" },
     { text: assistantId, style: "dim" },
     { text: "Species", style: "heading" },
     {
@@ -970,29 +991,37 @@ function DefaultMainScreen({
       <Box flexDirection="row">
         <Box flexDirection="column" width={LEFT_PANEL_WIDTH}>
           {Array.from({ length: maxLines }, (_, i) => {
-            const line = leftLines[i] ?? " ";
-            if (i === 1) {
+            const item = leftLines[i];
+            if (!item) return <Text key={i}> </Text>;
+            if (item.style === "eyebrow") {
+              return (
+                <Text key={i} color={caps.isDumb ? undefined : accentColor}>
+                  {item.text}
+                </Text>
+              );
+            }
+            if (item.style === "title") {
               return (
                 <Text key={i} bold>
-                  {line}
+                  {item.text}
                 </Text>
               );
             }
-            if (i > 2 && i <= 2 + art.length) {
+            if (item.style === "art") {
               return (
                 <Text key={i} color={caps.isDumb ? undefined : accentColor}>
-                  {line}
+                  {item.text}
                 </Text>
               );
             }
-            if (i > 2 + art.length) {
+            if (item.style === "dim") {
               return (
                 <Text key={i} dimColor>
-                  {line}
+                  {item.text}
                 </Text>
               );
             }
-            return <Text key={i}>{line}</Text>;
+            return <Text key={i}>{item.text}</Text>;
           })}
         </Box>
         <Box flexDirection="column" width={rightPanelWidth}>
@@ -1113,8 +1142,7 @@ function calculateHeaderHeight(
   if ((terminalColumns ?? DEFAULT_TERMINAL_COLUMNS) < COMPACT_THRESHOLD) {
     return COMPACT_HEADER_HEIGHT;
   }
-  const config = SPECIES_CONFIG[species];
-  const artLength = config.art.length;
+  const artLength = SPECIES_CONFIG[species].art.length;
   const leftLineCount = LEFT_HEADER_LINES + artLength + LEFT_FOOTER_LINES;
   const maxLines = Math.max(leftLineCount, RIGHT_PANEL_LINE_COUNT);
   return maxLines + HEADER_CHROME_LINES;
@@ -1126,12 +1154,11 @@ export function render(
   runtimeUrl: string,
   assistantId: string,
   species: Species,
+  assistantName?: string,
 ): number {
   const terminalColumns = process.stdout.columns || DEFAULT_TERMINAL_COLUMNS;
   const isCompact = terminalColumns < COMPACT_THRESHOLD;
-
-  const config = SPECIES_CONFIG[species];
-  const art = config.art;
+  const art = SPECIES_CONFIG[species].art;
 
   const leftLineCount = LEFT_HEADER_LINES + art.length + LEFT_FOOTER_LINES;
   const maxLines = Math.max(leftLineCount, RIGHT_PANEL_LINE_COUNT);
@@ -1140,6 +1167,7 @@ export function render(
     <DefaultMainScreen
       runtimeUrl={runtimeUrl}
       assistantId={assistantId}
+      assistantName={assistantName}
       species={species}
     />,
     { exitOnCtrlC: false },
@@ -1358,6 +1386,7 @@ export interface ChatAppHandle {
 interface ChatAppProps {
   runtimeUrl: string;
   assistantId: string;
+  assistantName?: string;
   species: Species;
   /** Pre-built auth headers (e.g. { Authorization: "Bearer ..." } for local,
    *  { "X-Session-Token": "...", "Vellum-Organization-Id": "..." } for platform). */
@@ -1371,6 +1400,7 @@ interface ChatAppProps {
 function ChatApp({
   runtimeUrl,
   assistantId,
+  assistantName,
   species,
   auth,
   project,
@@ -1403,11 +1433,9 @@ function ChatApp({
   const connectedRef = useRef(false);
   const connectingRef = useRef(false);
   const seenMessageIdsRef = useRef(new Set<string>());
-  const chatLogRef = useRef<ChatLogEntry[]>([]);
   const sseAbortRef = useRef<AbortController | null>(null);
   const streamingTextRef = useRef("");
   const streamingToolCallsRef = useRef<ToolCallInfo[]>([]);
-  const doctorSessionIdRef = useRef(randomUUID());
   const handleRef_ = useRef<ChatAppHandle | null>(null);
 
   const { stdout } = useStdout();
@@ -1838,10 +1866,6 @@ function ChatApp({
                   };
                   seenMessageIdsRef.current.add(msg.id);
                   hRef.addMessage(msg);
-                  chatLogRef.current.push({
-                    role: "assistant",
-                    content: text,
-                  });
                   process.stdout.write("\x07");
                 }
 
@@ -1856,6 +1880,11 @@ function ChatApp({
                 hRef.setBusy(false);
                 break;
 
+              case "sync_changed":
+                // The interactive CLI does not currently keep any sync-tagged
+                // caches, so generic invalidations are intentionally ignored.
+                break;
+
               default:
                 // Ignore events we don't handle (activity state, traces, etc.)
                 break;
@@ -2005,79 +2034,6 @@ function ChatApp({
         return;
       }
 
-      if (trimmed === "/doctor" || trimmed.startsWith("/doctor ")) {
-        if (!project || !zone) {
-          h.showError(
-            "No instance info available. Connect to a hatched instance first.",
-          );
-          return;
-        }
-        const userPrompt = trimmed.slice("/doctor".length).trim() || undefined;
-        const recentChatContext = chatLogRef.current.slice(-20);
-
-        chatLogRef.current.push({ role: "user", content: trimmed });
-
-        if (userPrompt) {
-          const doctorUserMsg: RuntimeMessage = {
-            id: "local-user-" + Date.now(),
-            role: "user",
-            content: userPrompt,
-            timestamp: new Date().toISOString(),
-            label: "You (to Doctor):",
-          };
-          h.addMessage(doctorUserMsg);
-        }
-
-        h.showSpinner(`Analyzing ${assistantId}...`);
-
-        try {
-          const result = await callDoctorDaemon(
-            assistantId,
-            project,
-            zone,
-            userPrompt,
-            (event) => {
-              switch (event.phase) {
-                case "invoking_prompt":
-                  handleRef_.current?.showSpinner(
-                    `Analyzing ${assistantId}...`,
-                  );
-                  break;
-                case "calling_tool":
-                  handleRef_.current?.showSpinner(
-                    `Running ${event.toolName ?? "tool"} on ${assistantId}...`,
-                  );
-                  break;
-                case "processing_tool_result":
-                  handleRef_.current?.showSpinner(
-                    `Reviewing diagnostics for ${assistantId}...`,
-                  );
-                  break;
-              }
-            },
-            doctorSessionIdRef.current,
-            recentChatContext,
-          );
-          h.hideSpinner();
-          if (result.recommendation) {
-            h.addStatus(`Recommendation:\n${result.recommendation}`);
-            chatLogRef.current.push({
-              role: "assistant",
-              content: result.recommendation,
-            });
-          } else if (result.error) {
-            h.showError(result.error);
-            chatLogRef.current.push({ role: "error", content: result.error });
-          }
-        } catch (err) {
-          h.hideSpinner();
-          const errorMsg = `Doctor assistant unreachable: ${err instanceof Error ? err.message : err}`;
-          h.showError(errorMsg);
-          chatLogRef.current.push({ role: "error", content: errorMsg });
-        }
-        return;
-      }
-
       // If a connection attempt is already in progress, don't silently drop input
       if (connectingRef.current) {
         h.addStatus(
@@ -2194,7 +2150,6 @@ function ChatApp({
           );
           clearTimeout(timeoutId);
           if (sendResult.accepted) {
-            chatLogRef.current.push({ role: "user", content: trimmed });
             h.addStatus(
               "Message queued — will be processed after current response",
               "gray",
@@ -2226,7 +2181,6 @@ function ChatApp({
         return;
       }
 
-      chatLogRef.current.push({ role: "user", content: trimmed });
       seenMessageIdsRef.current.add("pending-user-" + Date.now());
 
       h.showSpinner("Sending...");
@@ -2257,7 +2211,6 @@ function ChatApp({
         const errorMsg =
           sendErr instanceof Error ? sendErr.message : String(sendErr);
         h.showError(errorMsg);
-        chatLogRef.current.push({ role: "error", content: errorMsg });
         return;
       }
 
@@ -2265,15 +2218,7 @@ function ChatApp({
       // racing with SSE events that may arrive during the sendMessage await.
       h.showSpinner("Working...");
     },
-    [
-      runtimeUrl,
-      assistantId,
-      auth,
-      project,
-      zone,
-      cleanup,
-      ensureConnected,
-    ],
+    [runtimeUrl, assistantId, auth, project, zone, cleanup, ensureConnected],
   );
 
   const handleSubmit = useCallback(
@@ -2463,6 +2408,7 @@ function ChatApp({
       <DefaultMainScreen
         runtimeUrl={runtimeUrl}
         assistantId={assistantId}
+        assistantName={assistantName}
         species={species}
         healthStatus={healthStatus}
       />
@@ -2582,7 +2528,12 @@ export function renderChatApp(
   assistantId: string,
   species: Species,
   onExit: () => void,
-  options?: { auth?: Record<string, string>; project?: string; zone?: string },
+  options?: {
+    auth?: Record<string, string>;
+    project?: string;
+    zone?: string;
+    assistantName?: string;
+  },
 ): ChatAppInstance {
   let chatHandle: ChatAppHandle | null = null;
 
@@ -2590,6 +2541,7 @@ export function renderChatApp(
     <ChatApp
       runtimeUrl={runtimeUrl}
       assistantId={assistantId}
+      assistantName={options?.assistantName}
       species={species}
       auth={options?.auth}
       project={options?.project}

package/src/lib/__tests__/docker.test.ts

@@ -128,6 +128,17 @@ describe("buildServiceRunArgs — gateway", () => {
       buildGatewayArgs().some((arg) => arg.startsWith("VELAY_BASE_URL=")),
     ).toBe(false);
   });
+
+  test("forces gateway to run as uid 0 so it can connect to the assistant's root-owned IPC socket (mirrors K8s securityContext.runAsUser=0)", () => {
+    const args = buildGatewayArgs();
+    const userIdx = args.indexOf("--user");
+    expect(userIdx).toBeGreaterThan(-1);
+    expect(args[userIdx + 1]).toBe("0");
+  });
+
+  test("assistant container does NOT get a --user override (image USER root wins)", () => {
+    expect(buildAssistantArgs().includes("--user")).toBe(false);
+  });
 });
 
 describe("VELLUM_AVATAR_DEVICE passthrough", () => {

package/src/lib/assistant-config.ts

@@ -18,6 +18,8 @@ import {
   getMultiInstanceDir,
 } from "./environments/paths.js";
 import { getCurrentEnvironment } from "./environments/resolve.js";
+import { SEEDS } from "./environments/seeds.js";
+import type { EnvironmentDefinition } from "./environments/types.js";
 import { probePort } from "./port-probe.js";
 
 /**
@@ -65,6 +67,10 @@ export interface ContainerInfo {
 
 export interface AssistantEntry {
   assistantId: string;
+  /** Platform-provided display name, when available. */
+  name?: string;
+  /** Older lockfile key for the display name, if present. */
+  assistantName?: string;
   runtimeUrl: string;
   /** Loopback URL for same-machine health checks (e.g. `http://127.0.0.1:7831`).
    *  Avoids mDNS resolution issues when the machine checks its own gateway. */
@@ -327,6 +333,69 @@ export function loadAllAssistants(): AssistantEntry[] {
   return readAssistants();
 }
 
+/**
+ * Read the first existing lockfile for an explicitly-provided environment,
+ * without applying legacy migrations. This is the cross-env read path used by
+ * {@link loadAllAssistantsAcrossEnvs}: it deliberately bypasses
+ * {@link readLockfile} (which always resolves the *current* env) so callers
+ * can enumerate state from every env without flipping `process.env` or the
+ * persisted default. Migrations are skipped because we never want to write
+ * to another env's lockfile from the current env's process.
+ */
+function readLockfileForEnv(env: EnvironmentDefinition): LockfileData {
+  for (const lockfilePath of getLockfilePaths(env)) {
+    if (!existsSync(lockfilePath)) continue;
+    try {
+      const raw = readFileSync(lockfilePath, "utf-8");
+      const parsed = JSON.parse(raw) as unknown;
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return parsed as LockfileData;
+      }
+    } catch {
+      // Malformed; try next candidate
+    }
+  }
+  return {};
+}
+
+/**
+ * Load assistant entries from every known environment's lockfile.
+ *
+ * Each {@link SEEDS} entry has its own on-host data layout (config dir,
+ * lockfile path, data dir). A running assistant from `dev` is invisible to
+ * `loadAllAssistants()` when the current env is `local`, but its host
+ * processes (daemon/gateway/qdrant) still show up in `ps ax`. The orphan
+ * detector and `vellum clean` need the union of all envs' entries to avoid
+ * misclassifying — or worse, killing — another env's running services.
+ *
+ * Optional `envs` override is provided for testability so call sites can
+ * inject a curated env list with `lockfileDirOverride` set, without having
+ * to manipulate the global SEEDS table or process.env.
+ */
+export function loadAllAssistantsAcrossEnvs(
+  envs?: EnvironmentDefinition[],
+): AssistantEntry[] {
+  const envList = envs ?? Object.values(SEEDS).map((env) => ({ ...env }));
+  const all: AssistantEntry[] = [];
+  for (const env of envList) {
+    const data = readLockfileForEnv(env);
+    const entries = data.assistants;
+    if (!Array.isArray(entries)) continue;
+    for (const raw of entries) {
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) continue;
+      const entry = raw as AssistantEntry;
+      if (
+        typeof entry.assistantId !== "string" ||
+        typeof entry.runtimeUrl !== "string"
+      ) {
+        continue;
+      }
+      all.push(entry);
+    }
+  }
+  return all;
+}
+
 export function getActiveAssistant(): string | null {
   const data = readLockfile();
   return data.activeAssistant ?? null;
@@ -507,5 +576,3 @@ export function getLockfilePlatformBaseUrl(): string | undefined {
   if (typeof url === "string" && url.trim()) return url.trim();
   return undefined;
 }
-
-

package/src/lib/client-identity.ts

@@ -12,6 +12,7 @@ import { homedir } from "os";
 import { join } from "path";
 
 export const CLI_INTERFACE_ID = "cli";
+export const WEB_INTERFACE_ID = "web";
 
 let cached: string | null = null;
 

package/src/lib/environments/paths.ts

@@ -110,6 +110,21 @@ export function getStateDir(env: EnvironmentDefinition): string {
   return join(xdgDataHome(), `vellum-${env.name}`);
 }
 
+/**
+ * Path to the interactive CLI's input history file.
+ *
+ * Follows the XDG Base Directory spec: history files are state data
+ * (persistent across runs but not portable / user-owned content), so they
+ * belong under `$XDG_STATE_HOME`, mirroring `bash`, `zsh`, `psql`, and `gh`.
+ * Defaults to `~/.local/state/vellum/input-history`.
+ *
+ * Not environment-scoped: terminal input history is per-user, not per-assistant,
+ * so dev and prod CLIs share the same history file.
+ */
+export function getInputHistoryPath(): string {
+  return join(xdgStateHome(), "vellum", "input-history");
+}
+
 /**
  * Named port constants derived from `DEFAULT_PORTS`.
  * These are the ports the assistant and gateway services bind to *inside*
@@ -127,3 +142,9 @@ function xdgDataHome(): string {
 function xdgConfigHome(): string {
   return process.env.XDG_CONFIG_HOME?.trim() || join(homedir(), ".config");
 }
+
+function xdgStateHome(): string {
+  return (
+    process.env.XDG_STATE_HOME?.trim() || join(homedir(), ".local", "state")
+  );
+}

package/src/lib/input-history.ts

@@ -1,16 +1,13 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { homedir } from "os";
-import { dirname, join } from "path";
+import { dirname } from "path";
 
-const MAX_ENTRIES = 1000;
+import { getInputHistoryPath } from "./environments/paths.js";
 
-function historyPath(): string {
-  return join(homedir(), ".vellum", "input-history");
-}
+const MAX_ENTRIES = 1000;
 
 export function loadHistory(): string[] {
   try {
-    const path = historyPath();
+    const path = getInputHistoryPath();
     if (!existsSync(path)) return [];
     const content = readFileSync(path, "utf-8");
     return content
@@ -26,7 +23,7 @@ export function appendHistory(entry: string): void {
   const trimmed = entry.trim();
   if (!trimmed || trimmed.startsWith("/")) return;
   try {
-    const path = historyPath();
+    const path = getInputHistoryPath();
     const dir = dirname(path);
     if (!existsSync(dir)) {
       mkdirSync(dir, { recursive: true });