refactor: split twitter client

src/lib/twitter-client-media.ts

@@ -0,0 +1,166 @@
+import { TWITTER_MEDIA_METADATA_URL, TWITTER_UPLOAD_URL } from './twitter-client-constants.js';
+import { type AbstractConstructor, type TwitterClientBase } from './twitter-client-base.js';
+import type { UploadMediaResult } from './twitter-client-types.js';
+
+export function withMedia<TBase extends AbstractConstructor<TwitterClientBase>>(Base: TBase) {
+  return class extends Base {
+    private mediaCategoryForMime(mimeType: string): string | null {
+      if (mimeType.startsWith('image/')) {
+        if (mimeType === 'image/gif') {
+          return 'tweet_gif';
+        }
+        return 'tweet_image';
+      }
+      if (mimeType.startsWith('video/')) {
+        return 'tweet_video';
+      }
+      return null;
+    }
+
+    private async sleep(ms: number): Promise<void> {
+      await new Promise((resolve) => setTimeout(resolve, ms));
+    }
+
+    async uploadMedia(input: { data: Uint8Array; mimeType: string; alt?: string }): Promise<UploadMediaResult> {
+      const category = this.mediaCategoryForMime(input.mimeType);
+      if (!category) {
+        return { success: false, error: `Unsupported media type: ${input.mimeType}` };
+      }
+
+      try {
+        const initParams = new URLSearchParams({
+          command: 'INIT',
+          total_bytes: String(input.data.byteLength),
+          media_type: input.mimeType,
+          media_category: category,
+        });
+
+        const initResp = await this.fetchWithTimeout(TWITTER_UPLOAD_URL, {
+          method: 'POST',
+          headers: this.getUploadHeaders(),
+          body: initParams,
+        });
+
+        if (!initResp.ok) {
+          const text = await initResp.text();
+          return { success: false, error: `HTTP ${initResp.status}: ${text.slice(0, 200)}` };
+        }
+
+        const initBody = (await initResp.json()) as { media_id_string?: string; media_id?: string | number };
+        const mediaId =
+          typeof initBody.media_id_string === 'string'
+            ? initBody.media_id_string
+            : initBody.media_id !== undefined
+              ? String(initBody.media_id)
+              : undefined;
+        if (!mediaId) {
+          return { success: false, error: 'Media upload INIT did not return media_id' };
+        }
+
+        const chunkSize = 5 * 1024 * 1024;
+        let segmentIndex = 0;
+        for (let offset = 0; offset < input.data.byteLength; offset += chunkSize) {
+          const chunk = input.data.slice(offset, Math.min(input.data.byteLength, offset + chunkSize));
+          const form = new FormData();
+          form.set('command', 'APPEND');
+          form.set('media_id', mediaId);
+          form.set('segment_index', String(segmentIndex));
+          form.set('media', new Blob([chunk], { type: input.mimeType }), 'media');
+
+          const appendResp = await this.fetchWithTimeout(TWITTER_UPLOAD_URL, {
+            method: 'POST',
+            headers: this.getUploadHeaders(),
+            body: form,
+          });
+
+          if (!appendResp.ok) {
+            const text = await appendResp.text();
+            return { success: false, error: `HTTP ${appendResp.status}: ${text.slice(0, 200)}` };
+          }
+          segmentIndex += 1;
+        }
+
+        const finalizeParams = new URLSearchParams({ command: 'FINALIZE', media_id: mediaId });
+        const finalizeResp = await this.fetchWithTimeout(TWITTER_UPLOAD_URL, {
+          method: 'POST',
+          headers: this.getUploadHeaders(),
+          body: finalizeParams,
+        });
+
+        if (!finalizeResp.ok) {
+          const text = await finalizeResp.text();
+          return { success: false, error: `HTTP ${finalizeResp.status}: ${text.slice(0, 200)}` };
+        }
+
+        const finalizeBody = (await finalizeResp.json()) as {
+          processing_info?: {
+            state?: string;
+            check_after_secs?: number;
+            error?: { message?: string; name?: string };
+          };
+        };
+
+        const info = finalizeBody.processing_info;
+        if (info?.state && info.state !== 'succeeded') {
+          let attempts = 0;
+          while (attempts < 20) {
+            if (info.state === 'failed') {
+              const msg = info.error?.message || info.error?.name || 'Media processing failed';
+              return { success: false, error: msg };
+            }
+            const delaySecs = Number.isFinite(info.check_after_secs) ? Math.max(1, info.check_after_secs as number) : 2;
+            await this.sleep(delaySecs * 1000);
+
+            const statusUrl = `${TWITTER_UPLOAD_URL}?${new URLSearchParams({
+              command: 'STATUS',
+              media_id: mediaId,
+            }).toString()}`;
+            const statusResp = await this.fetchWithTimeout(statusUrl, {
+              method: 'GET',
+              headers: this.getUploadHeaders(),
+            });
+
+            if (!statusResp.ok) {
+              const text = await statusResp.text();
+              return { success: false, error: `HTTP ${statusResp.status}: ${text.slice(0, 200)}` };
+            }
+
+            const statusBody = (await statusResp.json()) as {
+              processing_info?: {
+                state?: string;
+                check_after_secs?: number;
+                error?: { message?: string; name?: string };
+              };
+            };
+            if (!statusBody.processing_info) {
+              break;
+            }
+            info.state = statusBody.processing_info.state;
+            info.check_after_secs = statusBody.processing_info.check_after_secs;
+            info.error = statusBody.processing_info.error;
+            if (info.state === 'succeeded') {
+              break;
+            }
+            attempts += 1;
+          }
+        }
+
+        if (input.alt && input.mimeType.startsWith('image/')) {
+          const metaResp = await this.fetchWithTimeout(TWITTER_MEDIA_METADATA_URL, {
+            method: 'POST',
+            headers: this.getJsonHeaders(),
+            body: JSON.stringify({ media_id: mediaId, alt_text: { text: input.alt } }),
+          });
+          if (!metaResp.ok) {
+            const text = await metaResp.text();
+            return { success: false, error: `HTTP ${metaResp.status}: ${text.slice(0, 200)}` };
+          }
+        }
+
+        return { success: true, mediaId };
+      } catch (error) {
+        return { success: false, error: error instanceof Error ? error.message : String(error) };
+      }
+    }
+  };
+}