vellum 0.2.1 → 0.2.2

package/src/tools/browser/x-auto-navigate.ts

@@ -0,0 +1,207 @@
+/**
+ * CDP-based auto-navigation for X.com.
+ *
+ * Drives Chrome through key X.com pages to trigger GraphQL API calls,
+ * so the NetworkRecorder captures the full API surface without manual browsing.
+ */
+
+import { getLogger } from '../../util/logger.js';
+
+const log = getLogger('x-auto-navigate');
+
+const CDP_BASE = 'http://localhost:9222';
+
+interface NavStep {
+  label: string;
+  url?: string;
+  clickSelector?: string;
+}
+
+/** Minimal CDP client — connects to one page tab. */
+class MiniCDP {
+  private ws: WebSocket | null = null;
+  private nextId = 1;
+  private callbacks = new Map<number, { resolve: (v: unknown) => void; reject: (e: Error) => void }>();
+
+  async connect(wsUrl: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(wsUrl);
+      ws.onopen = () => { this.ws = ws; resolve(); };
+      ws.onerror = (e) => reject(new Error(`CDP error: ${e}`));
+      ws.onclose = () => { this.ws = null; };
+      ws.onmessage = (event) => {
+        const msg = JSON.parse(String(event.data));
+        if (msg.id != null) {
+          const cb = this.callbacks.get(msg.id);
+          if (cb) {
+            this.callbacks.delete(msg.id);
+            msg.error ? cb.reject(new Error(msg.error.message)) : cb.resolve(msg.result);
+          }
+        }
+      };
+    });
+  }
+
+  async send(method: string, params?: Record<string, unknown>): Promise<unknown> {
+    if (!this.ws) throw new Error('Not connected');
+    const id = this.nextId++;
+    return new Promise((resolve, reject) => {
+      this.callbacks.set(id, { resolve, reject });
+      this.ws!.send(JSON.stringify({ id, method, params }));
+    });
+  }
+
+  close() { this.ws?.close(); }
+}
+
+/**
+ * Navigate Chrome through X.com pages to trigger GraphQL calls.
+ * The NetworkRecorder should already be attached and capturing.
+ *
+ * @param abortSignal Optional signal to stop navigation early.
+ * @returns List of step labels that completed successfully.
+ */
+export async function navigateXPages(abortSignal?: { aborted: boolean }): Promise<string[]> {
+  let wsUrl: string | null = null;
+  try {
+    const res = await fetch(`${CDP_BASE}/json/list`);
+    if (!res.ok) {
+      log.warn('CDP not available for auto-navigation');
+      return [];
+    }
+    const targets = (await res.json()) as Array<{ type: string; url: string; webSocketDebuggerUrl: string }>;
+    const xTab = targets.find(
+      t => t.type === 'page' && (t.url.includes('x.com') || t.url.includes('twitter.com')),
+    );
+    wsUrl = xTab?.webSocketDebuggerUrl ?? targets.find(t => t.type === 'page')?.webSocketDebuggerUrl ?? null;
+  } catch (err) {
+    log.warn({ err }, 'Failed to discover Chrome tabs');
+    return [];
+  }
+
+  if (!wsUrl) {
+    log.warn('No Chrome tab found for auto-navigation');
+    return [];
+  }
+
+  const cdp = new MiniCDP();
+  try {
+    await cdp.connect(wsUrl);
+  } catch (err) {
+    log.warn({ err }, 'Failed to connect CDP for auto-navigation');
+    return [];
+  }
+
+  await cdp.send('Page.enable').catch(() => {});
+  const completed: string[] = [];
+
+  // Navigate to home first to discover the screen name
+  try {
+    await cdp.send('Page.navigate', { url: 'https://x.com/home' });
+    await sleep(3000);
+  } catch (err) {
+    log.warn({ err }, 'Failed to navigate to home');
+    cdp.close();
+    return [];
+  }
+
+  // Resolve screen name for profile-based URLs
+  let screenName: string | null = null;
+  try {
+    const result = await cdp.send('Runtime.evaluate', {
+      expression: `
+        (function() {
+          const link = document.querySelector('a[data-testid="AppTabBar_Profile_Link"]');
+          if (link) return link.getAttribute('href')?.replace('/', '') ?? null;
+          return null;
+        })()
+      `,
+      awaitPromise: false,
+      returnByValue: true,
+    }) as { result?: { value?: string | null } };
+    screenName = result?.result?.value ?? null;
+  } catch { /* ignore */ }
+
+  log.info({ screenName }, 'Detected screen name');
+
+  // Build steps with resolved URLs
+  const steps: NavStep[] = [
+    { label: 'Home timeline', url: 'https://x.com/home' },
+    { label: 'Profile', clickSelector: 'a[data-testid="AppTabBar_Profile_Link"]' },
+    { label: 'Tweet detail', clickSelector: 'article[data-testid="tweet"] a[href*="/status/"]' },
+    { label: 'Search', url: 'https://x.com/search?q=hello&src=typed_query' },
+    { label: 'Bookmarks', url: 'https://x.com/i/bookmarks' },
+    { label: 'Notifications', url: 'https://x.com/notifications' },
+  ];
+
+  // Add profile-based URLs if we have the screen name
+  if (screenName) {
+    steps.push(
+      { label: 'Likes', url: `https://x.com/${screenName}/likes` },
+      { label: 'Followers', url: `https://x.com/${screenName}/followers` },
+      { label: 'Following', url: `https://x.com/${screenName}/following` },
+      { label: 'Media', url: `https://x.com/${screenName}/media` },
+    );
+  }
+
+  for (const step of steps) {
+    if (abortSignal?.aborted) break;
+
+    log.info({ step: step.label }, 'Auto-navigate step starting');
+
+    try {
+      if (step.url) {
+        await cdp.send('Page.navigate', { url: step.url });
+        await sleep(3000);
+      }
+
+      if (step.clickSelector) {
+        await sleep(1500);
+        await clickInPage(cdp, step.clickSelector);
+        await sleep(2000);
+      }
+
+      // Scroll to trigger lazy-loaded content
+      await cdp.send('Runtime.evaluate', {
+        expression: 'window.scrollBy(0, 800)',
+        awaitPromise: false,
+      }).catch(() => {});
+
+      await sleep(2000);
+
+      completed.push(step.label);
+      log.info({ step: step.label }, 'Auto-navigate step completed');
+    } catch (err) {
+      log.warn({ err, step: step.label }, 'Auto-navigate step failed');
+    }
+  }
+
+  cdp.close();
+  log.info({ completed: completed.length, total: steps.length }, 'Auto-navigation finished');
+  return completed;
+}
+
+async function clickInPage(cdp: MiniCDP, selector: string): Promise<boolean> {
+  try {
+    const result = await cdp.send('Runtime.evaluate', {
+      expression: `
+        (function() {
+          const el = document.querySelector(${JSON.stringify(selector)});
+          if (!el) return false;
+          el.scrollIntoView({ block: 'center' });
+          el.click();
+          return true;
+        })()
+      `,
+      awaitPromise: false,
+      returnByValue: true,
+    }) as { result?: { value?: boolean } };
+    return result?.result?.value === true;
+  } catch {
+    return false;
+  }
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise(r => setTimeout(r, ms));
+}

