@vellumai/assistant 0.4.43 → 0.4.45

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

@@ -1,412 +0,0 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-// --- Mocks (must be declared before importing the module under test) ---
-
-let mockOauthPostResult: {
-  tweetId: string;
-  text: string;
-  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 },
-  ) => {
-    if (mockOauthPostError) throw mockOauthPostError;
-    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
-class MockTwitterProxyError extends Error {
-  public readonly code: string;
-  public readonly retryable: boolean;
-  public readonly statusCode: number;
-  constructor(
-    message: string,
-    code: string,
-    retryable: boolean,
-    statusCode = 0,
-  ) {
-    super(message);
-    this.name = "TwitterProxyError";
-    this.code = code;
-    this.retryable = retryable;
-    this.statusCode = statusCode;
-  }
-}
-
-// Mock the platform proxy client
-mock.module("../../../../twitter/platform-proxy-client.js", () => ({
-  postTweet: async (_text: string, _opts?: { replyToId?: string }) => {
-    if (mockManagedPostError) throw mockManagedPostError;
-    if (mockManagedPostResult) return mockManagedPostResult;
-    throw new Error("Managed mock not configured");
-  },
-  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: () => ({
-    info: () => {},
-    warn: () => {},
-    error: () => {},
-    debug: () => {},
-    trace: () => {},
-    fatal: () => {},
-    child: () => ({
-      info: () => {},
-      warn: () => {},
-      error: () => {},
-      debug: () => {},
-    }),
-  }),
-}));
-
-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", () => {
-    test("fails with helpful error when OAuth is not configured", async () => {
-      try {
-        await routedPostTweet("hello", { strategy: "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",
-        );
-        expect(e.pathUsed).toBe("oauth");
-        expect(e.suggestAlternative).toBe("browser");
-      }
-    });
-
-    test("uses OAuth when available", async () => {
-      mockOauthPostResult = { tweetId: "555", text: "oauth post" };
-
-      const { result, pathUsed } = await routedPostTweet("oauth post", {
-        strategy: "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",
-      };
-
-      const { result, pathUsed } = await routedPostTweet("browser post", {
-        strategy: "browser",
-        oauthToken: "test-token", // available but should be ignored
-      });
-
-      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");
-      }
-    });
-  });
-
-  describe("managed strategy", () => {
-    test("routes post through platform proxy", async () => {
-      mockManagedPostResult = {
-        data: { data: { id: "managed-1" } },
-        status: 200,
-      };
-
-      const { result, pathUsed } = await routedPostTweet("managed post", {
-        strategy: "managed",
-      });
-
-      expect(pathUsed).toBe("managed");
-      expect(result.tweetId).toBe("managed-1");
-      expect(result.url).toBe("https://x.com/i/status/managed-1");
-    });
-
-    test("routes reply through platform proxy", async () => {
-      mockManagedPostResult = {
-        data: { data: { id: "managed-reply-1" } },
-        status: 200,
-      };
-
-      const { result, pathUsed } = await routedPostTweet("reply text", {
-        strategy: "managed",
-        inReplyToTweetId: "original-tweet-123",
-      });
-
-      expect(pathUsed).toBe("managed");
-      expect(result.tweetId).toBe("managed-reply-1");
-    });
-
-    test("surfaces proxy errors with actionable metadata", async () => {
-      mockManagedPostError = new MockTwitterProxyError(
-        "Connect Twitter in Settings as the assistant owner",
-        "owner_credential_required",
-        false,
-        403,
-      );
-
-      try {
-        await routedPostTweet("will fail", { strategy: "managed" });
-        expect(true).toBe(false); // should not reach
-      } catch (err) {
-        const e = err as Error & {
-          pathUsed: string;
-          proxyErrorCode: string;
-          retryable: boolean;
-        };
-        expect(e.message).toBe(
-          "Connect Twitter in Settings as the assistant owner",
-        );
-        expect(e.pathUsed).toBe("managed");
-        expect(e.proxyErrorCode).toBe("owner_credential_required");
-        expect(e.retryable).toBe(false);
-      }
-    });
-
-    test("surfaces retryable proxy errors", async () => {
-      mockManagedPostError = new MockTwitterProxyError(
-        "Reconnect Twitter or retry",
-        "auth_failure",
-        true,
-        401,
-      );
-
-      try {
-        await routedPostTweet("will fail", { strategy: "managed" });
-        expect(true).toBe(false);
-      } catch (err) {
-        const e = err as Error & {
-          pathUsed: string;
-          proxyErrorCode: string;
-          retryable: boolean;
-        };
-        expect(e.pathUsed).toBe("managed");
-        expect(e.proxyErrorCode).toBe("auth_failure");
-        expect(e.retryable).toBe(true);
-      }
-    });
-
-    test("re-throws non-proxy errors without wrapping", async () => {
-      mockManagedPostError = new Error("Network failure");
-
-      try {
-        await routedPostTweet("will fail", { strategy: "managed" });
-        expect(true).toBe(false);
-      } catch (err) {
-        expect((err as Error).message).toBe("Network failure");
-        expect((err as Record<string, unknown>).pathUsed).toBeUndefined();
-      }
-    });
-  });
-
-  describe("reply routing", () => {
-    test("auto strategy routes reply through OAuth when available", async () => {
-      mockOauthPostResult = {
-        tweetId: "777",
-        text: "reply text",
-        url: "https://x.com/u/status/777",
-      };
-
-      const { result, pathUsed } = await routedPostTweet("reply text", {
-        inReplyToTweetId: "100",
-        strategy: "auto",
-        oauthToken: "test-token",
-      });
-
-      expect(pathUsed).toBe("oauth");
-      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",
-      };
-
-      const { result, pathUsed } = await routedPostTweet("reply text", {
-        inReplyToTweetId: "200",
-        strategy: "browser",
-      });
-
-      expect(pathUsed).toBe("browser");
-      expect(result.tweetId).toBe("888");
-    });
-  });
-});

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

