@vellumai/cli 0.4.45 → 0.4.46

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/cli",
-  "version": "0.4.45",
+  "version": "0.4.46",
   "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/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");