@vellumai/assistant 0.4.43 → 0.4.45

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

@@ -9,7 +9,6 @@ import {
 import { NetworkRecorder } from "../tools/browser/network-recorder.js";
 import type { SessionRecording } from "../tools/browser/network-recording-types.js";
 import { saveRecording } from "../tools/browser/recording-store.js";
-import { navigateXPages } from "../tools/browser/x-auto-navigate.js";
 import type { WatchSession } from "../tools/watch/watch-state.js";
 import {
   fireWatchCompletionNotifier,
@@ -35,13 +34,7 @@ const activeCdpSessions = new Map<string, CdpSession>();
 const activeProgressIntervals = new Map<string, NodeJS.Timeout>();
 
 /** 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
-    ];
-  }
+function getLoginSignals(_targetDomain?: string): string[] {
   // DoorDash and general fallback
   return [
     "/graphql/postLoginQuery",
@@ -324,40 +317,7 @@ export async function handleRideShotgunStart(
           }, 5000);
           activeProgressIntervals.set(watchId, progressInterval);
 
-          // 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") &&
-            msg.autoNavigate !== false
-          ) {
-            // 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, cdpBaseUrl })
-              .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) {
+          if (msg.autoNavigate && targetDomain) {
             const navDomain = msg.navigateDomain ?? targetDomain;
             const abortSignal = { aborted: false };
             const checkInterval = setInterval(() => {
@@ -538,13 +498,45 @@ async function finalizeLearnRecording(
     const networkEntries = recorder ? await recorder.stop() : [];
     activeRecorders.delete(watchId);
 
+    // Save cookies to the encrypted credential store (keyed by target domain)
+    // so they don't need to be persisted in the plaintext recording file.
+    if (session.targetDomain && cookies.length > 0) {
+      const { setSecureKeyAsync } = await import("../security/secure-keys.js");
+      const { upsertCredentialMetadata } =
+        await import("../tools/credentials/metadata-store.js");
+
+      const service = session.targetDomain;
+      const field = "session:cookies";
+      const storageKey = `credential:${service}:${field}`;
+      const stored = await setSecureKeyAsync(
+        storageKey,
+        JSON.stringify(cookies),
+      );
+      if (stored) {
+        try {
+          upsertCredentialMetadata(service, field, {});
+        } catch {
+          // Non-critical: metadata upsert is best-effort
+        }
+        log.info(
+          { targetDomain: service, cookieCount: cookies.length },
+          "Cookies saved to credential store",
+        );
+      } else {
+        log.warn(
+          { targetDomain: service },
+          "Failed to save cookies to credential store",
+        );
+      }
+    }
+
     const recording: SessionRecording = {
       id: recordingId,
       startedAt: session.startedAt,
       endedAt: Date.now(),
       targetDomain: session.targetDomain,
       networkEntries,
-      cookies,
+      cookies: [], // Cookies saved to credential store — never persisted in recording
       observations: session.observations.map((obs) => ({
         ocrText: obs.ocrText,
         appName: obs.appName,

package/src/daemon/seed-files.ts

@@ -2,16 +2,15 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
 
-import { loadPrebuiltHtml } from "../home-base/prebuilt/seed.js";
 import { getLogger } from "../util/logger.js";
 import { getInterfacesDir } from "../util/platform.js";
 
 const log = getLogger("seed-files");
 
 /**
- * Seeds interface files (TUI main-window, desktop index.html) from their
- * source packages when they don't already exist on disk. Called during
- * daemon startup so the runtime can serve these files immediately.
+ * Seeds interface files (TUI main-window) from their source packages when they
+ * don't already exist on disk. Called during daemon startup so the runtime can
+ * serve these files immediately.
  */
 export function seedInterfaceFiles(): void {
   // Seed the TUI main-window interface from the CLI package's DefaultMainScreen
@@ -35,27 +34,4 @@ export function seedInterfaceFiles(): void {
       log.warn({ err }, "Could not seed tui/main-window.tsx from CLI package");
     }
   }
-
-  // Seed the vellum-desktop interface from the prebuilt Home Base HTML if it
-  // doesn't already exist. This ensures the Home tab renders immediately
-  // on first launch for both local and remote hatches.
-  const desktopIndexPath = join(
-    getInterfacesDir(),
-    "vellum-desktop",
-    "index.html",
-  );
-  if (!existsSync(desktopIndexPath)) {
-    const prebuiltHtml = loadPrebuiltHtml();
-    if (prebuiltHtml) {
-      mkdirSync(join(getInterfacesDir(), "vellum-desktop"), {
-        recursive: true,
-      });
-      writeFileSync(desktopIndexPath, prebuiltHtml);
-      log.info("Seeded vellum-desktop/index.html from prebuilt Home Base");
-    } else {
-      log.warn(
-        "Could not seed vellum-desktop/index.html — prebuilt HTML not found (missing embedded index.html in home-base/prebuilt/)",
-      );
-    }
-  }
 }

package/src/daemon/server.ts

@@ -14,7 +14,6 @@ import {
 import { getConfig } from "../config/loader.js";
 import { onContactChange } from "../contacts/contact-events.js";
 import type { HeartbeatService } from "../heartbeat/heartbeat-service.js";
-import { bootstrapHomeBaseAppLink } from "../home-base/bootstrap.js";
 import * as attachmentsStore from "../memory/attachments-store.js";
 import {
   createCanonicalGuardianRequest,
@@ -57,6 +56,8 @@ import type {
   SessionCreateOptions,
 } from "./handlers/shared.js";
 import type { SkillOperationContext } from "./handlers/skills.js";
+import { HostBashProxy } from "./host-bash-proxy.js";
+import { HostFileProxy } from "./host-file-proxy.js";
 import type { ServerMessage } from "./message-protocol.js";
 import {
   DEFAULT_MEMORY_POLICY,
@@ -131,8 +132,9 @@ function resolveCanonicalRequestSourceType(
 
 /**
  * Build an onEvent callback that registers pending interactions when the agent
- * loop emits confirmation_request or secret_request events. This ensures that
- * channel approval interception can look up the session by requestId.
+ * loop emits confirmation_request, secret_request, host_bash_request, or
+ * host_file_request events. This ensures that channel approval interception
+ * can look up the session by requestId.
  */
 function makePendingInteractionRegistrar(
   session: Session,
@@ -200,6 +202,18 @@ function makePendingInteractionRegistrar(
         conversationId,
         kind: "secret",
       });
+    } else if (msg.type === "host_bash_request") {
+      pendingInteractions.register(msg.requestId, {
+        session,
+        conversationId,
+        kind: "host_bash",
+      });
+    } else if (msg.type === "host_file_request") {
+      pendingInteractions.register(msg.requestId, {
+        session,
+        conversationId,
+        kind: "host_file",
+      });
     }
   };
 }
@@ -292,14 +306,7 @@ export class DaemonServer {
         undefined,
         metadata,
       );
-      if (enqueueResult.rejected) {
-        log.warn(
-          { parentSessionId },
-          "Parent session queue full, dropping subagent notification",
-        );
-        return;
-      }
-      if (!enqueueResult.queued) {
+      if (!enqueueResult.queued && !enqueueResult.rejected) {
         const messageId = await parentSession.persistUserMessage(
           message,
           [],
@@ -325,10 +332,7 @@ export class DaemonServer {
    * Publications are serialized via a promise chain so subscribers
    * always observe events in send order.
    */
-  private publishAssistantEvent(
-    msg: ServerMessage,
-    sessionId?: string,
-  ): void {
+  private publishAssistantEvent(msg: ServerMessage, sessionId?: string): void {
     const id = this.assistantId ?? "default";
     const event = buildAssistantEvent(id, msg, sessionId);
     this._hubChain = this._hubChain
@@ -373,15 +377,6 @@ export class DaemonServer {
     initializeProviders(config);
     this.configWatcher.initFingerprint(config);
 
-    try {
-      bootstrapHomeBaseAppLink();
-    } catch (err) {
-      log.warn(
-        { err },
-        "Failed to bootstrap Home Base app link at daemon startup",
-      );
-    }
-
     this.evictor.start();
 
     registerDaemonCallbacks({
@@ -629,10 +624,7 @@ export class DaemonServer {
       );
     }
 
-    const session = await this.getOrCreateSession(
-      conversationId,
-      options,
-    );
+    const session = await this.getOrCreateSession(conversationId, options);
 
     if (session.isProcessing()) {
       throw new Error("Session is already processing a message");
@@ -652,6 +644,31 @@ export class DaemonServer {
     session.setChannelCapabilities(
       resolveChannelCapabilities(sourceChannel, sourceInterface),
     );
+    // Only create the host bash proxy for desktop client interfaces that can
+    // execute commands on the user's machine. Non-desktop sessions (CLI,
+    // channels, headless) fall back to local execution.
+    // Guard: don't replace an active proxy during concurrent turn races —
+    // another request may have started processing between the isProcessing()
+    // check above and the await on ensureActorScopedHistory().
+    if (resolvedInterface === "macos" || resolvedInterface === "ios") {
+      if (!session.isProcessing() || !session.hostBashProxy) {
+        session.setHostBashProxy(
+          new HostBashProxy(session.getCurrentSender(), (requestId) => {
+            pendingInteractions.resolve(requestId);
+          }),
+        );
+      }
+      if (!session.isProcessing() || !session.hostFileProxy) {
+        session.setHostFileProxy(
+          new HostFileProxy(session.getCurrentSender(), (requestId) => {
+            pendingInteractions.resolve(requestId);
+          }),
+        );
+      }
+    } else if (!session.isProcessing()) {
+      session.setHostBashProxy(undefined);
+      session.setHostFileProxy(undefined);
+    }
     session.setCommandIntent(options?.commandIntent ?? null);
     session.setTurnChannelContext({
       userMessageChannel: resolvedChannel,

package/src/daemon/session-agent-loop-handlers.ts

@@ -164,22 +164,22 @@ export function emitLlmCallStartedIfNeeded(
   );
 }
 
-// ── IPC Size Caps ────────────────────────────────────────────────────
+// ── Client Payload Size Caps ─────────────────────────────────────────
 // The client truncates tool results anyway (2 000 chars in ChatViewModel),
 // but the full string can be megabytes (file_read, bash output). Capping
-// here avoids sending oversized payloads over IPC which get decoded on
-// the client's main thread.
+// here avoids sending oversized payloads which get decoded on the
+// client's main thread.
 
 const TOOL_RESULT_MAX_CHARS = 2_000;
 const TOOL_RESULT_TRUNCATION_SUFFIX = "...[truncated]";
 
 // tool_input_delta streams accumulated JSON as tools run. For non-app
 // tools the client discards it (extractCodePreview only handles app tools),
-// so we cap it aggressively to avoid excessive IPC traffic.
+// so we cap it aggressively to avoid excessive client traffic.
 const TOOL_INPUT_DELTA_MAX_CHARS = 50_000;
 const APP_TOOL_NAMES = new Set(["app_create", "app_update"]);
 
-function truncateForIpc(
+function truncateForClient(
   value: string,
   maxChars: number,
   suffix: string,
@@ -206,6 +206,7 @@ const TOOL_FRIENDLY_NAMES: Record<string, string> = {
   app_create: "app",
   app_update: "app",
   skill_load: "skill",
+  skill_execute: "skill",
   app_file_edit: "app file",
   app_file_write: "app file",
 };
@@ -304,6 +305,27 @@ export function handleToolUse(
   });
 }
 
+export function handleToolUsePreviewStart(
+  _state: EventHandlerState,
+  deps: EventHandlerDeps,
+  event: Extract<AgentEvent, { type: "tool_use_preview_start" }>,
+): void {
+  deps.onEvent({
+    type: "tool_use_preview_start",
+    toolUseId: event.toolUseId,
+    toolName: event.toolName,
+    sessionId: deps.ctx.conversationId,
+  });
+  const statusText = `Preparing ${friendlyToolName(event.toolName)}...`;
+  deps.ctx.emitActivityState(
+    "tool_running",
+    "preview_start",
+    "assistant_turn",
+    deps.reqId,
+    statusText,
+  );
+}
+
 export function handleToolOutputChunk(
   _state: EventHandlerState,
   deps: EventHandlerDeps,
@@ -386,7 +408,7 @@ export function handleInputJsonDelta(
   // app_create/app_update code previews; all other tools discard it.
   const content = APP_TOOL_NAMES.has(event.toolName)
     ? event.accumulatedJson
-    : truncateForIpc(
+    : truncateForClient(
         event.accumulatedJson,
         TOOL_INPUT_DELTA_MAX_CHARS,
         TOOL_RESULT_TRUNCATION_SUFFIX,
@@ -396,6 +418,7 @@ export function handleInputJsonDelta(
     toolName: event.toolName,
     content,
     sessionId: deps.ctx.conversationId,
+    toolUseId: event.toolUseId,
   });
 }
 
@@ -410,7 +433,7 @@ export function handleToolResult(
   deps.onEvent({
     type: "tool_result",
     toolName: "",
-    result: truncateForIpc(
+    result: truncateForClient(
       event.content,
       TOOL_RESULT_MAX_CHARS,
       TOOL_RESULT_TRUNCATION_SUFFIX,
@@ -420,6 +443,7 @@ export function handleToolResult(
     status: event.status,
     sessionId: deps.ctx.conversationId,
     imageData: imageBlock?.source.data,
+    toolUseId: event.toolUseId,
   });
   state.pendingToolResults.set(event.toolUseId, {
     content: event.content,
@@ -481,7 +505,7 @@ export function handleToolResult(
     return ts && ts.completedAt != null;
   });
   if (allToolsDone && state.currentTurnToolUseIds.length > 0) {
-    annotatePersistedAssistantMessage(state);
+    annotatePersistedAssistantMessage(state, deps);
   }
 }
 
@@ -491,7 +515,10 @@ export function handleToolResult(
  * and update the DB. This runs post-tool-execution so the metadata maps are
  * fully populated (unlike message_complete which fires before tools run).
  */
-function annotatePersistedAssistantMessage(state: EventHandlerState): void {
+function annotatePersistedAssistantMessage(
+  state: EventHandlerState,
+  deps: EventHandlerDeps,
+): void {
   const messageId = state.lastAssistantMessageId;
   if (!messageId) return;
 
@@ -529,6 +556,25 @@ function annotatePersistedAssistantMessage(state: EventHandlerState): void {
     }
   }
 
+  // Persist any surfaces created during tool execution.
+  // message_complete fires BEFORE tools run, so currentTurnSurfaces is empty
+  // at write time. We append them here after all tools have completed.
+  if (deps.ctx.currentTurnSurfaces.length > 0) {
+    for (const surface of deps.ctx.currentTurnSurfaces) {
+      content.push({
+        type: "ui_surface",
+        surfaceId: surface.surfaceId,
+        surfaceType: surface.surfaceType,
+        title: surface.title,
+        data: surface.data,
+        actions: surface.actions,
+        display: surface.display,
+      } as unknown as ContentBlock);
+    }
+    modified = true;
+    deps.ctx.currentTurnSurfaces = [];
+  }
+
   if (modified) {
     updateMessageContent(messageId, JSON.stringify(content));
   }
@@ -759,6 +805,9 @@ export async function dispatchAgentEvent(
     case "tool_use":
       handleToolUse(state, deps, event);
       break;
+    case "tool_use_preview_start":
+      handleToolUsePreviewStart(state, deps, event);
+      break;
     case "tool_output_chunk":
       handleToolOutputChunk(state, deps, event);
       break;
@@ -768,6 +817,20 @@ export async function dispatchAgentEvent(
     case "tool_result":
       handleToolResult(state, deps, event);
       break;
+    case "server_tool_start": {
+      const friendlyNames: Record<string, string> = {
+        web_search: "Searching the web",
+      };
+      const statusText = friendlyNames[event.name] ?? `Running ${event.name}`;
+      deps.ctx.emitActivityState(
+        "tool_running",
+        "tool_use_start",
+        "assistant_turn",
+        deps.reqId,
+        statusText,
+      );
+      break;
+    }
     case "error":
       handleError(state, deps, event);
       break;

package/src/daemon/session-agent-loop.ts

@@ -139,6 +139,7 @@ const TOOL_FRIENDLY_LABEL: Record<string, string> = {
   app_create: "Create App",
   app_update: "Update App",
   skill_load: "Load Skill",
+  skill_execute: "Run Skill Tool",
   app_file_edit: "Edit App File",
   app_file_write: "Write App File",
 };
@@ -226,6 +227,7 @@ export interface AgentLoopSessionContext {
       | "thinking_delta"
       | "first_text_delta"
       | "tool_use_start"
+      | "preview_start"
       | "tool_result_received"
       | "confirmation_requested"
       | "confirmation_resolved"
@@ -1301,60 +1303,10 @@ export async function runAgentLoopImpl(
       sessionId: ctx.conversationId,
     });
 
-    // Resolve attachments
-    const attachmentResult = await resolveAssistantAttachments(
-      state.accumulatedDirectives,
-      state.accumulatedToolContentBlocks,
-      state.directiveWarnings,
-      ctx.workingDir,
-      async (filePath) =>
-        approveHostAttachmentRead(
-          filePath,
-          ctx.workingDir,
-          ctx.prompter,
-          ctx.conversationId,
-          ctx.hasNoClient,
-        ),
-      state.lastAssistantMessageId,
-      state.toolContentBlockToolNames,
-    );
-    const { assistantAttachments, emittedAttachments } = attachmentResult;
-
-    ctx.lastAssistantAttachments = assistantAttachments;
-    ctx.lastAttachmentWarnings = attachmentResult.directiveWarnings;
-
-    const warningText = formatAttachmentWarnings(
-      attachmentResult.directiveWarnings,
-    );
-    if (warningText) {
-      onEvent({
-        type: "assistant_text_delta",
-        text: warningText,
-        sessionId: ctx.conversationId,
-      });
-    }
-
-    // Emit completion event
-    if (yieldedForHandoff) {
-      ctx.traceEmitter.emit(
-        "generation_handoff",
-        "Handing off to next queued message",
-        {
-          requestId: reqId,
-          status: "info",
-          attributes: { queuedCount: ctx.getQueueDepth() },
-        },
-      );
-      onEvent({
-        type: "generation_handoff",
-        sessionId: ctx.conversationId,
-        requestId: reqId,
-        queuedCount: ctx.getQueueDepth(),
-        ...(emittedAttachments.length > 0
-          ? { attachments: emittedAttachments }
-          : {}),
-      });
-    } else if (abortController.signal.aborted) {
+    // Fast-path: when the user cancelled, skip expensive post-loop work
+    // (attachment resolution) and emit the cancellation event immediately
+    // so the client can re-enable the UI without delay.
+    if (abortController.signal.aborted) {
       ctx.emitActivityState("idle", "generation_cancelled", "global", reqId);
       ctx.traceEmitter.emit(
         "generation_cancelled",
@@ -1366,18 +1318,97 @@ export async function runAgentLoopImpl(
       );
       onEvent({ type: "generation_cancelled", sessionId: ctx.conversationId });
     } else {
-      ctx.emitActivityState("idle", "message_complete", "global", reqId);
-      ctx.traceEmitter.emit("message_complete", "Message processing complete", {
-        requestId: reqId,
-        status: "success",
-      });
-      onEvent({
-        type: "message_complete",
-        sessionId: ctx.conversationId,
-        ...(emittedAttachments.length > 0
-          ? { attachments: emittedAttachments }
-          : {}),
-      });
+      // Resolve attachments (only when not cancelled — this is expensive async I/O)
+      const attachmentResult = await resolveAssistantAttachments(
+        state.accumulatedDirectives,
+        state.accumulatedToolContentBlocks,
+        state.directiveWarnings,
+        ctx.workingDir,
+        async (filePath) =>
+          approveHostAttachmentRead(
+            filePath,
+            ctx.workingDir,
+            ctx.prompter,
+            ctx.conversationId,
+            ctx.hasNoClient,
+          ),
+        state.lastAssistantMessageId,
+        state.toolContentBlockToolNames,
+      );
+      const { assistantAttachments, emittedAttachments } = attachmentResult;
+
+      ctx.lastAssistantAttachments = assistantAttachments;
+      ctx.lastAttachmentWarnings = attachmentResult.directiveWarnings;
+
+      const warningText = formatAttachmentWarnings(
+        attachmentResult.directiveWarnings,
+      );
+      if (warningText) {
+        onEvent({
+          type: "assistant_text_delta",
+          text: warningText,
+          sessionId: ctx.conversationId,
+        });
+      }
+
+      // Re-check: the user may have cancelled during attachment resolution
+      if (abortController.signal.aborted) {
+        ctx.emitActivityState("idle", "generation_cancelled", "global", reqId);
+        ctx.traceEmitter.emit(
+          "generation_cancelled",
+          "Generation cancelled by user",
+          {
+            requestId: reqId,
+            status: "warning",
+          },
+        );
+        onEvent({
+          type: "generation_cancelled",
+          sessionId: ctx.conversationId,
+        });
+      } else if (yieldedForHandoff) {
+        ctx.traceEmitter.emit(
+          "generation_handoff",
+          "Handing off to next queued message",
+          {
+            requestId: reqId,
+            status: "info",
+            attributes: { queuedCount: ctx.getQueueDepth() },
+          },
+        );
+        onEvent({
+          type: "generation_handoff",
+          sessionId: ctx.conversationId,
+          requestId: reqId,
+          queuedCount: ctx.getQueueDepth(),
+          ...(emittedAttachments.length > 0
+            ? { attachments: emittedAttachments }
+            : {}),
+          ...(state.lastAssistantMessageId
+            ? { messageId: state.lastAssistantMessageId }
+            : {}),
+        });
+      } else {
+        ctx.emitActivityState("idle", "message_complete", "global", reqId);
+        ctx.traceEmitter.emit(
+          "message_complete",
+          "Message processing complete",
+          {
+            requestId: reqId,
+            status: "success",
+          },
+        );
+        onEvent({
+          type: "message_complete",
+          sessionId: ctx.conversationId,
+          ...(emittedAttachments.length > 0
+            ? { attachments: emittedAttachments }
+            : {}),
+          ...(state.lastAssistantMessageId
+            ? { messageId: state.lastAssistantMessageId }
+            : {}),
+        });
+      }
     }
 
     // Second title pass: after 3 completed turns, re-generate the title

package/src/daemon/session-attachments.ts

@@ -199,7 +199,7 @@ export async function resolveAssistantAttachments(
   }
 
   // Persist resolved attachments and link to the last assistant message.
-  // Large video attachments are omitted from the IPC payload and lazy-loaded
+  // Large video attachments are omitted from the event payload and lazy-loaded
   // by the client via the HTTP endpoint (same pattern as history_response).
   const MAX_INLINE_B64_SIZE = 512 * 1024;