@vellumai/cli 0.6.6 → 0.7.1

package/src/commands/terminal.ts

@@ -11,19 +11,17 @@
  *   vellum terminal list                — List tmux sessions
  */
 
-import {
-  findAssistantByName,
-  loadLatestAssistant,
-  resolveCloud,
-} from "../lib/assistant-config.js";
-import { getPlatformUrl, readPlatformToken } from "../lib/platform-client.js";
 import {
   closeTerminalSession,
   createTerminalSession,
-  resizeTerminalSession,
   sendTerminalInput,
   subscribeTerminalEvents,
 } from "../lib/terminal-client.js";
+import {
+  interactiveSession,
+  resolveManagedAssistant,
+} from "../lib/terminal-session.js";
+import type { ResolvedManagedAssistant } from "../lib/terminal-session.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -60,223 +58,13 @@ function printHelp(): void {
   console.log("  vellum terminal --assistant my-assistant");
 }
 
-interface ResolvedAssistant {
-  assistantId: string;
-  token: string;
-  platformUrl: string;
-}
-
-function resolveAssistant(nameArg?: string): ResolvedAssistant {
-  const entry = nameArg ? findAssistantByName(nameArg) : loadLatestAssistant();
-
-  if (!entry) {
-    if (nameArg) {
-      console.error(`No assistant instance found with name '${nameArg}'.`);
-    } else {
-      console.error("No assistant instance found. Run `vellum hatch` first.");
-    }
-    process.exit(1);
-  }
-
-  const cloud = resolveCloud(entry);
-  if (cloud !== "vellum") {
-    if (cloud === "local") {
-      console.error(
-        "This assistant runs locally on your machine. You can access it directly.",
-      );
-    } else if (cloud === "docker") {
-      console.error(
-        `Use 'vellum exec -it -- /bin/bash' or 'vellum ssh' for ${cloud} instances.`,
-      );
-    } else {
-      console.error(
-        `'vellum terminal' is for managed (cloud-hosted) assistants. This assistant uses '${cloud}'.`,
-      );
-    }
-    process.exit(1);
-  }
-
-  const token = readPlatformToken();
-  if (!token) {
-    console.error(
-      "Not logged in. Run `vellum login` first to authenticate with the platform.",
-    );
-    process.exit(1);
-  }
-
-  return {
-    assistantId: entry.assistantId,
-    token,
-    platformUrl: getPlatformUrl(),
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Interactive session
-// ---------------------------------------------------------------------------
-
-async function interactiveSession(
-  assistant: ResolvedAssistant,
-  initialCommand?: string,
-): Promise<void> {
-  const cols = process.stdout.columns || 80;
-  const rows = process.stdout.rows || 24;
-
-  console.error(`\x1b[2m🔗 Connecting to ${assistant.assistantId}...\x1b[0m`);
-
-  const { session_id: sessionId } = await createTerminalSession(
-    assistant.token,
-    assistant.assistantId,
-    cols,
-    rows,
-    assistant.platformUrl,
-  );
-
-  // --- TTY raw mode setup ---
-  const wasRaw = process.stdin.isRaw;
-  if (process.stdin.isTTY) {
-    process.stdin.setRawMode(true);
-  }
-  process.stdin.resume();
-  process.stdin.setEncoding("utf-8");
-
-  // Abort controller for the SSE stream
-  const abortController = new AbortController();
-  let exiting = false;
-
-  // --- Cleanup function (idempotent) ---
-  async function cleanup(): Promise<void> {
-    if (exiting) return;
-    exiting = true;
-
-    // Restore tty
-    if (process.stdin.isTTY) {
-      process.stdin.setRawMode(wasRaw ?? false);
-    }
-    process.stdin.pause();
-
-    // Abort SSE stream
-    abortController.abort();
-
-    // Close remote session (best-effort)
-    try {
-      await closeTerminalSession(
-        assistant.token,
-        assistant.assistantId,
-        sessionId,
-        assistant.platformUrl,
-      );
-    } catch {
-      // Best-effort cleanup
-    }
-  }
-
-  // --- Signal handlers ---
-  const onSigInt = () => {
-    cleanup().then(() => process.exit(0));
-  };
-  const onSigTerm = () => {
-    cleanup().then(() => process.exit(0));
-  };
-  process.on("SIGINT", onSigInt);
-  process.on("SIGTERM", onSigTerm);
-
-  // --- SIGWINCH (terminal resize) ---
-  const onResize = () => {
-    const newCols = process.stdout.columns || 80;
-    const newRows = process.stdout.rows || 24;
-    resizeTerminalSession(
-      assistant.token,
-      assistant.assistantId,
-      sessionId,
-      newCols,
-      newRows,
-      assistant.platformUrl,
-    ).catch(() => {
-      // Resize failures are non-fatal
-    });
-  };
-  process.stdout.on("resize", onResize);
-
-  // --- Input: stdin → remote ---
-  let inputBuffer = "";
-  let inputTimer: ReturnType<typeof setTimeout> | null = null;
-  const INPUT_DEBOUNCE_MS = 30;
-
-  function flushInput(): void {
-    if (inputBuffer.length === 0) return;
-    const data = inputBuffer;
-    inputBuffer = "";
-    sendTerminalInput(
-      assistant.token,
-      assistant.assistantId,
-      sessionId,
-      data,
-      assistant.platformUrl,
-    ).catch((err) => {
-      if (!exiting) {
-        console.error(`\r\nInput error: ${err.message}\r\n`);
-      }
-    });
-  }
-
-  process.stdin.on("data", (chunk: string) => {
-    if (exiting) return;
-    inputBuffer += chunk;
-    if (inputTimer) clearTimeout(inputTimer);
-    inputTimer = setTimeout(flushInput, INPUT_DEBOUNCE_MS);
-  });
-
-  // --- Send initial command (for `attach` subcommand) ---
-  if (initialCommand) {
-    // Brief delay to let the shell initialize
-    await new Promise((resolve) => setTimeout(resolve, 300));
-    await sendTerminalInput(
-      assistant.token,
-      assistant.assistantId,
-      sessionId,
-      initialCommand + "\r",
-      assistant.platformUrl,
-    );
-  }
-
-  // --- Output: remote SSE → stdout ---
-  try {
-    for await (const event of subscribeTerminalEvents(
-      assistant.token,
-      assistant.assistantId,
-      sessionId,
-      assistant.platformUrl,
-      abortController.signal,
-    )) {
-      if (exiting) break;
-      // Decode base64 output and write raw bytes to stdout
-      const bytes = Buffer.from(event.data, "base64");
-      process.stdout.write(bytes);
-    }
-  } catch (err) {
-    if (!exiting) {
-      const msg = err instanceof Error ? err.message : String(err);
-      // AbortError is expected on cleanup
-      if (!msg.includes("abort")) {
-        console.error(`\r\nConnection lost: ${msg}\r\n`);
-      }
-    }
-  } finally {
-    await cleanup();
-
-    // Remove listeners
-    process.off("SIGINT", onSigInt);
-    process.off("SIGTERM", onSigTerm);
-    process.stdout.off("resize", onResize);
-  }
-}
-
 // ---------------------------------------------------------------------------
 // List tmux sessions
 // ---------------------------------------------------------------------------
 
-async function listTmuxSessions(assistant: ResolvedAssistant): Promise<void> {
+async function listTmuxSessions(
+  assistant: ResolvedManagedAssistant,
+): Promise<void> {
   const cols = 120;
   const rows = 24;
 
@@ -411,7 +199,7 @@ export async function terminal(): Promise<void> {
     }
   }
 
-  const assistant = resolveAssistant(assistantName);
+  const assistant = resolveManagedAssistant(assistantName);
 
   if (subcommand === "list") {
     await listTmuxSessions(assistant);

package/src/commands/tunnel.ts

@@ -1,7 +1,4 @@
-import {
-  findAssistantByName,
-  loadLatestAssistant,
-} from "../lib/assistant-config";
+import { resolveAssistant } from "../lib/assistant-config";
 import { runNgrokTunnel } from "../lib/ngrok";
 
 const VALID_PROVIDERS = ["vellum", "ngrok", "cloudflare", "tailscale"] as const;
@@ -63,9 +60,7 @@ function parseArgs(): TunnelArgs {
 export async function tunnel(): Promise<void> {
   const { assistantName, provider } = parseArgs();
 
-  const entry = assistantName
-    ? findAssistantByName(assistantName)
-    : loadLatestAssistant();
+  const entry = resolveAssistant(assistantName ?? undefined);
 
   if (!entry) {
     if (assistantName) {

package/src/commands/upgrade.ts

@@ -1,4 +1,5 @@
 import { randomBytes } from "crypto";
+import { spawnSync } from "child_process";
 
 import cliPkg from "../../package.json";
 
@@ -16,7 +17,10 @@ import {
   startContainers,
   stopContainers,
 } from "../lib/docker";
-import { resolveImageRefs } from "../lib/platform-releases";
+import {
+  fetchLatestStableVersion,
+  resolveImageRefs,
+} from "../lib/platform-releases";
 import {
   authHeaders,
   getPlatformUrl,
@@ -47,6 +51,7 @@ import { compareVersions } from "../lib/version-compat.js";
 interface UpgradeArgs {
   name: string | null;
   version: string | null;
+  latest: boolean;
   prepare: boolean;
   finalize: boolean;
 }
@@ -55,6 +60,7 @@ function parseArgs(): UpgradeArgs {
   const args = process.argv.slice(3);
   let name: string | null = null;
   let version: string | null = null;
+  let latest = false;
   let prepare = false;
   let finalize = false;
 
@@ -73,7 +79,10 @@ function parseArgs(): UpgradeArgs {
       console.log("");
       console.log("Options:");
       console.log(
-        "  --version <version>  Target version to upgrade to (default: latest)",
+        "  --version <version>  Target version to upgrade to (default: CLI version)",
+      );
+      console.log(
+        "  --latest             Upgrade to the latest stable release, updating the CLI first if needed",
       );
       console.log(
         "  --prepare            Run pre-upgrade steps only (backup, notify) without swapping versions",
@@ -84,7 +93,10 @@ function parseArgs(): UpgradeArgs {
       console.log("");
       console.log("Examples:");
       console.log(
-        "  vellum upgrade                              # Upgrade the active assistant to the latest version",
+        "  vellum upgrade                              # Upgrade the active assistant to the CLI's version",
+      );
+      console.log(
+        "  vellum upgrade --latest                     # Upgrade CLI + assistant to the latest stable release",
       );
       console.log(
         "  vellum upgrade my-assistant                  # Upgrade a specific assistant by name",
@@ -102,6 +114,8 @@ function parseArgs(): UpgradeArgs {
       }
       version = next;
       i++;
+    } else if (arg === "--latest") {
+      latest = true;
     } else if (arg === "--prepare") {
       prepare = true;
     } else if (arg === "--finalize") {
@@ -121,7 +135,13 @@ function parseArgs(): UpgradeArgs {
     process.exit(1);
   }
 
-  return { name, version, prepare, finalize };
+  if (latest && version) {
+    console.error("Error: --latest and --version are mutually exclusive.");
+    emitCliError("UNKNOWN", "--latest and --version are mutually exclusive");
+    process.exit(1);
+  }
+
+  return { name, version, latest, prepare, finalize };
 }
 
 function resolveCloud(entry: AssistantEntry): string {
@@ -867,8 +887,80 @@ async function upgradeFinalize(
   );
 }
 
+/**
+ * When `--latest` is passed, resolve the latest stable version from the
+ * platform API.  If the running CLI is older than that version, self-update
+ * the CLI via `bun install -g` and re-exec so the new CLI's upgrade logic
+ * (and its cliPkg.version) drives the rest of the upgrade.
+ *
+ * Returns the resolved latest version string (e.g. "v0.7.0") for callers
+ * that need it.  If the CLI was updated and re-exec'd, this function never
+ * returns — the process is replaced.
+ */
+async function resolveLatestAndMaybeSelfUpdate(
+  name: string | null,
+): Promise<string> {
+  console.log("🔍 Fetching latest stable release...");
+  const latestVersion = await fetchLatestStableVersion();
+  if (!latestVersion) {
+    console.error(
+      "Error: Could not determine the latest stable release from the platform API.",
+    );
+    emitCliError(
+      "UNKNOWN",
+      "Could not determine the latest stable release from the platform API",
+    );
+    process.exit(1);
+  }
+
+  const latestTag = latestVersion.startsWith("v")
+    ? latestVersion
+    : `v${latestVersion}`;
+  const currentTag = cliPkg.version ? `v${cliPkg.version}` : null;
+
+  console.log(`   Latest stable: ${latestTag}`);
+  console.log(`   CLI version:   ${currentTag ?? "unknown"}\n`);
+
+  // Check if the CLI needs updating
+  const cmp = currentTag ? compareVersions(latestTag, currentTag) : null;
+  if (cmp !== null && cmp > 0) {
+    console.log(`🔄 Updating CLI to ${latestTag}...`);
+    const installResult = spawnSync(
+      "bun",
+      ["install", "-g", `vellum@${latestVersion}`],
+      { stdio: "inherit" },
+    );
+    if (installResult.error || installResult.status !== 0) {
+      const detail =
+        installResult.error?.message ?? `exited with code ${installResult.status}`;
+      console.error(`\n❌ CLI self-update failed: ${detail}`);
+      emitCliError("CLI_UPDATE_FAILED", "CLI self-update failed", detail);
+      process.exit(1);
+    }
+    console.log(`✅ CLI updated to ${latestTag}\n`);
+
+    // Re-exec with the updated CLI. Pass --version instead of --latest
+    // to avoid re-fetching and to prevent infinite re-exec loops.
+    const reexecArgs = ["upgrade"];
+    if (name) reexecArgs.push(name);
+    reexecArgs.push("--version", latestTag);
+
+    console.log(`🚀 Re-running upgrade with updated CLI...\n`);
+    const reexecResult = spawnSync("vellum", reexecArgs, {
+      stdio: "inherit",
+    });
+    process.exit(reexecResult.status ?? 1);
+  }
+
+  if (cmp !== null && cmp === 0) {
+    console.log(`✅ CLI is already on the latest version (${latestTag})\n`);
+  }
+
+  return latestTag;
+}
+
 export async function upgrade(): Promise<void> {
-  const { name, version, prepare, finalize } = parseArgs();
+  const { name, version, latest, prepare, finalize } = parseArgs();
   const entry = resolveTargetAssistant(name);
 
   if (prepare) {
@@ -881,16 +973,25 @@ export async function upgrade(): Promise<void> {
     return;
   }
 
+  // When --latest is passed, resolve the target from the platform API and
+  // self-update the CLI if it's behind.  The resolved version is then used
+  // as the explicit target for the rest of the upgrade flow.
+  let effectiveVersion = version;
+  if (latest) {
+    const latestTag = await resolveLatestAndMaybeSelfUpdate(name);
+    effectiveVersion = latestTag;
+  }
+
   const cloud = resolveCloud(entry);
 
   try {
     if (cloud === "docker") {
-      await upgradeDocker(entry, version);
+      await upgradeDocker(entry, effectiveVersion);
       return;
     }
 
     if (cloud === "vellum") {
-      await upgradePlatform(entry, version);
+      await upgradePlatform(entry, effectiveVersion);
       return;
     }
   } catch (err) {

package/src/commands/wake.ts

@@ -2,6 +2,7 @@ import { existsSync, readFileSync, writeFileSync } from "fs";
 import { join } from "path";
 
 import {
+  getDaemonPidPath,
   resolveTargetAssistant,
   saveAssistantEntry,
 } from "../lib/assistant-config.js";
@@ -82,7 +83,7 @@ export async function wake(): Promise<void> {
   }
   const resources = entry.resources;
 
-  const pidFile = resources.pidFile;
+  const pidFile = getDaemonPidPath(resources);
 
   // Check if daemon is already running
   let daemonRunning = false;