@vellumai/cli 0.4.7 → 0.4.9

package/package.json

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

package/src/adapters/install.sh

@@ -34,10 +34,15 @@ ensure_git() {
             # confirmation.
             touch /tmp/.com.apple.dt.CommandLineTools.installondemand.in-progress
             local clt_package
+            # softwareupdate -l output has two relevant lines per update:
+            #   * Label: Command Line Tools for Xcode-16.0       <-- label (what -i expects)
+            #       Title: Command Line Tools for Xcode, ...      <-- description
+            # We need the label, which is on lines starting with "* ".
+            # Use the same parsing approach as Homebrew's installer.
             clt_package=$(softwareupdate -l 2>/dev/null \
-                | grep -o '.*Command Line Tools.*' \
-                | grep -v "^\*" \
-                | sed 's/^ *//' \
+                | grep -B 1 -E 'Command Line Tools' \
+                | awk -F'*' '/^\*/{print $2}' \
+                | sed -e 's/^ Label: //' -e 's/^ *//' \
                 | sort -V \
                 | tail -1)
 

package/src/commands/hatch.ts

@@ -504,11 +504,40 @@ function installCLISymlink(): void {
   console.log(`   ⚠ Could not create symlink for vellum CLI (tried ${preferredPath} and ${fallbackPath})`);
 }
 
+async function waitForDaemonReady(runtimeUrl: string, bearerToken: string | undefined, timeoutMs = 15000): Promise<boolean> {
+  const start = Date.now();
+  const pollInterval = 1000;
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const res = await fetch(`${runtimeUrl}/v1/health`, {
+        method: "GET",
+        headers: bearerToken ? { Authorization: `Bearer ${bearerToken}` } : {},
+        signal: AbortSignal.timeout(2000),
+      });
+      if (res.ok) return true;
+    } catch {
+      // Daemon not ready yet
+    }
+    await new Promise((r) => setTimeout(r, pollInterval));
+  }
+  return false;
+}
+
 async function displayPairingQRCode(runtimeUrl: string, bearerToken: string | undefined): Promise<void> {
   try {
     const pairingRequestId = randomUUID();
     const pairingSecret = randomBytes(32).toString("hex");
 
+    // The daemon's HTTP server may not be fully ready even though the gateway
+    // health check passed (the gateway is up, but the upstream daemon HTTP
+    // endpoint it proxies to may still be initializing). Poll the daemon's
+    // health endpoint through the gateway to ensure it's reachable.
+    const daemonReady = await waitForDaemonReady(runtimeUrl, bearerToken);
+    if (!daemonReady) {
+      console.warn("⚠ Daemon health check did not pass within 15s. Run `vellum pair` to try again.\n");
+      return;
+    }
+
     const registerRes = await fetch(`${runtimeUrl}/pairing/register`, {
       method: "POST",
       headers: {

package/src/commands/retire.ts

@@ -10,6 +10,7 @@ import { retireInstance as retireGcpInstance } from "../lib/gcp";
 import { stopProcessByPidFile } from "../lib/process";
 import { getArchivePath, getMetadataPath } from "../lib/retire-archive";
 import { exec } from "../lib/step-runner";
+import { openLogFile, closeLogFile, writeToLogFile } from "../lib/xdg-log";
 
 function resolveCloud(entry: AssistantEntry): string {
   if (entry.cloud) {
@@ -120,7 +121,42 @@ function parseSource(): string | undefined {
   return undefined;
 }
 
+/** Patch console methods to also append output to the given log file descriptor. */
+function teeConsoleToLogFile(fd: number | "ignore"): void {
+  if (fd === "ignore") return;
+
+  const origLog = console.log.bind(console);
+  const origWarn = console.warn.bind(console);
+  const origError = console.error.bind(console);
+
+  const timestamp = () => new Date().toISOString();
+
+  console.log = (...args: unknown[]) => {
+    origLog(...args);
+    writeToLogFile(fd, `[${timestamp()}] ${args.map(String).join(" ")}\n`);
+  };
+  console.warn = (...args: unknown[]) => {
+    origWarn(...args);
+    writeToLogFile(fd, `[${timestamp()}] WARN: ${args.map(String).join(" ")}\n`);
+  };
+  console.error = (...args: unknown[]) => {
+    origError(...args);
+    writeToLogFile(fd, `[${timestamp()}] ERROR: ${args.map(String).join(" ")}\n`);
+  };
+}
+
 export async function retire(): Promise<void> {
+  const logFd = process.env.VELLUM_DESKTOP_APP ? openLogFile("retire.log") : "ignore";
+  teeConsoleToLogFile(logFd);
+
+  try {
+    await retireInner();
+  } finally {
+    closeLogFile(logFd);
+  }
+}
+
+async function retireInner(): Promise<void> {
   const args = process.argv.slice(3);
   if (args.includes("--help") || args.includes("-h")) {
     console.log("Usage: vellum retire <name> [--source <source>]");

package/src/components/DefaultMainScreen.tsx

@@ -1884,46 +1884,48 @@ function ChatApp({
         healthStatus={healthStatus}
       />
 
-      {visibleWindow.hiddenAbove > 0 ? (
-        <Text dimColor>
-          {"\u2191"} {visibleWindow.hiddenAbove} more above (Shift+\u2191/Cmd+\u2191)
-        </Text>
-      ) : null}
-
-      {visibleWindow.items.map((item, i) => {
-        const feedIndex = visibleWindow.startIndex + i;
-        if (isRuntimeMessage(item)) {
-          return (
-            <Box key={feedIndex} flexDirection="column" marginBottom={1}>
-              <MessageDisplay msg={item} />
-            </Box>
-          );
-        }
-        if (item.type === "status") {
-          return (
-            <Text key={feedIndex} color={item.color as "green" | "yellow" | "red" | undefined}>
-              {item.text}
-            </Text>
-          );
-        }
-        if (item.type === "help") {
-          return <HelpDisplay key={feedIndex} />;
-        }
-        if (item.type === "error") {
-          return (
-            <Text key={feedIndex} color="red">
-              {item.text}
-            </Text>
-          );
-        }
-        return null;
-      })}
+      <Box flexDirection="column" flexGrow={1} overflow="hidden">
+        {visibleWindow.hiddenAbove > 0 ? (
+          <Text dimColor>
+            {"\u2191"} {visibleWindow.hiddenAbove} more above (Shift+\u2191/Cmd+\u2191)
+          </Text>
+        ) : null}
+
+        {visibleWindow.items.map((item, i) => {
+          const feedIndex = visibleWindow.startIndex + i;
+          if (isRuntimeMessage(item)) {
+            return (
+              <Box key={feedIndex} flexDirection="column" marginBottom={1}>
+                <MessageDisplay msg={item} />
+              </Box>
+            );
+          }
+          if (item.type === "status") {
+            return (
+              <Text key={feedIndex} color={item.color as "green" | "yellow" | "red" | undefined}>
+                {item.text}
+              </Text>
+            );
+          }
+          if (item.type === "help") {
+            return <HelpDisplay key={feedIndex} />;
+          }
+          if (item.type === "error") {
+            return (
+              <Text key={feedIndex} color="red">
+                {item.text}
+              </Text>
+            );
+          }
+          return null;
+        })}
 
-      {visibleWindow.hiddenBelow > 0 ? (
-        <Text dimColor>
-          {"\u2193"} {visibleWindow.hiddenBelow} more below (Shift+\u2193/Cmd+\u2193)
-        </Text>
-      ) : null}
+        {visibleWindow.hiddenBelow > 0 ? (
+          <Text dimColor>
+            {"\u2193"} {visibleWindow.hiddenBelow} more below (Shift+\u2193/Cmd+\u2193)
+          </Text>
+        ) : null}
+      </Box>
 
       {spinnerText ? <SpinnerDisplay text={spinnerText} /> : null}
 

package/src/lib/constants.ts

@@ -51,25 +51,25 @@ export const SPECIES_CONFIG: Record<Species, SpeciesConfig> = {
   vellum: {
     color: ANSI.magenta,
     art: [
-      `${ANSI.magenta}    ,___,${ANSI.reset}`,
-      `${ANSI.magenta}   (${ANSI.reset}${ANSI.bold} O O ${ANSI.reset}${ANSI.magenta})${ANSI.reset}`,
-      `${ANSI.magenta}    /)${ANSI.reset}${ANSI.bold}V${ANSI.reset}${ANSI.magenta}(\\${ANSI.reset}`,
-      `${ANSI.magenta}   //   \\\\${ANSI.reset}`,
-      `${ANSI.magenta}  /"     "\\${ANSI.reset}`,
-      `${ANSI.magenta}  ^       ^${ANSI.reset}`,
+      `${ANSI.magenta}   .-.-.-.${ANSI.reset}`,
+      `${ANSI.magenta}  |${ANSI.reset}${ANSI.bold} o   o ${ANSI.reset}${ANSI.magenta}|${ANSI.reset}`,
+      `${ANSI.magenta}  |${ANSI.reset}${ANSI.bold}  ---  ${ANSI.reset}${ANSI.magenta}|${ANSI.reset}`,
+      `${ANSI.magenta}  |_|_|_|_|${ANSI.reset}`,
+      `${ANSI.magenta}   | | | |${ANSI.reset}`,
+      `${ANSI.magenta}   ^ ^_^ ^${ANSI.reset}`,
     ],
-    hatchedEmoji: "🦉",
+    hatchedEmoji: "👾",
     waitingMessages: [
-      "Warming up the nest...",
+      "Warming up the mothership...",
       "Getting cozy in there...",
-      "Fluffing the feathers...",
-      "Preening in the moonlight...",
+      "Calibrating the antenna...",
+      "Scanning the galaxy...",
     ],
     runningMessages: [
       "Running startup script...",
-      "Teaching the owlet to code...",
-      "Spreading wings...",
-      "Almost ready to take flight...",
+      "Teaching the alien to code...",
+      "Powering up...",
+      "Almost ready to beam down...",
     ],
   },
 };

package/src/lib/local.ts

@@ -1,5 +1,5 @@
 import { execFileSync, spawn } from "child_process";
-import { closeSync, existsSync, mkdirSync, openSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
 import { createRequire } from "module";
 import { createConnection } from "net";
 import { homedir } from "os";
@@ -8,35 +8,10 @@ import { dirname, join } from "path";
 import { loadLatestAssistant } from "./assistant-config.js";
 import { GATEWAY_PORT } from "./constants.js";
 import { stopProcessByPidFile } from "./process.js";
+import { openLogFile, closeLogFile } from "./xdg-log.js";
 
 const _require = createRequire(import.meta.url);
 
-/** Returns the XDG-compatible log directory for Vellum hatch logs. */
-function getHatchLogDir(): string {
-  const configHome = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
-  return join(configHome, "vellum", "logs");
-}
-
-/** Open (or create) a log file in append mode, returning the file descriptor.
- *  Creates the parent directory if it doesn't exist. Returns "ignore" if the
- *  directory or file cannot be created (permissions, read-only filesystem, etc.)
- *  so that spawn falls back to discarding output instead of aborting startup. */
-function openHatchLogFile(name: string): number | "ignore" {
-  try {
-    const dir = getHatchLogDir();
-    mkdirSync(dir, { recursive: true });
-    return openSync(join(dir, name), "a");
-  } catch {
-    return "ignore";
-  }
-}
-
-/** Close a file descriptor returned by openHatchLogFile (no-op for "ignore"). */
-function closeHatchLogFile(fd: number | "ignore"): void {
-  if (typeof fd === "number") {
-    try { closeSync(fd); } catch { /* best-effort */ }
-  }
-}
 
 function isAssistantSourceDir(dir: string): boolean {
   const pkgPath = join(dir, "package.json");
@@ -276,41 +251,76 @@ function isSocketResponsive(socketPath: string, timeoutMs = 1500): Promise<boole
 
 async function discoverPublicUrl(): Promise<string | undefined> {
   const cloud = process.env.VELLUM_CLOUD;
-  if (!cloud || cloud === "local") {
-    return `http://localhost:${GATEWAY_PORT}`;
-  }
 
   let externalIp: string | undefined;
-  try {
-    if (cloud === "gcp") {
-      const resp = await fetch(
-        "http://169.254.169.254/computeMetadata/v1/instance/network-interfaces/0/access-configs/0/external-ip",
-        { headers: { "Metadata-Flavor": "Google" } },
-      );
-      if (resp.ok) externalIp = (await resp.text()).trim();
-    } else if (cloud === "aws") {
-      // Use IMDSv2 (token-based) for compatibility with HttpTokens=required
-      const tokenResp = await fetch(
-        "http://169.254.169.254/latest/api/token",
-        { method: "PUT", headers: { "X-aws-ec2-metadata-token-ttl-seconds": "30" } },
-      );
-      if (tokenResp.ok) {
-        const token = await tokenResp.text();
-        const ipResp = await fetch(
-          "http://169.254.169.254/latest/meta-data/public-ipv4",
-          { headers: { "X-aws-ec2-metadata-token": token } },
+
+  // Try cloud-specific metadata services first for GCP and AWS.
+  if (cloud && cloud !== "local") {
+    try {
+      if (cloud === "gcp") {
+        const resp = await fetch(
+          "http://169.254.169.254/computeMetadata/v1/instance/network-interfaces/0/access-configs/0/external-ip",
+          { headers: { "Metadata-Flavor": "Google" } },
+        );
+        if (resp.ok) externalIp = (await resp.text()).trim();
+      } else if (cloud === "aws") {
+        // Use IMDSv2 (token-based) for compatibility with HttpTokens=required
+        const tokenResp = await fetch(
+          "http://169.254.169.254/latest/api/token",
+          { method: "PUT", headers: { "X-aws-ec2-metadata-token-ttl-seconds": "30" } },
         );
-        if (ipResp.ok) externalIp = (await ipResp.text()).trim();
+        if (tokenResp.ok) {
+          const token = await tokenResp.text();
+          const ipResp = await fetch(
+            "http://169.254.169.254/latest/meta-data/public-ipv4",
+            { headers: { "X-aws-ec2-metadata-token": token } },
+          );
+          if (ipResp.ok) externalIp = (await ipResp.text()).trim();
+        }
       }
+    } catch {
+      // metadata service not reachable
     }
-  } catch {
-    // metadata service not reachable
+  }
+
+  // Fall back to a public IP discovery service for all environments
+  // (local, custom, or when cloud-specific metadata didn't resolve).
+  if (!externalIp) {
+    externalIp = await discoverPublicIpFallback();
   }
 
   if (externalIp) {
     console.log(`   Discovered external IP: ${externalIp}`);
     return `http://${externalIp}:${GATEWAY_PORT}`;
   }
+
+  // Final fallback to localhost when no public IP could be discovered.
+  return `http://localhost:${GATEWAY_PORT}`;
+}
+
+/** Try to discover the machine's public IP using external services.
+ *  Attempts multiple providers for resilience. */
+async function discoverPublicIpFallback(): Promise<string | undefined> {
+  const services = [
+    "https://api.ipify.org",
+    "https://ifconfig.me/ip",
+    "https://icanhazip.com",
+  ];
+
+  for (const url of services) {
+    try {
+      const resp = await fetch(url, { signal: AbortSignal.timeout(3000) });
+      if (resp.ok) {
+        const ip = (await resp.text()).trim();
+        // Basic validation: must look like an IPv4 or IPv6 address
+        if (ip && /^[\d.:a-fA-F]+$/.test(ip)) {
+          return ip;
+        }
+      }
+    } catch {
+      // Service unreachable, try the next one
+    }
+  }
   return undefined;
 }
 
@@ -403,7 +413,7 @@ export async function startLocalDaemon(): Promise<void> {
         }
       }
 
-      const daemonLogFd = openHatchLogFile("daemon.log");
+      const daemonLogFd = openLogFile("daemon.log");
       let daemonPid: number | undefined;
       try {
         const child = spawn(daemonBinary, [], {
@@ -415,7 +425,7 @@ export async function startLocalDaemon(): Promise<void> {
         child.unref();
         daemonPid = child.pid;
       } finally {
-        closeHatchLogFile(daemonLogFd);
+        closeLogFile(daemonLogFd);
       }
 
       // Write PID file immediately so the health monitor can find the process
@@ -568,7 +578,7 @@ export async function startGateway(assistantId?: string): Promise<string> {
       );
     }
 
-    const gatewayLogFd = openHatchLogFile("gateway.log");
+    const gatewayLogFd = openLogFile("gateway.log");
     try {
       gateway = spawn(gatewayBinary, [], {
         detached: true,
@@ -576,12 +586,12 @@ export async function startGateway(assistantId?: string): Promise<string> {
         env: gatewayEnv,
       });
     } finally {
-      closeHatchLogFile(gatewayLogFd);
+      closeLogFile(gatewayLogFd);
     }
   } else {
     // Source tree / bunx: resolve the gateway source directory and run via bun.
     const gatewayDir = resolveGatewayDir();
-    const gwLogFd = openHatchLogFile("gateway.log");
+    const gwLogFd = openLogFile("gateway.log");
     try {
       gateway = spawn("bun", ["run", "src/index.ts"], {
         cwd: gatewayDir,
@@ -590,7 +600,7 @@ export async function startGateway(assistantId?: string): Promise<string> {
         env: gatewayEnv,
       });
     } finally {
-      closeHatchLogFile(gwLogFd);
+      closeLogFile(gwLogFd);
     }
   }
 

package/src/lib/xdg-log.ts

@@ -0,0 +1,37 @@
+import { closeSync, mkdirSync, openSync, writeSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+/** Returns the XDG-compatible log directory for Vellum CLI logs. */
+export function getLogDir(): string {
+  const configHome = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+  return join(configHome, "vellum", "logs");
+}
+
+/** Open (or create) a log file in append mode, returning the file descriptor.
+ *  Creates the parent directory if it doesn't exist. Returns "ignore" if the
+ *  directory or file cannot be created (permissions, read-only filesystem, etc.)
+ *  so that callers can fall back to discarding output instead of aborting. */
+export function openLogFile(name: string): number | "ignore" {
+  try {
+    const dir = getLogDir();
+    mkdirSync(dir, { recursive: true });
+    return openSync(join(dir, name), "a");
+  } catch {
+    return "ignore";
+  }
+}
+
+/** Close a file descriptor returned by openLogFile (no-op for "ignore"). */
+export function closeLogFile(fd: number | "ignore"): void {
+  if (typeof fd === "number") {
+    try { closeSync(fd); } catch { /* best-effort */ }
+  }
+}
+
+/** Write a string to a file descriptor returned by openLogFile (no-op for "ignore"). */
+export function writeToLogFile(fd: number | "ignore", msg: string): void {
+  if (typeof fd === "number") {
+    try { writeSync(fd, msg); } catch { /* best-effort */ }
+  }
+}