@vellumai/cli 0.1.9 → 0.1.11

package/src/commands/ps.ts

@@ -0,0 +1,322 @@
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+import {
+  findAssistantByName,
+  loadAllAssistants,
+  type AssistantEntry,
+} from "../lib/assistant-config";
+import { checkHealth } from "../lib/health-check";
+import { withStatusEmoji } from "../lib/status-emoji";
+import { execOutput } from "../lib/step-runner";
+
+// ── Table formatting helpers ────────────────────────────────────
+
+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}`;
+}
+
+function printTable(rows: TableRow[]): void {
+  const colWidths = computeColWidths(rows);
+  const headers: TableRow = { name: "PROCESS", 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));
+  }
+}
+
+// ── Remote process listing via SSH ──────────────────────────────
+
+const SSH_OPTS = [
+  "-o", "StrictHostKeyChecking=no",
+  "-o", "UserKnownHostsFile=/dev/null",
+  "-o", "ConnectTimeout=10",
+  "-o", "LogLevel=ERROR",
+];
+
+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 -v grep",
+].join(" ");
+
+interface RemoteProcess {
+  pid: string;
+  ppid: string;
+  command: string;
+}
+
+function classifyProcess(command: string): string {
+  if (/qdrant/.test(command)) return "qdrant";
+  if (/gateway/.test(command)) return "gateway";
+  if (/openclaw/.test(command)) return "openclaw-adapter";
+  if (/daemon\s+(start|restart)/.test(command)) return "daemon";
+  if (/vellum/.test(command)) return "vellum";
+  return "unknown";
+}
+
+function parseRemotePs(output: string): RemoteProcess[] {
+  return output
+    .trim()
+    .split("\n")
+    .filter((line) => line.trim().length > 0)
+    .map((line) => {
+      const trimmed = line.trim();
+      const parts = trimmed.split(/\s+/);
+      const pid = parts[0];
+      const ppid = parts[1];
+      const command = parts.slice(2).join(" ");
+      return { pid, ppid, command };
+    });
+}
+
+function extractHostFromUrl(url: string): string {
+  try {
+    const parsed = new URL(url);
+    return parsed.hostname;
+  } catch {
+    return url.replace(/^https?:\/\//, "").split(":")[0];
+  }
+}
+
+function resolveCloud(entry: AssistantEntry): string {
+  if (entry.cloud) return entry.cloud;
+  if (entry.project) return "gcp";
+  if (entry.sshUser) return "custom";
+  return "local";
+}
+
+async function getRemoteProcessesGcp(
+  entry: AssistantEntry,
+): Promise<string> {
+  return execOutput("gcloud", [
+    "compute",
+    "ssh",
+    `${entry.sshUser ?? entry.assistantId}@${entry.assistantId}`,
+    `--zone=${entry.zone}`,
+    `--project=${entry.project}`,
+    `--command=${REMOTE_PS_CMD}`,
+    "--ssh-flag=-o StrictHostKeyChecking=no",
+    "--ssh-flag=-o UserKnownHostsFile=/dev/null",
+    "--ssh-flag=-o ConnectTimeout=10",
+    "--ssh-flag=-o LogLevel=ERROR",
+  ]);
+}
+
+async function getRemoteProcessesCustom(
+  entry: AssistantEntry,
+): Promise<string> {
+  const host = extractHostFromUrl(entry.runtimeUrl);
+  const sshUser = entry.sshUser ?? "root";
+  return execOutput("ssh", [
+    ...SSH_OPTS,
+    `${sshUser}@${host}`,
+    REMOTE_PS_CMD,
+  ]);
+}
+
+async function getLocalProcesses(): Promise<TableRow[]> {
+  const rows: TableRow[] = [];
+  const vellumDir = join(homedir(), ".vellum");
+
+  // Check daemon PID
+  const pidFile = join(vellumDir, "vellum.pid");
+  if (existsSync(pidFile)) {
+    const pid = readFileSync(pidFile, "utf-8").trim();
+    let status = "running";
+    try {
+      process.kill(parseInt(pid, 10), 0);
+    } catch {
+      status = "not running";
+    }
+    rows.push({ name: "daemon", status: withStatusEmoji(status), info: `PID ${pid}` });
+  } else {
+    rows.push({ name: "daemon", status: withStatusEmoji("not running"), info: "no PID file" });
+  }
+
+  // Check qdrant PID
+  const qdrantPidFile = join(vellumDir, "workspace", "data", "qdrant", "qdrant.pid");
+  if (existsSync(qdrantPidFile)) {
+    const pid = readFileSync(qdrantPidFile, "utf-8").trim();
+    let status = "running";
+    try {
+      process.kill(parseInt(pid, 10), 0);
+    } catch {
+      status = "not running";
+    }
+    rows.push({ name: "qdrant", status: withStatusEmoji(status), info: `PID ${pid} | port 6333` });
+  } else {
+    rows.push({ name: "qdrant", status: withStatusEmoji("not running"), info: "no PID file" });
+  }
+
+  // Check gateway via ps
+  try {
+    const output = await execOutput("ps", ["ax", "-o", "pid=,command="]);
+    const gatewayLines = output
+      .split("\n")
+      .filter((l) => /gateway\/src\/index\.ts/.test(l) && !l.includes("grep"));
+    if (gatewayLines.length > 0) {
+      const trimmed = gatewayLines[0].trim();
+      const pid = trimmed.split(/\s+/)[0];
+      rows.push({ name: "gateway", status: withStatusEmoji("running"), info: `PID ${pid} | port 7830` });
+    } else {
+      rows.push({ name: "gateway", status: withStatusEmoji("not running"), info: "" });
+    }
+  } catch {
+    rows.push({ name: "gateway", status: withStatusEmoji("unknown"), info: "" });
+  }
+
+  return rows;
+}
+
+async function showAssistantProcesses(entry: AssistantEntry): Promise<void> {
+  const cloud = resolveCloud(entry);
+
+  console.log(`Processes for ${entry.assistantId} (${cloud}):\n`);
+
+  if (cloud === "local") {
+    const rows = await getLocalProcesses();
+    printTable(rows);
+    return;
+  }
+
+  let output: string;
+  try {
+    if (cloud === "gcp") {
+      output = await getRemoteProcessesGcp(entry);
+    } else if (cloud === "custom") {
+      output = await getRemoteProcessesCustom(entry);
+    } else {
+      console.error(`Unsupported cloud type '${cloud}' for process listing.`);
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(`Failed to list processes: ${error instanceof Error ? error.message : error}`);
+    process.exit(1);
+  }
+
+  const procs = parseRemotePs(output);
+
+  if (procs.length === 0) {
+    console.log("No vellum processes found on the remote instance.");
+    return;
+  }
+
+  const rows: TableRow[] = procs.map((p) => ({
+    name: classifyProcess(p.command),
+    status: withStatusEmoji("running"),
+    info: `PID ${p.pid} | ${p.command.slice(0, 80)}`,
+  }));
+
+  printTable(rows);
+}
+
+// ── List all assistants (no arg) ────────────────────────────────
+
+async function listAllAssistants(): 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` : ""),
+      );
+    }),
+  );
+}
+
+// ── Entry point ─────────────────────────────────────────────────
+
+export async function ps(): Promise<void> {
+  const assistantId = process.argv[3];
+
+  if (!assistantId) {
+    await listAllAssistants();
+    return;
+  }
+
+  const entry = findAssistantByName(assistantId);
+  if (!entry) {
+    console.error(`No assistant found with name '${assistantId}'.`);
+    process.exit(1);
+  }
+
+  await showAssistantProcesses(entry);
+}

