@vellumai/assistant 0.3.3 → 0.3.5

package/src/daemon/ipc-handler.ts

@@ -0,0 +1,87 @@
+/**
+ * IPC wire-level helpers: socket writing, broadcast, and assistant-event
+ * hub publishing. Extracted from DaemonServer to separate transport
+ * concerns from session management and business logic.
+ */
+import * as net from 'node:net';
+import { serialize, type ServerMessage } from './ipc-protocol.js';
+import { assistantEventHub } from '../runtime/assistant-event-hub.js';
+import { buildAssistantEvent } from '../runtime/assistant-event.js';
+import { getLogger } from '../util/logger.js';
+
+const log = getLogger('ipc-handler');
+
+/**
+ * Manages IPC message delivery: writing to individual sockets,
+ * broadcasting to all authenticated sockets, and publishing events
+ * to the assistant-events hub in order.
+ */
+export class IpcSender {
+  private _hubChain: Promise<void> = Promise.resolve();
+
+  /** Write to a single socket without publishing to the event hub. */
+  writeToSocket(socket: net.Socket, msg: ServerMessage): void {
+    if (!socket.destroyed && socket.writable) {
+      socket.write(serialize(msg));
+    }
+  }
+
+  /**
+   * Send a message to a single socket and publish to the event hub.
+   * `sessionId` is resolved from the message itself or the socket binding.
+   */
+  send(
+    socket: net.Socket,
+    msg: ServerMessage,
+    socketToSession: Map<net.Socket, string>,
+    assistantId: string,
+  ): void {
+    this.writeToSocket(socket, msg);
+    const sessionId = extractSessionId(msg) ?? socketToSession.get(socket);
+    this.publishAssistantEvent(msg, sessionId, assistantId);
+  }
+
+  /**
+   * Broadcast a message to all authenticated sockets, then publish
+   * a single event to the hub.
+   */
+  broadcast(
+    authenticatedSockets: Set<net.Socket>,
+    msg: ServerMessage,
+    socketToSession: Map<net.Socket, string>,
+    assistantId: string,
+    excludeSocket?: net.Socket,
+  ): void {
+    for (const socket of authenticatedSockets) {
+      if (socket === excludeSocket) continue;
+      this.writeToSocket(socket, msg);
+    }
+    const sessionId = extractSessionId(msg)
+      ?? (excludeSocket ? socketToSession.get(excludeSocket) : undefined);
+    this.publishAssistantEvent(msg, sessionId, assistantId);
+  }
+
+  /**
+   * Publish `msg` as an `AssistantEvent` to the process-level hub.
+   * Publications are serialized via a promise chain so subscribers
+   * always observe events in send order.
+   */
+  private publishAssistantEvent(msg: ServerMessage, sessionId?: string, assistantId?: string): void {
+    const id = assistantId ?? 'default';
+    const event = buildAssistantEvent(id, msg, sessionId);
+    this._hubChain = this._hubChain
+      .then(() => assistantEventHub.publish(event))
+      .catch((err: unknown) => {
+        log.warn({ err }, 'assistant-events hub subscriber threw during IPC send');
+      });
+  }
+}
+
+/** Extract sessionId from a ServerMessage if present. */
+function extractSessionId(msg: ServerMessage): string | undefined {
+  const record = msg as unknown as Record<string, unknown>;
+  if ('sessionId' in msg && typeof record.sessionId === 'string') {
+    return record.sessionId as string;
+  }
+  return undefined;
+}

package/src/daemon/lifecycle.ts

@@ -42,6 +42,7 @@ import { registerMessagingProvider } from '../messaging/registry.js';
 import { slackProvider as slackMessagingProvider } from '../messaging/providers/slack/adapter.js';
 import { gmailMessagingProvider } from '../messaging/providers/gmail/adapter.js';
 import { telegramBotMessagingProvider } from '../messaging/providers/telegram-bot/adapter.js';
+import { smsMessagingProvider } from '../messaging/providers/sms/adapter.js';
 import { browserManager } from '../tools/browser/browser-manager.js';
 import { RuntimeHttpServer } from '../runtime/http-server.js';
 import { getHookManager } from '../hooks/manager.js';
@@ -386,6 +387,7 @@ export async function runDaemon(): Promise<void> {
   registerMessagingProvider(slackMessagingProvider);
   registerMessagingProvider(gmailMessagingProvider);
   registerMessagingProvider(telegramBotMessagingProvider);
+  registerMessagingProvider(smsMessagingProvider);
 
   const scheduler = startScheduler(
     async (conversationId, message) => {
@@ -429,11 +431,23 @@ export async function runDaemon(): Promise<void> {
   if (httpPortEnv) {
     const port = parseInt(httpPortEnv, 10);
     if (!isNaN(port) && port > 0) {
-      // Use an explicit env var if provided; otherwise generate a fresh
-      // random token. Either way, write it to disk so HTTP clients and
-      // the gateway can authenticate.
-      const bearerToken = process.env.RUNTIME_PROXY_BEARER_TOKEN || randomBytes(32).toString('hex');
+      // Resolve the bearer token in priority order:
+      //   1. Explicit env var (e.g. cloud deploys)
+      //   2. Existing token file on disk (preserves QR-paired iOS devices across restarts)
+      //   3. Fresh random token (first-time startup)
       const httpTokenPath = getHttpTokenPath();
+      let bearerToken = process.env.RUNTIME_PROXY_BEARER_TOKEN;
+      if (!bearerToken) {
+        try {
+          const existing = readFileSync(httpTokenPath, 'utf-8').trim();
+          if (existing) bearerToken = existing;
+        } catch {
+          // File doesn't exist or can't be read — will generate below
+        }
+      }
+      if (!bearerToken) {
+        bearerToken = randomBytes(32).toString('hex');
+      }
       writeFileSync(httpTokenPath, bearerToken, { mode: 0o600 });
       chmodSync(httpTokenPath, 0o600);
 

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

@@ -169,7 +169,17 @@ export async function handleRideShotgunStart(
                 clearInterval(checkInterval);
               }
             }, 1000);
-            autoNavigate(navDomain, abortSignal).then(visited => {
+            autoNavigate(navDomain, abortSignal, (progress) => {
+              // Send progress to connected client
+              if (progress.type === 'visiting' && progress.url) {
+                const shortUrl = progress.url.replace(/^https?:\/\//, '');
+                ctx.send(socket, {
+                  type: 'ride_shotgun_progress',
+                  watchId,
+                  message: `[${progress.pageNumber || '?'}] ${shortUrl}`,
+                });
+              }
+            }).then(visited => {
               clearInterval(checkInterval);
               log.info({ watchId, visitedPages: visited.length }, 'Generic auto-navigation finished');
               if (session.status === 'active') {