@vellumai/cli 0.4.43 → 0.4.45

package/src/components/DefaultMainScreen.tsx

@@ -34,6 +34,7 @@ export const ANSI = {
 } as const;
 
 export const SLASH_COMMANDS = [
+  "/btw",
   "/clear",
   "/doctor",
   "/exit",
@@ -98,7 +99,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 = 6;
+const HELP_DISPLAY_HEIGHT = 8;
 
 interface ListMessagesResponse {
   messages: RuntimeMessage[];
@@ -152,6 +153,19 @@ interface HealthResponse {
   message?: string;
 }
 
+/** Extract human-readable message from a daemon JSON error response. */
+function friendlyErrorMessage(status: number, body: string): string {
+  try {
+    const parsed = JSON.parse(body) as { error?: { message?: string } };
+    if (parsed?.error?.message) {
+      return parsed.error.message;
+    }
+  } catch {
+    // Not JSON — fall through
+  }
+  return `HTTP ${status}: ${body || "Unknown error"}`;
+}
+
 async function runtimeRequest<T>(
   baseUrl: string,
   assistantId: string,
@@ -171,7 +185,7 @@ async function runtimeRequest<T>(
 
   if (!response.ok) {
     const body = await response.text().catch(() => "");
-    throw new Error(`HTTP ${response.status}: ${body || response.statusText}`);
+    throw new Error(friendlyErrorMessage(response.status, body));
   }
 
   if (response.status === 204) {
@@ -359,13 +373,7 @@ async function handleConfirmationPrompt(
   const index = await chatApp.showSelection("Tool Approval", options);
 
   if (index === 0) {
-    await submitDecision(
-      baseUrl,
-      assistantId,
-      requestId,
-      "allow",
-      bearerToken,
-    );
+    await submitDecision(baseUrl, assistantId, requestId, "allow", bearerToken);
     chatApp.addStatus("\u2714 Allowed", "green");
     return;
   }
@@ -394,13 +402,7 @@ async function handleConfirmationPrompt(
     return;
   }
 
-  await submitDecision(
-    baseUrl,
-    assistantId,
-    requestId,
-    "deny",
-    bearerToken,
-  );
+  await submitDecision(baseUrl, assistantId, requestId, "deny", bearerToken);
   chatApp.addStatus("\u2718 Denied", "yellow");
 }
 
@@ -437,13 +439,7 @@ async function handlePatternSelection(
     return;
   }
 
-  await submitDecision(
-    baseUrl,
-    assistantId,
-    requestId,
-    "deny",
-    bearerToken,
-  );
+  await submitDecision(baseUrl, assistantId, requestId, "deny", bearerToken);
   chatApp.addStatus("\u2718 Denied", "yellow");
 }
 
@@ -491,13 +487,7 @@ async function handleScopeSelection(
     return;
   }
 
-  await submitDecision(
-    baseUrl,
-    assistantId,
-    requestId,
-    "deny",
-    bearerToken,
-  );
+  await submitDecision(baseUrl, assistantId, requestId, "deny", bearerToken);
   chatApp.addStatus("\u2718 Denied", "yellow");
 }
 
@@ -629,6 +619,10 @@ function HelpDisplay(): ReactElement {
   return (
     <Box flexDirection="column">
       <Text bold>Commands:</Text>
+      <Text>
+        {"  /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>
@@ -1252,7 +1246,6 @@ function ChatApp({
 
   const showSpinner = useCallback((text: string) => {
     setSpinnerText(text);
-    setInputFocused(false);
   }, []);
 
   const hideSpinner = useCallback(() => {
@@ -1488,79 +1481,6 @@ function ChatApp({
         return;
       }
 
-      if (trimmed === "/pair") {
-        h.showSpinner("Generating pairing credentials...");
-
-        const isConnected = await ensureConnected();
-        if (!isConnected) {
-          h.hideSpinner();
-          h.showError("Cannot pair — not connected to the assistant runtime.");
-          return;
-        }
-
-        try {
-          const pairingRequestId = randomUUID();
-          const pairingSecret = randomBytes(32).toString("hex");
-          const gatewayUrl = runtimeUrl;
-
-          // Call /pairing/register on the gateway (dedicated pairing proxy route)
-          const registerUrl = `${runtimeUrl}/pairing/register`;
-          const registerRes = await fetch(registerUrl, {
-            method: "POST",
-            headers: {
-              "Content-Type": "application/json",
-              ...(bearerToken
-                ? { Authorization: `Bearer ${bearerToken}` }
-                : {}),
-            },
-            body: JSON.stringify({
-              pairingRequestId,
-              pairingSecret,
-              gatewayUrl,
-            }),
-          });
-
-          if (!registerRes.ok) {
-            const body = await registerRes.text().catch(() => "");
-            throw new Error(
-              `HTTP ${registerRes.status}: ${body || registerRes.statusText}`,
-            );
-          }
-
-          const hostId = createHash("sha256")
-            .update(hostname() + userInfo().username)
-            .digest("hex");
-          const payload = JSON.stringify({
-            type: "vellum-daemon",
-            v: 4,
-            id: hostId,
-            g: gatewayUrl,
-            pairingRequestId,
-            pairingSecret,
-          });
-
-          const qrString = await new Promise<string>((resolve) => {
-            qrcode.generate(payload, { small: true }, (code: string) => {
-              resolve(code);
-            });
-          });
-
-          h.hideSpinner();
-          h.addStatus(
-            `Pairing Ready\n\n` +
-              `Scan this QR code with the Vellum iOS app:\n\n` +
-              `${qrString}\n` +
-              `This pairing request expires in 5 minutes. Run /pair again to generate a new one.`,
-          );
-        } catch (err) {
-          h.hideSpinner();
-          h.showError(
-            `Pairing failed: ${err instanceof Error ? err.message : err}`,
-          );
-        }
-        return;
-      }
-
       if (trimmed === "/retire") {
         if (!project || !zone) {
           h.showError(
@@ -1714,6 +1634,214 @@ function ChatApp({
         return;
       }
 
+      // If a connection attempt is already in progress, don't silently drop input
+      if (connectingRef.current) {
+        h.addStatus(
+          "Still connecting — please wait a moment and try again.",
+          "yellow",
+        );
+        return;
+      }
+
+      if (trimmed.startsWith("/btw ")) {
+        const question = trimmed.slice(5).trim();
+        if (!question) return;
+
+        h.addStatus(`/btw ${question}`, "gray");
+
+        const isConnected = await ensureConnected();
+        if (!isConnected) return;
+
+        try {
+          const res = await fetch(
+            `${runtimeUrl}/v1/assistants/${assistantId}/btw`,
+            {
+              method: "POST",
+              headers: {
+                "Content-Type": "application/json",
+                ...(bearerToken
+                  ? { Authorization: `Bearer ${bearerToken}` }
+                  : {}),
+              },
+              body: JSON.stringify({
+                conversationKey: assistantId,
+                content: question,
+              }),
+              signal: AbortSignal.timeout(30_000),
+            },
+          );
+
+          if (!res.ok) throw new Error(`HTTP ${res.status}`);
+
+          let fullText = "";
+          let sseError = "";
+          const reader = res.body?.getReader();
+          const decoder = new TextDecoder();
+          if (reader) {
+            let buffer = "";
+            let currentEvent = "";
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done) break;
+              buffer += decoder.decode(value, { stream: true });
+              const lines = buffer.split("\n");
+              buffer = lines.pop() ?? "";
+              for (const line of lines) {
+                if (line.startsWith("event: ")) {
+                  currentEvent = line.slice(7).trim();
+                } else if (line.startsWith("data: ")) {
+                  try {
+                    const data = JSON.parse(line.slice(6));
+                    if (currentEvent === "btw_error" || data.error) {
+                      sseError = data.error ?? data.text ?? "Unknown error";
+                    } else if (data.text) {
+                      fullText += data.text;
+                    }
+                  } catch {
+                    /* skip malformed */
+                  }
+                } else if (line.trim() === "") {
+                  // Empty line marks end of SSE event; reset event type
+                  currentEvent = "";
+                }
+              }
+            }
+          }
+          if (sseError) {
+            h.showError(`/btw: ${sseError}`);
+          } else {
+            h.addStatus(fullText || "No response");
+          }
+        } catch (err) {
+          h.showError(
+            `/btw failed: ${err instanceof Error ? err.message : err}`,
+          );
+        }
+        return;
+      }
+
+      if (trimmed === "/pair") {
+        h.showSpinner("Generating pairing credentials...");
+
+        const isConnected = await ensureConnected();
+        if (!isConnected) {
+          h.hideSpinner();
+          h.showError("Cannot pair — not connected to the assistant runtime.");
+          return;
+        }
+
+        try {
+          const pairingRequestId = randomUUID();
+          const pairingSecret = randomBytes(32).toString("hex");
+          const gatewayUrl = runtimeUrl;
+
+          // Call /pairing/register on the gateway (dedicated pairing proxy route)
+          const registerUrl = `${runtimeUrl}/pairing/register`;
+          const registerRes = await fetch(registerUrl, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              ...(bearerToken
+                ? { Authorization: `Bearer ${bearerToken}` }
+                : {}),
+            },
+            body: JSON.stringify({
+              pairingRequestId,
+              pairingSecret,
+              gatewayUrl,
+            }),
+          });
+
+          if (!registerRes.ok) {
+            const body = await registerRes.text().catch(() => "");
+            throw new Error(
+              `HTTP ${registerRes.status}: ${body || registerRes.statusText}`,
+            );
+          }
+
+          const hostId = createHash("sha256")
+            .update(hostname() + userInfo().username)
+            .digest("hex");
+          const payload = JSON.stringify({
+            type: "vellum-daemon",
+            v: 4,
+            id: hostId,
+            g: gatewayUrl,
+            pairingRequestId,
+            pairingSecret,
+          });
+
+          const qrString = await new Promise<string>((resolve) => {
+            qrcode.generate(payload, { small: true }, (code: string) => {
+              resolve(code);
+            });
+          });
+
+          h.hideSpinner();
+          h.addStatus(
+            `Pairing Ready\n\n` +
+              `Scan this QR code with the Vellum iOS app:\n\n` +
+              `${qrString}\n` +
+              `This pairing request expires in 5 minutes. Run /pair again to generate a new one.`,
+          );
+        } catch (err) {
+          h.hideSpinner();
+          h.showError(
+            `Pairing failed: ${err instanceof Error ? err.message : err}`,
+          );
+        }
+        return;
+      }
+
+      if (busyRef.current) {
+        // /btw is already handled above this block
+        if (!trimmed.startsWith("/")) {
+          const userMsg: RuntimeMessage = {
+            id: "local-user-" + Date.now(),
+            role: "user",
+            content: trimmed,
+            timestamp: new Date().toISOString(),
+          };
+          h.addMessage(userMsg);
+        }
+        const isConnected = await ensureConnected();
+        if (!isConnected) {
+          h.showError("Cannot send — not connected to the assistant.");
+          setInputFocused(true);
+          return;
+        }
+        try {
+          const controller = new AbortController();
+          const timeoutId = setTimeout(
+            () => controller.abort(),
+            SEND_TIMEOUT_MS,
+          );
+          const sendResult = await sendMessage(
+            runtimeUrl,
+            assistantId,
+            trimmed,
+            controller.signal,
+            bearerToken,
+          );
+          clearTimeout(timeoutId);
+          if (sendResult.accepted) {
+            chatLogRef.current.push({ role: "user", content: trimmed });
+            h.addStatus(
+              "Message queued — will be processed after current response",
+              "gray",
+            );
+          } else {
+            h.showError("Message was not accepted by the assistant");
+          }
+        } catch (err) {
+          h.showError(
+            `Failed to queue message: ${err instanceof Error ? err.message : String(err)}`,
+          );
+        }
+        setInputFocused(true);
+        return;
+      }
+
       if (!trimmed.startsWith("/")) {
         const userMsg: RuntimeMessage = {
           id: "local-user-" + Date.now(),
@@ -1758,7 +1886,8 @@ function ChatApp({
           clearTimeout(timeoutId);
           h.setBusy(false);
           h.hideSpinner();
-          const errorMsg = `Failed to send: ${sendErr instanceof Error ? sendErr.message : sendErr}`;
+          const errorMsg =
+            sendErr instanceof Error ? sendErr.message : String(sendErr);
           h.showError(errorMsg);
           chatLogRef.current.push({ role: "error", content: errorMsg });
           return;

package/src/index.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env bun
 
 import cliPkg from "../package.json";
+import { clean } from "./commands/clean";
 import { client } from "./commands/client";
 import { hatch } from "./commands/hatch";
 import { login, logout, whoami } from "./commands/login";
@@ -15,6 +16,7 @@ import { use } from "./commands/use";
 import { wake } from "./commands/wake";
 
 const commands = {
+  clean,
   client,
   hatch,
   login,
@@ -46,6 +48,7 @@ async function main() {
     console.log("Usage: vellum <command> [options]");
     console.log("");
     console.log("Commands:");
+    console.log("  clean    Kill orphaned vellum processes");
     console.log("  client   Connect to a hatched assistant");
     console.log("  hatch    Create a new assistant instance");
     console.log("  login    Log in to the Vellum platform");

package/src/lib/assistant-config.ts

@@ -16,7 +16,9 @@ import { probePort } from "./port-probe.js";
  */
 export interface LocalInstanceResources {
   /**
-   * Instance-specific data root at `~/.local/share/vellum/assistants/<name>/`.
+   * Instance-specific data root. The first local assistant uses `~` (home
+   * directory) with default ports. Subsequent instances are placed under
+   * `~/.local/share/vellum/assistants/<name>/`.
    * The daemon's `.vellum/` directory lives inside it.
    */
   instanceDir: string;
@@ -28,6 +30,7 @@ export interface LocalInstanceResources {
   qdrantPort: number;
   /** Absolute path to the daemon PID file */
   pidFile: string;
+  [key: string]: unknown;
 }
 
 export interface AssistantEntry {
@@ -48,10 +51,11 @@ export interface AssistantEntry {
   hatchedAt?: string;
   /** Per-instance resource config. Present for local entries in multi-instance setups. */
   resources?: LocalInstanceResources;
+  [key: string]: unknown;
 }
 
 interface LockfileData {
-  assistants?: AssistantEntry[];
+  assistants?: Record<string, unknown>[];
   activeAssistant?: string;
   platformBaseUrl?: string;
   [key: string]: unknown;
@@ -92,14 +96,132 @@ function writeLockfile(data: LockfileData): void {
   writeFileSync(lockfilePath, JSON.stringify(data, null, 2) + "\n");
 }
 
+/**
+ * Try to extract a port number from a URL string (e.g. `http://localhost:7830`).
+ * Returns undefined if the URL is malformed or has no explicit port.
+ */
+function parsePortFromUrl(url: unknown): number | undefined {
+  if (typeof url !== "string") return undefined;
+  try {
+    const parsed = new URL(url);
+    const port = parseInt(parsed.port, 10);
+    return isNaN(port) ? undefined : port;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Detect and migrate legacy lockfile entries to the current format.
+ *
+ * Legacy entries stored `baseDataDir` as a top-level field. The current
+ * format nests this under `resources.instanceDir`. This function also
+ * synthesises a full `resources` object when one is missing by inferring
+ * ports from the entry's `runtimeUrl` and falling back to defaults.
+ *
+ * Returns `true` if the entry was mutated (so the caller can persist).
+ */
+export function migrateLegacyEntry(raw: Record<string, unknown>): boolean {
+  if (typeof raw.cloud === "string" && raw.cloud !== "local") {
+    return false;
+  }
+
+  let mutated = false;
+
+  // Migrate top-level `baseDataDir` → `resources.instanceDir`
+  if (typeof raw.baseDataDir === "string" && raw.baseDataDir) {
+    if (!raw.resources || typeof raw.resources !== "object") {
+      raw.resources = {};
+    }
+    const res = raw.resources as Record<string, unknown>;
+    if (!res.instanceDir) {
+      res.instanceDir = raw.baseDataDir;
+      mutated = true;
+    }
+    delete raw.baseDataDir;
+    mutated = true;
+  }
+
+  // Synthesise missing `resources` for local entries
+  if (!raw.resources || typeof raw.resources !== "object") {
+    const gatewayPort =
+      parsePortFromUrl(raw.runtimeUrl) ?? DEFAULT_GATEWAY_PORT;
+    const instanceDir = join(
+      homedir(),
+      ".local",
+      "share",
+      "vellum",
+      "assistants",
+      typeof raw.assistantId === "string" ? raw.assistantId : "default",
+    );
+    raw.resources = {
+      instanceDir,
+      daemonPort: DEFAULT_DAEMON_PORT,
+      gatewayPort,
+      qdrantPort: DEFAULT_QDRANT_PORT,
+      pidFile: join(instanceDir, ".vellum", "vellum.pid"),
+    };
+    mutated = true;
+  } else {
+    // Backfill any missing fields on an existing partial `resources` object
+    const res = raw.resources as Record<string, unknown>;
+    if (!res.instanceDir) {
+      res.instanceDir = join(
+        homedir(),
+        ".local",
+        "share",
+        "vellum",
+        "assistants",
+        typeof raw.assistantId === "string" ? raw.assistantId : "default",
+      );
+      mutated = true;
+    }
+    if (typeof res.daemonPort !== "number") {
+      res.daemonPort = DEFAULT_DAEMON_PORT;
+      mutated = true;
+    }
+    if (typeof res.gatewayPort !== "number") {
+      res.gatewayPort =
+        parsePortFromUrl(raw.runtimeUrl) ?? DEFAULT_GATEWAY_PORT;
+      mutated = true;
+    }
+    if (typeof res.qdrantPort !== "number") {
+      res.qdrantPort = DEFAULT_QDRANT_PORT;
+      mutated = true;
+    }
+    if (typeof res.pidFile !== "string") {
+      res.pidFile = join(
+        res.instanceDir as string,
+        ".vellum",
+        "vellum.pid",
+      );
+      mutated = true;
+    }
+  }
+
+  return mutated;
+}
+
 function readAssistants(): AssistantEntry[] {
   const data = readLockfile();
   const entries = data.assistants;
   if (!Array.isArray(entries)) {
     return [];
   }
+
+  let migrated = false;
+  for (const entry of entries) {
+    if (migrateLegacyEntry(entry)) {
+      migrated = true;
+    }
+  }
+
+  if (migrated) {
+    writeLockfile(data);
+  }
+
   return entries.filter(
-    (e) =>
+    (e): e is AssistantEntry =>
       typeof e.assistantId === "string" && typeof e.runtimeUrl === "string",
   );
 }
@@ -131,14 +253,14 @@ export function findAssistantByName(name: string): AssistantEntry | null {
 export function removeAssistantEntry(assistantId: string): void {
   const data = readLockfile();
   const entries = (data.assistants ?? []).filter(
-    (e: AssistantEntry) => e.assistantId !== assistantId,
+    (e) => e.assistantId !== assistantId,
   );
   data.assistants = entries;
   // Reassign active assistant if it matches the removed entry
   if (data.activeAssistant === assistantId) {
     const remaining = entries[0];
     if (remaining) {
-      data.activeAssistant = remaining.assistantId;
+      data.activeAssistant = String(remaining.assistantId);
     } else {
       delete data.activeAssistant;
     }
@@ -229,12 +351,28 @@ async function findAvailablePort(
 
 /**
  * Allocate an isolated set of resources for a named local instance.
- * Each assistant is placed under
+ * The first local assistant uses the home directory with default ports.
+ * Subsequent assistants are placed under
  * `~/.local/share/vellum/assistants/<name>/` with scanned ports.
  */
 export async function allocateLocalResources(
   instanceName: string,
 ): Promise<LocalInstanceResources> {
+  // First local assistant gets the home directory with default ports.
+  const existingLocals = loadAllAssistants().filter((e) => e.cloud === "local");
+  if (existingLocals.length === 0) {
+    const home = homedir();
+    const vellumDir = join(home, ".vellum");
+    mkdirSync(vellumDir, { recursive: true });
+    return {
+      instanceDir: home,
+      daemonPort: DEFAULT_DAEMON_PORT,
+      gatewayPort: DEFAULT_GATEWAY_PORT,
+      qdrantPort: DEFAULT_QDRANT_PORT,
+      pidFile: join(vellumDir, "vellum.pid"),
+    };
+  }
+
   const instanceDir = join(
     homedir(),
     ".local",

package/src/lib/aws.ts

@@ -513,7 +513,6 @@ export async function hatchAws(
     const awsEntry: AssistantEntry = {
       assistantId: instanceName,
       runtimeUrl,
-      bearerToken,
       cloud: "aws",
       instanceId,
       region,