@vellumai/assistant 0.4.42 → 0.4.44

package/src/config/bundled-skills/doordash/__tests__/doordash-session.test.ts

@@ -1,24 +1,11 @@
-import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { describe, expect, it } from "bun:test";
 
 import {
   type DoorDashSession,
   getCookieHeader,
   getCsrfToken,
-  importFromRecording,
 } from "../lib/session.js";
 
-// Override getDataDir to use a temp directory during tests
-const TEST_DIR = join(tmpdir(), `vellum-dd-test-${process.pid}`);
-let originalDataDir: string | undefined;
-
-// We mock getDataDir by patching the module at the fs level:
-// session.ts calls getSessionDir() -> join(getDataDir(), 'doordash')
-// We'll test session.ts helpers that don't depend on getDataDir directly,
-// and test the persistence functions via the actual file system with a known path.
-
 function makeCookie(
   name: string,
   value: string,
@@ -85,79 +72,3 @@ describe("DoorDash session helpers", () => {
     });
   });
 });
-
-describe("DoorDash session persistence", () => {
-  // These tests exercise the real loadSession/saveSession/clearSession
-  // by writing to the actual session path. We need to mock getDataDir.
-  // Since the module uses a private function we can't easily mock,
-  // we test via importFromRecording which exercises save+load.
-
-  beforeEach(() => {
-    originalDataDir = process.env.BASE_DATA_DIR;
-    process.env.BASE_DATA_DIR = TEST_DIR;
-    // Ensure test dir exists
-    mkdirSync(TEST_DIR, { recursive: true });
-  });
-
-  afterEach(() => {
-    // Restore original BASE_DATA_DIR
-    if (originalDataDir === undefined) {
-      delete process.env.BASE_DATA_DIR;
-    } else {
-      process.env.BASE_DATA_DIR = originalDataDir;
-    }
-    // Clean up test dir
-    if (existsSync(TEST_DIR)) {
-      rmSync(TEST_DIR, { recursive: true, force: true });
-    }
-  });
-
-  describe("importFromRecording", () => {
-    it("throws when the recording file does not exist", () => {
-      expect(() => importFromRecording("/nonexistent/recording.json")).toThrow(
-        "Recording not found",
-      );
-    });
-
-    it("throws when the recording contains no cookies", () => {
-      const recordingPath = join(TEST_DIR, "empty-recording.json");
-      writeFileSync(
-        recordingPath,
-        JSON.stringify({
-          id: "rec-empty",
-          startedAt: 0,
-          endedAt: 1,
-          targetDomain: "doordash.com",
-          networkEntries: [],
-          cookies: [],
-          observations: [],
-        }),
-      );
-      expect(() => importFromRecording(recordingPath)).toThrow(
-        "Recording contains no cookies",
-      );
-    });
-
-    it("successfully imports a recording with cookies", () => {
-      const recordingPath = join(TEST_DIR, "valid-recording.json");
-      writeFileSync(
-        recordingPath,
-        JSON.stringify({
-          id: "rec-valid",
-          startedAt: 0,
-          endedAt: 1,
-          targetDomain: "doordash.com",
-          networkEntries: [],
-          cookies: [makeCookie("session_id", "xyz")],
-          observations: [],
-        }),
-      );
-      const session = importFromRecording(recordingPath);
-      expect(session.cookies).toHaveLength(1);
-      expect(session.cookies[0].name).toBe("session_id");
-      expect(session.cookies[0].value).toBe("xyz");
-      expect(session.recordingId).toBe("rec-valid");
-      expect(session.importedAt).toBeTruthy();
-    });
-  });
-});

package/src/config/bundled-skills/doordash/doordash-cli.ts

@@ -5,7 +5,8 @@
  * All commands output JSON to stdout. Use --json for machine-readable output.
  */
 
-import * as net from "node:net";
+import { statSync } from "node:fs";
+import { join } from "node:path";
 
 import { Command } from "commander";
 
