vellum 0.2.1 → 0.2.2

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,
     });
   }
 
@@ -987,14 +1011,11 @@ export class DaemonServer {
       throw new Error('Session is already processing a message');
     }
 
-    // Set the session identity AFTER the isProcessing check so a rejected
-    // request doesn't mutate the session state visible to an in-flight request.
-    session.setAssistantId('self');
     session.setChannelCapabilities(resolveChannelCapabilities(sourceChannel));
 
     // Resolve attachment IDs to full attachment data for the session
     const attachments = attachmentIds
-      ? attachmentsStore.getAttachmentsByIds('self', attachmentIds).map((a) => ({
+      ? attachmentsStore.getAttachmentsByIds(attachmentIds).map((a) => ({
           id: a.id,
           filename: a.originalFilename,
           mimeType: a.mimeType,
@@ -1002,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) => {
@@ -1039,14 +1082,11 @@ export class DaemonServer {
       throw new Error('Session is already processing a message');
     }
 
-    // Set the session identity AFTER the isProcessing check so a rejected
-    // request doesn't mutate the session state visible to an in-flight request.
-    session.setAssistantId('self');
     session.setChannelCapabilities(resolveChannelCapabilities(sourceChannel));
 
     // Resolve attachment IDs to full attachment data for the session
     const attachments = attachmentIds
-      ? attachmentsStore.getAttachmentsByIds('self', attachmentIds).map((a) => ({
+      ? attachmentsStore.getAttachmentsByIds(attachmentIds).map((a) => ({
           id: a.id,
           filename: a.originalFilename,
           mimeType: a.mimeType,
@@ -1054,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 };
   }
 
@@ -1071,7 +1173,7 @@ export class DaemonServer {
       getOrCreateSession: (conversationId) =>
         this.getOrCreateSession(conversationId),
       resolveAttachments: (attachmentIds) =>
-        attachmentsStore.getAttachmentsByIds('self', attachmentIds).map((a) => ({
+        attachmentsStore.getAttachmentsByIds(attachmentIds).map((a) => ({
           id: a.id,
           filename: a.originalFilename,
           mimeType: a.mimeType,
@@ -1081,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;
+}