@vellumai/assistant 0.4.43 → 0.4.44

package/src/cli/commands/twitter/__tests__/cli-routing.test.ts

@@ -8,19 +8,12 @@ let mockOauthPostResult: {
   url?: string;
 } | null = null;
 let mockOauthPostError: Error | null = null;
-let mockBrowserPostResult: {
-  tweetId: string;
-  text: string;
-  url: string;
-} | null = null;
-let mockBrowserPostError: Error | null = null;
 let mockManagedPostResult: { data: unknown; status: number } | null = null;
 let mockManagedPostError: Error | null = null;
 
 // Mock the OAuth client
 mock.module("../oauth-client.js", () => ({
   oauthIsAvailable: (token?: string) => token != null && token.length > 0,
-  oauthSupportsOperation: (op: string) => op === "post" || op === "reply",
   oauthPostTweet: async (
     _text: string,
     _opts: { inReplyToTweetId?: string; oauthToken: string },
@@ -29,16 +22,6 @@ mock.module("../oauth-client.js", () => ({
     if (mockOauthPostResult) return mockOauthPostResult;
     throw new Error("OAuth mock not configured");
   },
-  UnsupportedOAuthOperationError: class UnsupportedOAuthOperationError extends Error {
-    public readonly suggestFallback = true;
-    public readonly fallbackPath = "browser" as const;
-    public readonly operation: string;
-    constructor(operation: string) {
-      super(`The "${operation}" operation is not available via the OAuth API.`);
-      this.name = "UnsupportedOAuthOperationError";
-      this.operation = operation;
-    }
-  },
 }));
 
 // Mock TwitterProxyError for managed path tests
@@ -70,24 +53,6 @@ mock.module("../../../../twitter/platform-proxy-client.js", () => ({
   TwitterProxyError: MockTwitterProxyError,
 }));
 
-// Create a SessionExpiredError class that matches the real one
-class MockSessionExpiredError extends Error {
-  constructor(reason: string) {
-    super(reason);
-    this.name = "SessionExpiredError";
-  }
-}
-
-// Mock the browser client
-mock.module("../client.js", () => ({
-  postTweet: async (_text: string, _opts?: { inReplyToTweetId?: string }) => {
-    if (mockBrowserPostError) throw mockBrowserPostError;
-    if (mockBrowserPostResult) return mockBrowserPostResult;
-    throw new Error("Browser mock not configured");
-  },
-  SessionExpiredError: MockSessionExpiredError,
-}));
-
 // Mock the logger to silence output
 mock.module("../../../../util/logger.js", () => ({
   getLogger: () => ({
@@ -111,114 +76,25 @@ import { routedPostTweet } from "../router.js";
 beforeEach(() => {
   mockOauthPostResult = null;
   mockOauthPostError = null;
-  mockBrowserPostResult = null;
-  mockBrowserPostError = null;
   mockManagedPostResult = null;
   mockManagedPostError = null;
 });
 
-describe("Twitter strategy router", () => {
-  describe("auto strategy", () => {
-    test("uses OAuth when available and supported", async () => {
-      mockOauthPostResult = {
-        tweetId: "111",
-        text: "hello",
-        url: "https://x.com/u/status/111",
-      };
-
-      const { result, pathUsed } = await routedPostTweet("hello", {
-        strategy: "auto",
-        oauthToken: "test-token",
-      });
-
-      expect(pathUsed).toBe("oauth");
-      expect(result.tweetId).toBe("111");
-      expect(result.text).toBe("hello");
-      expect(result.url).toBe("https://x.com/u/status/111");
-    });
-
-    test("falls back to browser when OAuth is unavailable", async () => {
-      mockBrowserPostResult = {
-        tweetId: "222",
-        text: "hello",
-        url: "https://x.com/u/status/222",
-      };
-
-      const { result, pathUsed } = await routedPostTweet("hello", {
-        strategy: "auto",
-      });
-
-      expect(pathUsed).toBe("browser");
-      expect(result.tweetId).toBe("222");
-    });
-
-    test("falls back to browser when OAuth fails", async () => {
-      mockOauthPostError = new Error("OAuth token expired");
-      mockBrowserPostResult = {
-        tweetId: "333",
-        text: "hello",
-        url: "https://x.com/u/status/333",
-      };
-
-      const { result, pathUsed } = await routedPostTweet("hello", {
-        strategy: "auto",
-        oauthToken: "test-token",
-      });
-
-      expect(pathUsed).toBe("browser");
-      expect(result.tweetId).toBe("333");
-    });
-
-    test("constructs URL from tweetId when OAuth result has no url", async () => {
-      mockOauthPostResult = { tweetId: "444", text: "no url" };
-
-      const { result, pathUsed } = await routedPostTweet("no url", {
-        strategy: "auto",
-        oauthToken: "test-token",
-      });
-
-      expect(pathUsed).toBe("oauth");
-      expect(result.url).toBe("https://x.com/i/status/444");
-    });
-
-    test("throws combined error when both OAuth and browser fail with SessionExpiredError", async () => {
-      mockOauthPostError = new Error("OAuth failed");
-      mockBrowserPostError = new MockSessionExpiredError(
-        "Browser session expired",
-      );
-
-      try {
-        await routedPostTweet("will fail", {
-          strategy: "auto",
-          oauthToken: "test-token",
-        });
-        expect(true).toBe(false); // should not reach
-      } catch (err) {
-        const e = err as Error & { pathUsed: string; oauthError?: string };
-        expect(e).toBeInstanceOf(MockSessionExpiredError);
-        expect(e.message).toBe("Browser session expired");
-        expect(e.pathUsed).toBe("auto");
-        expect(e.oauthError).toBe("OAuth failed");
-      }
-    });
-  });
-
-  describe("explicit oauth strategy", () => {
+describe("Twitter mode router", () => {
+  describe("explicit oauth mode", () => {
     test("fails with helpful error when OAuth is not configured", async () => {
       try {
-        await routedPostTweet("hello", { strategy: "oauth" });
+        await routedPostTweet("hello", { mode: "oauth" });
         expect(true).toBe(false); // should not reach
       } catch (err) {
         const e = err as Error & {
           pathUsed: string;
-          suggestAlternative: string;
         };
         expect(e.message).toContain("OAuth is not configured");
         expect(e.message).toContain(
-          "assistant config set twitter.operationStrategy browser",
+          "Connect your X developer credentials to set up OAuth",
         );
         expect(e.pathUsed).toBe("oauth");
-        expect(e.suggestAlternative).toBe("browser");
       }
     });
 
@@ -226,63 +102,28 @@ describe("Twitter strategy router", () => {
       mockOauthPostResult = { tweetId: "555", text: "oauth post" };
 
       const { result, pathUsed } = await routedPostTweet("oauth post", {
-        strategy: "oauth",
+        mode: "oauth",
         oauthToken: "test-token",
       });
 
       expect(pathUsed).toBe("oauth");
       expect(result.tweetId).toBe("555");
     });
-  });
 
-  describe("explicit browser strategy", () => {
-    test("uses browser directly, ignoring OAuth availability", async () => {
-      mockBrowserPostResult = {
-        tweetId: "666",
-        text: "browser post",
-        url: "https://x.com/u/status/666",
-      };
+    test("constructs URL from tweetId when OAuth result has no url", async () => {
+      mockOauthPostResult = { tweetId: "444", text: "no url" };
 
-      const { result, pathUsed } = await routedPostTweet("browser post", {
-        strategy: "browser",
-        oauthToken: "test-token", // available but should be ignored
+      const { result, pathUsed } = await routedPostTweet("no url", {
+        mode: "oauth",
+        oauthToken: "test-token",
       });
 
-      expect(pathUsed).toBe("browser");
-      expect(result.tweetId).toBe("666");
-    });
-
-    test("preserves SessionExpiredError type with router metadata", async () => {
-      mockBrowserPostError = new MockSessionExpiredError("Session expired");
-
-      try {
-        await routedPostTweet("will fail", { strategy: "browser" });
-        expect(true).toBe(false); // should not reach
-      } catch (err) {
-        const e = err as Error & {
-          pathUsed: string;
-          suggestAlternative: string;
-        };
-        expect(e).toBeInstanceOf(MockSessionExpiredError);
-        expect(e.message).toBe("Session expired");
-        expect(e.pathUsed).toBe("browser");
-        expect(e.suggestAlternative).toBe("oauth");
-      }
-    });
-
-    test("re-throws non-session errors without wrapping", async () => {
-      mockBrowserPostError = new Error("Network failure");
-
-      try {
-        await routedPostTweet("will fail", { strategy: "browser" });
-        expect(true).toBe(false); // should not reach
-      } catch (err) {
-        expect((err as Error).message).toBe("Network failure");
-      }
+      expect(pathUsed).toBe("oauth");
+      expect(result.url).toBe("https://x.com/i/status/444");
     });
   });
 
-  describe("managed strategy", () => {
+  describe("managed mode", () => {
     test("routes post through platform proxy", async () => {
       mockManagedPostResult = {
         data: { data: { id: "managed-1" } },
@@ -290,7 +131,7 @@ describe("Twitter strategy router", () => {
       };
 
       const { result, pathUsed } = await routedPostTweet("managed post", {
-        strategy: "managed",
+        mode: "managed",
       });
 
       expect(pathUsed).toBe("managed");
@@ -305,7 +146,7 @@ describe("Twitter strategy router", () => {
       };
 
       const { result, pathUsed } = await routedPostTweet("reply text", {
-        strategy: "managed",
+        mode: "managed",
         inReplyToTweetId: "original-tweet-123",
       });
 
@@ -322,7 +163,7 @@ describe("Twitter strategy router", () => {
       );
 
       try {
-        await routedPostTweet("will fail", { strategy: "managed" });
+        await routedPostTweet("will fail", { mode: "managed" });
         expect(true).toBe(false); // should not reach
       } catch (err) {
         const e = err as Error & {
@@ -348,7 +189,7 @@ describe("Twitter strategy router", () => {
       );
 
       try {
-        await routedPostTweet("will fail", { strategy: "managed" });
+        await routedPostTweet("will fail", { mode: "managed" });
         expect(true).toBe(false);
       } catch (err) {
         const e = err as Error & {
@@ -366,7 +207,7 @@ describe("Twitter strategy router", () => {
       mockManagedPostError = new Error("Network failure");
 
       try {
-        await routedPostTweet("will fail", { strategy: "managed" });
+        await routedPostTweet("will fail", { mode: "managed" });
         expect(true).toBe(false);
       } catch (err) {
         expect((err as Error).message).toBe("Network failure");
@@ -376,7 +217,7 @@ describe("Twitter strategy router", () => {
   });
 
   describe("reply routing", () => {
-    test("auto strategy routes reply through OAuth when available", async () => {
+    test("oauth mode routes reply through OAuth when available", async () => {
       mockOauthPostResult = {
         tweetId: "777",
         text: "reply text",
@@ -385,7 +226,7 @@ describe("Twitter strategy router", () => {
 
       const { result, pathUsed } = await routedPostTweet("reply text", {
         inReplyToTweetId: "100",
-        strategy: "auto",
+        mode: "oauth",
         oauthToken: "test-token",
       });
 
@@ -393,19 +234,18 @@ describe("Twitter strategy router", () => {
       expect(result.tweetId).toBe("777");
     });
 
-    test("browser strategy routes reply through browser", async () => {
-      mockBrowserPostResult = {
-        tweetId: "888",
-        text: "reply text",
-        url: "https://x.com/u/status/888",
+    test("managed mode routes reply through platform proxy", async () => {
+      mockManagedPostResult = {
+        data: { data: { id: "888" } },
+        status: 200,
       };
 
       const { result, pathUsed } = await routedPostTweet("reply text", {
         inReplyToTweetId: "200",
-        strategy: "browser",
+        mode: "managed",
       });
 
-      expect(pathUsed).toBe("browser");
+      expect(pathUsed).toBe("managed");
       expect(result.tweetId).toBe("888");
     });
   });

package/src/cli/commands/twitter/__tests__/oauth-client.test.ts

@@ -19,12 +19,7 @@ mock.module("../../../../util/logger.js", () => ({
   }),
 }));
 
-import {
-  oauthIsAvailable,
-  oauthPostTweet,
-  oauthSupportsOperation,
-  UnsupportedOAuthOperationError,
-} from "../oauth-client.js";
+import { oauthIsAvailable, oauthPostTweet } from "../oauth-client.js";
 
 // --- Global fetch mock ---
 
@@ -153,45 +148,4 @@ describe("Twitter OAuth client", () => {
       expect(oauthIsAvailable("")).toBe(false);
     });
   });
-
-  describe("oauthSupportsOperation", () => {
-    test("returns true for post", () => {
-      expect(oauthSupportsOperation("post")).toBe(true);
-    });
-
-    test("returns true for reply", () => {
-      expect(oauthSupportsOperation("reply")).toBe(true);
-    });
-
-    test("returns false for unsupported operations", () => {
-      const unsupported = [
-        "timeline",
-        "search",
-        "bookmarks",
-        "home",
-        "notifications",
-        "likes",
-        "followers",
-        "following",
-        "media",
-        "tweet",
-      ];
-      for (const op of unsupported) {
-        expect(oauthSupportsOperation(op)).toBe(false);
-      }
-    });
-  });
-
-  describe("UnsupportedOAuthOperationError", () => {
-    test("has correct properties", () => {
-      const err = new UnsupportedOAuthOperationError("search");
-      expect(err.name).toBe("UnsupportedOAuthOperationError");
-      expect(err.operation).toBe("search");
-      expect(err.suggestFallback).toBe(true);
-      expect(err.fallbackPath).toBe("browser");
-      expect(err.message).toContain("search");
-      expect(err.message).toContain("not available via the OAuth API");
-      expect(err).toBeInstanceOf(Error);
-    });
-  });
 });