@@ -32,12 +33,16 @@ import {
 import { extractQueries, saveQueries } from "./lib/query-extractor.js";
 import {
   clearSession,
-  importFromRecording,
+  importFromCredentialStore,
   loadSession,
 } from "./lib/session.js";
-import { createMessageParser, serialize } from "./lib/shared/ipc.js";
 import { NetworkRecorder } from "./lib/shared/network-recorder.js";
-import { getSocketPath, readSessionToken } from "./lib/shared/platform.js";
+import {
+  buildDaemonUrl,
+  getDataDir,
+  getHttpPort,
+  readHttpToken,
+} from "./lib/shared/platform.js";
 import { loadRecording, saveRecording } from "./lib/shared/recording-store.js";
 import type { SessionRecording } from "./lib/shared/recording-types.js";
 
@@ -94,27 +99,10 @@ export function registerDoordashCommand(program: Command): void {
   const dd = program
     .command("doordash")
     .description(
-      "Order food from DoorDash. Requires a session imported from a Ride Shotgun recording.",
+      'Order food from DoorDash. Requires an active session (use "refresh" to authenticate).',
     )
     .option("--json", "Machine-readable JSON output");
 
-  // =========================================================================
-  // login — import session from a recording
-  // =========================================================================
-  dd.command("login")
-    .description("Import a DoorDash session from a Ride Shotgun recording")
-    .requiredOption("--recording <path>", "Path to the recording JSON file")
-    .action(async (opts: { recording: string }, cmd: Command) => {
-      await run(cmd, async () => {
-        const session = importFromRecording(opts.recording);
-        return {
-          message: "Session imported successfully",
-          cookieCount: session.cookies.length,
-          recordingId: session.recordingId,
-        };
-      });
-    });
-
   // =========================================================================
   // logout — clear saved session
   // =========================================================================
@@ -148,13 +136,13 @@ export function registerDoordashCommand(program: Command): void {
         }
 
         const result = await startLearnSession(duration);
-        if (result.recordingPath) {
-          const session = importFromRecording(result.recordingPath);
+        if (result.recordingId) {
+          const session = await importFromCredentialStore("doordash.com");
 
           // Also extract and save captured queries for self-healing
           let queriesCaptured = 0;
           try {
-            const recording = loadRecording(result.recordingId ?? "");
+            const recording = loadRecording(result.recordingId);
             if (recording) {
               const queries = extractQueries(recording);
               if (queries.length > 0) {
@@ -188,7 +176,7 @@ export function registerDoordashCommand(program: Command): void {
           output(
             {
               ok: false,
-              error: "Recording completed but no recording path returned",
+              error: "Recording completed but no recording ID returned",
               recordingId: result.recordingId,
             },
             json,
@@ -958,101 +946,136 @@ async function startLearnSession(
     startUrl: "https://www.doordash.com/consumer/login/",
   });
 
-  // Step 2: Connect to daemon and start recording
-  return new Promise((resolve, reject) => {
-    const socketPath = getSocketPath();
-    const sessionToken = readSessionToken();
-    const socket = net.createConnection(socketPath);
-    const parser = createMessageParser();
-
-    socket.on("error", (err) => {
-      reject(
-        new Error(
-          `Cannot connect to assistant: ${err.message}. Is the assistant running?`,
-        ),
-      );
-    });
+  // Step 2: Start ride-shotgun learn session via HTTP
+  const port = getHttpPort();
+  const baseUrl = buildDaemonUrl(port);
+  const token = readHttpToken();
 
-    // Timeout safety — unref so it doesn't keep process alive
-    const timeoutHandle = setTimeout(
-      () => {
-        socket.destroy();
-        reject(
-          new Error(`Learn session timed out after ${durationSeconds + 30}s`),
-        );
-      },
-      (durationSeconds + 30) * 1000,
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+  };
+  if (token) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+
+  const startResponse = await fetch(
+    `${baseUrl}/v1/computer-use/ride-shotgun/start`,
+    {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        durationSeconds,
+        intervalSeconds: 5,
+        mode: "learn",
+        targetDomain: "doordash.com",
+      }),
+    },
+  );
+
+  if (!startResponse.ok) {
+    const errorBody = await startResponse.text();
+    throw new Error(
+      `Failed to start ride-shotgun session (HTTP ${startResponse.status}): ${errorBody}`,
     );
-    timeoutHandle.unref();
+  }
 
-    let authenticated = !sessionToken; // If no token needed, consider already authenticated
+  const startResult = (await startResponse.json()) as {
+    watchId: string;
+    sessionId: string;
+  };
 
-    const sendStartCommand = () => {
-      socket.write(
-        serialize({
-          type: "ride_shotgun_start",
-          durationSeconds,
-          intervalSeconds: 5,
-          mode: "learn",
-          targetDomain: "doordash.com",
-        } as Record<string, unknown>),
-      );
-    };
+  if (!startResult.watchId) {
+    throw new Error("Ride-shotgun start response missing watchId");
+  }
 
-    socket.on("data", (chunk) => {
-      const messages = parser.feed(chunk.toString("utf-8"));
-      for (const msg of messages) {
-        const m = msg as unknown as Record<string, unknown>;
+  // Step 3: Poll session status endpoint for completion or failure, then
+  // look for the correlated recording file using the recordingId from the session.
+  const { watchId } = startResult;
+  const statusUrl = `${baseUrl}/v1/computer-use/ride-shotgun/status/${watchId}`;
+  const timeoutMs = (durationSeconds + 30) * 1000;
+  const pollIntervalMs = 2000;
+  const startTime = Date.now();
+
+  return new Promise<LearnResult>((resolve, reject) => {
+    const pollOnce = async () => {
+      if (Date.now() - startTime > timeoutMs) {
+        reject(
+          new Error(`Learn session timed out after ${durationSeconds + 30}s`),
+        );
+        return;
+      }
 
-        // Handle auth handshake
-        if (!authenticated && m.type === "auth_result") {
-          if ((m as { success: boolean }).success) {
-            authenticated = true;
-            sendStartCommand();
-          } else {
-            clearTimeout(timeoutHandle);
-            socket.destroy();
-            reject(new Error("Authentication failed"));
+      // Poll session status to detect failures early
+      try {
+        const fetchAbort = AbortSignal.timeout(10_000);
+        const statusRes = await fetch(statusUrl, {
+          headers,
+          signal: fetchAbort,
+        });
+        if (statusRes.ok) {
+          const status = (await statusRes.json()) as {
+            status: string;
+            recordingId?: string;
+            savedRecordingPath?: string;
+            bootstrapFailureReason?: string;
+          };
+
+          // Session failed without producing a recording
+          if (status.bootstrapFailureReason) {
+            reject(
+              new Error(
+                `Learn session failed: ${status.bootstrapFailureReason}`,
+              ),
+            );
+            return;
           }
-          continue;
-        }
 
-        // Skip duplicate auth_result after already authenticated
-        if (m.type === "auth_result") {
-          continue;
-        }
+          // Session completed — check for the correlated recording file
+          if (status.status === "completed") {
+            if (status.savedRecordingPath && status.recordingId) {
+              resolve({
+                recordingId: status.recordingId,
+                recordingPath: status.savedRecordingPath,
+              });
+              return;
+            }
 
-        if (m.type === "ride_shotgun_error") {
-          clearTimeout(timeoutHandle);
-          socket.destroy();
-          reject(new Error((m as { message: string }).message));
-          continue;
-        }
+            // Recording path not in status — fall back to filesystem lookup
+            // using the recordingId for correlation
+            if (status.recordingId) {
+              const recordingsDir = join(getDataDir(), "recordings");
+              const expectedPath = join(
+                recordingsDir,
+                `${status.recordingId}.json`,
+              );
+              try {
+                statSync(expectedPath);
+                resolve({
+                  recordingId: status.recordingId,
+                  recordingPath: expectedPath,
+                });
+                return;
+              } catch {
+                // Recording file not yet written — continue polling
+                setTimeout(pollOnce, pollIntervalMs);
+                return;
+              }
+            }
 
-        if (m.type === "ride_shotgun_result") {
-          clearTimeout(timeoutHandle);
-          socket.destroy();
-          resolve({
-            recordingId: m.recordingId as string | undefined,
-            recordingPath: m.recordingPath as string | undefined,
-          });
+            // Completed but no recordingId — cannot correlate
+            reject(
+              new Error("Learn session completed but no recording was saved."),
+            );
+            return;
+          }
         }
+      } catch {
+        // Status endpoint not reachable — continue polling
       }
-    });
 
-    socket.on("connect", () => {
-      if (sessionToken) {
-        // Send auth and wait for auth_result before sending the command
-        socket.write(
-          serialize({
-            type: "auth",
-            token: sessionToken,
-          } as Record<string, unknown>),
-        );
-      } else {
-        // No auth needed, send command immediately
-        sendStartCommand();
-      }
-    });
+      setTimeout(pollOnce, pollIntervalMs);
+    };
+
+    setTimeout(pollOnce, pollIntervalMs);
   });
 }

package/src/config/bundled-skills/doordash/lib/session.ts

@@ -1,8 +1,9 @@
 /**
  * DoorDash session persistence.
- * Stores/loads auth cookies from a recording or manual login.
+ * Stores/loads auth cookies via the credential store.
  */
 
+import { execFile } from "node:child_process";
 import {
   existsSync,
   mkdirSync,
@@ -11,13 +12,12 @@ import {
   writeFileSync,
 } from "node:fs";
 import { join } from "node:path";
+import { promisify } from "node:util";
 
 import { ConfigError } from "./shared/errors.js";
-import { getDataDir } from "./shared/platform.js";
-import type {
-  ExtractedCredential,
-  SessionRecording,
-} from "./shared/recording-types.js";
+import type { ExtractedCredential } from "./shared/recording-types.js";
+
+const execFileAsync = promisify(execFile);
 
 export interface DoorDashSession {
   cookies: ExtractedCredential[];
@@ -26,7 +26,7 @@ export interface DoorDashSession {
 }
 
 function getSessionDir(): string {
-  return join(getDataDir(), "doordash");
+  return join(process.env.VELLUM_DATA_DIR!, "doordash");
 }
 
 function getSessionPath(): string {
@@ -57,22 +57,25 @@ export function clearSession(): void {
 }
 
 /**
- * Import cookies from a Ride Shotgun recording file.
+ * Import cookies that the daemon saved to the credential store under the
+ * target domain key. Copies them into the local DoorDash session file.
  */
-export function importFromRecording(recordingPath: string): DoorDashSession {
-  if (!existsSync(recordingPath)) {
-    throw new ConfigError(`Recording not found: ${recordingPath}`);
-  }
-  const recording = JSON.parse(
-    readFileSync(recordingPath, "utf-8"),
-  ) as SessionRecording;
-  if (!recording.cookies?.length) {
-    throw new ConfigError("Recording contains no cookies");
+export async function importFromCredentialStore(
+  targetDomain: string,
+): Promise<DoorDashSession> {
+  const { stdout } = await execFileAsync("assistant", [
+    "credentials",
+    "reveal",
+    `${targetDomain}:session:cookies`,
+  ]);
+  const cookies = JSON.parse(stdout.trim()) as ExtractedCredential[];
+  if (!cookies.length) {
+    throw new ConfigError("No cookies found in credential store");
   }
+
   const session: DoorDashSession = {
-    cookies: recording.cookies,
+    cookies,
     importedAt: new Date().toISOString(),
-    recordingId: recording.id,
   };
   saveSession(session);
   return session;

package/src/config/bundled-skills/doordash/lib/shared/platform.ts

@@ -16,19 +16,36 @@ export function getDataDir(): string {
   return join(getRootDir(), "workspace", "data");
 }
 
-export function getSocketPath(): string {
-  const override = process.env.VELLUM_DAEMON_SOCKET?.trim();
-  if (override) {
-    if (override === "~") return homedir();
-    if (override.startsWith("~/")) return join(homedir(), override.slice(2));
-    return override;
+/** Default daemon HTTP port — matches cli/src/lib/constants.ts. */
+const DEFAULT_DAEMON_PORT = 7821;
+
+/**
+ * Resolve the daemon HTTP port from RUNTIME_HTTP_PORT env var or default.
+ */
+export function getHttpPort(): number {
+  const envPort = process.env.RUNTIME_HTTP_PORT;
+  if (envPort) {
+    const parsed = parseInt(envPort, 10);
+    if (!isNaN(parsed)) return parsed;
   }
-  return join(getRootDir(), "vellum.sock");
+  return DEFAULT_DAEMON_PORT;
 }
 
-export function readSessionToken(): string | null {
+/**
+ * Build the base URL for the daemon HTTP server.
+ */
+export function buildDaemonUrl(port?: number): string {
+  return `http://127.0.0.1:${port ?? getHttpPort()}`;
+}
+
+/**
+ * Read the HTTP bearer token from `<rootDir>/http-token`.
+ * Returns null if the token file doesn't exist or is empty.
+ */
+export function readHttpToken(): string | null {
   try {
-    return readFileSync(join(getRootDir(), "session-token"), "utf-8").trim();
+    const token = readFileSync(join(getRootDir(), "http-token"), "utf-8").trim();
+    return token || null;
   } catch {
     return null;
   }

package/src/config/bundled-skills/elevenlabs-voice/SKILL.md

@@ -0,0 +1,140 @@
+---
+name: elevenlabs-voice
+description: Select and tune an ElevenLabs TTS voice — curated voice list, custom/cloned voices via API key, and tuning parameters
+compatibility: "Designed for Vellum personal assistants"
+metadata: {"emoji":"🗣️","vellum":{"display-name":"ElevenLabs Voice","user-invocable":true}}
+---
+
+## Overview
+
+ElevenLabs provides text-to-speech voices for both **in-app TTS** and **phone calls**. The shared config key `elevenlabs.voiceId` controls the voice across all channels. Use the `voice_config_update` tool to change the voice — it writes to the config file and pushes to the macOS app via SSE in one call.
+
+## Choose a Voice
+
+Pick a voice that matches the your identity and the user's preferences. Offer to show the full list if they want to choose themselves.
+
+### Female voices
+
+| Voice     | Style                      | Voice ID               |
+| --------- | -------------------------- | ---------------------- |
+| Rachel    | Calm, warm, conversational | `21m00Tcm4TlvDq8ikWAM` |
+| Sarah     | Soft, young, approachable  | `EXAVITQu4vr4xnSDxMaL` |
+| Charlotte | Warm, Swedish-accented     | `XB0fDUnXU5powFXDhCwa` |
+| Alice     | Confident, British         | `Xb7hH8MSUJpSbSDYk0k2` |
+| Matilda   | Warm, friendly, young      | `XrExE9yKIg1WjnnlVkGX` |
+| Lily      | Warm, British              | `pFZP5JQG7iQjIQuC4Bku` |
+
+### Male voices
+
+| Voice   | Style                           | Voice ID               |
+| ------- | ------------------------------- | ---------------------- |
+| Antoni  | Warm, well-rounded              | `ErXwobaYiN019PkySvjV` |
+| Josh    | Deep, young, clear              | `TxGEqnHWrfWFTfGW9XjX` |
+| Arnold  | Crisp, narrative                | `VR6AewLTigWG4xSOukaG` |
+| Adam    | Deep, middle-aged, professional | `pNInz6obpgDQGcFmaJgB` |
+| Bill    | Trustworthy, American           | `pqHfZKP75CvOlQylNhV4` |
+| George  | Warm, British, distinguished    | `JBFqnCBsd6RMkjVDRZzb` |
+| Daniel  | Authoritative, British          | `onwK4e9ZLuTAKqWW03F9` |
+| Charlie | Casual, Australian              | `IKne3meq5aSn9XLyUdCD` |
+| Liam    | Young, articulate               | `TX3LPaxmHKxFdv7VOQHJ` |
+
+### Setting the voice
+
+To set the chosen voice, use `voice_config_update`. This writes to the config file (`elevenlabs.voiceId`) for phone calls **and** pushes to the macOS app via SSE (`ttsVoiceId`) for in-app TTS in one call:
+
+```
+voice_config_update setting="tts_voice_id" value="<selected-voice-id>"
+```
+
+Verify it worked:
+
+```bash
+assistant config get elevenlabs.voiceId
+```
+
+Tell the user what voice you chose and why, but also offer to show all available voices so they can choose for themselves.
+
+## ElevenLabs API Key Setup
+
+For advanced voice selection (browsing the full library, custom/cloned voices), the user needs an ElevenLabs API key. A free tier is available at https://elevenlabs.io.
+
+To collect the API key securely:
+
+```
+credential_store action="prompt" service="elevenlabs" field="api_key"
+```
+
+## Advanced Voice Selection (with API key)
+
+Users with an ElevenLabs API key can go beyond the curated list above.
+
+### Check for an existing key
+
+```bash
+assistant credentials inspect elevenlabs:api_key --json
+```
+
+### Browse the voice library
+
+```bash
+curl -s "https://api.elevenlabs.io/v2/voices?category=premade&page_size=50" \
+  -H "xi-api-key: $(assistant credentials reveal elevenlabs:api_key)" | python3 -m json.tool
+```
+
+### Search for a specific style
+
+```bash
+curl -s "https://api.elevenlabs.io/v2/voices?search=warm+female&page_size=10" \
+  -H "xi-api-key: $(assistant credentials reveal elevenlabs:api_key)" | python3 -m json.tool
+```
+
+### Custom and cloned voices
+
+If the user has created a custom voice or voice clone in their ElevenLabs account, they can use its voice ID directly. These voices work in both in-app TTS and Twilio ConversationRelay.
+
+### Preview voices
+
+Each voice in the API response includes a `preview_url` with an audio sample the user can listen to before deciding.
+
+### Set the chosen voice
+
+After the user picks a voice from the library:
+
+```
+voice_config_update setting="tts_voice_id" value="<selected-voice-id>"
+```
+
+## Voice Tuning
+
+Fine-tune how the selected voice sounds. These parameters apply to all ElevenLabs modes (in-app TTS and phone calls):
+
+```bash
+# Playback speed (0.7 = slower, 1.0 = normal, 1.2 = faster)
+assistant config set elevenlabs.speed 1.0
+
+# Stability (0.0 = more expressive/variable, 1.0 = more consistent/monotone)
+assistant config set elevenlabs.stability 0.5
+
+# Similarity boost (0.0 = more creative, 1.0 = closer to original voice)
+assistant config set elevenlabs.similarityBoost 0.75
+```
+
+Lower stability makes the voice more expressive but less predictable — good for conversational calls. Higher stability is better for scripted or formal contexts.
+
+## Voice Model Tuning
+
+By default, the system sends a **bare** `voiceId` to Twilio ConversationRelay (no model/tuning suffix). This is the safest default across voice IDs.
+
+To optionally force Twilio's extended voice spec, set a model ID:
+
+```bash
+assistant config set elevenlabs.voiceModelId "flash_v2_5"
+```
+
+When `voiceModelId` is set, the emitted voice string becomes: `voiceId-model-speed_stability_similarity`.
+
+To clear and revert to the bare voiceId default:
+
+```bash
+assistant config set elevenlabs.voiceModelId ""
+```