@vellumai/cli 0.1.1 → 0.1.2

package/src/commands/retire.ts

@@ -0,0 +1,139 @@
+import { spawn } from "child_process";
+import { rmSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+import { findAssistantByName, removeAssistantEntry } from "../lib/assistant-config";
+import type { AssistantEntry } from "../lib/assistant-config";
+import { retireInstance as retireAwsInstance } from "../lib/aws";
+import { retireInstance as retireGcpInstance } from "../lib/gcp";
+import { exec } from "../lib/step-runner";
+
+function resolveCloud(entry: AssistantEntry): string {
+  if (entry.cloud) {
+    return entry.cloud;
+  }
+  if (entry.project) {
+    return "gcp";
+  }
+  if (entry.sshUser) {
+    return "custom";
+  }
+  return "local";
+}
+
+function extractHostFromUrl(url: string): string {
+  try {
+    const parsed = new URL(url);
+    return parsed.hostname;
+  } catch {
+    return url.replace(/^https?:\/\//, "").split(":")[0];
+  }
+}
+
+async function retireLocal(): Promise<void> {
+  console.log("\u{1F5D1}\ufe0f  Stopping local daemon...\n");
+
+  try {
+    const child = spawn("bunx", ["vellum", "daemon", "stop"], {
+      stdio: "inherit",
+    });
+
+    await new Promise<void>((resolve) => {
+      child.on("close", () => resolve());
+      child.on("error", () => resolve());
+    });
+  } 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 {}
+
+  const vellumDir = join(homedir(), ".vellum");
+  rmSync(vellumDir, { recursive: true, force: true });
+  console.log("\u2705 Local instance retired.");
+}
+
+async function retireCustom(entry: AssistantEntry): Promise<void> {
+  const host = extractHostFromUrl(entry.runtimeUrl);
+  const sshUser = entry.sshUser ?? "root";
+  const sshHost = `${sshUser}@${host}`;
+
+  console.log(`\u{1F5D1}\ufe0f  Retiring custom instance on ${sshHost}...\n`);
+
+  const remoteCmd = [
+    "bunx vellum daemon stop 2>/dev/null || true",
+    "pkill -f gateway 2>/dev/null || true",
+    "rm -rf ~/.vellum",
+  ].join(" && ");
+
+  try {
+    await exec("ssh", [
+      "-o", "StrictHostKeyChecking=no",
+      "-o", "UserKnownHostsFile=/dev/null",
+      "-o", "ConnectTimeout=10",
+      "-o", "LogLevel=ERROR",
+      sshHost,
+      remoteCmd,
+    ]);
+  } catch (error) {
+    console.warn(
+      `\u26a0\ufe0f  Remote cleanup may have partially failed: ${error instanceof Error ? error.message : error}`,
+    );
+  }
+
+  console.log(`\u2705 Custom instance retired.`);
+}
+
+export async function retire(): Promise<void> {
+  const name = process.argv[3];
+
+  if (!name) {
+    console.error("Error: Instance name is required.");
+    console.error("Usage: vellum-cli retire <name>");
+    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.");
+    process.exit(1);
+  }
+
+  const cloud = resolveCloud(entry);
+
+  if (cloud === "gcp") {
+    const project = entry.project;
+    const zone = entry.zone;
+    if (!project || !zone) {
+      console.error("Error: GCP project and zone not found in assistant config.");
+      process.exit(1);
+    }
+    await retireGcpInstance(name, project, zone);
+  } else if (cloud === "aws") {
+    const region = entry.region;
+    if (!region) {
+      console.error("Error: AWS region not found in assistant config.");
+      process.exit(1);
+    }
+    await retireAwsInstance(name, region);
+  } else if (cloud === "local") {
+    await retireLocal();
+  } else if (cloud === "custom") {
+    await retireCustom(entry);
+  } else {
+    console.error(`Error: Unknown cloud type '${cloud}'.`);
+    process.exit(1);
+  }
+
+  removeAssistantEntry(name);
+  console.log(`Removed ${name} from config.`);
+}

package/src/index.ts

@@ -1,9 +1,11 @@
 #!/usr/bin/env bun
 
 import { hatch } from "./commands/hatch";
+import { retire } from "./commands/retire";
 
 const commands = {
   hatch,
+  retire,
 } as const;
 
 type CommandName = keyof typeof commands;
@@ -16,7 +18,8 @@ async function main() {
     console.log("Usage: vellum-cli <command> [options]");
     console.log("");
     console.log("Commands:");
-    console.log("  hatch   Create a new assistant instance");
+    console.log("  hatch    Create a new assistant instance");
+    console.log("  retire   Delete an assistant instance");
     process.exit(0);
   }
 

package/src/lib/assistant-config.ts

@@ -0,0 +1,95 @@
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+export interface AssistantEntry {
+  assistantId: string;
+  runtimeUrl: string;
+  bearerToken?: string;
+  cloud: string;
+  instanceId?: string;
+  project?: string;
+  region?: string;
+  species?: string;
+  sshUser?: string;
+  zone?: string;
+  hatchedAt?: string;
+}
+
+interface LockfileData {
+  assistants?: AssistantEntry[];
+  [key: string]: unknown;
+}
+
+function getLockfilePath(): string {
+  return join(homedir(), ".vellum.lock.json");
+}
+
+function readLockfile(): LockfileData {
+  const lockfilePath = getLockfilePath();
+  if (!existsSync(lockfilePath)) {
+    return {};
+  }
+
+  try {
+    const raw = readFileSync(lockfilePath, "utf-8");
+    const parsed = JSON.parse(raw) as unknown;
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed as LockfileData;
+    }
+  } catch {
+    // Malformed lockfile; return empty
+  }
+  return {};
+}
+
+function writeLockfile(data: LockfileData): void {
+  const lockfilePath = getLockfilePath();
+  writeFileSync(lockfilePath, JSON.stringify(data, null, 2) + "\n");
+}
+
+function readAssistants(): AssistantEntry[] {
+  const data = readLockfile();
+  const entries = data.assistants;
+  if (!Array.isArray(entries)) {
+    return [];
+  }
+  return entries.filter(
+    (e) => typeof e.assistantId === "string" && typeof e.runtimeUrl === "string",
+  );
+}
+
+function writeAssistants(entries: AssistantEntry[]): void {
+  const data = readLockfile();
+  data.assistants = entries;
+  writeLockfile(data);
+}
+
+export function loadLatestAssistant(): AssistantEntry | null {
+  const entries = readAssistants();
+  if (entries.length === 0) {
+    return null;
+  }
+  const sorted = [...entries].sort((a, b) => {
+    const ta = a.hatchedAt ? new Date(a.hatchedAt).getTime() : 0;
+    const tb = b.hatchedAt ? new Date(b.hatchedAt).getTime() : 0;
+    return tb - ta;
+  });
+  return sorted[0];
+}
+
+export function findAssistantByName(name: string): AssistantEntry | null {
+  const entries = readAssistants();
+  return entries.find((e) => e.assistantId === name) ?? null;
+}
+
+export function removeAssistantEntry(assistantId: string): void {
+  const entries = readAssistants();
+  writeAssistants(entries.filter((e) => e.assistantId !== assistantId));
+}
+
+export function saveAssistantEntry(entry: AssistantEntry): void {
+  const entries = readAssistants();
+  entries.unshift(entry);
+  writeAssistants(entries);
+}