@vellumai/assistant 0.6.4 → 0.6.6

package/src/credential-execution/executable-discovery.ts

@@ -67,17 +67,28 @@ function getManagedBootstrapSocketPath(): string {
  * a malicious binary there. Removed to close the sandbox-escape vector.
  *
  * Search order:
- * 1. Alongside the running executable (packaged macOS app:
- *    `<App>.app/Contents/MacOS/credential-executor`). When running from
- *    source via `bun run`, `process.execPath` points at the bun binary
- *    itself, so this path won't exist and the search falls through.
+ * 1. Alongside the running executable, but ONLY when running from a
+ *    packaged macOS app bundle (`<App>.app/Contents/MacOS/credential-executor`).
+ *    In dev mode, `process.execPath` points at the bun/node install dir
+ *    (e.g. `~/.bun/bin`), where an unrelated file named `credential-executor`
+ *    could be picked up by accident.
  * 2. `<binDir>/credential-executor` — user-installed override (dev flow).
  */
 function getLocalBinarySearchPaths(): string[] {
-  return [
-    join(dirname(process.execPath), "credential-executor"),
-    join(getBinDir(), "credential-executor"),
-  ];
+  const paths: string[] = [];
+
+  // Only check the sibling of process.execPath when running from a packaged
+  // app bundle — the .app/Contents/MacOS directory is a controlled location.
+  // In dev mode, process.execPath is the bun/node binary (e.g. ~/.bun/bin/bun)
+  // and a sibling lookup there could discover an unrelated or untrusted
+  // executable.
+  const execDir = dirname(process.execPath);
+  if (execDir.includes(".app/Contents/MacOS")) {
+    paths.push(join(execDir, "credential-executor"));
+  }
+
+  paths.push(join(getBinDir(), "credential-executor"));
+  return paths;
 }
 
 // ---------------------------------------------------------------------------

package/src/credential-execution/process-manager.test.ts

@@ -0,0 +1,109 @@
+import { describe, expect, mock, test } from "bun:test";
+
+import { logCesLine } from "./process-manager.js";
+
+function makeLogger() {
+  return {
+    debug: mock((_obj: object, _msg: string) => {}),
+    info: mock((_obj: object, _msg: string) => {}),
+    warn: mock((_obj: object, _msg: string) => {}),
+    error: mock((_obj: object, _msg: string) => {}),
+  };
+}
+
+describe("logCesLine", () => {
+  test("pino JSON INFO line routes to log.info (not log.error)", () => {
+    const logger = makeLogger();
+    const line = JSON.stringify({
+      level: 30,
+      msg: "CES ready",
+      time: Date.now(),
+    });
+
+    logCesLine(line, 42, logger);
+
+    expect(logger.info).toHaveBeenCalledTimes(1);
+    expect(logger.error).not.toHaveBeenCalled();
+    expect(logger.warn).not.toHaveBeenCalled();
+    expect(logger.debug).not.toHaveBeenCalled();
+
+    const [meta, msg] = logger.info.mock.calls[0] as [object, string];
+    expect(meta).toEqual({ pid: 42 });
+    expect(msg).toBe(`[ces-stderr] ${line}`);
+  });
+
+  test("pino JSON ERROR line routes to log.error", () => {
+    const logger = makeLogger();
+    const line = JSON.stringify({
+      level: 50,
+      msg: "credential store failed",
+      time: Date.now(),
+    });
+
+    logCesLine(line, 42, logger);
+
+    expect(logger.error).toHaveBeenCalledTimes(1);
+    expect(logger.info).not.toHaveBeenCalled();
+    expect(logger.warn).not.toHaveBeenCalled();
+    expect(logger.debug).not.toHaveBeenCalled();
+  });
+
+  test("non-JSON fragment like 'args: []' routes to log.info", () => {
+    const logger = makeLogger();
+
+    logCesLine("args: []", 42, logger);
+
+    expect(logger.info).toHaveBeenCalledTimes(1);
+    expect(logger.error).not.toHaveBeenCalled();
+    expect(logger.warn).not.toHaveBeenCalled();
+    expect(logger.debug).not.toHaveBeenCalled();
+
+    const [meta, msg] = logger.info.mock.calls[0] as [object, string];
+    expect(meta).toEqual({ pid: 42 });
+    expect(msg).toBe("[ces-stderr] args: []");
+  });
+
+  test("non-JSON line starting with 'ERROR:' routes to log.error", () => {
+    const logger = makeLogger();
+
+    logCesLine("ERROR: bad thing happened", 42, logger);
+
+    expect(logger.error).toHaveBeenCalledTimes(1);
+    expect(logger.info).not.toHaveBeenCalled();
+    expect(logger.warn).not.toHaveBeenCalled();
+    expect(logger.debug).not.toHaveBeenCalled();
+  });
+
+  test("pino-pretty timestamped ERROR line routes to log.error", () => {
+    const logger = makeLogger();
+
+    logCesLine("[12:07:37.467] ERROR oh no", 42, logger);
+
+    expect(logger.error).toHaveBeenCalledTimes(1);
+    expect(logger.info).not.toHaveBeenCalled();
+    expect(logger.warn).not.toHaveBeenCalled();
+    expect(logger.debug).not.toHaveBeenCalled();
+  });
+
+  test("pino-pretty timestamped WARN line routes to log.warn", () => {
+    const logger = makeLogger();
+
+    logCesLine("[12:07:37.467] WARN wat", 42, logger);
+
+    expect(logger.warn).toHaveBeenCalledTimes(1);
+    expect(logger.error).not.toHaveBeenCalled();
+    expect(logger.info).not.toHaveBeenCalled();
+    expect(logger.debug).not.toHaveBeenCalled();
+  });
+
+  test("pino-pretty timestamped INFO line routes to log.info", () => {
+    const logger = makeLogger();
+
+    logCesLine("[12:07:37.467] INFO starting", 42, logger);
+
+    expect(logger.info).toHaveBeenCalledTimes(1);
+    expect(logger.error).not.toHaveBeenCalled();
+    expect(logger.warn).not.toHaveBeenCalled();
+    expect(logger.debug).not.toHaveBeenCalled();
+  });
+});

package/src/credential-execution/process-manager.ts

@@ -444,6 +444,69 @@ function createSocketTransport(socket: Socket): CesTransport {
 // Helpers
 // ---------------------------------------------------------------------------
 
+/**
+ * Route a single CES stderr line to the appropriate log level so that
+ * only genuine errors reach the Sentry stream.
+ *
+ * CES is a pino-backed child process that writes INFO/DEBUG/WARN/ERROR
+ * all to stderr (stdout is reserved for the stdio-RPC transport). We
+ * parse the embedded pino level (JSON path) or match a severity prefix
+ * (pretty-printed path) and route each line to the matching log method.
+ *
+ * Exported for testing.
+ */
+export function logCesLine(
+  line: string,
+  pid: number | undefined,
+  logger: {
+    debug: (obj: object, msg: string) => void;
+    info: (obj: object, msg: string) => void;
+    warn: (obj: object, msg: string) => void;
+    error: (obj: object, msg: string) => void;
+  } = log,
+): void {
+  const meta = { pid };
+  const msg = `[ces-stderr] ${line}`;
+
+  // Pino JSON path: parse the line and bucket by numeric `level`.
+  try {
+    const parsed = JSON.parse(line);
+    if (
+      parsed &&
+      typeof parsed === "object" &&
+      typeof (parsed as { level?: unknown }).level === "number"
+    ) {
+      const level = (parsed as { level: number }).level;
+      if (level >= 50) {
+        logger.error(meta, msg);
+      } else if (level >= 40) {
+        logger.warn(meta, msg);
+      } else if (level >= 30) {
+        logger.info(meta, msg);
+      } else {
+        logger.debug(meta, msg);
+      }
+      return;
+    }
+  } catch {
+    // Not JSON — fall through to prefix-based routing.
+  }
+
+  // Pretty-printed / fragment path: look for a level prefix on the line.
+  // Strip an optional pino-pretty-style leading timestamp: "[HH:MM:SS.mmm] ".
+  const prefixStripped = line.replace(
+    /^\[\d{1,2}:\d{2}:\d{2}(?:\.\d{1,3})?\]\s+/,
+    "",
+  );
+  if (/^(FATAL|ERROR)\b/i.test(prefixStripped)) {
+    logger.error(meta, msg);
+  } else if (/^(WARN|WARNING)\b/i.test(prefixStripped)) {
+    logger.warn(meta, msg);
+  } else {
+    logger.info(meta, msg);
+  }
+}
+
 function forwardStderrToLogger(proc: Subprocess): void {
   if (!proc.stderr || typeof proc.stderr === "number") return;
 
@@ -462,11 +525,11 @@ function forwardStderrToLogger(proc: Subprocess): void {
         while ((newlineIdx = buffer.indexOf("\n")) !== -1) {
           const line = buffer.slice(0, newlineIdx).trimEnd();
           buffer = buffer.slice(newlineIdx + 1);
-          if (line) log.error({ pid: proc.pid }, `[ces-stderr] ${line}`);
+          if (line) logCesLine(line, proc.pid);
         }
       }
       const trailing = buffer.trimEnd();
-      if (trailing) log.error({ pid: proc.pid }, `[ces-stderr] ${trailing}`);
+      if (trailing) logCesLine(trailing, proc.pid);
     } catch {
       // Process ended or stream closed; nothing to forward.
     }

package/src/credential-health/credential-health-service.ts

@@ -16,6 +16,7 @@ import {
   oauthConnectionAccessTokenPath,
 } from "@vellumai/credential-storage";
 
+import { manualTokenAccessCredentialKey } from "../oauth/manual-token-connection.js";
 import {
   getProvider,
   listActiveConnectionsByProvider,
@@ -100,7 +101,9 @@ async function pingProvider(
 
   const body =
     method !== "GET" && pingBody
-      ? (typeof pingBody === "string" ? pingBody : JSON.stringify(pingBody))
+      ? typeof pingBody === "string"
+        ? pingBody
+        : JSON.stringify(pingBody)
       : undefined;
 
   try {
@@ -155,12 +158,22 @@ async function checkConnection(
     pingBody,
   } = opts;
 
-  const base = { connectionId, provider, accountInfo, missingScopes: [] as string[] };
+  const base = {
+    connectionId,
+    provider,
+    accountInfo,
+    missingScopes: [] as string[],
+  };
 
-  // 1. Check token presence
-  const token = await getSecureKeyAsync(
-    oauthConnectionAccessTokenPath(connectionId),
-  );
+  // 1. Check token presence. Manual-token providers (e.g. slack_channel,
+  // telegram) store their primary token under credential/<provider>/<field>
+  // rather than oauth_connection/<id>/access_token, so resolve the correct
+  // path before looking up the token — otherwise the lookup always returns
+  // null and marks these providers as "missing_token".
+  const tokenPath =
+    manualTokenAccessCredentialKey(provider) ??
+    oauthConnectionAccessTokenPath(connectionId);
+  const token = await getSecureKeyAsync(tokenPath);
   if (!token) {
     return {
       ...base,

package/src/daemon/__tests__/conversation-feed-event.test.ts

@@ -0,0 +1,317 @@
+/**
+ * Tests for the background conversation feed event emission logic in
+ * conversation-agent-loop.ts.
+ *
+ * Rather than running the full agent loop, these tests exercise the
+ * extraction logic in isolation by simulating the conditions under which
+ * emitFeedEvent is called: conversation type, message content, and title.
+ */
+
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Module-level mocks — must be in place before importing the module under test
+// ---------------------------------------------------------------------------
+
+const emitFeedEventSpy = mock<
+  (params: {
+    source: string;
+    title: string;
+    summary: string;
+    dedupKey?: string;
+  }) => Promise<unknown>
+>(async () => ({}));
+
+mock.module("../../home/emit-feed-event.js", () => ({
+  emitFeedEvent: emitFeedEventSpy,
+}));
+
+const getConversationSpy = mock<
+  (id: string) => {
+    conversationType: string;
+    title: string | null;
+  } | null
+>(() => null);
+
+const getMessageByIdSpy = mock<
+  (
+    messageId: string,
+    conversationId?: string,
+  ) => { id: string; content: string } | null
+>(() => null);
+
+// We need to stub enough of conversation-crud to avoid DB initialization.
+// The actual agent loop imports getConversation and getMessageById from
+// conversation-crud — we intercept those here for test assertions.
+mock.module("../../memory/conversation-crud.js", () => ({
+  getConversation: getConversationSpy,
+  getMessageById: getMessageByIdSpy,
+  // Stubs for other exports that may be transitively referenced:
+  addMessage: () => {},
+  clearStrippedInjectionMetadataForConversation: () => {},
+  deleteMessageById: () => {},
+  getConversationOriginChannel: () => null,
+  getConversationOriginInterface: () => null,
+  getLastUserTimestampBefore: () => null,
+  provenanceFromTrustContext: () => ({}),
+  updateConversationContextWindow: () => {},
+  updateConversationTitle: () => {},
+  updateMessageMetadata: () => {},
+}));
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Simulates the feed-event emission logic from conversation-agent-loop.ts.
+ *
+ * This mirrors the block inserted after `message_complete` so we can test it
+ * in isolation without spinning up the full agent loop infrastructure.
+ */
+/**
+ * Tracks the last warning logged by simulateFeedEventEmission, so tests can
+ * assert that malformed content is swallowed gracefully.
+ */
+let lastFeedEventWarning: unknown = undefined;
+
+function simulateFeedEventEmission(
+  conversationId: string,
+  lastAssistantMessageId: string | undefined,
+): void {
+  lastFeedEventWarning = undefined;
+  try {
+    const conv = getConversationSpy(conversationId);
+    if (
+      conv &&
+      (conv.conversationType === "background" ||
+        conv.conversationType === "scheduled")
+    ) {
+      const lastMsg = lastAssistantMessageId
+        ? getMessageByIdSpy(lastAssistantMessageId, conversationId)
+        : undefined;
+      let summary: string;
+      if (lastMsg) {
+        const parsed: unknown = JSON.parse(lastMsg.content);
+        if (typeof parsed === "string") {
+          summary = parsed.slice(0, 200);
+        } else if (Array.isArray(parsed)) {
+          const textBlock = (
+            parsed as Array<{ type?: string; text?: string }>
+          ).find((b) => b.type === "text");
+          summary =
+            typeof textBlock?.text === "string"
+              ? textBlock.text.slice(0, 200)
+              : (conv.title ?? "Background task completed.");
+        } else {
+          summary = conv.title ?? "Background task completed.";
+        }
+      } else {
+        summary = conv.title ?? "Background task completed.";
+      }
+      void emitFeedEventSpy({
+        source: "assistant",
+        title: conv.title ?? "Background Task",
+        summary,
+        dedupKey: `bg-conv:${conversationId}`,
+      });
+    }
+  } catch (feedErr) {
+    lastFeedEventWarning = feedErr;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("background conversation feed event", () => {
+  beforeEach(() => {
+    emitFeedEventSpy.mockClear();
+    getConversationSpy.mockClear();
+    getMessageByIdSpy.mockClear();
+  });
+
+  afterEach(() => {
+    emitFeedEventSpy.mockReset();
+    getConversationSpy.mockReset();
+    getMessageByIdSpy.mockReset();
+  });
+
+  test("emits feed event for background conversation with text content", () => {
+    const convId = "conv-bg-123";
+    const msgId = "msg-456";
+
+    getConversationSpy.mockReturnValue({
+      conversationType: "background",
+      title: "Nightly Cleanup",
+    });
+    getMessageByIdSpy.mockReturnValue({
+      id: msgId,
+      content: JSON.stringify([
+        { type: "text", text: "Cleaned up 42 files successfully." },
+      ]),
+    });
+
+    simulateFeedEventEmission(convId, msgId);
+
+    expect(emitFeedEventSpy).toHaveBeenCalledTimes(1);
+    expect(emitFeedEventSpy).toHaveBeenCalledWith({
+      source: "assistant",
+      title: "Nightly Cleanup",
+      summary: "Cleaned up 42 files successfully.",
+      dedupKey: `bg-conv:${convId}`,
+    });
+  });
+
+  test("emits feed event for scheduled conversation", () => {
+    const convId = "conv-sched-789";
+    const msgId = "msg-101";
+
+    getConversationSpy.mockReturnValue({
+      conversationType: "scheduled",
+      title: "Weekly Report",
+    });
+    getMessageByIdSpy.mockReturnValue({
+      id: msgId,
+      content: JSON.stringify([{ type: "text", text: "Report generated." }]),
+    });
+
+    simulateFeedEventEmission(convId, msgId);
+
+    expect(emitFeedEventSpy).toHaveBeenCalledTimes(1);
+    expect(emitFeedEventSpy).toHaveBeenCalledWith({
+      source: "assistant",
+      title: "Weekly Report",
+      summary: "Report generated.",
+      dedupKey: `bg-conv:${convId}`,
+    });
+  });
+
+  test("truncates summary to 200 characters", () => {
+    const convId = "conv-bg-long";
+    const msgId = "msg-long";
+    const longText = "A".repeat(300);
+
+    getConversationSpy.mockReturnValue({
+      conversationType: "background",
+      title: "Long Task",
+    });
+    getMessageByIdSpy.mockReturnValue({
+      id: msgId,
+      content: JSON.stringify([{ type: "text", text: longText }]),
+    });
+
+    simulateFeedEventEmission(convId, msgId);
+
+    expect(emitFeedEventSpy).toHaveBeenCalledTimes(1);
+    const call = emitFeedEventSpy.mock.calls[0]![0];
+    expect(call.summary).toHaveLength(200);
+    expect(call.summary).toBe(longText.slice(0, 200));
+  });
+
+  test("falls back to conversation title when no text block in content", () => {
+    const convId = "conv-bg-notext";
+    const msgId = "msg-notext";
+
+    getConversationSpy.mockReturnValue({
+      conversationType: "background",
+      title: "Image Task",
+    });
+    getMessageByIdSpy.mockReturnValue({
+      id: msgId,
+      content: JSON.stringify([{ type: "image", source: { data: "..." } }]),
+    });
+
+    simulateFeedEventEmission(convId, msgId);
+
+    expect(emitFeedEventSpy).toHaveBeenCalledTimes(1);
+    expect(emitFeedEventSpy.mock.calls[0]![0].summary).toBe("Image Task");
+  });
+
+  test("falls back to default summary when no message and no title", () => {
+    const convId = "conv-bg-notitle";
+
+    getConversationSpy.mockReturnValue({
+      conversationType: "background",
+      title: null,
+    });
+
+    simulateFeedEventEmission(convId, undefined);
+
+    expect(emitFeedEventSpy).toHaveBeenCalledTimes(1);
+    const call = emitFeedEventSpy.mock.calls[0]![0];
+    expect(call.title).toBe("Background Task");
+    expect(call.summary).toBe("Background task completed.");
+  });
+
+  test("does NOT emit feed event for standard (foreground) conversations", () => {
+    const convId = "conv-standard-1";
+
+    getConversationSpy.mockReturnValue({
+      conversationType: "standard",
+      title: "Regular Chat",
+    });
+
+    simulateFeedEventEmission(convId, undefined);
+
+    expect(emitFeedEventSpy).not.toHaveBeenCalled();
+  });
+
+  test("does NOT emit feed event for private conversations", () => {
+    const convId = "conv-private-1";
+
+    getConversationSpy.mockReturnValue({
+      conversationType: "private",
+      title: "Secret Chat",
+    });
+
+    simulateFeedEventEmission(convId, undefined);
+
+    expect(emitFeedEventSpy).not.toHaveBeenCalled();
+  });
+
+  test("uses dedupKey per conversation for in-place updates", () => {
+    const convId = "conv-bg-dedup";
+
+    getConversationSpy.mockReturnValue({
+      conversationType: "background",
+      title: "Recurring Job",
+    });
+
+    // First run
+    simulateFeedEventEmission(convId, undefined);
+    // Second run (re-run of same conversation)
+    simulateFeedEventEmission(convId, undefined);
+
+    expect(emitFeedEventSpy).toHaveBeenCalledTimes(2);
+    // Both calls use the same dedupKey
+    expect(emitFeedEventSpy.mock.calls[0]![0].dedupKey).toBe(
+      `bg-conv:${convId}`,
+    );
+    expect(emitFeedEventSpy.mock.calls[1]![0].dedupKey).toBe(
+      `bg-conv:${convId}`,
+    );
+  });
+
+  test("swallows malformed JSON content without throwing", () => {
+    const convId = "conv-bg-badjson";
+    const msgId = "msg-badjson";
+
+    getConversationSpy.mockReturnValue({
+      conversationType: "background",
+      title: "Bad JSON Task",
+    });
+    getMessageByIdSpy.mockReturnValue({
+      id: msgId,
+      content: "this is not valid JSON {{{",
+    });
+
+    // Should not throw
+    expect(() => simulateFeedEventEmission(convId, msgId)).not.toThrow();
+    // The error was caught and logged as a warning
+    expect(lastFeedEventWarning).toBeInstanceOf(SyntaxError);
+    // emitFeedEvent should NOT have been called
+    expect(emitFeedEventSpy).not.toHaveBeenCalled();
+  });
+});

package/src/daemon/__tests__/conversation-lifecycle-auto-analyze.test.ts

@@ -7,9 +7,9 @@
  * `auto-analyze` feature flag and source-type guard).
  *
  * We stub the downstream enqueue helpers and the side-effecting lifecycle
- * deps (hook manager, notifier/skill cleanup, browser-screencast) so the test
- * can invoke `disposeConversation` with a minimal `DisposeContext` and assert
- * on the enqueue bookkeeping alone.
+ * deps (notifier/skill cleanup, browser-screencast) so the test can invoke
+ * `disposeConversation` with a minimal `DisposeContext` and assert on the
+ * enqueue bookkeeping alone.
  *
  * Two recursion guards apply when the source conversation is itself an
  * auto-analysis conversation:
@@ -83,19 +83,12 @@ mock.module("../../memory/auto-analysis-enqueue.js", () => ({
 
 // Stub all side-effecting cleanup helpers that disposeConversation chains
 // into after the enqueue block. We assert on enqueue behavior only.
-mock.module("../../hooks/manager.js", () => ({
-  getHookManager: () => ({
-    trigger: () => undefined,
-  }),
-}));
-
 mock.module("../../tools/browser/browser-screencast.js", () => ({
   unregisterConversationSender: () => {},
 }));
 
 mock.module("../conversation-notifiers.js", () => ({
   unregisterCallNotifiers: () => {},
-  unregisterWatchNotifiers: () => {},
 }));
 
 mock.module("../conversation-skill-tools.js", () => ({
@@ -105,8 +98,7 @@ mock.module("../conversation-skill-tools.js", () => ({
 // Dynamic import after mock.module calls so stubs take effect.
 const { disposeConversation } = await import("../conversation-lifecycle.js");
 type DisposeContext = import("../conversation-lifecycle.js").DisposeContext;
-type TrustClass =
-  import("../../runtime/actor-trust-resolver.js").TrustClass;
+type TrustClass = import("../../runtime/actor-trust-resolver.js").TrustClass;
 
 // ---------------------------------------------------------------------------
 // Fixture builder — minimal DisposeContext satisfying the interface shape.