@vellumai/cli 0.3.0 → 0.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/cli",
-  "version": "0.3.0",
+  "version": "0.3.3",
   "description": "CLI tools for vellum-assistant",
   "type": "module",
   "exports": {

package/src/commands/hatch.ts

@@ -1,11 +1,13 @@
 import { randomBytes } from "crypto";
 import { existsSync, unlinkSync, writeFileSync } from "fs";
-import { createRequire } from "module";
-import { tmpdir, userInfo } from "os";
+import { homedir, tmpdir, userInfo } from "os";
 import { join } from "path";
 
+// Direct import — bun embeds this at compile time so it works in compiled binaries.
+import cliPkg from "../../package.json";
+
 import { buildOpenclawStartupScript } from "../adapters/openclaw";
-import { saveAssistantEntry } from "../lib/assistant-config";
+import { loadAllAssistants, saveAssistantEntry } from "../lib/assistant-config";
 import type { AssistantEntry } from "../lib/assistant-config";
 import { hatchAws } from "../lib/aws";
 import {
@@ -17,7 +19,8 @@ import {
 import type { RemoteHost, Species } from "../lib/constants";
 import { hatchGcp } from "../lib/gcp";
 import type { PollResult, WatchHatchingResult } from "../lib/gcp";
-import { startLocalDaemon, startGateway } from "../lib/local";
+import { startLocalDaemon, startGateway, stopLocalProcesses } from "../lib/local";
+import { isProcessAlive } from "../lib/process";
 import { generateRandomSuffix } from "../lib/random-name";
 import { exec } from "../lib/step-runner";
 
@@ -514,13 +517,36 @@ async function hatchLocal(species: Species, name: string | null, daemonOnly: boo
   const instanceName =
     name ?? process.env.VELLUM_ASSISTANT_NAME ?? `${species}-${generateRandomSuffix()}`;
 
+  // Clean up stale local state: if daemon/gateway processes are running but
+  // the lock file has no entries, stop them before starting fresh.
+  const vellumDir = join(homedir(), ".vellum");
+  const existingAssistants = loadAllAssistants();
+  const localAssistants = existingAssistants.filter((a) => a.cloud === "local");
+  if (localAssistants.length === 0) {
+    const daemonPid = isProcessAlive(join(vellumDir, "vellum.pid"));
+    const gatewayPid = isProcessAlive(join(vellumDir, "gateway.pid"));
+    if (daemonPid.alive || gatewayPid.alive) {
+      console.log("🧹 Cleaning up stale local processes (no lock file entry)...\n");
+      await stopLocalProcesses();
+    }
+  }
+
   console.log(`🥚 Hatching local assistant: ${instanceName}`);
   console.log(`   Species: ${species}`);
   console.log("");
 
   await startLocalDaemon();
 
-  const runtimeUrl = await startGateway();
+  let runtimeUrl: string;
+  try {
+    runtimeUrl = await startGateway();
+  } catch (error) {
+    // Gateway failed — stop the daemon we just started so we don't leave
+    // orphaned processes with no lock file entry.
+    console.error(`\n❌ Gateway startup failed — stopping daemon to avoid orphaned processes.`);
+    await stopLocalProcesses();
+    throw error;
+  }
 
   const baseDataDir = join(process.env.BASE_DATA_DIR?.trim() || (process.env.HOME ?? userInfo().homedir), ".vellum");
   const localEntry: AssistantEntry = {
@@ -545,14 +571,7 @@ async function hatchLocal(species: Species, name: string | null, daemonOnly: boo
 }
 
 function getCliVersion(): string {
-  try {
-    // Use createRequire for JSON import — works in both Bun dev and compiled binary.
-    const require = createRequire(import.meta.url);
-    const pkg = require("../../package.json") as { version?: string };
-    return pkg.version ?? "unknown";
-  } catch {
-    return "unknown";
-  }
+  return cliPkg.version ?? "unknown";
 }
 
 export async function hatch(): Promise<void> {

package/src/index.ts

@@ -1,5 +1,8 @@
 #!/usr/bin/env bun
 
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { spawn } from "node:child_process";
 import { client } from "./commands/client";
 import { hatch } from "./commands/hatch";
 import { ps } from "./commands/ps";
@@ -23,7 +26,7 @@ async function main() {
   const commandName = args[0];
 
   if (!commandName || commandName === "--help" || commandName === "-h") {
-    console.log("Usage: vellum-cli <command> [options]");
+    console.log("Usage: vellum <command> [options]");
     console.log("");
     console.log("Commands:");
     console.log("  client   Connect to a hatched assistant");
@@ -38,9 +41,30 @@ async function main() {
   const command = commands[commandName as CommandName];
 
   if (!command) {
-    console.error(`Error: Unknown command '${commandName}'`);
-    console.error("Run 'vellum-cli --help' for usage information.");
-    process.exit(1);
+    try {
+      const require = createRequire(import.meta.url);
+      const assistantPkgPath = require.resolve(
+        "@vellumai/assistant/package.json"
+      );
+      const assistantEntry = join(
+        dirname(assistantPkgPath),
+        "src",
+        "index.ts"
+      );
+      const child = spawn("bun", ["run", assistantEntry, ...args], {
+        stdio: "inherit",
+      });
+      child.on("exit", (code) => {
+        process.exit(code ?? 1);
+      });
+    } catch {
+      console.error(`Unknown command: ${commandName}`);
+      console.error(
+        "Install the full stack with: bun install -g vellum"
+      );
+      process.exit(1);
+    }
+    return;
   }
 
   try {

package/src/lib/local.ts

@@ -6,6 +6,7 @@ import { dirname, join } from "path";
 
 import { loadAllAssistants, loadLatestAssistant } from "./assistant-config.js";
 import { GATEWAY_PORT } from "./constants.js";
+import { stopProcessByPidFile } from "./process.js";
 
 const _require = createRequire(import.meta.url);
 
@@ -49,11 +50,18 @@ function resolveGatewayDir(): string {
     return override;
   }
 
+  // Source tree: cli/src/lib/ → ../../.. → repo root → gateway/
   const sourceDir = join(import.meta.dir, "..", "..", "..", "gateway");
   if (isGatewaySourceDir(sourceDir)) {
     return sourceDir;
   }
 
+  // Compiled binary: gateway/ bundled adjacent to the CLI executable.
+  const binGateway = join(dirname(process.execPath), "gateway");
+  if (isGatewaySourceDir(binGateway)) {
+    return binGateway;
+  }
+
   const cwdSourceDir = findGatewaySourceFromCwd();
   if (cwdSourceDir) {
     return cwdSourceDir;
@@ -286,7 +294,7 @@ export async function startGateway(): Promise<string> {
   }
 
   console.log("🌐 Starting gateway...");
-  const gatewayDir = resolveGatewayDir();
+
   // Only auto-configure default routing when the workspace has exactly one
   // assistant.  In multi-assistant deployments, falling back to "default"
   // would silently deliver unmapped Telegram chats to whichever assistant was
@@ -323,12 +331,34 @@ export async function startGateway(): Promise<string> {
     console.log(`   Ingress URL: ${ingressPublicBaseUrl}`);
   }
 
-  const gateway = spawn("bun", ["run", "src/index.ts"], {
-    cwd: gatewayDir,
-    detached: true,
-    stdio: "ignore",
-    env: gatewayEnv,
-  });
+  let gateway;
+
+  if (process.env.VELLUM_DESKTOP_APP) {
+    // Desktop app: spawn the compiled gateway binary directly (mirrors daemon pattern).
+    const gatewayBinary = join(dirname(process.execPath), "vellum-gateway");
+    if (!existsSync(gatewayBinary)) {
+      throw new Error(
+        `vellum-gateway binary not found at ${gatewayBinary}.\n` +
+          "  Ensure the gateway binary is bundled alongside the CLI in the app bundle.",
+      );
+    }
+
+    gateway = spawn(gatewayBinary, [], {
+      detached: true,
+      stdio: "ignore",
+      env: gatewayEnv,
+    });
+  } else {
+    // Source tree / bunx: resolve the gateway source directory and run via bun.
+    const gatewayDir = resolveGatewayDir();
+    gateway = spawn("bun", ["run", "src/index.ts"], {
+      cwd: gatewayDir,
+      detached: true,
+      stdio: "ignore",
+      env: gatewayEnv,
+    });
+  }
+
   gateway.unref();
 
   if (gateway.pid) {
@@ -339,3 +369,18 @@ export async function startGateway(): Promise<string> {
   console.log("✅ Gateway started\n");
   return publicUrl || `http://localhost:${GATEWAY_PORT}`;
 }
+
+/**
+ * Stop any locally-running daemon and gateway processes and clean up
+ * PID/socket files. Called when hatch fails partway through so we don't
+ * leave orphaned processes with no lock file entry.
+ */
+export async function stopLocalProcesses(): Promise<void> {
+  const vellumDir = join(homedir(), ".vellum");
+  const daemonPidFile = join(vellumDir, "vellum.pid");
+  const socketFile = join(vellumDir, "vellum.sock");
+  await stopProcessByPidFile(daemonPidFile, "daemon", [socketFile]);
+
+  const gatewayPidFile = join(vellumDir, "gateway.pid");
+  await stopProcessByPidFile(gatewayPidFile, "gateway");
+}