@vellumai/cli 0.4.30 → 0.4.31

package/package.json

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

package/src/commands/contacts.ts

@@ -82,10 +82,7 @@ interface ContactChannel {
 interface Contact {
   id: string;
   displayName: string;
-  relationship: string | null;
-  importance: number;
-  responseExpectation: string | null;
-  preferredTone: string | null;
+  notes: string | null;
   lastInteraction: number | null;
   interactionCount: number;
   channels: ContactChannel[];
@@ -109,10 +106,7 @@ function formatContact(c: Contact): string {
   const lines = [
     `  ID:           ${c.id}`,
     `  Name:         ${c.displayName}`,
-    `  Relationship: ${c.relationship ?? "(none)"}`,
-    `  Importance:   ${c.importance.toFixed(2)}`,
-    `  Response:     ${c.responseExpectation ?? "(none)"}`,
-    `  Tone:         ${c.preferredTone ?? "(none)"}`,
+    `  Notes:        ${c.notes ?? "(none)"}`,
     `  Interactions: ${c.interactionCount}`,
   ];
   if (c.lastInteraction) {

package/src/commands/hatch.ts

@@ -39,7 +39,6 @@ import type { PollResult, WatchHatchingResult } from "../lib/gcp";
 import {
   startLocalDaemon,
   startGateway,
-  startOutboundProxy,
   stopLocalProcesses,
 } from "../lib/local";
 import { probePort } from "../lib/port-probe";
@@ -757,8 +756,6 @@ async function hatchLocal(
     throw error;
   }
 
-  await startOutboundProxy(watch);
-
   // Read the bearer token written by the daemon so the client can authenticate
   // with the gateway (which requires auth by default).
   let bearerToken: string | undefined;

package/src/commands/ps.ts

@@ -220,8 +220,6 @@ function formatDetectionInfo(proc: DetectedProcess): string {
 async function getLocalProcesses(entry: AssistantEntry): Promise<TableRow[]> {
   const vellumDir = entry.baseDataDir ?? join(homedir(), ".vellum");
 
-  const PROXY_PORT = Number(process.env.PROXY_PORT) || 7829;
-
   const specs: ProcessSpec[] = [
     {
       name: "assistant",
@@ -241,12 +239,6 @@ async function getLocalProcesses(entry: AssistantEntry): Promise<TableRow[]> {
       port: GATEWAY_PORT,
       pidFile: join(vellumDir, "gateway.pid"),
     },
-    {
-      name: "outbound-proxy",
-      pgrepName: "outbound-proxy",
-      port: PROXY_PORT,
-      pidFile: join(vellumDir, "outbound-proxy.pid"),
-    },
     {
       name: "embed-worker",
       pgrepName: "embed-worker",

package/src/commands/retire.ts

@@ -60,10 +60,6 @@ async function retireLocal(name: string, entry: AssistantEntry): Promise<void> {
   const gatewayPidFile = join(vellumDir, "gateway.pid");
   await stopProcessByPidFile(gatewayPidFile, "gateway");
 
-  // Stop outbound proxy via PID file
-  const outboundProxyPidFile = join(vellumDir, "outbound-proxy.pid");
-  await stopProcessByPidFile(outboundProxyPidFile, "outbound-proxy");
-
   // If the PID file didn't track a running daemon, scan for orphaned
   // daemon processes that may have been started without writing a PID.
   if (!daemonStopped) {

package/src/commands/sleep.ts

@@ -8,7 +8,7 @@ export async function sleep(): Promise<void> {
   if (args.includes("--help") || args.includes("-h")) {
     console.log("Usage: vellum sleep");
     console.log("");
-    console.log("Stop the assistant, gateway, and outbound-proxy processes.");
+    console.log("Stop the assistant and gateway processes.");
     process.exit(0);
   }
 
@@ -16,7 +16,6 @@ export async function sleep(): Promise<void> {
   const daemonPidFile = join(vellumDir, "vellum.pid");
   const socketFile = join(vellumDir, "vellum.sock");
   const gatewayPidFile = join(vellumDir, "gateway.pid");
-  const outboundProxyPidFile = join(vellumDir, "outbound-proxy.pid");
 
   // Stop daemon
   const daemonStopped = await stopProcessByPidFile(daemonPidFile, "daemon", [
@@ -36,14 +35,4 @@ export async function sleep(): Promise<void> {
     console.log("Gateway stopped.");
   }
 
-  // Stop outbound proxy
-  const outboundProxyStopped = await stopProcessByPidFile(
-    outboundProxyPidFile,
-    "outbound-proxy",
-  );
-  if (!outboundProxyStopped) {
-    console.log("Outbound proxy is not running.");
-  } else {
-    console.log("Outbound proxy stopped.");
-  }
 }

package/src/commands/wake.ts

@@ -4,11 +4,7 @@ import { join } from "path";
 
 import { loadAllAssistants } from "../lib/assistant-config";
 import { isProcessAlive, stopProcessByPidFile } from "../lib/process";
-import {
-  startLocalDaemon,
-  startGateway,
-  startOutboundProxy,
-} from "../lib/local";
+import { startLocalDaemon, startGateway } from "../lib/local";
 
 export async function wake(): Promise<void> {
   const args = process.argv.slice(3);
@@ -88,17 +84,5 @@ export async function wake(): Promise<void> {
     }
   }
 
-  // Start outbound proxy
-  const outboundProxyPidFile = join(vellumDir, "outbound-proxy.pid");
-  const outboundProxyStatus = isProcessAlive(outboundProxyPidFile);
-  if (outboundProxyStatus.alive && watch) {
-    // Restart in watch mode
-    console.log(
-      `Outbound proxy running (pid ${outboundProxyStatus.pid}) — restarting in watch mode...`,
-    );
-    await stopProcessByPidFile(outboundProxyPidFile, "outbound-proxy");
-  }
-  await startOutboundProxy(watch);
-
   console.log("✅ Wake complete.");
 }

package/src/lib/local.ts

@@ -79,18 +79,6 @@ function findGatewaySourceFromCwd(): string | undefined {
   }
 }
 
-function isOutboundProxySourceDir(dir: string): boolean {
-  const pkgPath = join(dir, "package.json");
-  if (!existsSync(pkgPath) || !existsSync(join(dir, "src", "main.ts")))
-    return false;
-  try {
-    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-    return pkg.name === "@vellumai/outbound-proxy";
-  } catch {
-    return false;
-  }
-}
-
 function resolveAssistantIndexPath(): string | undefined {
   // Source tree layout: cli/src/lib/ -> ../../.. -> repo root -> assistant/src/index.ts
   const sourceTreeIndex = join(
@@ -354,21 +342,6 @@ function resolveGatewayDir(): string {
   }
 }
 
-function resolveOutboundProxyDir(): string | undefined {
-  // Compiled binary: outbound-proxy/ bundled adjacent to the CLI executable.
-  const binProxy = join(dirname(process.execPath), "outbound-proxy");
-  if (isOutboundProxySourceDir(binProxy)) {
-    return binProxy;
-  }
-
-  try {
-    const pkgPath = _require.resolve("@vellumai/outbound-proxy/package.json");
-    return dirname(pkgPath);
-  } catch {
-    return undefined;
-  }
-}
-
 function normalizeIngressUrl(value: unknown): string | undefined {
   if (typeof value !== "string") return undefined;
   const normalized = value.trim().replace(/\/+$/, "");
@@ -949,130 +922,10 @@ export async function startGateway(
   return gatewayUrl;
 }
 
-export async function startOutboundProxy(
-  watch: boolean = false,
-): Promise<void> {
-  const proxyDir = resolveOutboundProxyDir();
-  if (!proxyDir) {
-    console.log("   ⚠️  Outbound proxy not found — skipping");
-    return;
-  }
-
-  console.log("🔒 Starting outbound proxy...");
-
-  const vellumDir = join(homedir(), ".vellum");
-  mkdirSync(vellumDir, { recursive: true });
-
-  const pidFile = join(vellumDir, "outbound-proxy.pid");
-
-  // Check if already running
-  if (existsSync(pidFile)) {
-    try {
-      const pid = parseInt(readFileSync(pidFile, "utf-8").trim(), 10);
-      if (!isNaN(pid)) {
-        try {
-          process.kill(pid, 0);
-          console.log(`   Outbound proxy already running (pid ${pid})\n`);
-          return;
-        } catch {
-          try {
-            unlinkSync(pidFile);
-          } catch {}
-        }
-      }
-    } catch {}
-  }
-
-  const proxyEnv: Record<string, string> = {
-    ...(process.env as Record<string, string>),
-    PROXY_PORT: process.env.PROXY_PORT || "7829",
-    PROXY_HEALTH_PORT: process.env.PROXY_HEALTH_PORT || "7828",
-  };
-
-  const proxyLogFd = openLogFile("hatch.log");
-
-  let proxy;
-  if (process.env.VELLUM_DESKTOP_APP && !watch) {
-    const proxyBinary = join(
-      dirname(process.execPath),
-      "vellum-outbound-proxy",
-    );
-    if (!existsSync(proxyBinary)) {
-      console.log(
-        "   ⚠️  Outbound proxy binary not found — falling back to source",
-      );
-      const bunArgs = watch
-        ? ["--watch", "run", "src/main.ts"]
-        : ["run", "src/main.ts"];
-      proxy = spawn("bun", bunArgs, {
-        cwd: proxyDir,
-        detached: true,
-        stdio: ["ignore", "pipe", "pipe"],
-        env: proxyEnv,
-      });
-    } else {
-      proxy = spawn(proxyBinary, [], {
-        detached: true,
-        stdio: ["ignore", "pipe", "pipe"],
-        env: proxyEnv,
-      });
-    }
-  } else {
-    const bunArgs = watch
-      ? ["--watch", "run", "src/main.ts"]
-      : ["run", "src/main.ts"];
-    proxy = spawn("bun", bunArgs, {
-      cwd: proxyDir,
-      detached: true,
-      stdio: ["ignore", "pipe", "pipe"],
-      env: proxyEnv,
-    });
-  }
-
-  pipeToLogFile(proxy, proxyLogFd, "outbound-proxy");
-  proxy.unref();
-
-  if (proxy.pid) {
-    writeFileSync(pidFile, String(proxy.pid), "utf-8");
-  }
-
-  if (watch) {
-    console.log("   Outbound proxy started in watch mode (bun --watch)");
-  }
-
-  // Wait for the health endpoint to respond
-  const healthPort = Number(process.env.PROXY_HEALTH_PORT) || 7828;
-  const start = Date.now();
-  const timeoutMs = 15000;
-  let ready = false;
-  while (Date.now() - start < timeoutMs) {
-    try {
-      const res = await fetch(`http://localhost:${healthPort}/healthz`, {
-        signal: AbortSignal.timeout(2000),
-      });
-      if (res.ok) {
-        ready = true;
-        break;
-      }
-    } catch {
-      // Not ready yet
-    }
-    await new Promise((r) => setTimeout(r, 250));
-  }
-
-  if (!ready) {
-    console.warn(
-      "   ⚠️  Outbound proxy started but health check did not respond within 15s",
-    );
-  }
-
-  console.log("✅ Outbound proxy started\n");
-}
-
 /**
- * Stop any locally-running daemon, gateway, and outbound-proxy 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.
+ * 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");
@@ -1083,6 +936,4 @@ export async function stopLocalProcesses(): Promise<void> {
   const gatewayPidFile = join(vellumDir, "gateway.pid");
   await stopProcessByPidFile(gatewayPidFile, "gateway");
 
-  const outboundProxyPidFile = join(vellumDir, "outbound-proxy.pid");
-  await stopProcessByPidFile(outboundProxyPidFile, "outbound-proxy");
 }