@vellumai/cli 0.8.6 → 0.8.7

package/src/lib/__tests__/lifecycle-reporter.test.ts

@@ -0,0 +1,59 @@
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+
+import { consoleLifecycleReporter } from "../lifecycle-reporter.js";
+
+describe("consoleLifecycleReporter", () => {
+  const originalDesktopApp = process.env.VELLUM_DESKTOP_APP;
+  let stdoutWriteSpy: ReturnType<typeof spyOn>;
+
+  beforeEach(() => {
+    stdoutWriteSpy = spyOn(process.stdout, "write").mockImplementation(
+      () => true,
+    );
+  });
+
+  afterEach(() => {
+    stdoutWriteSpy.mockRestore();
+    if (originalDesktopApp === undefined) {
+      delete process.env.VELLUM_DESKTOP_APP;
+    } else {
+      process.env.VELLUM_DESKTOP_APP = originalDesktopApp;
+    }
+  });
+
+  test("routes log/warn/error to the matching console methods", () => {
+    const logSpy = spyOn(console, "log").mockImplementation(() => {});
+    const warnSpy = spyOn(console, "warn").mockImplementation(() => {});
+    const errorSpy = spyOn(console, "error").mockImplementation(() => {});
+
+    consoleLifecycleReporter.log("hello");
+    consoleLifecycleReporter.warn("careful");
+    consoleLifecycleReporter.error("boom");
+
+    expect(logSpy).toHaveBeenCalledWith("hello");
+    expect(warnSpy).toHaveBeenCalledWith("careful");
+    expect(errorSpy).toHaveBeenCalledWith("boom");
+
+    logSpy.mockRestore();
+    warnSpy.mockRestore();
+    errorSpy.mockRestore();
+  });
+
+  test("emits the HATCH_PROGRESS stdout contract under VELLUM_DESKTOP_APP", () => {
+    process.env.VELLUM_DESKTOP_APP = "1";
+
+    consoleLifecycleReporter.progress(3, 6, "Starting assistant...");
+
+    expect(stdoutWriteSpy).toHaveBeenCalledWith(
+      `HATCH_PROGRESS:${JSON.stringify({ step: 3, total: 6, label: "Starting assistant..." })}\n`,
+    );
+  });
+
+  test("suppresses progress output when not running under the desktop app", () => {
+    delete process.env.VELLUM_DESKTOP_APP;
+
+    consoleLifecycleReporter.progress(1, 6, "Allocating resources...");
+
+    expect(stdoutWriteSpy).not.toHaveBeenCalled();
+  });
+});

package/src/lib/assistant-config.ts