package/src/commands/retire.ts

@@ -1,5 +1,5 @@
 import { spawn } from "child_process";
-import { existsSync, readFileSync, rmSync, unlinkSync } from "fs";
+import { rmSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
 
@@ -7,6 +7,7 @@ import { findAssistantByName, removeAssistantEntry } from "../lib/assistant-conf
 import type { AssistantEntry } from "../lib/assistant-config";
 import { retireInstance as retireAwsInstance } from "../lib/aws";
 import { retireInstance as retireGcpInstance } from "../lib/gcp";
+import { stopProcessByPidFile } from "../lib/process";
 import { exec } from "../lib/step-runner";
 
 function resolveCloud(entry: AssistantEntry): string {
@@ -37,39 +38,17 @@ async function retireLocal(): Promise<void> {
   const vellumDir = join(homedir(), ".vellum");
   const isDesktopApp = !!process.env.VELLUM_DESKTOP_APP;
 
-  // Stop daemon via PID file (works for both desktop app and standalone)
-  const pidFile = join(vellumDir, "vellum.pid");
+  // Stop daemon via PID file
+  const daemonPidFile = join(vellumDir, "vellum.pid");
   const socketFile = join(vellumDir, "vellum.sock");
+  await stopProcessByPidFile(daemonPidFile, "daemon", [socketFile]);
 
-  if (existsSync(pidFile)) {
-    try {
-      const pid = parseInt(readFileSync(pidFile, "utf-8").trim(), 10);
-      if (!isNaN(pid)) {
-        try {
-          process.kill(pid, 0); // Check if alive
-          process.kill(pid, "SIGTERM");
-          const deadline = Date.now() + 2000;
-          while (Date.now() < deadline) {
-            try {
-              process.kill(pid, 0);
-              await new Promise((r) => setTimeout(r, 100));
-            } catch {
-              break;
-            }
-          }
-          try {
-            process.kill(pid, 0);
-            process.kill(pid, "SIGKILL");
-          } catch {}
-        } catch {}
-      }
-    } catch {}
-    try { unlinkSync(pidFile); } catch {}
-    try { unlinkSync(socketFile); } catch {}
-  }
+  // Stop gateway via PID file
+  const gatewayPidFile = join(vellumDir, "gateway.pid");
+  await stopProcessByPidFile(gatewayPidFile, "gateway");
 
   if (!isDesktopApp) {
-    // Non-desktop: also stop daemon via bunx (fallback) and kill gateway
+    // Non-desktop: also stop daemon via bunx (fallback)
     try {
       const child = spawn("bunx", ["vellum", "daemon", "stop"], {
         stdio: "inherit",
@@ -81,17 +60,6 @@ async function retireLocal(): Promise<void> {
       });
     } catch {}
 
-    try {
-      const killGateway = spawn("pkill", ["-f", "gateway/src/index.ts"], {
-        stdio: "ignore",
-      });
-
-      await new Promise<void>((resolve) => {
-        killGateway.on("close", () => resolve());
-        killGateway.on("error", () => resolve());
-      });
-    } catch {}
-
     // Only delete ~/.vellum in non-desktop mode
     rmSync(vellumDir, { recursive: true, force: true });
   }

package/src/commands/sleep.ts

@@ -1,63 +1,35 @@
-import { existsSync, readFileSync, unlinkSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
 
-export async function sleep(): Promise<void> {
-  const vellumDir = join(homedir(), ".vellum");
-  const pidFile = join(vellumDir, "vellum.pid");
-  const socketFile = join(vellumDir, "vellum.sock");
-
-  if (!existsSync(pidFile)) {
-    console.log("No daemon PID file found — nothing to stop.");
-    process.exit(0);
-  }
-
-  const pidStr = readFileSync(pidFile, "utf-8").trim();
-  const pid = parseInt(pidStr, 10);
-
-  if (isNaN(pid)) {
-    console.log("Invalid PID file contents — cleaning up.");
-    try { unlinkSync(pidFile); } catch {}
-    try { unlinkSync(socketFile); } catch {}
-    process.exit(0);
-  }
+import { loadAllAssistants } from "../lib/assistant-config";
+import { stopProcessByPidFile } from "../lib/process";
 
-  // Check if process is alive
-  try {
-    process.kill(pid, 0);
-  } catch {
-    console.log(`Daemon process ${pid} is not running — cleaning up stale files.`);
-    try { unlinkSync(pidFile); } catch {}
-    try { unlinkSync(socketFile); } catch {}
-    process.exit(0);
+export async function sleep(): Promise<void> {
+  const assistants = loadAllAssistants();
+  const hasLocal = assistants.some((a) => a.cloud === "local");
+  if (!hasLocal) {
+    console.error("Error: No local assistant found in lock file. Run 'vellum hatch local' first.");
+    process.exit(1);
   }
 
-  console.log(`Stopping daemon (pid ${pid})...`);
-  process.kill(pid, "SIGTERM");
-
-  // Wait up to 2s for graceful exit
-  const deadline = Date.now() + 2000;
-  while (Date.now() < deadline) {
-    try {
-      process.kill(pid, 0);
-      await new Promise((r) => setTimeout(r, 100));
-    } catch {
-      break; // Process exited
-    }
+  const vellumDir = join(homedir(), ".vellum");
+  const daemonPidFile = join(vellumDir, "vellum.pid");
+  const socketFile = join(vellumDir, "vellum.sock");
+  const gatewayPidFile = join(vellumDir, "gateway.pid");
+
+  // Stop daemon
+  const daemonStopped = await stopProcessByPidFile(daemonPidFile, "daemon", [socketFile]);
+  if (!daemonStopped) {
+    console.log("Daemon is not running.");
+  } else {
+    console.log("Daemon stopped.");
   }
 
-  // Force kill if still alive
-  try {
-    process.kill(pid, 0);
-    console.log("Daemon did not exit after SIGTERM, sending SIGKILL...");
-    process.kill(pid, "SIGKILL");
-  } catch {
-    // Already dead
+  // Stop gateway
+  const gatewayStopped = await stopProcessByPidFile(gatewayPidFile, "gateway");
+  if (!gatewayStopped) {
+    console.log("Gateway is not running.");
+  } else {
+    console.log("Gateway stopped.");
   }
-
-  // Clean up PID and socket files
-  try { unlinkSync(pidFile); } catch {}
-  try { unlinkSync(socketFile); } catch {}
-
-  console.log("Daemon stopped.");
 }

package/src/commands/wake.ts

@@ -0,0 +1,52 @@
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+import { loadAllAssistants } from "../lib/assistant-config";
+import { isProcessAlive } from "../lib/process";
+import { startLocalDaemon, startGateway } from "../lib/local";
+
+export async function wake(): Promise<void> {
+  const assistants = loadAllAssistants();
+  const hasLocal = assistants.some((a) => a.cloud === "local");
+  if (!hasLocal) {
+    console.error("Error: No local assistant found in lock file. Run 'vellum hatch local' first.");
+    process.exit(1);
+  }
+
+  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) {
+    const gatewayPidFile = join(vellumDir, "gateway.pid");
+    const { alive, pid } = isProcessAlive(gatewayPidFile);
+    if (alive) {
+      console.log(`Gateway already running (pid ${pid}).`);
+    } else {
+      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 (or processes for a specific assistant)");
     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(