@vellumai/cli 0.4.4 → 0.4.6

package/package.json

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

package/src/adapters/install.sh

@@ -24,11 +24,33 @@ ensure_git() {
 
     info "Installing git..."
     if [ "$(uname -s)" = "Darwin" ]; then
-        if command -v brew >/dev/null 2>&1; then
-            brew install git
-        else
-            error "git is required. Install Homebrew (https://brew.sh) then run: brew install git"
-            exit 1
+        # On macOS, the standard way to get git is via Xcode Command Line Tools.
+        # Try installing CLT first before falling back to Homebrew.
+        if ! xcode-select -p >/dev/null 2>&1; then
+            info "Installing Xcode Command Line Tools (includes git)..."
+            xcode-select --install 2>/dev/null || true
+            info "Please follow the on-screen dialog to install. Waiting..."
+            local waited=0
+            while ! xcode-select -p >/dev/null 2>&1; do
+                sleep 5
+                waited=$((waited + 5))
+                if [ "$waited" -ge 600 ]; then
+                    error "Timed out waiting for Xcode Command Line Tools. Please install manually and re-run."
+                    exit 1
+                fi
+            done
+            hash -r 2>/dev/null || true
+        fi
+
+        # If git still doesn't work after CLT, try Homebrew as a fallback.
+        if ! git --version >/dev/null 2>&1; then
+            hash -r 2>/dev/null || true
+            if command -v brew >/dev/null 2>&1; then
+                brew install git
+            else
+                error "git is still not available. Please install manually: xcode-select --install"
+                exit 1
+            fi
         fi
     elif command -v apt-get >/dev/null 2>&1; then
         sudo apt-get update -qq && sudo apt-get install -y -qq git

package/src/commands/hatch.ts

@@ -1,8 +1,9 @@
 import { createHash, randomBytes, randomUUID } from "crypto";
-import { appendFileSync, existsSync, lstatSync, mkdirSync, readFileSync, readlinkSync, symlinkSync, unlinkSync } from "fs";
+import { appendFileSync, existsSync, lstatSync, mkdirSync, readFileSync, readlinkSync, symlinkSync, unlinkSync, writeFileSync } from "fs";
 import { homedir, hostname, userInfo } from "os";
 import { join } from "path";
 
+import QRCode from "qrcode";
 import qrcode from "qrcode-terminal";
 
 // Direct import — bun embeds this at compile time so it works in compiled binaries.
@@ -508,7 +509,7 @@ async function displayPairingQRCode(runtimeUrl: string, bearerToken: string | un
     const pairingRequestId = randomUUID();
     const pairingSecret = randomBytes(32).toString("hex");
 
-    const registerRes = await fetch(`${runtimeUrl}/v1/pairing/register`, {
+    const registerRes = await fetch(`${runtimeUrl}/pairing/register`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -539,6 +540,20 @@ async function displayPairingQRCode(runtimeUrl: string, bearerToken: string | un
       });
     });
 
+    // Save QR code as PNG to a well-known location so it can be retrieved
+    // (e.g. via SCP) for pairing through the Desktop app.
+    const qrDir = join(homedir(), ".vellum", "pairing-qr");
+    mkdirSync(qrDir, { recursive: true });
+    const qrPngPath = join(qrDir, "initial.png");
+    try {
+      const pngBuffer = await QRCode.toBuffer(payload, { type: "png", width: 512 });
+      writeFileSync(qrPngPath, pngBuffer);
+      console.log(`QR code PNG saved to ${qrPngPath}\n`);
+    } catch (pngErr) {
+      const pngReason = pngErr instanceof Error ? pngErr.message : String(pngErr);
+      console.warn(`\u26A0 Could not save QR code PNG: ${pngReason}\n`);
+    }
+
     console.log("Scan this QR code with the Vellum iOS app to pair:\n");
     console.log(qrString);
     console.log("This pairing request expires in 5 minutes.");

package/src/components/DefaultMainScreen.tsx

@@ -1347,8 +1347,8 @@ function ChatApp({
           const pairingSecret = randomBytes(32).toString("hex");
           const gatewayUrl = runtimeUrl;
 
-          // Call /v1/pairing/register directly (not under /v1/assistants/:id/)
-          const registerUrl = `${runtimeUrl}/v1/pairing/register`;
+          // Call /pairing/register on the gateway (dedicated pairing proxy route)
+          const registerUrl = `${runtimeUrl}/pairing/register`;
           const registerRes = await fetch(registerUrl, {
             method: "POST",
             headers: {

package/src/lib/local.ts

@@ -1,5 +1,5 @@
 import { execFileSync, spawn } from "child_process";
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, unlinkSync, writeFileSync } from "fs";
 import { createRequire } from "module";
 import { createConnection } from "net";
 import { homedir } from "os";
@@ -11,6 +11,33 @@ import { stopProcessByPidFile } from "./process.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");
   if (!existsSync(pkgPath) || !existsSync(join(dir, "src", "index.ts"))) return false;
@@ -376,18 +403,25 @@ export async function startLocalDaemon(): Promise<void> {
         }
       }
 
-      const child = spawn(daemonBinary, [], {
-        cwd: dirname(daemonBinary),
-        detached: true,
-        stdio: "ignore",
-        env: daemonEnv,
-      });
-      child.unref();
+      const daemonLogFd = openHatchLogFile("daemon.log");
+      let daemonPid: number | undefined;
+      try {
+        const child = spawn(daemonBinary, [], {
+          cwd: dirname(daemonBinary),
+          detached: true,
+          stdio: ["ignore", daemonLogFd, daemonLogFd],
+          env: daemonEnv,
+        });
+        child.unref();
+        daemonPid = child.pid;
+      } finally {
+        closeHatchLogFile(daemonLogFd);
+      }
 
       // Write PID file immediately so the health monitor can find the process
       // and concurrent hatch() calls see it as alive.
-      if (child.pid) {
-        writeFileSync(pidFile, String(child.pid), "utf-8");
+      if (daemonPid) {
+        writeFileSync(pidFile, String(daemonPid), "utf-8");
       }
     }
 
@@ -534,20 +568,30 @@ export async function startGateway(assistantId?: string): Promise<string> {
       );
     }
 
-    gateway = spawn(gatewayBinary, [], {
-      detached: true,
-      stdio: "ignore",
-      env: gatewayEnv,
-    });
+    const gatewayLogFd = openHatchLogFile("gateway.log");
+    try {
+      gateway = spawn(gatewayBinary, [], {
+        detached: true,
+        stdio: ["ignore", gatewayLogFd, gatewayLogFd],
+        env: gatewayEnv,
+      });
+    } finally {
+      closeHatchLogFile(gatewayLogFd);
+    }
   } 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,
-    });
+    const gwLogFd = openHatchLogFile("gateway.log");
+    try {
+      gateway = spawn("bun", ["run", "src/index.ts"], {
+        cwd: gatewayDir,
+        detached: true,
+        stdio: ["ignore", gwLogFd, gwLogFd],
+        env: gatewayEnv,
+      });
+    } finally {
+      closeHatchLogFile(gwLogFd);
+    }
   }
 
   gateway.unref();