package/src/tools/calls/call-end.ts

@@ -2,13 +2,7 @@ import { RiskLevel } from '../../permissions/types.js';
 import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
 import type { ToolDefinition } from '../../providers/types.js';
 import { registerTool } from '../registry.js';
-import { getCallSession, updateCallSession } from '../../calls/call-store.js';
-import { getCallOrchestrator, unregisterCallOrchestrator } from '../../calls/call-state.js';
-import { activeRelayConnections } from '../../calls/relay-server.js';
-import { TwilioConversationRelayProvider } from '../../calls/twilio-provider.js';
-import { getLogger } from '../../util/logger.js';
-
-const log = getLogger('call-end');
+import { cancelCall } from '../../calls/call-domain.js';
 
 const definition: ToolDefinition = {
   name: 'call_end',
@@ -47,70 +41,26 @@ class CallEndTool implements Tool {
 
     const reason = input.reason as string | undefined;
 
-    try {
-      const session = getCallSession(callSessionId);
-      if (!session) {
-        return { content: `Error: no call session found with ID ${callSessionId}`, isError: true };
-      }
-
-      if (session.status === 'completed' || session.status === 'failed') {
-        return {
-          content: `Call session ${callSessionId} has already ended with status: ${session.status}`,
-          isError: false,
-        };
-      }
-
-      log.info({ callSessionId, reason }, 'Ending call');
-
-      // Terminate the call via the provider API so Twilio hangs up,
-      // even if the relay WebSocket is not connected.
-      if (session.providerCallSid) {
-        try {
-          const provider = new TwilioConversationRelayProvider();
-          await provider.endCall(session.providerCallSid);
-        } catch (endErr) {
-          log.warn({ err: endErr, callSessionId, callSid: session.providerCallSid }, 'Failed to terminate call via provider API — proceeding with cleanup');
-        }
-      }
+    const result = await cancelCall({ callSessionId, reason });
 
-      // End the relay connection if active
-      const relayConnection = activeRelayConnections.get(callSessionId);
-      if (relayConnection) {
-        relayConnection.endSession(reason);
-        relayConnection.destroy();
-        activeRelayConnections.delete(callSessionId);
-      }
-
-      // Clean up orchestrator
-      const orchestrator = getCallOrchestrator(callSessionId);
-      if (orchestrator) {
-        orchestrator.destroy();
-        unregisterCallOrchestrator(callSessionId);
-      }
-
-      // Update session status
-      updateCallSession(callSessionId, {
-        status: 'completed',
-        endedAt: Date.now(),
-      });
-
-      log.info({ callSessionId }, 'Call ended successfully');
-
-      const lines = [
-        'Call ended successfully.',
-        `  Call Session ID: ${callSessionId}`,
-        `  Status: completed`,
-      ];
-      if (reason) {
-        lines.push(`  Reason: ${reason}`);
+    if (!result.ok) {
+      // If the call already ended, report it as a non-error for the tool
+      if (result.status === 409) {
+        return { content: result.error, isError: false };
       }
+      return { content: `Error: ${result.error}`, isError: true };
+    }
 
-      return { content: lines.join('\n'), isError: false };
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      log.error({ err, callSessionId }, 'Failed to end call');
-      return { content: `Error ending call: ${msg}`, isError: true };
+    const lines = [
+      'Call ended successfully.',
+      `  Call Session ID: ${callSessionId}`,
+      `  Status: cancelled`,
+    ];
+    if (reason) {
+      lines.push(`  Reason: ${reason}`);
     }
+
+    return { content: lines.join('\n'), isError: false };
   }
 }
 

package/src/tools/calls/call-start.ts

@@ -2,15 +2,8 @@ import { RiskLevel } from '../../permissions/types.js';
 import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
 import type { ToolDefinition } from '../../providers/types.js';
 import { registerTool } from '../registry.js';
-import { DENIED_NUMBERS } from '../../calls/call-constants.js';
-import { createCallSession, updateCallSession } from '../../calls/call-store.js';
-import { TwilioConversationRelayProvider } from '../../calls/twilio-provider.js';
-import { getTwilioConfig } from '../../calls/twilio-config.js';
-import { getLogger } from '../../util/logger.js';
-
-const log = getLogger('call-start');
-
-const E164_REGEX = /^\+\d+$/;
+import { startCall } from '../../calls/call-domain.js';
+import { getConfig } from '../../config/loader.js';
 
 const definition: ToolDefinition = {
   name: 'call_start',
@@ -47,87 +40,33 @@ class CallStartTool implements Tool {
   }
 
   async execute(input: Record<string, unknown>, context: ToolContext): Promise<ToolExecutionResult> {
-    const phoneNumber = input.phone_number as string | undefined;
-    if (!phoneNumber || typeof phoneNumber !== 'string') {
-      return { content: 'Error: phone_number is required and must be a string', isError: true };
-    }
-
-    if (!E164_REGEX.test(phoneNumber)) {
-      return {
-        content: 'Error: phone_number must be in E.164 format (starts with + followed by digits, e.g. +14155551234)',
-        isError: true,
-      };
+    if (!getConfig().calls.enabled) {
+      return { content: 'Error: Calls feature is disabled via configuration. Set calls.enabled to true to use this feature.', isError: true };
     }
 
-    const task = input.task as string | undefined;
-    if (!task || typeof task !== 'string' || task.trim().length === 0) {
-      return { content: 'Error: task is required and must be a non-empty string', isError: true };
-    }
+    const result = await startCall({
+      phoneNumber: input.phone_number as string,
+      task: input.task as string,
+      context: input.context as string | undefined,
+      conversationId: context.conversationId,
+    });
 
-    if (DENIED_NUMBERS.has(phoneNumber)) {
-      return { content: 'Error: this phone number is not allowed to be called', isError: true };
+    if (!result.ok) {
+      return { content: `Error: ${result.error}`, isError: true };
     }
 
-    const callContext = input.context as string | undefined;
-
-    // Create session outside the try block so it's available in the catch block
-    // for marking as failed if the provider call fails.
-    let sessionId: string | null = null;
-
-    try {
-      const config = getTwilioConfig();
-      const provider = new TwilioConversationRelayProvider();
-
-      const session = createCallSession({
-        conversationId: context.conversationId,
-        provider: 'twilio',
-        fromNumber: config.phoneNumber,
-        toNumber: phoneNumber,
-        task: callContext ? `${task}\n\nContext: ${callContext}` : task,
-      });
-      sessionId = session.id;
-
-      log.info({ callSessionId: session.id, to: phoneNumber, task }, 'Initiating outbound call');
-
-      const baseUrl = config.webhookBaseUrl.replace(/\/$/, '');
-      const { callSid } = await provider.initiateCall({
-        from: config.phoneNumber,
-        to: phoneNumber,
-        webhookUrl: `${baseUrl}/v1/calls/twilio/voice-webhook?callSessionId=${session.id}`,
-        statusCallbackUrl: `${baseUrl}/v1/calls/twilio/status`,
-      });
-
-      updateCallSession(session.id, { providerCallSid: callSid });
-
-      log.info({ callSessionId: session.id, callSid }, 'Call initiated successfully');
-
-      return {
-        content: [
-          'Call initiated successfully.',
-          `  Call Session ID: ${session.id}`,
-          `  Call SID: ${callSid}`,
-          `  To: ${phoneNumber}`,
-          `  Status: initiated`,
-          '',
-          'The AI voice assistant is now placing the call. Use call_status to check progress.',
-        ].join('\n'),
-        isError: false,
-      };
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      log.error({ err, phoneNumber }, 'Failed to initiate call');
-
-      // Mark the session as failed so it doesn't stay in 'initiated' state
-      if (sessionId) {
-        updateCallSession(sessionId, {
-          status: 'failed',
-          endedAt: Date.now(),
-          lastError: msg,
-        });
-      }
-
-      return { content: `Error initiating call: ${msg}`, isError: true };
-    }
+    return {
+      content: [
+        'Call initiated successfully.',
+        `  Call Session ID: ${result.session.id}`,
+        `  Call SID: ${result.callSid}`,
+        `  To: ${result.session.toNumber}`,
+        `  Status: initiated`,
+        '',
+        'The AI voice assistant is now placing the call. Use call_status to check progress.',
+      ].join('\n'),
+      isError: false,
+    };
   }
 }
 

package/src/tools/calls/call-status.ts

@@ -2,10 +2,7 @@ import { RiskLevel } from '../../permissions/types.js';
 import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
 import type { ToolDefinition } from '../../providers/types.js';
 import { registerTool } from '../registry.js';
-import { getCallSession, getActiveCallSessionForConversation, getPendingQuestion } from '../../calls/call-store.js';
-import { getLogger } from '../../util/logger.js';
-
-const log = getLogger('call-status');
+import { getCallStatus } from '../../calls/call-domain.js';
 
 const definition: ToolDefinition = {
   name: 'call_status',
@@ -35,62 +32,49 @@ class CallStatusTool implements Tool {
   async execute(input: Record<string, unknown>, context: ToolContext): Promise<ToolExecutionResult> {
     const callSessionId = input.call_session_id as string | undefined;
 
-    try {
-      let session;
+    const result = getCallStatus(callSessionId, context.conversationId);
 
-      if (callSessionId) {
-        session = getCallSession(callSessionId);
-        if (!session) {
-          return { content: `Error: no call session found with ID ${callSessionId}`, isError: true };
-        }
-      } else {
-        session = getActiveCallSessionForConversation(context.conversationId);
-        if (!session) {
-          return { content: 'No active call found in the current conversation.', isError: false };
-        }
+    if (!result.ok) {
+      // When no active call is found and no specific ID was requested, it's not an error
+      if (!callSessionId && result.error === 'No active call found in the current conversation') {
+        return { content: result.error, isError: false };
       }
+      return { content: `Error: ${result.error}`, isError: true };
+    }
 
-      log.info({ callSessionId: session.id, status: session.status }, 'Checking call status');
-
-      const lines = [
-        `Call Session: ${session.id}`,
-        `  Status: ${session.status}`,
-        `  To: ${session.toNumber}`,
-        `  From: ${session.fromNumber}`,
-      ];
+    const { session } = result;
+    const lines = [
+      `Call Session: ${session.id}`,
+      `  Status: ${session.status}`,
+      `  To: ${session.toNumber}`,
+      `  From: ${session.fromNumber}`,
+    ];
 
-      if (session.providerCallSid) {
-        lines.push(`  Call SID: ${session.providerCallSid}`);
-      }
-
-      if (session.task) {
-        lines.push(`  Task: ${session.task}`);
-      }
+    if (session.providerCallSid) {
+      lines.push(`  Call SID: ${session.providerCallSid}`);
+    }
 
-      if (session.startedAt) {
-        const durationMs = (session.endedAt ?? Date.now()) - session.startedAt;
-        const durationSec = Math.round(durationMs / 1000);
-        lines.push(`  Duration: ${durationSec}s`);
-      }
+    if (session.task) {
+      lines.push(`  Task: ${session.task}`);
+    }
 
-      if (session.lastError) {
-        lines.push(`  Last Error: ${session.lastError}`);
-      }
+    if (session.startedAt) {
+      const durationMs = (session.endedAt ?? Date.now()) - session.startedAt;
+      const durationSec = Math.round(durationMs / 1000);
+      lines.push(`  Duration: ${durationSec}s`);
+    }
 
-      // Check for pending questions from the call
-      const pendingQuestion = getPendingQuestion(session.id);
-      if (pendingQuestion) {
-        lines.push('');
-        lines.push(`  Pending Question: ${pendingQuestion.questionText}`);
-        lines.push(`  Question ID: ${pendingQuestion.id}`);
-      }
+    if (session.lastError) {
+      lines.push(`  Last Error: ${session.lastError}`);
+    }
 
-      return { content: lines.join('\n'), isError: false };
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      log.error({ err, callSessionId }, 'Failed to check call status');
-      return { content: `Error checking call status: ${msg}`, isError: true };
+    if (result.pendingQuestion) {
+      lines.push('');
+      lines.push(`  Pending Question: ${result.pendingQuestion.questionText}`);
+      lines.push(`  Question ID: ${result.pendingQuestion.id}`);
     }
+
+    return { content: lines.join('\n'), isError: false };
   }
 }