@vellumai/cli 0.1.10 → 0.1.12

package/src/commands/ps.ts

@@ -1,6 +1,17 @@
-import { loadAllAssistants } from "../lib/assistant-config";
+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;
@@ -32,7 +43,207 @@ 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> {
+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) {
@@ -90,3 +301,22 @@ export async function ps(): Promise<void> {
     }),
   );
 }
+
+// ── 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

@@ -2,9 +2,18 @@ import { existsSync, readFileSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
 
-import { startLocalDaemon, startGateway } from "./hatch";
+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");
 
@@ -30,7 +39,13 @@ export async function wake(): Promise<void> {
 
   // Start gateway (non-desktop only)
   if (!process.env.VELLUM_DESKTOP_APP) {
-    await startGateway();
+    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.");