@vellumai/cli 0.4.45 → 0.4.48

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/cli",
-  "version": "0.4.45",
+  "version": "0.4.48",
   "description": "CLI tools for vellum-assistant",
   "type": "module",
   "exports": {
@@ -11,7 +11,7 @@
     "./src/commands/*": "./src/commands/*.ts"
   },
   "bin": {
-    "assistant": "./src/index.ts"
+    "vellum": "./src/index.ts"
   },
   "scripts": {
     "format": "prettier --write .",

package/src/adapters/install.sh

@@ -179,27 +179,30 @@ configure_shell_profile() {
     done
 }
 
-# Create a symlink so `vellum` is available without ~/.bun/bin in PATH.
+# Create a symlink so a CLI command is available without ~/.bun/bin in PATH.
 # Tries /usr/local/bin first (works on most systems), falls back to
 # ~/.local/bin (user-writable, no sudo needed).
 # This is best-effort — failure must not abort the install script.
-symlink_vellum() {
-    local vellum_bin="$HOME/.bun/bin/vellum"
-    if [ ! -f "$vellum_bin" ]; then
+#
+# Usage: symlink_cli <command_name>
+symlink_cli() {
+    local cmd_name="$1"
+    local cmd_bin="$HOME/.bun/bin/$cmd_name"
+    if [ ! -f "$cmd_bin" ]; then
         return 0
     fi
 
-    # Skip if vellum is already resolvable outside of ~/.bun/bin
+    # Skip if the command is already resolvable outside of ~/.bun/bin
     local resolved
-    resolved=$(command -v vellum 2>/dev/null || true)
-    if [ -n "$resolved" ] && [ "$resolved" != "$vellum_bin" ]; then
+    resolved=$(command -v "$cmd_name" 2>/dev/null || true)
+    if [ -n "$resolved" ] && [ "$resolved" != "$cmd_bin" ]; then
         return 0
     fi
 
     # Try /usr/local/bin (may need sudo on some systems)
     if [ -d "/usr/local/bin" ] && [ -w "/usr/local/bin" ]; then
-        if ln -sf "$vellum_bin" /usr/local/bin/vellum 2>/dev/null; then
-            success "Symlinked /usr/local/bin/vellum → $vellum_bin"
+        if ln -sf "$cmd_bin" "/usr/local/bin/$cmd_name" 2>/dev/null; then
+            success "Symlinked /usr/local/bin/$cmd_name → $cmd_bin"
             return 0
         fi
     fi
@@ -207,8 +210,8 @@ symlink_vellum() {
     # Fallback: ~/.local/bin
     local local_bin="$HOME/.local/bin"
     mkdir -p "$local_bin" 2>/dev/null || true
-    if ln -sf "$vellum_bin" "$local_bin/vellum" 2>/dev/null; then
-        success "Symlinked $local_bin/vellum → $vellum_bin"
+    if ln -sf "$cmd_bin" "$local_bin/$cmd_name" 2>/dev/null; then
+        success "Symlinked $local_bin/$cmd_name → $cmd_bin"
         # Ensure ~/.local/bin is in PATH in shell profile
         for profile in "$HOME/.zshrc" "$HOME/.bashrc" "$HOME/.bash_profile"; do
             if [ -f "$profile" ] && ! grep -q "$local_bin" "$profile" 2>/dev/null; then
@@ -221,6 +224,11 @@ symlink_vellum() {
     return 0
 }
 
+symlink_vellum() {
+    symlink_cli "vellum"
+    symlink_cli "assistant"
+}
+
 # Write a small sourceable env file to ~/.config/vellum/env so callers can
 # pick up PATH changes without restarting their shell:
 #   curl -fsSL https://assistant.vellum.ai/install.sh | bash && . ~/.config/vellum/env
@@ -265,6 +273,11 @@ main() {
     install_vellum
     symlink_vellum
 
+    # Verify the assistant CLI is available
+    if ! command -v assistant >/dev/null 2>&1; then
+        info "Note: 'assistant' command may require opening a new terminal session"
+    fi
+
     # Write a sourceable env file so the quickstart one-liner can pick up
     # PATH changes in the caller's shell:
     #   curl ... | bash && . ~/.config/vellum/env

package/src/commands/hatch.ts

@@ -48,7 +48,8 @@ import {
   stopLocalProcesses,
 } from "../lib/local";
 import { maybeStartNgrokTunnel } from "../lib/ngrok";
-import { isProcessAlive } from "../lib/process";
+import { detectOrphanedProcesses } from "../lib/orphan-detection";
+import { isProcessAlive, stopProcess } from "../lib/process";
 import { generateRandomSuffix } from "../lib/random-name";
 import { validateAssistantName } from "../lib/retire-archive";
 import { archiveLogFile, resetLogFile } from "../lib/xdg-log";
@@ -731,6 +732,22 @@ async function hatchLocal(
     }
   }
 
+  // On desktop, scan the process table for orphaned vellum processes that
+  // are not tracked by any PID file or lock file entry and kill them before
+  // starting new ones. This prevents resource leaks when the desktop app
+  // crashes or is force-quit without a clean shutdown.
+  if (IS_DESKTOP) {
+    const orphans = await detectOrphanedProcesses();
+    if (orphans.length > 0) {
+      desktopLog(
+        `🧹 Found ${orphans.length} orphaned process${orphans.length === 1 ? "" : "es"} — cleaning up...`,
+      );
+      for (const orphan of orphans) {
+        await stopProcess(parseInt(orphan.pid, 10), `${orphan.name} (PID ${orphan.pid})`);
+      }
+    }
+  }
+
   // Reuse existing resources if re-hatching with --name that matches a known
   // local assistant, otherwise allocate fresh per-instance ports and directories.
   let resources: LocalInstanceResources;

package/src/commands/retire.ts

@@ -9,6 +9,10 @@ import {
   removeAssistantEntry,
 } from "../lib/assistant-config";
 import type { AssistantEntry } from "../lib/assistant-config";
+import {
+  getPlatformUrl,
+  readPlatformToken,
+} from "../lib/platform-client";
 import { retireInstance as retireAwsInstance } from "../lib/aws";
 import { retireDocker } from "../lib/docker";
 import { retireInstance as retireGcpInstance } from "../lib/gcp";
@@ -18,7 +22,12 @@ import {
 } from "../lib/process";
 import { getArchivePath, getMetadataPath } from "../lib/retire-archive";
 import { exec } from "../lib/step-runner";
-import { openLogFile, closeLogFile, writeToLogFile } from "../lib/xdg-log";
+import {
+  openLogFile,
+  closeLogFile,
+  resetLogFile,
+  writeToLogFile,
+} from "../lib/xdg-log";
 
 function resolveCloud(entry: AssistantEntry): string {
   if (entry.cloud) {
@@ -172,6 +181,34 @@ async function retireCustom(entry: AssistantEntry): Promise<void> {
   console.log(`\u2705 Custom instance retired.`);
 }
 
+async function retireVellum(assistantId: string): Promise<void> {
+  console.log("\u{1F5D1}\ufe0f  Retiring platform-hosted instance...\n");
+
+  const token = readPlatformToken();
+  if (!token) {
+    console.error(
+      "Error: Not logged in. Run `vellum login --token <token>` first.",
+    );
+    process.exit(1);
+  }
+
+  const url = `${getPlatformUrl()}/v1/assistants/${encodeURIComponent(assistantId)}/retire/`;
+  const response = await fetch(url, {
+    method: "DELETE",
+    headers: { "X-Session-Token": token },
+  });
+
+  if (!response.ok) {
+    const body = await response.text();
+    console.error(
+      `Error: Platform retire failed (${response.status}): ${body}`,
+    );
+    process.exit(1);
+  }
+
+  console.log("\u2705 Platform-hosted instance retired.");
+}
+
 function parseSource(): string | undefined {
   const args = process.argv.slice(4);
   for (let i = 0; i < args.length; i++) {
@@ -213,6 +250,9 @@ function teeConsoleToLogFile(fd: number | "ignore"): void {
 }
 
 export async function retire(): Promise<void> {
+  if (process.env.VELLUM_DESKTOP_APP) {
+    resetLogFile("retire.log");
+  }
   const logFd = process.env.VELLUM_DESKTOP_APP
     ? openLogFile("retire.log")
     : "ignore";
@@ -281,6 +321,8 @@ async function retireInner(): Promise<void> {
     await retireLocal(name, entry);
   } else if (cloud === "custom") {
     await retireCustom(entry);
+  } else if (cloud === "vellum") {
+    await retireVellum(entry.assistantId);
   } else {
     console.error(`Error: Unknown cloud type '${cloud}'.`);
     process.exit(1);

package/src/lib/docker.ts

@@ -31,7 +31,7 @@ interface DockerRoot {
  * Dockerfiles live under `meta/`, but when installed as an npm package they
  * are at the package root.
  */
-function findDockerRoot(): DockerRoot {
+function findDockerRoot(developmentMode: boolean = false): DockerRoot {
   // Source tree: cli/src/lib/ -> repo root (Dockerfiles in meta/)
   const sourceTreeRoot = join(import.meta.dir, "..", "..", "..");
   if (existsSync(join(sourceTreeRoot, "meta", "Dockerfile"))) {
@@ -55,6 +55,21 @@ function findDockerRoot(): DockerRoot {
     dir = parent;
   }
 
+  // In development mode, walk up from the executable path to find the repo
+  // root. This handles the macOS app bundle case where the binary lives inside
+  // the repo at e.g. clients/macos/dist/Vellum.app/Contents/MacOS/.
+  if (developmentMode) {
+    let execDir = dirname(process.execPath);
+    while (true) {
+      if (existsSync(join(execDir, "meta", "Dockerfile.development"))) {
+        return { root: execDir, dockerfileDir: "meta" };
+      }
+      const parent = dirname(execDir);
+      if (parent === execDir) break;
+      execDir = parent;
+    }
+  }
+
   // macOS app bundle: Contents/MacOS/vellum-cli -> Contents/Resources/Dockerfile
   const appResourcesDir = join(dirname(process.execPath), "..", "Resources");
   if (existsSync(join(appResourcesDir, "Dockerfile"))) {
@@ -168,7 +183,7 @@ export async function hatchDocker(
   let repoRoot: string;
   let dockerfileDir: string;
   try {
-    ({ root: repoRoot, dockerfileDir } = findDockerRoot());
+    ({ root: repoRoot, dockerfileDir } = findDockerRoot(watch));
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     const logFd = openLogFile("hatch.log");