@@ -1,197 +0,0 @@
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-
-// --- Mocks (must be declared before importing the module under test) ---
-
-mock.module("../../../../util/logger.js", () => ({
-  getLogger: () => ({
-    info: () => {},
-    warn: () => {},
-    error: () => {},
-    debug: () => {},
-    trace: () => {},
-    fatal: () => {},
-    child: () => ({
-      info: () => {},
-      warn: () => {},
-      error: () => {},
-      debug: () => {},
-    }),
-  }),
-}));
-
-import {
-  oauthIsAvailable,
-  oauthPostTweet,
-  oauthSupportsOperation,
-  UnsupportedOAuthOperationError,
-} from "../oauth-client.js";
-
-// --- Global fetch mock ---
-
-const originalFetch = globalThis.fetch;
-let _fetchMock: ReturnType<typeof mock> | null = null;
-
-beforeEach(() => {
-  _fetchMock = null;
-});
-
-afterEach(() => {
-  globalThis.fetch = originalFetch;
-});
-
-function mockFetch(response: {
-  ok: boolean;
-  status: number;
-  json?: unknown;
-  text?: string;
-}) {
-  const fn = mock(() =>
-    Promise.resolve({
-      ok: response.ok,
-      status: response.status,
-      json: () => Promise.resolve(response.json),
-      text: () => Promise.resolve(response.text ?? ""),
-    }),
-  );
-  globalThis.fetch = fn as unknown as typeof fetch;
-  _fetchMock = fn;
-  return fn;
-}
-
-describe("Twitter OAuth client", () => {
-  describe("oauthPostTweet", () => {
-    test("successfully posts and returns tweet ID", async () => {
-      const fn = mockFetch({
-        ok: true,
-        status: 200,
-        json: { data: { id: "12345", text: "Hello world" } },
-      });
-
-      const result = await oauthPostTweet("Hello world", {
-        oauthToken: "fake-oauth-token",
-      });
-
-      expect(result.tweetId).toBe("12345");
-      expect(result.text).toBe("Hello world");
-
-      // Verify the request was made correctly
-      expect(fn).toHaveBeenCalledTimes(1);
-      const [url, opts] = fn.mock.calls[0] as unknown as [string, RequestInit];
-      expect(url).toBe("https://api.x.com/2/tweets");
-      expect(opts.method).toBe("POST");
-      expect((opts.headers as Record<string, string>)["Authorization"]).toBe(
-        "Bearer fake-oauth-token",
-      );
-      expect((opts.headers as Record<string, string>)["Content-Type"]).toBe(
-        "application/json",
-      );
-
-      const body = JSON.parse(opts.body as string);
-      expect(body.text).toBe("Hello world");
-      expect(body.reply).toBeUndefined();
-    });
-
-    test("with reply returns correct result", async () => {
-      const fn = mockFetch({
-        ok: true,
-        status: 200,
-        json: { data: { id: "67890", text: "My reply" } },
-      });
-
-      const result = await oauthPostTweet("My reply", {
-        inReplyToTweetId: "11111",
-        oauthToken: "fake-oauth-token",
-      });
-
-      expect(result.tweetId).toBe("67890");
-      expect(result.text).toBe("My reply");
-
-      const [, opts] = fn.mock.calls[0] as unknown as [string, RequestInit];
-      const body = JSON.parse(opts.body as string);
-      expect(body.text).toBe("My reply");
-      expect(body.reply).toEqual({ in_reply_to_tweet_id: "11111" });
-    });
-
-    test("throws on API error", async () => {
-      mockFetch({
-        ok: false,
-        status: 429,
-        text: "Rate limit exceeded",
-      });
-
-      await expect(
-        oauthPostTweet("will fail", { oauthToken: "fake-oauth-token" }),
-      ).rejects.toThrow(/Twitter API error \(429\)/);
-    });
-
-    test("throws with status in error message on 401", async () => {
-      mockFetch({
-        ok: false,
-        status: 401,
-        text: "Unauthorized",
-      });
-
-      try {
-        await oauthPostTweet("will fail", { oauthToken: "fake-oauth-token" });
-        expect(true).toBe(false); // should not reach
-      } catch (err) {
-        expect((err as Error).message).toContain("401");
-      }
-    });
-  });
-
-  describe("oauthIsAvailable", () => {
-    test("returns true when token is provided", () => {
-      expect(oauthIsAvailable("some-token")).toBe(true);
-    });
-
-    test("returns false when token is undefined", () => {
-      expect(oauthIsAvailable(undefined)).toBe(false);
-    });
-
-    test("returns false when token is empty string", () => {
-      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);
-    });
-  });
-});