vellum 0.2.0 → 0.2.2

package/src/daemon/ride-shotgun-handler.ts

@@ -15,12 +15,30 @@ import { getLogger } from '../util/logger.js';
 import { NetworkRecorder } from '../tools/browser/network-recorder.js';
 import { saveRecording } from '../tools/browser/recording-store.js';
 import type { SessionRecording } from '../tools/browser/network-recording-types.js';
+import { navigateXPages } from '../tools/browser/x-auto-navigate.js';
+import { autoNavigate } from '../tools/browser/auto-navigate.js';
 
 const log = getLogger('ride-shotgun-handler');
 
 /** Active network recorders keyed by watchId. */
 const activeRecorders = new Map<string, NetworkRecorder>();
 
+/** Return domain-specific URL patterns that indicate a successful login. */
+function getLoginSignals(targetDomain?: string): string[] {
+  if (targetDomain === 'x.com' || targetDomain === 'twitter.com') {
+    return [
+      '/i/api/graphql/',       // any authenticated GraphQL call
+      '/1.1/account/settings', // legacy API session check
+    ];
+  }
+  // DoorDash and general fallback
+  return [
+    '/graphql/postLoginQuery',
+    '/graphql/homePageFacetFeed',
+    '/graphql/getConsumerOrdersWithDetails',
+  ];
+}
+
 /**
  * Complete a session — finalize recording (if learn mode), generate summary, fire notifier.
  * Shared by both the duration timeout and the early-stop handler.
@@ -106,11 +124,7 @@ export async function handleRideShotgunStart(
         }
         try {
           const recorder = new NetworkRecorder(targetDomain);
-          recorder.loginSignals = [
-            '/graphql/postLoginQuery',
-            '/graphql/homePageFacetFeed',
-            '/graphql/getConsumerOrdersWithDetails',
-          ];
+          recorder.loginSignals = getLoginSignals(targetDomain);
           await recorder.startDirect();
           // If session completed while we were connecting, stop immediately to avoid leak
           if (session.status !== 'active') {
@@ -118,13 +132,63 @@ export async function handleRideShotgunStart(
             await recorder.stop();
             return;
           }
-          // Auto-stop when login is detected
-          recorder.onLoginDetected = () => {
-            log.info({ watchId }, 'Login detected — auto-stopping learn session');
-            completeSession(session);
-          };
           activeRecorders.set(watchId, recorder);
           log.info({ watchId, targetDomain, attempt }, 'Network recording started for learn session');
+
+          // For x.com, auto-navigate Chrome through key pages to capture the full API surface.
+          // Skip login detection — auto-navigation will complete the session when done.
+          if (targetDomain === 'x.com' || targetDomain === 'twitter.com') {
+            // Don't set onLoginDetected — it would kill the session after the first
+            // GraphQL call (5s grace), before auto-navigation finishes.
+            const abortSignal = { aborted: false };
+            const checkInterval = setInterval(() => {
+              if (session.status !== 'active') {
+                abortSignal.aborted = true;
+                clearInterval(checkInterval);
+              }
+            }, 1000);
+            navigateXPages(abortSignal).then(completed => {
+              clearInterval(checkInterval);
+              log.info({ watchId, completedSteps: completed.length }, 'X auto-navigation finished');
+              if (session.status === 'active') {
+                completeSession(session);
+              }
+            }).catch(err => {
+              clearInterval(checkInterval);
+              log.warn({ err, watchId }, 'X auto-navigation failed');
+              if (session.status === 'active') {
+                completeSession(session);
+              }
+            });
+          } else if (msg.autoNavigate && targetDomain) {
+            const abortSignal = { aborted: false };
+            const checkInterval = setInterval(() => {
+              if (session.status !== 'active') {
+                abortSignal.aborted = true;
+                clearInterval(checkInterval);
+              }
+            }, 1000);
+            autoNavigate(targetDomain, abortSignal).then(visited => {
+              clearInterval(checkInterval);
+              log.info({ watchId, visitedPages: visited.length }, 'Generic auto-navigation finished');
+              if (session.status === 'active') {
+                completeSession(session);
+              }
+            }).catch(err => {
+              clearInterval(checkInterval);
+              log.warn({ err, watchId }, 'Generic auto-navigation failed');
+              if (session.status === 'active') {
+                completeSession(session);
+              }
+            });
+          } else {
+            // No targetDomain: use login detection as before
+            recorder.onLoginDetected = () => {
+              log.info({ watchId }, 'Login detected — auto-stopping learn session');
+              completeSession(session);
+            };
+          }
+
           return;
         } catch (err) {
           if (attempt < 9) {

package/src/daemon/server.ts

@@ -1,6 +1,6 @@
 import * as net from 'node:net';
 import { randomBytes } from 'node:crypto';
-import { existsSync, chmodSync, writeFileSync, unlinkSync, readdirSync, watch, type FSWatcher } from 'node:fs';
+import { existsSync, chmodSync, readFileSync, writeFileSync, unlinkSync, readdirSync, watch, type FSWatcher } from 'node:fs';
 import { join } from 'node:path';
 import { getSocketPath, getSessionTokenPath, getRootDir, getWorkspaceDir, getWorkspaceSkillsDir, getSandboxWorkingDir, removeSocketFile, getTCPPort, getTCPHost, isTCPEnabled } from '../util/platform.js';
 import { hasNoAuthOverride } from './connection-policy.js';
@@ -10,7 +10,7 @@ import { RateLimitProvider } from '../providers/ratelimit.js';
 import { getConfig, invalidateConfigCache } from '../config/loader.js';
 import { buildSystemPrompt } from '../config/system-prompt.js';
 import { clearCache as clearTrustCache } from '../permissions/trust-store.js';
-import { resetAllowlist } from '../security/secret-allowlist.js';
+import { resetAllowlist, validateAllowlistFile } from '../security/secret-allowlist.js';
 import { checkIngressForSecrets } from '../security/secret-ingress.js';
 import { IngressBlockedError } from '../util/errors.js';
 import { clearEmbeddingBackendCache } from '../memory/embedding-backend.js';
@@ -36,9 +36,24 @@ import { assistantEventHub } from '../runtime/assistant-event-hub.js';
 import { buildAssistantEvent } from '../runtime/assistant-event.js';
 import { SessionEvictor } from './session-evictor.js';
 import { getSubagentManager } from '../subagent/index.js';
+import { tryHandlePendingCallAnswer } from '../calls/call-bridge.js';
+import { resolveSlash } from './session-slash.js';
+import { createUserMessage, createAssistantMessage } from '../agent/message-types.js';
 
 const log = getLogger('server');
 
+function readPackageVersion(): string | undefined {
+  try {
+    const pkgPath = join(import.meta.dir, '../../package.json');
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8')) as { version?: string };
+    return pkg.version;
+  } catch {
+    return undefined;
+  }
+}
+
+const daemonVersion = readPackageVersion();
+
 export class DaemonServer {
   private server: net.Server | null = null;
   private tcpServer: net.Server | null = null;
@@ -125,21 +140,23 @@ export class DaemonServer {
     };
     // When a subagent finishes, inject the result into the parent session
     // so the LLM automatically informs the user.
-    getSubagentManager().onSubagentFinished = (parentSessionId, message, sendToClient) => {
+    getSubagentManager().onSubagentFinished = (parentSessionId, message, sendToClient, notification) => {
       const parentSession = this.sessions.get(parentSessionId);
       if (!parentSession) {
         log.warn({ parentSessionId }, 'Subagent finished but parent session not found');
         return;
       }
       const requestId = `subagent-notify-${Date.now()}`;
-      const enqueueResult = parentSession.enqueueMessage(message, [], sendToClient, requestId);
+      // Store structured notification data in the DB for history reconstruction
+      const metadata = { subagentNotification: notification };
+      const enqueueResult = parentSession.enqueueMessage(message, [], sendToClient, requestId, undefined, undefined, metadata);
       if (enqueueResult.rejected) {
         log.warn({ parentSessionId }, 'Parent session queue full, dropping subagent notification');
         return;
       }
       if (!enqueueResult.queued) {
         // Parent is idle — send directly.
-        const messageId = parentSession.persistUserMessage(message, []);
+        const messageId = parentSession.persistUserMessage(message, [], undefined, metadata);
         parentSession.runAgentLoop(message, messageId, sendToClient).catch((err) => {
           log.error({ parentSessionId, err }, 'Failed to process subagent notification in parent');
         });
@@ -330,6 +347,16 @@ export class DaemonServer {
       },
       'secret-allowlist.json': () => {
         resetAllowlist();
+        try {
+          const errors = validateAllowlistFile();
+          if (errors && errors.length > 0) {
+            for (const e of errors) {
+              log.warn({ index: e.index, pattern: e.pattern }, `Invalid regex in secret-allowlist.json: ${e.message}`);
+            }
+          }
+        } catch (err) {
+          log.warn({ err }, 'Failed to validate secret-allowlist.json');
+        }
       },
     };
 
@@ -381,6 +408,7 @@ export class DaemonServer {
     this.broadcast({
       type: 'daemon_status',
       httpPort: port,
+      version: daemonVersion,
     });
   }
 
@@ -744,10 +772,7 @@ export class DaemonServer {
       ('sessionId' in msg && typeof msgRecord.sessionId === 'string'
         ? msgRecord.sessionId as string
         : undefined) ?? this.socketToSession.get(socket);
-    // Resolve assistantId from the session if available; fall back to daemon default.
-    const socketSession = sessionId ? this.sessions.get(sessionId) : undefined;
-    const assistantId = socketSession?.assistantId ?? this.assistantId;
-    this.publishAssistantEvent(msg, sessionId, assistantId);
+    this.publishAssistantEvent(msg, sessionId, this.assistantId);
   }
 
   broadcast(msg: ServerMessage, excludeSocket?: net.Socket): void {
@@ -763,10 +788,7 @@ export class DaemonServer {
       ('sessionId' in msg && typeof msgRecord.sessionId === 'string'
         ? msgRecord.sessionId as string
         : undefined) ?? (excludeSocket ? this.socketToSession.get(excludeSocket) : undefined);
-    // Resolve assistantId from the origin session if available; fall back to daemon default.
-    const originSession = sessionId ? this.sessions.get(sessionId) : undefined;
-    const assistantId = originSession?.assistantId ?? this.assistantId;
-    this.publishAssistantEvent(msg, sessionId, assistantId);
+    this.publishAssistantEvent(msg, sessionId, this.assistantId);
   }
 
   /**
@@ -797,6 +819,7 @@ export class DaemonServer {
       this.send(socket, {
         type: 'daemon_status',
         httpPort: this.httpPort,
+        version: daemonVersion,
       });
       return;
     }
@@ -815,6 +838,7 @@ export class DaemonServer {
     this.send(socket, {
       type: 'daemon_status',
       httpPort: this.httpPort,
+      version: daemonVersion,
     });
   }
 
@@ -967,7 +991,6 @@ export class DaemonServer {
    * is not blocked for the duration of the agent loop.
    */
   async persistAndProcessMessage(
-    assistantId: string,
     conversationId: string,
     content: string,
     attachmentIds?: string[],
@@ -988,14 +1011,11 @@ export class DaemonServer {
       throw new Error('Session is already processing a message');
     }
 
-    // Set assistantId AFTER the isProcessing check so a rejected request
-    // doesn't mutate the session state visible to an in-flight request.
-    session.setAssistantId(assistantId);
     session.setChannelCapabilities(resolveChannelCapabilities(sourceChannel));
 
     // Resolve attachment IDs to full attachment data for the session
     const attachments = attachmentIds
-      ? attachmentsStore.getAttachmentsByIds(assistantId, attachmentIds).map((a) => ({
+      ? attachmentsStore.getAttachmentsByIds(attachmentIds).map((a) => ({
           id: a.id,
           filename: a.originalFilename,
           mimeType: a.mimeType,
@@ -1003,10 +1023,32 @@ export class DaemonServer {
         }))
       : [];
 
-    // persistUserMessage throws if the session is busy or persistence fails
+    // Persist the user message immediately after the isProcessing() guard.
+    // This synchronously sets session.processing = true, closing the race
+    // window that previously existed between the guard and the async bridge
+    // check (two concurrent requests could both pass isProcessing() and
+    // race into message handling).
     const requestId = crypto.randomUUID();
     const messageId = session.persistUserMessage(content, attachments, requestId);
 
+    // Now that the processing lock is held, check the call-answer bridge.
+    let bridgeHandled = false;
+    try {
+      const bridgeResult = await tryHandlePendingCallAnswer(conversationId, content, messageId);
+      bridgeHandled = bridgeResult.handled;
+    } catch (err) {
+      log.warn({ err, conversationId }, 'Call-answer bridge check failed (non-fatal), proceeding with agent loop');
+    }
+
+    if (bridgeHandled) {
+      // The message was consumed by the call system. Release the session.
+      resetSessionProcessingState(session);
+      // Drain any queued messages that arrived while processing was true.
+      session.drainQueue('loop_complete');
+      log.info({ conversationId, messageId }, 'User message consumed by call-answer bridge, skipping agent loop');
+      return { messageId };
+    }
+
     // Fire-and-forget the agent loop. Errors are logged but do not
     // affect the HTTP response (the client polls GET /messages).
     session.runAgentLoop(content, messageId, () => {}).catch((err) => {
@@ -1022,7 +1064,6 @@ export class DaemonServer {
    * Used by the channel inbound endpoint which needs the assistant reply.
    */
   async processMessage(
-    assistantId: string,
     conversationId: string,
     content: string,
     attachmentIds?: string[],
@@ -1041,14 +1082,11 @@ export class DaemonServer {
       throw new Error('Session is already processing a message');
     }
 
-    // Set assistantId AFTER the isProcessing check so a rejected request
-    // doesn't mutate the session state visible to an in-flight request.
-    session.setAssistantId(assistantId);
     session.setChannelCapabilities(resolveChannelCapabilities(sourceChannel));
 
     // Resolve attachment IDs to full attachment data for the session
     const attachments = attachmentIds
-      ? attachmentsStore.getAttachmentsByIds(assistantId, attachmentIds).map((a) => ({
+      ? attachmentsStore.getAttachmentsByIds(attachmentIds).map((a) => ({
           id: a.id,
           filename: a.originalFilename,
           mimeType: a.mimeType,
@@ -1056,12 +1094,74 @@ export class DaemonServer {
         }))
       : [];
 
-    const messageId = await session.processMessage(content, attachments, () => {}, crypto.randomUUID());
+    // Resolve slash commands before persistence (synchronous — no race window).
+    const slashResult = resolveSlash(content);
+
+    // Unknown slash command — persist the exchange (user + assistant) and
+    // return immediately. This path doesn't set processing=true since no
+    // agent loop runs, so there is no race concern.
+    if (slashResult.kind === 'unknown') {
+      const userMsg = createUserMessage(content, attachments);
+      const persisted = conversationStore.addMessage(
+        conversationId,
+        'user',
+        JSON.stringify(userMsg.content),
+      );
+      session.getMessages().push(userMsg);
+
+      const assistantMsg = createAssistantMessage(slashResult.message);
+      conversationStore.addMessage(
+        conversationId,
+        'assistant',
+        JSON.stringify(assistantMsg.content),
+      );
+      session.getMessages().push(assistantMsg);
+      return { messageId: persisted.id };
+    }
 
-    if (!messageId) {
-      throw new Error('Failed to persist user message');
+    const resolvedContent = slashResult.content;
+
+    // Preactivate skill tools when slash resolution identifies a known skill
+    if (slashResult.kind === 'rewritten') {
+      (session as unknown as { preactivatedSkillIds?: string[] }).preactivatedSkillIds = [slashResult.skillId];
+    }
+
+    // Persist the user message immediately after the isProcessing() guard.
+    // This synchronously sets session.processing = true, closing the race
+    // window that previously existed between the guard and the async bridge
+    // check.
+    const requestId = crypto.randomUUID();
+    let messageId: string;
+    try {
+      messageId = session.persistUserMessage(resolvedContent, attachments, requestId);
+    } catch (err) {
+      // runAgentLoop never ran, so its finally block won't clear this
+      (session as unknown as { preactivatedSkillIds?: string[] }).preactivatedSkillIds = undefined;
+      throw err;
     }
 
+    // Now that the processing lock is held, check the call-answer bridge.
+    let bridgeHandled = false;
+    try {
+      const bridgeResult = await tryHandlePendingCallAnswer(conversationId, content, messageId);
+      bridgeHandled = bridgeResult.handled;
+    } catch (err) {
+      log.warn({ err, conversationId }, 'Call-answer bridge check failed (non-fatal), proceeding with agent loop');
+    }
+
+    if (bridgeHandled) {
+      // The message was consumed by the call system. Release the session.
+      (session as unknown as { preactivatedSkillIds?: string[] }).preactivatedSkillIds = undefined;
+      resetSessionProcessingState(session);
+      // Drain any queued messages that arrived while processing was true.
+      session.drainQueue('loop_complete');
+      log.info({ conversationId, messageId }, 'User message consumed by call-answer bridge, skipping agent loop');
+      return { messageId };
+    }
+
+    // Run the agent loop (blocking — the channel inbound endpoint needs the reply).
+    await session.runAgentLoop(resolvedContent, messageId, () => {});
+
     return { messageId };
   }
 
@@ -1072,8 +1172,8 @@ export class DaemonServer {
     return new RunOrchestrator({
       getOrCreateSession: (conversationId) =>
         this.getOrCreateSession(conversationId),
-      resolveAttachments: (assistantId, attachmentIds) =>
-        attachmentsStore.getAttachmentsByIds(assistantId, attachmentIds).map((a) => ({
+      resolveAttachments: (attachmentIds) =>
+        attachmentsStore.getAttachmentsByIds(attachmentIds).map((a) => ({
           id: a.id,
           filename: a.originalFilename,
           mimeType: a.mimeType,
@@ -1083,3 +1183,18 @@ export class DaemonServer {
   }
 
 }
+
+/**
+ * Reset the processing state set by `persistUserMessage` when the agent loop
+ * is intentionally skipped (e.g. call-answer bridge consumed the message).
+ */
+function resetSessionProcessingState(session: Session): void {
+  const s = session as unknown as {
+    processing: boolean;
+    abortController: AbortController | null;
+    currentRequestId: string | undefined;
+  };
+  s.processing = false;
+  s.abortController = null;
+  s.currentRequestId = undefined;
+}