@vellumai/cli 0.3.10 → 0.3.12

package/src/commands/hatch.ts

@@ -1,5 +1,5 @@
 import { randomBytes } from "crypto";
-import { existsSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { existsSync, lstatSync, mkdirSync, readFileSync, readlinkSync, symlinkSync, unlinkSync, writeFileSync } from "fs";
 import { homedir, tmpdir, userInfo } from "os";
 import { join } from "path";
 
@@ -29,13 +29,14 @@ export type { PollResult, WatchHatchingResult } from "../lib/gcp";
 
 const INSTALL_SCRIPT_REMOTE_PATH = "/tmp/vellum-install.sh";
 
-async function resolveInstallScriptPath(): Promise<string | null> {
-  const sourcePath = join(import.meta.dir, "..", "adapters", "install.sh");
-  if (existsSync(sourcePath)) {
-    return sourcePath;
-  }
-  console.warn("⚠️  Install script not found at", sourcePath, "(expected in compiled binary)");
-  return null;
+// Embedded install script — bun --compile doesn't bundle non-JS assets,
+// so we inline it to ensure it's available in the compiled binary.
+import INSTALL_SCRIPT_CONTENT from "../adapters/install.sh" with { type: "text" };
+
+function resolveInstallScriptPath(): string {
+  const tmpPath = join(tmpdir(), `vellum-install-${process.pid}.sh`);
+  writeFileSync(tmpPath, INSTALL_SCRIPT_CONTENT, { mode: 0o755 });
+  return tmpPath;
 }
 const HATCH_TIMEOUT_MS: Record<Species, number> = {
   vellum: 2 * 60 * 1000,
@@ -51,8 +52,8 @@ function desktopLog(msg: string): void {
   process.stdout.write(msg + "\n");
 }
 
-function buildTimestampRedirect(): string {
-  return `exec > >(while IFS= read -r line; do printf '[%s] %s\\n' "$(date -u '+%Y-%m-%dT%H:%M:%SZ')" "$line"; done > /var/log/startup-script.log) 2>&1`;
+function buildTimestampRedirect(logPath: string): string {
+  return `exec > >(while IFS= read -r line; do printf '[%s] %s\\n' "$(date -u '+%Y-%m-%dT%H:%M:%SZ')" "$line"; done > ${logPath}) 2>&1`;
 }
 
 function buildUserSetup(sshUser: string): string {
@@ -82,7 +83,9 @@ export async function buildStartupScript(
   cloud: RemoteHost,
 ): Promise<string> {
   const platformUrl = process.env.VELLUM_ASSISTANT_PLATFORM_URL ?? "https://assistant.vellum.ai";
-  const timestampRedirect = buildTimestampRedirect();
+  const logPath = cloud === "custom" ? "/tmp/vellum-startup.log" : "/var/log/startup-script.log";
+  const errorPath = cloud === "custom" ? "/tmp/vellum-startup-error" : "/var/log/startup-error";
+  const timestampRedirect = buildTimestampRedirect(logPath);
   const userSetup = buildUserSetup(sshUser);
   const ownershipFixup = buildOwnershipFixup();
 
@@ -102,7 +105,7 @@ set -e
 
 ${timestampRedirect}
 
-trap 'EXIT_CODE=\$?; if [ \$EXIT_CODE -ne 0 ]; then echo "Startup script failed with exit code \$EXIT_CODE at line \$LINENO" > /var/log/startup-error; echo "Last 20 log lines:" >> /var/log/startup-error; tail -20 /var/log/startup-script.log >> /var/log/startup-error 2>/dev/null || true; fi' EXIT
+trap 'EXIT_CODE=\$?; if [ \$EXIT_CODE -ne 0 ]; then echo "Startup script failed with exit code \$EXIT_CODE at line \$LINENO" > ${errorPath}; echo "Last 20 log lines:" >> ${errorPath}; tail -20 ${logPath} >> ${errorPath} 2>/dev/null || true; fi' EXIT
 ${userSetup}
 ANTHROPIC_API_KEY=${anthropicApiKey}
 GATEWAY_RUNTIME_PROXY_ENABLED=true
@@ -401,13 +404,31 @@ function watchHatchingDesktop(
 }
 
 function buildSshArgs(host: string): string[] {
-  return [
-    host,
+  const args: string[] = [host];
+  const keyPath = process.env.VELLUM_SSH_KEY_PATH;
+  if (keyPath) {
+    args.push("-i", keyPath);
+  }
+  args.push(
     "-o", "StrictHostKeyChecking=no",
     "-o", "UserKnownHostsFile=/dev/null",
     "-o", "ConnectTimeout=10",
     "-o", "LogLevel=ERROR",
-  ];
+  );
+  return args;
+}
+
+function buildScpArgs(keyPath?: string): string[] {
+  const args: string[] = [];
+  if (keyPath) {
+    args.push("-i", keyPath);
+  }
+  args.push(
+    "-o", "StrictHostKeyChecking=no",
+    "-o", "UserKnownHostsFile=/dev/null",
+    "-o", "LogLevel=ERROR",
+  );
+  return args;
 }
 
 function extractHostname(host: string): string {
@@ -454,27 +475,22 @@ async function hatchCustom(
     const startupScriptPath = join(tmpdir(), `${instanceName}-startup.sh`);
     writeFileSync(startupScriptPath, startupScript);
 
+    const sshKeyPath = process.env.VELLUM_SSH_KEY_PATH;
+
+    const installScriptPath = resolveInstallScriptPath();
+
     try {
-      const installScriptPath = await resolveInstallScriptPath();
-      if (installScriptPath) {
-        console.log("📋 Uploading install script to instance...");
-        await exec("scp", [
-          "-o", "StrictHostKeyChecking=no",
-          "-o", "UserKnownHostsFile=/dev/null",
-          "-o", "LogLevel=ERROR",
-          installScriptPath,
-          `${host}:${INSTALL_SCRIPT_REMOTE_PATH}`,
-        ]);
-      } else {
-        console.warn("⚠️  Skipping install script upload (not available in compiled binary)");
-      }
+      console.log("📋 Uploading install script to instance...");
+      await exec("scp", [
+        ...buildScpArgs(sshKeyPath),
+        installScriptPath,
+        `${host}:${INSTALL_SCRIPT_REMOTE_PATH}`,
+      ]);
 
       console.log("📋 Uploading startup script to instance...");
       const remoteStartupPath = `/tmp/${instanceName}-startup.sh`;
       await exec("scp", [
-        "-o", "StrictHostKeyChecking=no",
-        "-o", "UserKnownHostsFile=/dev/null",
-        "-o", "LogLevel=ERROR",
+        ...buildScpArgs(sshKeyPath),
         startupScriptPath,
         `${host}:${remoteStartupPath}`,
       ]);
@@ -485,9 +501,8 @@ async function hatchCustom(
         `chmod +x ${remoteStartupPath} ${INSTALL_SCRIPT_REMOTE_PATH} && bash ${remoteStartupPath}`,
       ]);
     } finally {
-      try {
-        unlinkSync(startupScriptPath);
-      } catch {}
+      try { unlinkSync(startupScriptPath); } catch {}
+      try { unlinkSync(installScriptPath); } catch {}
     }
 
     const runtimeUrl = `http://${hostname}:${GATEWAY_PORT}`;
@@ -520,6 +535,43 @@ async function hatchCustom(
   }
 }
 
+function installCLISymlink(): void {
+  const cliBinary = process.execPath;
+  if (!cliBinary || !existsSync(cliBinary)) return;
+
+  const symlinkPath = "/usr/local/bin/vellum";
+
+  try {
+    // Use lstatSync (not existsSync) to detect dangling symlinks —
+    // existsSync follows symlinks and returns false for broken links.
+    try {
+      const stats = lstatSync(symlinkPath);
+      if (!stats.isSymbolicLink()) {
+        // Real file — don't overwrite (developer's local install)
+        return;
+      }
+      // Already a symlink — skip if it already points to our binary
+      const dest = readlinkSync(symlinkPath);
+      if (dest === cliBinary) return;
+      // Stale or dangling symlink — remove before creating new one
+      unlinkSync(symlinkPath);
+    } catch (e) {
+      if ((e as NodeJS.ErrnoException)?.code !== "ENOENT") throw e;
+      // Path doesn't exist — proceed to create symlink
+    }
+
+    const dir = "/usr/local/bin";
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    symlinkSync(cliBinary, symlinkPath);
+    console.log(`   Symlinked ${symlinkPath} → ${cliBinary}`);
+  } catch {
+    // Permission denied or other error — not critical
+    console.log(`   ⚠ Could not create symlink at ${symlinkPath} (run with sudo or create manually)`);
+  }
+}
+
 async function hatchLocal(species: Species, name: string | null, daemonOnly: boolean = false): Promise<void> {
   const instanceName =
     name ?? process.env.VELLUM_ASSISTANT_NAME ?? `${species}-${generateRandomSuffix()}`;
@@ -538,6 +590,8 @@ async function hatchLocal(species: Species, name: string | null, daemonOnly: boo
     }
   }
 
+  const baseDataDir = join(process.env.BASE_DATA_DIR?.trim() || (process.env.HOME ?? userInfo().homedir), ".vellum");
+
   console.log(`🥚 Hatching local assistant: ${instanceName}`);
   console.log(`   Species: ${species}`);
   console.log("");
@@ -546,7 +600,7 @@ async function hatchLocal(species: Species, name: string | null, daemonOnly: boo
 
   let runtimeUrl: string;
   try {
-    runtimeUrl = await startGateway();
+    runtimeUrl = await startGateway(instanceName);
   } catch (error) {
     // Gateway failed — stop the daemon we just started so we don't leave
     // orphaned processes with no lock file entry.
@@ -555,8 +609,6 @@ async function hatchLocal(species: Species, name: string | null, daemonOnly: boo
     throw error;
   }
 
-  const baseDataDir = join(process.env.BASE_DATA_DIR?.trim() || (process.env.HOME ?? userInfo().homedir), ".vellum");
-
   // Read the bearer token written by the daemon so the client can authenticate
   // with the gateway (which requires auth by default).
   let bearerToken: string | undefined;
@@ -579,6 +631,10 @@ async function hatchLocal(species: Species, name: string | null, daemonOnly: boo
   if (!daemonOnly) {
     saveAssistantEntry(localEntry);
 
+    if (process.env.VELLUM_DESKTOP_APP) {
+      installCLISymlink();
+    }
+
     console.log("");
     console.log(`✅ Local assistant hatched!`);
     console.log("");

package/src/commands/login.ts

@@ -0,0 +1,68 @@
+import {
+  clearPlatformToken,
+  fetchCurrentUser,
+  readPlatformToken,
+  savePlatformToken,
+} from "../lib/platform-client";
+
+export async function login(): Promise<void> {
+  const args = process.argv.slice(3);
+  let token: string | null = null;
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--token") {
+      token = args[i + 1];
+      if (!token) {
+        console.error("Error: --token requires a value");
+        process.exit(1);
+      }
+      break;
+    }
+  }
+
+  if (!token) {
+    console.error("Usage: vellum login --token <session-token>");
+    console.error("");
+    console.error("To get your session token:");
+    console.error("  1. Log in to the Vellum platform in your browser");
+    console.error("  2. Open Developer Tools → Application → Cookies");
+    console.error("  3. Copy the value of the session token");
+    process.exit(1);
+  }
+
+  console.log("Validating token...");
+
+  try {
+    const user = await fetchCurrentUser(token);
+    savePlatformToken(token);
+    console.log(`✅ Logged in as ${user.email}`);
+  } catch (error) {
+    console.error(`❌ Login failed: ${error instanceof Error ? error.message : error}`);
+    process.exit(1);
+  }
+}
+
+export async function logout(): Promise<void> {
+  clearPlatformToken();
+  console.log("Logged out. Platform token removed.");
+}
+
+export async function whoami(): Promise<void> {
+  const token = readPlatformToken();
+  if (!token) {
+    console.error("Not logged in. Run `vellum login --token <token>` first.");
+    process.exit(1);
+  }
+
+  try {
+    const user = await fetchCurrentUser(token);
+    console.log(`Email: ${user.email}`);
+    if (user.display) {
+      console.log(`Name:  ${user.display}`);
+    }
+    console.log(`ID:    ${user.id}`);
+  } catch (error) {
+    console.error(`Error: ${error instanceof Error ? error.message : error}`);
+    process.exit(1);
+  }
+}

package/src/commands/ps.ts

@@ -66,7 +66,7 @@ const SSH_OPTS = [
 const REMOTE_PS_CMD = [
   // List vellum-related processes: daemon, gateway, qdrant, and any bun children
   "ps ax -o pid=,ppid=,args=",
-  "| grep -E 'vellum|gateway|qdrant|openclaw'",
+  "| grep -E 'vellum|vellum-gateway|qdrant|openclaw'",
   "| grep -v grep",
 ].join(" ");
 
@@ -78,9 +78,13 @@ interface RemoteProcess {
 
 function classifyProcess(command: string): string {
   if (/qdrant/.test(command)) return "qdrant";
-  if (/gateway/.test(command)) return "gateway";
+  if (/vellum-gateway/.test(command)) return "gateway";
   if (/openclaw/.test(command)) return "openclaw-adapter";
+  if (/vellum-daemon/.test(command)) return "daemon";
   if (/daemon\s+(start|restart)/.test(command)) return "daemon";
+  // Exclude macOS desktop app processes — their path contains .app/Contents/MacOS/
+  // but they are not background service processes.
+  if (/\.app\/Contents\/MacOS\//.test(command)) return "unknown";
   if (/vellum/.test(command)) return "vellum";
   return "unknown";
 }
@@ -277,7 +281,7 @@ async function detectOrphanedProcesses(): Promise<OrphanedProcess[]> {
   try {
     const output = await execOutput("sh", [
       "-c",
-      "ps ax -o pid=,ppid=,args= | grep -E 'vellum|gateway|qdrant|openclaw' | grep -v grep",
+      "ps ax -o pid=,ppid=,args= | grep -E 'vellum|vellum-gateway|qdrant|openclaw' | grep -v grep",
     ]);
     const procs = parseRemotePs(output);
     const ownPid = String(process.pid);

package/src/commands/recover.ts

@@ -11,7 +11,7 @@ import { exec } from "../lib/step-runner";
 export async function recover(): Promise<void> {
   const name = process.argv[3];
   if (!name) {
-    console.error("Usage: vellum-cli recover <name>");
+    console.error("Usage: vellum recover <name>");
     process.exit(1);
   }
 

package/src/commands/retire.ts

@@ -125,14 +125,14 @@ export async function retire(): Promise<void> {
 
   if (!name) {
     console.error("Error: Instance name is required.");
-    console.error("Usage: vellum-cli retire <name> [--source <source>]");
+    console.error("Usage: vellum retire <name> [--source <source>]");
     process.exit(1);
   }
 
   const entry = findAssistantByName(name);
   if (!entry) {
     console.error(`No assistant found with name '${name}'.`);
-    console.error("Run 'vellum-cli hatch' first, or check the instance name.");
+    console.error("Run 'vellum hatch' first, or check the instance name.");
     process.exit(1);
   }