@vellumai/assistant 0.4.46 → 0.4.49

package/src/watcher/providers/linear.ts

@@ -13,7 +13,8 @@
  * and issues.
  */
 
-import { withValidToken } from "../../security/token-manager.js";
+import type { OAuthConnection } from "../../oauth/connection.js";
+import { resolveOAuthConnection } from "../../oauth/connection-resolver.js";
 import { getLogger } from "../../util/logger.js";
 import { truncate } from "../../util/truncate.js";
 import type {
@@ -24,8 +25,6 @@ import type {
 
 const log = getLogger("watcher:linear");
 
-const LINEAR_GRAPHQL_URL = "https://api.linear.app/graphql";
-
 // ── GraphQL response types ────────────────────────────────────────────────────
 
 interface LinearNotification {
@@ -89,27 +88,23 @@ interface LinearViewer {
 // ── GraphQL helpers ───────────────────────────────────────────────────────────
 
 async function graphql<T>(
-  token: string,
+  connection: OAuthConnection,
   query: string,
   variables?: Record<string, unknown>,
 ): Promise<T> {
-  const resp = await fetch(LINEAR_GRAPHQL_URL, {
+  const resp = await connection.request({
     method: "POST",
-    headers: {
-      // Linear accepts both personal API keys and OAuth tokens; the Bearer scheme
-      // is required for all token types per Linear's API docs.
-      Authorization: `Bearer ${token}`,
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify({ query, variables }),
+    path: "/graphql",
+    body: { query, variables },
   });
 
-  if (!resp.ok) {
-    const body = await resp.text().catch(() => "");
+  if (resp.status >= 400) {
+    const body =
+      typeof resp.body === "string" ? resp.body : JSON.stringify(resp.body);
     throw new Error(`Linear API ${resp.status}: ${body}`);
   }
 
-  const result = (await resp.json()) as {
+  const result = resp.body as {
     data?: T;
     errors?: Array<{ message: string }>;
   };
@@ -128,9 +123,9 @@ async function graphql<T>(
 }
 
 /** Fetch the authenticated user's ID and name. */
-async function fetchViewer(token: string): Promise<LinearViewer> {
+async function fetchViewer(connection: OAuthConnection): Promise<LinearViewer> {
   const data = await graphql<{ viewer: LinearViewer }>(
-    token,
+    connection,
     `
       query {
         viewer {
@@ -150,7 +145,7 @@ async function fetchViewer(token: string): Promise<LinearViewer> {
  * between polls.
  */
 async function fetchNotifications(
-  token: string,
+  connection: OAuthConnection,
   since: string,
 ): Promise<LinearNotification[]> {
   const allNodes: LinearNotification[] = [];
@@ -165,7 +160,7 @@ async function fetchNotifications(
 
   do {
     const data: NotificationsResponse = await graphql<NotificationsResponse>(
-      token,
+      connection,
       `
         query FetchNotifications($after: DateTime, $cursor: String) {
           notifications(
@@ -242,7 +237,7 @@ async function fetchNotifications(
  * `pageInfo.hasNextPage` is false so updates beyond the first 50 aren't skipped.
  */
 async function fetchAssignedIssueUpdates(
-  token: string,
+  connection: OAuthConnection,
   viewerId: string,
   since: string,
 ): Promise<LinearIssue[]> {
@@ -258,7 +253,7 @@ async function fetchAssignedIssueUpdates(
 
   do {
     const data: IssuesResponse = await graphql<IssuesResponse>(
-      token,
+      connection,
       `
         query FetchAssignedIssues(
           $assigneeId: ID
@@ -319,7 +314,7 @@ async function fetchAssignedIssueUpdates(
  * complete set — needed for accurate eviction and reassignment detection.
  */
 async function fetchAllAssignedIssueIds(
-  token: string,
+  connection: OAuthConnection,
   viewerId: string,
 ): Promise<Set<string>> {
   const ids = new Set<string>();
@@ -334,7 +329,7 @@ async function fetchAllAssignedIssueIds(
 
   do {
     const data: IdsResponse = await graphql<IdsResponse>(
-      token,
+      connection,
       `
         query FetchAllAssignedIssueIds($assigneeId: ID, $cursor: String) {
           issues(
@@ -517,87 +512,86 @@ export const linearProvider: WatcherProvider = {
     _config: Record<string, unknown>,
     watcherKey: string,
   ): Promise<FetchResult> {
-    return withValidToken(credentialService, async (token) => {
-      const since = watermark ?? new Date().toISOString();
+    const connection = resolveOAuthConnection(credentialService);
+    const since = watermark ?? new Date().toISOString();
 
-      // Resolve the authenticated viewer's ID once per poll for the assigned-issues query
-      const viewer = await fetchViewer(token);
+    // Resolve the authenticated viewer's ID once per poll for the assigned-issues query
+    const viewer = await fetchViewer(connection);
 
-      // Fetch notifications (assignments, mentions, status changes via notification feed)
-      const notifications = await fetchNotifications(token, since);
+    // Fetch notifications (assignments, mentions, status changes via notification feed)
+    const notifications = await fetchNotifications(connection, since);
 
-      // Only surface notification types that warrant attention
-      const relevantTypes = new Set([
-        "issueAssignedToYou",
-        "issueMentionedYou",
-        "issueCommentMentionedYou",
-        "issueStatusChanged",
-      ]);
+    // Only surface notification types that warrant attention
+    const relevantTypes = new Set([
+      "issueAssignedToYou",
+      "issueMentionedYou",
+      "issueCommentMentionedYou",
+      "issueStatusChanged",
+    ]);
 
-      const items: WatcherItem[] = [];
+    const items: WatcherItem[] = [];
 
-      for (const n of notifications) {
-        if (!relevantTypes.has(n.type)) continue;
-        items.push(notificationToItem(n));
-      }
+    for (const n of notifications) {
+      if (!relevantTypes.has(n.type)) continue;
+      items.push(notificationToItem(n));
+    }
 
-      // Fetch the complete set of currently assigned issue IDs (no updatedAt
-      // filter) so we can accurately evict stale cache entries and guard against
-      // false-positive status change events on reassignment.
-      const currentAssignedIds = await fetchAllAssignedIssueIds(
-        token,
-        viewer.id,
-      );
-      const previousAssignedIds = lastSeenAssignedIdsByWatcher.get(watcherKey);
-
-      // Also poll assigned issues directly for status changes not covered by
-      // notifications (e.g., bulk team updates). We only emit an event when the
-      // state ID differs from what we recorded on the previous poll — any other
-      // field update (title, description, etc.) does not constitute a status change.
-      // On first sight of an issue we seed the map without emitting, so we don't
-      // fire false-positive events after a daemon restart.
-      const assignedIssues = await fetchAssignedIssueUpdates(
-        token,
-        viewer.id,
-        since,
-      );
-      const stateCache = getStateCache(watcherKey);
-      for (const issue of assignedIssues) {
-        const previousStateId = stateCache.get(issue.id);
-        // Only emit a status change if: (1) we have a cached state that differs,
-        // AND (2) the issue was also assigned in the previous poll. Condition (2)
-        // prevents false-positive events when an issue is unassigned, changes
-        // state while unassigned, and is then reassigned.
-        const wasPreviouslySeen = previousAssignedIds?.has(issue.id) ?? false;
-        if (
-          previousStateId !== undefined &&
-          previousStateId !== issue.state.id &&
-          wasPreviouslySeen
-        ) {
-          items.push(issueToStatusChangeItem(issue, previousStateId));
-        }
-        stateCache.set(issue.id, issue.state.id);
+    // Fetch the complete set of currently assigned issue IDs (no updatedAt
+    // filter) so we can accurately evict stale cache entries and guard against
+    // false-positive status change events on reassignment.
+    const currentAssignedIds = await fetchAllAssignedIssueIds(
+      connection,
+      viewer.id,
+    );
+    const previousAssignedIds = lastSeenAssignedIdsByWatcher.get(watcherKey);
+
+    // Also poll assigned issues directly for status changes not covered by
+    // notifications (e.g., bulk team updates). We only emit an event when the
+    // state ID differs from what we recorded on the previous poll — any other
+    // field update (title, description, etc.) does not constitute a status change.
+    // On first sight of an issue we seed the map without emitting, so we don't
+    // fire false-positive events after a daemon restart.
+    const assignedIssues = await fetchAssignedIssueUpdates(
+      connection,
+      viewer.id,
+      since,
+    );
+    const stateCache = getStateCache(watcherKey);
+    for (const issue of assignedIssues) {
+      const previousStateId = stateCache.get(issue.id);
+      // Only emit a status change if: (1) we have a cached state that differs,
+      // AND (2) the issue was also assigned in the previous poll. Condition (2)
+      // prevents false-positive events when an issue is unassigned, changes
+      // state while unassigned, and is then reassigned.
+      const wasPreviouslySeen = previousAssignedIds?.has(issue.id) ?? false;
+      if (
+        previousStateId !== undefined &&
+        previousStateId !== issue.state.id &&
+        wasPreviouslySeen
+      ) {
+        items.push(issueToStatusChangeItem(issue, previousStateId));
       }
+      stateCache.set(issue.id, issue.state.id);
+    }
 
-      // Evict cached state for issues that left the assigned set so stale
-      // entries don't accumulate and don't cause false-positive events if the
-      // issue is later reassigned.
-      if (previousAssignedIds) {
-        for (const id of previousAssignedIds) {
-          if (!currentAssignedIds.has(id)) {
-            stateCache.delete(id);
-          }
+    // Evict cached state for issues that left the assigned set so stale
+    // entries don't accumulate and don't cause false-positive events if the
+    // issue is later reassigned.
+    if (previousAssignedIds) {
+      for (const id of previousAssignedIds) {
+        if (!currentAssignedIds.has(id)) {
+          stateCache.delete(id);
         }
       }
-      lastSeenAssignedIdsByWatcher.set(watcherKey, currentAssignedIds);
+    }
+    lastSeenAssignedIdsByWatcher.set(watcherKey, currentAssignedIds);
 
-      const newWatermark = new Date().toISOString();
-      log.info(
-        { count: items.length, viewer: viewer.name, watermark: newWatermark },
-        "Linear: fetched new notifications",
-      );
+    const newWatermark = new Date().toISOString();
+    log.info(
+      { count: items.length, viewer: viewer.name, watermark: newWatermark },
+      "Linear: fetched new notifications",
+    );
 
-      return { items, watermark: newWatermark };
-    });
+    return { items, watermark: newWatermark };
   },
 };

package/src/__tests__/computer-use-session-compaction.test.ts

@@ -1,143 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import { ComputerUseSession } from "../daemon/computer-use-session.js";
-import type { Message } from "../providers/types.js";
-
-/**
- * Helper to create a user message with a tool_result block containing
- * an AX tree wrapped in markers.
- */
-function toolResultMsg(content: string): Message {
-  return {
-    role: "user",
-    content: [
-      {
-        type: "tool_result",
-        tool_use_id: "test-id",
-        content,
-      },
-    ],
-  };
-}
-
-describe("ComputerUseSession.escapeAxTreeContent", () => {
-  test("escapes a literal closing tag in the content", () => {
-    const input = "some text </ax-tree> more text";
-    const escaped = ComputerUseSession.escapeAxTreeContent(input);
-    expect(escaped).toBe("some text &lt;/ax-tree&gt; more text");
-  });
-
-  test("escapes multiple occurrences", () => {
-    const input = "</ax-tree> hello </ax-tree>";
-    const escaped = ComputerUseSession.escapeAxTreeContent(input);
-    expect(escaped).toBe("&lt;/ax-tree&gt; hello &lt;/ax-tree&gt;");
-  });
-
-  test("is case-insensitive", () => {
-    const input = "</AX-TREE> and </Ax-Tree>";
-    const escaped = ComputerUseSession.escapeAxTreeContent(input);
-    expect(escaped).toBe("&lt;/ax-tree&gt; and &lt;/ax-tree&gt;");
-  });
-
-  test("leaves content without closing tags unchanged", () => {
-    const input = 'Window "My App" [1]\n  Button "OK" [2]';
-    expect(ComputerUseSession.escapeAxTreeContent(input)).toBe(input);
-  });
-});
-
-describe("ComputerUseSession.compactHistory", () => {
-  test("[experimental] strips old AX trees and keeps the most recent ones", () => {
-    const messages: Message[] = [
-      { role: "assistant", content: [{ type: "text", text: "thinking..." }] },
-      toolResultMsg(
-        '<ax-tree>CURRENT SCREEN STATE:\nWindow "App" [1]</ax-tree>',
-      ),
-      { role: "assistant", content: [{ type: "text", text: "action 1" }] },
-      toolResultMsg(
-        '<ax-tree>CURRENT SCREEN STATE:\nWindow "App" [2]</ax-tree>',
-      ),
-      { role: "assistant", content: [{ type: "text", text: "action 2" }] },
-      toolResultMsg(
-        '<ax-tree>CURRENT SCREEN STATE:\nWindow "App" [3]</ax-tree>',
-      ),
-    ];
-
-    const compacted = ComputerUseSession.compactHistory(messages);
-
-    // First AX tree (index 1) should be stripped
-    const firstToolResult = compacted[1].content[0];
-    expect(firstToolResult.type).toBe("tool_result");
-    if (firstToolResult.type === "tool_result") {
-      expect(firstToolResult.content).toContain("<ax_tree_omitted />");
-      expect(firstToolResult.content).not.toContain("<ax-tree>");
-    }
-
-    // Last two AX trees should be preserved
-    const secondToolResult = compacted[3].content[0];
-    if (secondToolResult.type === "tool_result") {
-      expect(secondToolResult.content).toContain("<ax-tree>");
-    }
-    const thirdToolResult = compacted[5].content[0];
-    if (thirdToolResult.type === "tool_result") {
-      expect(thirdToolResult.content).toContain("<ax-tree>");
-    }
-  });
-
-  test("[experimental] handles AX tree content containing literal </ax-tree> (escaped)", () => {
-    // Simulate content where the AX tree text includes an escaped closing tag,
-    // e.g. user is viewing XML source code with "</ax-tree>" in it.
-    const escapedContent =
-      '<ax-tree>CURRENT SCREEN STATE:\nTextArea "editor" [1]\n  ' +
-      "Line: &lt;/ax-tree&gt; some xml\n</ax-tree>";
-
-    const messages: Message[] = [
-      { role: "assistant", content: [{ type: "text", text: "action 0" }] },
-      toolResultMsg(escapedContent),
-      { role: "assistant", content: [{ type: "text", text: "action 1" }] },
-      toolResultMsg(escapedContent),
-      { role: "assistant", content: [{ type: "text", text: "action 2" }] },
-      toolResultMsg(
-        '<ax-tree>CURRENT SCREEN STATE:\nWindow "App" [3]</ax-tree>',
-      ),
-    ];
-
-    const compacted = ComputerUseSession.compactHistory(messages);
-
-    // The first message with escaped content should be fully stripped
-    const firstToolResult = compacted[1].content[0];
-    if (firstToolResult.type === "tool_result") {
-      expect(firstToolResult.content).not.toContain("<ax-tree>");
-      expect(firstToolResult.content).toContain("<ax_tree_omitted />");
-    }
-  });
-
-  test("regex fails on unescaped </ax-tree> inside content (demonstrating the bug)", () => {
-    // This test demonstrates what happens WITHOUT escaping: the regex
-    // only partially removes the AX tree block.
-    const unescapedContent =
-      '<ax-tree>CURRENT SCREEN STATE:\nTextArea "editor" [1]\n  ' +
-      "Line: </ax-tree> some xml leftover\n</ax-tree>";
-
-    const messages: Message[] = [
-      { role: "assistant", content: [{ type: "text", text: "action 0" }] },
-      toolResultMsg(unescapedContent),
-      { role: "assistant", content: [{ type: "text", text: "action 1" }] },
-      toolResultMsg(unescapedContent),
-      { role: "assistant", content: [{ type: "text", text: "action 2" }] },
-      toolResultMsg(
-        '<ax-tree>CURRENT SCREEN STATE:\nWindow "App" [3]</ax-tree>',
-      ),
-    ];
-
-    const compacted = ComputerUseSession.compactHistory(messages);
-
-    // Without escaping, the first tool result has leftover content after
-    // the regex only matched up to the FIRST </ax-tree>.
-    const firstToolResult = compacted[1].content[0];
-    if (firstToolResult.type === "tool_result") {
-      // The non-greedy regex stops at the first </ax-tree>, leaving
-      // " some xml leftover\n</ax-tree>" behind.
-      expect(firstToolResult.content).toContain("some xml leftover");
-    }
-  });
-});