@vellumai/cli 0.1.9 → 0.1.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/cli",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "description": "CLI tools for vellum-assistant",
   "type": "module",
   "bin": {

package/src/adapters/install.sh

@@ -79,6 +79,23 @@ ensure_bun() {
     success "bun installed ($(bun --version))"
 }
 
+install_vellum() {
+    if command -v vellum >/dev/null 2>&1; then
+        info "Updating vellum to latest..."
+        bun install -g vellum@latest
+    else
+        info "Installing vellum globally..."
+        bun install -g vellum@latest
+    fi
+
+    if ! command -v vellum >/dev/null 2>&1; then
+        error "vellum installation failed. Please install manually: bun install -g vellum"
+        exit 1
+    fi
+
+    success "vellum installed ($(vellum --version 2>/dev/null || echo 'unknown'))"
+}
+
 main() {
     printf "\n"
     printf '  %bVellum Installer%b\n' "$BOLD" "$RESET"
@@ -86,13 +103,14 @@ main() {
 
     ensure_git
     ensure_bun
+    install_vellum
 
     info "Running vellum hatch..."
     printf "\n"
     if [ -n "${VELLUM_SSH_USER:-}" ] && [ "$(id -u)" = "0" ]; then
-        su - "$VELLUM_SSH_USER" -c "set -a; [ -f \"\$HOME/.vellum/.env\" ] && . \"\$HOME/.vellum/.env\"; set +a; export PATH=\"$HOME/.bun/bin:\$PATH\"; bunx vellum hatch"
+        su - "$VELLUM_SSH_USER" -c "set -a; [ -f \"\$HOME/.vellum/.env\" ] && . \"\$HOME/.vellum/.env\"; set +a; export PATH=\"$HOME/.bun/bin:\$PATH\"; vellum hatch"
     else
-        bunx vellum hatch
+        vellum hatch
     fi
 }
 

package/src/commands/hatch.ts

@@ -781,7 +781,14 @@ async function hatchCustom(
 }
 
 function isGatewaySourceDir(dir: string): boolean {
-  return existsSync(join(dir, "package.json")) && existsSync(join(dir, "src", "index.ts"));
+  const pkgPath = join(dir, "package.json");
+  if (!existsSync(pkgPath) || !existsSync(join(dir, "src", "index.ts"))) return false;
+  try {
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    return pkg.name === "@vellumai/vellum-gateway";
+  } catch {
+    return false;
+  }
 }
 
 function findGatewaySourceFromCwd(): string | undefined {
@@ -891,14 +898,7 @@ async function discoverPublicUrl(): Promise<string | undefined> {
   return undefined;
 }
 
-async function hatchLocal(species: Species, name: string | null, daemonOnly: boolean = false): Promise<void> {
-  const instanceName =
-    name ?? process.env.VELLUM_ASSISTANT_NAME ?? `${species}-${generateRandomSuffix()}`;
-
-  console.log(`🥚 Hatching local assistant: ${instanceName}`);
-  console.log(`   Species: ${species}`);
-  console.log("");
-
+export async function startLocalDaemon(): Promise<void> {
   if (process.env.VELLUM_DESKTOP_APP) {
     // When running inside the desktop app, the CLI owns the daemon lifecycle.
     // Find the vellum-daemon binary adjacent to the CLI binary.
@@ -1045,6 +1045,54 @@ async function hatchLocal(species: Species, name: string | null, daemonOnly: boo
       child.on("error", reject);
     });
   }
+}
+
+export async function startGateway(): Promise<string> {
+  const publicUrl = await discoverPublicUrl();
+  if (publicUrl) {
+    console.log(`   Public URL: ${publicUrl}`);
+  }
+
+  console.log("🌐 Starting gateway...");
+  const gatewayDir = resolveGatewayDir();
+  const gatewayEnv: Record<string, string> = {
+    ...process.env as Record<string, string>,
+    GATEWAY_RUNTIME_PROXY_ENABLED: "true",
+    GATEWAY_RUNTIME_PROXY_REQUIRE_AUTH: "false",
+  };
+  const workspaceIngressPublicBaseUrl = readWorkspaceIngressPublicBaseUrl();
+  const ingressPublicBaseUrl =
+    workspaceIngressPublicBaseUrl
+    ?? normalizeIngressUrl(process.env.INGRESS_PUBLIC_BASE_URL);
+  if (ingressPublicBaseUrl) {
+    gatewayEnv.INGRESS_PUBLIC_BASE_URL = ingressPublicBaseUrl;
+    console.log(`   Ingress URL: ${ingressPublicBaseUrl}`);
+    if (!workspaceIngressPublicBaseUrl) {
+      console.log("   (using INGRESS_PUBLIC_BASE_URL env fallback)");
+    }
+  }
+  if (publicUrl) gatewayEnv.GATEWAY_PUBLIC_URL = publicUrl;
+
+  const gateway = spawn("bun", ["run", "src/index.ts"], {
+    cwd: gatewayDir,
+    detached: true,
+    stdio: "ignore",
+    env: gatewayEnv,
+  });
+  gateway.unref();
+  console.log("✅ Gateway started\n");
+  return publicUrl || `http://localhost:${GATEWAY_PORT}`;
+}
+
+async function hatchLocal(species: Species, name: string | null, daemonOnly: boolean = false): Promise<void> {
+  const instanceName =
+    name ?? process.env.VELLUM_ASSISTANT_NAME ?? `${species}-${generateRandomSuffix()}`;
+
+  console.log(`🥚 Hatching local assistant: ${instanceName}`);
+  console.log(`   Species: ${species}`);
+  console.log("");
+
+  await startLocalDaemon();
 
   // The desktop app communicates with the daemon directly via Unix socket,
   // so the HTTP gateway is only needed for non-desktop (CLI) usage.
@@ -1054,40 +1102,7 @@ async function hatchLocal(species: Species, name: string | null, daemonOnly: boo
     // No gateway needed — the macOS app uses DaemonClient over the Unix socket.
     runtimeUrl = "local";
   } else {
-    const publicUrl = await discoverPublicUrl();
-    if (publicUrl) {
-      console.log(`   Public URL: ${publicUrl}`);
-    }
-
-    console.log("🌐 Starting gateway...");
-    const gatewayDir = resolveGatewayDir();
-    const gatewayEnv: Record<string, string> = {
-      ...process.env as Record<string, string>,
-      GATEWAY_RUNTIME_PROXY_ENABLED: "true",
-      GATEWAY_RUNTIME_PROXY_REQUIRE_AUTH: "false",
-    };
-    const workspaceIngressPublicBaseUrl = readWorkspaceIngressPublicBaseUrl();
-    const ingressPublicBaseUrl =
-      workspaceIngressPublicBaseUrl
-      ?? normalizeIngressUrl(process.env.INGRESS_PUBLIC_BASE_URL);
-    if (ingressPublicBaseUrl) {
-      gatewayEnv.INGRESS_PUBLIC_BASE_URL = ingressPublicBaseUrl;
-      console.log(`   Ingress URL: ${ingressPublicBaseUrl}`);
-      if (!workspaceIngressPublicBaseUrl) {
-        console.log("   (using INGRESS_PUBLIC_BASE_URL env fallback)");
-      }
-    }
-    if (publicUrl) gatewayEnv.GATEWAY_PUBLIC_URL = publicUrl;
-
-    const gateway = spawn("bun", ["run", "src/index.ts"], {
-      cwd: gatewayDir,
-      detached: true,
-      stdio: "ignore",
-      env: gatewayEnv,
-    });
-    gateway.unref();
-    console.log("✅ Gateway started\n");
-    runtimeUrl = publicUrl || `http://localhost:${GATEWAY_PORT}`;
+    runtimeUrl = await startGateway();
   }
 
   const baseDataDir = join(process.env.BASE_DATA_DIR?.trim() || (process.env.HOME ?? userInfo().homedir), ".vellum");

package/src/commands/ps.ts

@@ -0,0 +1,92 @@
+import { loadAllAssistants } from "../lib/assistant-config";
+import { checkHealth } from "../lib/health-check";
+import { withStatusEmoji } from "../lib/status-emoji";
+
+interface TableRow {
+  name: string;
+  status: string;
+  info: string;
+}
+
+interface ColWidths {
+  name: number;
+  status: number;
+  info: number;
+}
+
+function pad(s: string, w: number): string {
+  return s + " ".repeat(Math.max(0, w - s.length));
+}
+
+function computeColWidths(rows: TableRow[]): ColWidths {
+  const headers: TableRow = { name: "NAME", status: "STATUS", info: "INFO" };
+  const all = [headers, ...rows];
+  return {
+    name: Math.max(...all.map((r) => r.name.length)),
+    status: Math.max(...all.map((r) => r.status.length), "checking...".length),
+    info: Math.max(...all.map((r) => r.info.length)),
+  };
+}
+
+function formatRow(r: TableRow, colWidths: ColWidths): string {
+  return `  ${pad(r.name, colWidths.name)}  ${pad(r.status, colWidths.status)}  ${r.info}`;
+}
+
+export async function ps(): Promise<void> {
+  const assistants = loadAllAssistants();
+
+  if (assistants.length === 0) {
+    console.log("No assistants found.");
+    return;
+  }
+
+  const rows: TableRow[] = assistants.map((a) => {
+    const infoParts = [a.runtimeUrl];
+    if (a.cloud) infoParts.push(`cloud: ${a.cloud}`);
+    if (a.species) infoParts.push(`species: ${a.species}`);
+
+    return {
+      name: a.assistantId,
+      status: withStatusEmoji("checking..."),
+      info: infoParts.join(" | "),
+    };
+  });
+
+  const colWidths = computeColWidths(rows);
+
+  const headers: TableRow = { name: "NAME", status: "STATUS", info: "INFO" };
+  console.log(formatRow(headers, colWidths));
+  const sep = `  ${"-".repeat(colWidths.name)}  ${"-".repeat(colWidths.status)}  ${"-".repeat(colWidths.info)}`;
+  console.log(sep);
+  for (const row of rows) {
+    console.log(formatRow(row, colWidths));
+  }
+
+  const totalDataRows = rows.length;
+
+  await Promise.all(
+    assistants.map(async (a, rowIndex) => {
+      const health = await checkHealth(a.runtimeUrl);
+
+      const infoParts = [a.runtimeUrl];
+      if (a.cloud) infoParts.push(`cloud: ${a.cloud}`);
+      if (a.species) infoParts.push(`species: ${a.species}`);
+      if (health.detail) infoParts.push(health.detail);
+
+      const updatedRow: TableRow = {
+        name: a.assistantId,
+        status: withStatusEmoji(health.status),
+        info: infoParts.join(" | "),
+      };
+
+      const linesUp = totalDataRows - rowIndex;
+      process.stdout.write(
+        `\x1b[${linesUp}A` +
+          `\r\x1b[K` +
+          formatRow(updatedRow, colWidths) +
+          `\n` +
+          (linesUp > 1 ? `\x1b[${linesUp - 1}B` : ""),
+      );
+    }),
+  );
+}

package/src/commands/wake.ts

@@ -0,0 +1,37 @@
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+import { startLocalDaemon, startGateway } from "./hatch";
+
+export async function wake(): Promise<void> {
+  const vellumDir = join(homedir(), ".vellum");
+  const pidFile = join(vellumDir, "vellum.pid");
+
+  // Check if daemon is already running
+  let daemonRunning = false;
+  if (existsSync(pidFile)) {
+    const pidStr = readFileSync(pidFile, "utf-8").trim();
+    const pid = parseInt(pidStr, 10);
+    if (!isNaN(pid)) {
+      try {
+        process.kill(pid, 0);
+        daemonRunning = true;
+        console.log(`Daemon already running (pid ${pid}).`);
+      } catch {
+        // Process not alive, will start below
+      }
+    }
+  }
+
+  if (!daemonRunning) {
+    await startLocalDaemon();
+  }
+
+  // Start gateway (non-desktop only)
+  if (!process.env.VELLUM_DESKTOP_APP) {
+    await startGateway();
+  }
+
+  console.log("✅ Wake complete.");
+}

package/src/index.ts

@@ -1,13 +1,17 @@
 #!/usr/bin/env bun
 
 import { hatch } from "./commands/hatch";
+import { ps } from "./commands/ps";
 import { retire } from "./commands/retire";
 import { sleep } from "./commands/sleep";
+import { wake } from "./commands/wake";
 
 const commands = {
   hatch,
+  ps,
   retire,
   sleep,
+  wake,
 } as const;
 
 type CommandName = keyof typeof commands;
@@ -21,8 +25,10 @@ async function main() {
     console.log("");
     console.log("Commands:");
     console.log("  hatch    Create a new assistant instance");
+    console.log("  ps       List assistants and their health status");
     console.log("  retire   Delete an assistant instance");
     console.log("  sleep    Stop the daemon process");
+    console.log("  wake     Start the daemon and gateway");
     process.exit(0);
   }
 

package/src/lib/assistant-config.ts

@@ -89,6 +89,10 @@ export function removeAssistantEntry(assistantId: string): void {
   writeAssistants(entries.filter((e) => e.assistantId !== assistantId));
 }
 
+export function loadAllAssistants(): AssistantEntry[] {
+  return readAssistants();
+}
+
 export function saveAssistantEntry(entry: AssistantEntry): void {
   const entries = readAssistants();
   entries.unshift(entry);

package/src/lib/aws.ts

@@ -556,11 +556,29 @@ async function getInstanceIdByName(
   }
 }
 
+async function checkAwsCliAvailable(): Promise<boolean> {
+  try {
+    await execOutput("aws", ["--version"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 export async function retireInstance(
   name: string,
   region: string,
   source?: string,
 ): Promise<void> {
+  const awsOk = await checkAwsCliAvailable();
+  if (!awsOk) {
+    throw new Error(
+      `Cannot retire AWS instance '${name}': AWS CLI is not installed or not in PATH. ` +
+        `Please install the AWS CLI and try again, or terminate the instance manually ` +
+        `via the AWS Console (region=${region}).`,
+    );
+  }
+
   const instanceId = await getInstanceIdByName(name, region);
   if (!instanceId) {
     console.warn(

package/src/lib/gcp.ts

@@ -313,12 +313,30 @@ export async function fetchAndDisplayStartupLogs(
   }
 }
 
+async function checkGcloudAvailable(): Promise<boolean> {
+  try {
+    await execOutput("gcloud", ["--version"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 export async function retireInstance(
   name: string,
   project: string,
   zone: string,
   source?: string,
 ): Promise<void> {
+  const gcloudOk = await checkGcloudAvailable();
+  if (!gcloudOk) {
+    throw new Error(
+      `Cannot retire GCP instance '${name}': gcloud CLI is not installed or not in PATH. ` +
+        `Please install the Google Cloud SDK and try again, or delete the instance manually ` +
+        `via the GCP Console (project=${project}, zone=${zone}).`,
+    );
+  }
+
   const exists = await instanceExists(name, project, zone);
   if (!exists) {
     console.warn(