@@ -10,6 +10,8 @@ import {
 import { homedir } from "os";
 import { dirname, join } from "path";
 
+import { SEEDS, type EnvironmentDefinition } from "@vellumai/environments";
+
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "./constants.js";
 import {
   getDefaultPorts,
@@ -18,8 +20,6 @@ import {
   getMultiInstanceDir,
 } from "./environments/paths.js";
 import { getCurrentEnvironment } from "./environments/resolve.js";
-import { SEEDS } from "./environments/seeds.js";
-import type { EnvironmentDefinition } from "./environments/types.js";
 import { probePort } from "./port-probe.js";
 
 /**
@@ -631,7 +631,7 @@ export async function allocateLocalResources(
 
   // Env-aware bases: non-prod envs sit in their own 1000-port window so
   // running prod and staging assistants side-by-side doesn't collide. See
-  // `environments/seeds.ts:portBlock` for the layout.
+  // the `@vellumai/environments` `portBlock` layout.
   const basePorts = getDefaultPorts(env);
   const daemonPort = await findAvailablePort(basePorts.daemon, reservedPorts);
   const gatewayPort = await findAvailablePort(basePorts.gateway, [

package/src/lib/environments/__tests__/paths.test.ts

@@ -27,7 +27,8 @@ const {
   getLockfilePaths,
   getMultiInstanceDir,
 } = await import("../paths.js");
-type EnvironmentDefinition = import("../types.js").EnvironmentDefinition;
+type EnvironmentDefinition =
+  import("@vellumai/environments").EnvironmentDefinition;
 
 const prod: EnvironmentDefinition = {
   name: "production",

package/src/lib/environments/__tests__/seeds.test.ts

@@ -1,7 +1,8 @@
 import { describe, expect, test } from "bun:test";
 
+import { SEEDS } from "@vellumai/environments";
+
 import { getDefaultPorts } from "../paths.js";
-import { SEEDS } from "../seeds.js";
 
 describe("SEEDS port blocks", () => {
   test("production uses the legacy (pre-MVP) port layout", () => {

package/src/lib/environments/paths.ts

@@ -1,7 +1,7 @@
 import { homedir } from "os";
 import { join } from "path";
 
-import type { EnvironmentDefinition, PortMap } from "./types.js";
+import type { EnvironmentDefinition, PortMap } from "@vellumai/environments";
 
 const PRODUCTION_ENVIRONMENT_NAME = "production";
 

package/src/lib/environments/resolve.ts

@@ -8,8 +8,7 @@ import {
 import { homedir } from "os";
 import { dirname, join } from "path";
 
-import { SEEDS } from "./seeds.js";
-import type { EnvironmentDefinition } from "./types.js";
+import { SEEDS, type EnvironmentDefinition } from "@vellumai/environments";
 
 const DEFAULT_ENVIRONMENT_NAME = "production";
 
@@ -115,7 +114,7 @@ export function getCurrentEnvironment(
       // writers don't end up in disjoint states on a typo.
       process.stderr.write(
         `warning: unknown environment "${name}"; falling back to "${DEFAULT_ENVIRONMENT_NAME}". ` +
-          `Add it to cli/src/lib/environments/seeds.ts and rebuild if this was intentional.\n`,
+          `Add it to packages/environments/src/seeds.ts and rebuild if this was intentional.\n`,
       );
     }
     const fallback = SEEDS[DEFAULT_ENVIRONMENT_NAME];
@@ -174,5 +173,3 @@ export function resolveEnvironmentSource(override?: string): {
   }
   return { name: DEFAULT_ENVIRONMENT_NAME, source: "default" };
 }
-
-

package/src/lib/guardian-token.ts

@@ -11,9 +11,10 @@ import {
 import { platform } from "os";
 import { dirname, join } from "path";
 
+import { SEEDS } from "@vellumai/environments";
+
 import { getConfigDir } from "./environments/paths.js";
 import { getCurrentEnvironment } from "./environments/resolve.js";
-import { SEEDS } from "./environments/seeds.js";
 
 const DEVICE_ID_SALT = "vellum-assistant-host-id";
 
@@ -176,7 +177,8 @@ export async function refreshGuardianToken(
   // Gateway persists expiresAt as epoch-ms numbers; Date.parse("1234567890000")
   // returns NaN. new Date() accepts both ISO strings and epoch-ms numbers.
   const refreshExpiry = new Date(tokenData.refreshTokenExpiresAt).getTime();
-  if (!Number.isFinite(refreshExpiry) || refreshExpiry <= Date.now()) return null;
+  if (!Number.isFinite(refreshExpiry) || refreshExpiry <= Date.now())
+    return null;
 
   try {
     const response = await fetch(`${gatewayUrl}/v1/guardian/refresh`, {
@@ -191,11 +193,16 @@ export async function refreshGuardianToken(
 
     const json = (await response.json()) as Record<string, unknown>;
     const refreshed: GuardianTokenData = {
-      guardianPrincipalId: (json.guardianPrincipalId as string) ?? tokenData.guardianPrincipalId,
+      guardianPrincipalId:
+        (json.guardianPrincipalId as string) ?? tokenData.guardianPrincipalId,
       accessToken: json.accessToken as string,
-      accessTokenExpiresAt: (json.accessTokenExpiresAt as string | number) ?? tokenData.accessTokenExpiresAt,
+      accessTokenExpiresAt:
+        (json.accessTokenExpiresAt as string | number) ??
+        tokenData.accessTokenExpiresAt,
       refreshToken: (json.refreshToken as string) ?? tokenData.refreshToken,
-      refreshTokenExpiresAt: (json.refreshTokenExpiresAt as string | number) ?? tokenData.refreshTokenExpiresAt,
+      refreshTokenExpiresAt:
+        (json.refreshTokenExpiresAt as string | number) ??
+        tokenData.refreshTokenExpiresAt,
       refreshAfter: (json.refreshAfter as string) ?? tokenData.refreshAfter,
       isNew: false,
       deviceId: tokenData.deviceId,

package/src/lib/hatch-local.ts

@@ -33,7 +33,10 @@ import {
 import { generateInstanceName } from "./random-name.js";
 import { leaseGuardianToken } from "./guardian-token.js";
 import { archiveLogFile, resetLogFile } from "./xdg-log.js";
-import { emitProgress } from "./desktop-progress.js";
+import {
+  consoleLifecycleReporter,
+  type LifecycleReporter,
+} from "./lifecycle-reporter.js";
 import {
   configureHatchProviderApiKey,
   formatProviderName,
@@ -134,6 +137,25 @@ function installCLISymlink(): void {
 
 export interface HatchLocalOptions {
   setupProviderCredentials?: boolean;
+  /**
+   * Sink for progress and log output. Defaults to the console reporter so CLI
+   * callers keep their existing terminal output; in-process callers can inject
+   * their own reporter to consume progress without writing to stdout.
+   */
+  reporter?: LifecycleReporter;
+}
+
+export interface HatchLocalResult {
+  assistantId: string;
+  runtimeUrl: string;
+  localUrl: string;
+  species: Species;
+  /**
+   * Guardian access token leased during hatch, when the lease succeeded. The
+   * full token pair is persisted to disk regardless; this is surfaced so an
+   * in-process caller can prime a connection without re-reading the file.
+   */
+  guardianAccessToken?: string;
 }
 
 export async function hatchLocal(
@@ -143,7 +165,8 @@ export async function hatchLocal(
   keepAlive: boolean = false,
   configValues: Record<string, string> = {},
   options: HatchLocalOptions = {},
-): Promise<void> {
+): Promise<HatchLocalResult> {
+  const reporter = options.reporter ?? consoleLifecycleReporter;
   const provider =
     options.setupProviderCredentials === false
       ? undefined
@@ -153,7 +176,7 @@ export async function hatchLocal(
     name ?? process.env.VELLUM_ASSISTANT_NAME,
   );
 
-  emitProgress(1, 6, "Allocating resources...");
+  reporter.progress(1, 6, "Allocating resources...");
 
   const existing = findAssistantByName(instanceName);
   if (existing && (!existing.cloud || existing.cloud === "local")) {
@@ -175,29 +198,29 @@ export async function hatchLocal(
   archiveLogFile("hatch.log", logsDir);
   resetLogFile("hatch.log");
 
-  console.log(`🥚 Hatching local assistant: ${instanceName}`);
-  console.log(`   Species: ${species}`);
-  console.log("");
+  reporter.log(`🥚 Hatching local assistant: ${instanceName}`);
+  reporter.log(`   Species: ${species}`);
+  reporter.log("");
 
   const apiKeyCheck = checkProviderApiKey();
   if (!apiKeyCheck.hasKey) {
-    console.warn(
+    reporter.warn(
       "Warning: No LLM provider API key is configured. The assistant will fail when you try to send a message.",
     );
-    console.warn("  To fix, export your key before running vellum hatch:");
-    console.warn("  export ANTHROPIC_API_KEY=<your-key>");
-    console.warn("");
+    reporter.warn("  To fix, export your key before running vellum hatch:");
+    reporter.warn("  export ANTHROPIC_API_KEY=<your-key>");
+    reporter.warn("");
   }
 
   if (!process.env.APP_VERSION) {
     process.env.APP_VERSION = cliPkg.version;
   }
 
-  emitProgress(2, 6, "Writing configuration...");
+  reporter.progress(2, 6, "Writing configuration...");
   const hatchConfigValues = buildHatchConfigValues(configValues, provider);
   const defaultWorkspaceConfigPath = writeInitialConfig(hatchConfigValues);
 
-  emitProgress(3, 6, "Starting assistant...");
+  reporter.progress(3, 6, "Starting assistant...");
   const signingKey = generateLocalSigningKey();
   const bootstrapSecret = generateLocalSigningKey();
   await startLocalDaemon(watch, resources, {
@@ -205,14 +228,17 @@ export async function hatchLocal(
     signingKey,
   });
 
-  emitProgress(4, 6, "Starting gateway...");
+  reporter.progress(4, 6, "Starting gateway...");
   let runtimeUrl = `http://127.0.0.1:${resources.gatewayPort}`;
   try {
-    runtimeUrl = await startGateway(watch, resources, { signingKey, bootstrapSecret });
+    runtimeUrl = await startGateway(watch, resources, {
+      signingKey,
+      bootstrapSecret,
+    });
   } catch (error) {
     // Gateway failed — stop the daemon we just started so we don't leave
     // orphaned processes with no lock file entry.
-    console.error(
+    reporter.error(
       `\n❌ Gateway startup failed — stopping assistant to avoid orphaned processes.`,
     );
     await stopLocalProcesses(resources);
@@ -223,24 +249,28 @@ export async function hatchLocal(
   // instead of hitting /v1/guardian/init itself. Use loopback to satisfy
   // the daemon's local-only check — the mDNS runtimeUrl resolves to a LAN
   // IP which the daemon rejects as non-loopback.
-  emitProgress(5, 6, "Securing connection...");
+  reporter.progress(5, 6, "Securing connection...");
   const loopbackUrl = `http://127.0.0.1:${resources.gatewayPort}`;
   const maxLeaseAttempts = 3;
   let guardianAccessToken: string | undefined;
   for (let attempt = 1; attempt <= maxLeaseAttempts; attempt++) {
     try {
-      const tokenData = await leaseGuardianToken(loopbackUrl, instanceName, bootstrapSecret);
+      const tokenData = await leaseGuardianToken(
+        loopbackUrl,
+        instanceName,
+        bootstrapSecret,
+      );
       guardianAccessToken = tokenData.accessToken;
       break;
     } catch (err) {
       if (attempt < maxLeaseAttempts) {
         const delayMs = 2000 * 2 ** (attempt - 1);
-        console.error(
+        reporter.error(
           `⚠️  Guardian token lease attempt ${attempt}/${maxLeaseAttempts} failed — retrying in ${delayMs / 1000}s: ${err}`,
         );
         await new Promise((r) => setTimeout(r, delayMs));
       } else {
-        console.error(
+        reporter.error(
           `⚠️  Guardian token lease failed after ${maxLeaseAttempts} attempts: ${err}\n` +
             `   The assistant is running but guardian-token.json was not written.\n` +
             `   If the desktop app loses its stored credentials, re-hatch to recover.`,
@@ -261,7 +291,7 @@ export async function hatchLocal(
     guardianBootstrapSecret: bootstrapSecret,
   };
 
-  emitProgress(6, 6, "Saving configuration...");
+  reporter.progress(6, 6, "Saving configuration...");
   saveAssistantEntry(localEntry);
   setActiveAssistant(instanceName);
 
@@ -270,13 +300,13 @@ export async function hatchLocal(
   }
 
   if (provider !== undefined && provider !== null && !guardianAccessToken) {
-    console.error(
+    reporter.error(
       `⚠️  Provider credential setup skipped because the guardian token was not leased.\n` +
         `   The assistant is still hatched. Run \`vellum setup --provider ${provider}\` after fixing the connection.`,
     );
   } else if (provider !== undefined) {
-    console.log("");
-    console.log(
+    reporter.log("");
+    reporter.log(
       provider === null
         ? "Checking provider credentials..."
         : `Checking ${formatProviderName(provider)} credentials...`,
@@ -289,14 +319,22 @@ export async function hatchLocal(
     });
   }
 
-  console.log("");
-  console.log(`✅ Local assistant hatched!`);
-  console.log("");
-  console.log("Instance details:");
-  console.log(`  Name: ${instanceName}`);
-  console.log(`  Runtime: ${runtimeUrl}`);
-  console.log("");
-  logHatchNextSteps(console.log, instanceName);
+  reporter.log("");
+  reporter.log(`✅ Local assistant hatched!`);
+  reporter.log("");
+  reporter.log("Instance details:");
+  reporter.log(`  Name: ${instanceName}`);
+  reporter.log(`  Runtime: ${runtimeUrl}`);
+  reporter.log("");
+  logHatchNextSteps((message) => reporter.log(message), instanceName);
+
+  const result: HatchLocalResult = {
+    assistantId: instanceName,
+    runtimeUrl,
+    localUrl: `http://127.0.0.1:${resources.gatewayPort}`,
+    species,
+    guardianAccessToken,
+  };
 
   if (keepAlive) {
     const healthUrl = `http://127.0.0.1:${resources.gatewayPort}/healthz`;
@@ -306,7 +344,7 @@ export async function hatchLocal(
     let consecutiveFailures = 0;
 
     const shutdown = async (): Promise<void> => {
-      console.log("\nShutting down local processes...");
+      reporter.log("\nShutting down local processes...");
       await stopLocalProcesses(resources);
       process.exit(0);
     };
@@ -330,7 +368,7 @@ export async function hatchLocal(
         consecutiveFailures++;
       }
       if (consecutiveFailures >= MAX_FAILURES) {
-        console.log(
+        reporter.log(
           `\n⚠️  ${healthTarget} stopped responding — shutting down.`,
         );
         await stopLocalProcesses(resources);
@@ -338,4 +376,6 @@ export async function hatchLocal(
       }
     }
   }
+
+  return result;
 }

package/src/lib/lifecycle-reporter.ts

@@ -0,0 +1,31 @@
+import { emitProgress } from "./desktop-progress.js";
+
+/**
+ * Sink for the human-facing and structured output of long-running lifecycle
+ * operations (hatch, retire). Injecting it lets an in-process caller (e.g. a
+ * desktop main process embedding these functions) observe progress without the
+ * operation writing to the terminal, while the CLI keeps its existing stdout.
+ */
+export interface LifecycleReporter {
+  /**
+   * Coarse step progress. The CLI reporter mirrors this to the desktop
+   * `HATCH_PROGRESS:` stdout channel.
+   */
+  progress(step: number, total: number, label: string): void;
+  log(message: string): void;
+  warn(message: string): void;
+  error(message: string): void;
+}
+
+/**
+ * Reporter used by the CLI commands: human-readable lines to the console plus
+ * structured step events on the desktop progress channel. Reproduces the exact
+ * terminal output — and the `HATCH_PROGRESS:` lines under `VELLUM_DESKTOP_APP` —
+ * that existing subprocess consumers parse.
+ */
+export const consoleLifecycleReporter: LifecycleReporter = {
+  progress: (step, total, label) => emitProgress(step, total, label),
+  log: (message) => console.log(message),
+  warn: (message) => console.warn(message),
+  error: (message) => console.error(message),
+};

package/src/lib/retire-local.ts

@@ -3,22 +3,34 @@ import { homedir } from "os";
 import { existsSync, mkdirSync, renameSync, writeFileSync } from "fs";
 import { basename, dirname, join } from "path";
 
-import {
-  getDaemonPidPath,
-  loadAllAssistants,
-} from "./assistant-config.js";
+import { getDaemonPidPath, loadAllAssistants } from "./assistant-config.js";
 import type { AssistantEntry } from "./assistant-config.js";
 import {
   stopOrphanedDaemonProcesses,
   stopProcessByPidFile,
 } from "./process.js";
 import { getArchivePath, getMetadataPath } from "./retire-archive.js";
+import {
+  consoleLifecycleReporter,
+  type LifecycleReporter,
+} from "./lifecycle-reporter.js";
+
+export interface RetireLocalResult {
+  assistantId: string;
+  /** Whether the instance data directory was archived (false when skipped). */
+  archived: boolean;
+  /** Path to the background tar archive, when archiving was started. */
+  archivePath?: string;
+  /** True when another local assistant shared the data dir, so it was kept. */
+  sharedDataDir?: boolean;
+}
 
 export async function retireLocal(
   name: string,
   entry: AssistantEntry,
-): Promise<void> {
-  console.log("\u{1F5D1}\ufe0f  Stopping local assistant...\n");
+  reporter: LifecycleReporter = consoleLifecycleReporter,
+): Promise<RetireLocalResult> {
+  reporter.log("\u{1F5D1}\ufe0f  Stopping local assistant...\n");
 
   if (!entry.resources) {
     throw new Error(
@@ -38,11 +50,11 @@ export async function retireLocal(
   });
 
   if (otherSharesDir) {
-    console.log(
+    reporter.log(
       `   Skipping process stop and archive — another local assistant shares ${vellumDir}.`,
     );
-    console.log("\u2705 Local instance retired (config entry removed only).");
-    return;
+    reporter.log("\u2705 Local instance retired (config entry removed only).");
+    return { assistantId: name, archived: false, sharedDataDir: true };
   }
 
   const daemonPidFile = getDaemonPidPath(resources);
@@ -87,11 +99,11 @@ export async function retireLocal(
   const stagingDir = `${archivePath}.staging`;
 
   if (!existsSync(dirToArchive)) {
-    console.log(
+    reporter.log(
       `   No data directory at ${dirToArchive} — nothing to archive.`,
     );
-    console.log("\u2705 Local instance retired.");
-    return;
+    reporter.log("\u2705 Local instance retired.");
+    return { assistantId: name, archived: false };
   }
 
   // Ensure the retired archive directory exists before attempting the rename
@@ -123,6 +135,8 @@ export async function retireLocal(
   });
   child.unref();
 
-  console.log(`📦 Archiving to ${archivePath} in the background.`);
-  console.log("\u2705 Local instance retired.");
+  reporter.log(`📦 Archiving to ${archivePath} in the background.`);
+  reporter.log("\u2705 Local instance retired.");
+
+  return { assistantId: name, archived: true, archivePath };
 }

package/src/lib/segments-to-plain-text.ts

@@ -0,0 +1,35 @@
+/**
+ * Derive a message's flat plain-text body from its ordered text segments.
+ *
+ * Mirrors the daemon's `joinWithSpacing` (assistant `daemon/handlers/shared.ts`):
+ * adjacent segments are concatenated, inserting a single space between two
+ * segments only when neither the end of the left nor the start of the right is
+ * already whitespace. Keeping these byte-identical means CLI-rendered text
+ * matches what the daemon would have produced for the now-removed flat
+ * `content` field.
+ */
+export function segmentsToPlainText(segments: string[] | undefined): string {
+  if (!segments || segments.length === 0) {
+    return "";
+  }
+  let result = segments[0] ?? "";
+  for (let i = 1; i < segments.length; i++) {
+    const prev = result[result.length - 1];
+    const next = segments[i]![0];
+    // Only insert a space when neither side already has whitespace.
+    if (
+      prev &&
+      next &&
+      prev !== " " &&
+      prev !== "\n" &&
+      prev !== "\t" &&
+      next !== " " &&
+      next !== "\n" &&
+      next !== "\t"
+    ) {
+      result += " ";
+    }
+    result += segments[i];
+  }
+  return result;
+}