thumbgate 1.4.2 → 1.4.4

package/scripts/social-analytics/publishers/tiktok.js

@@ -1,217 +0,0 @@
-'use strict';
-
-/**
- * tiktok.js
- * Publishes videos to TikTok via the official Content Posting API v2.
- *
- * Required env vars:
- *   TIKTOK_ACCESS_TOKEN  — OAuth 2.0 access token with post.publish scope (required)
- *
- * TikTok API reference:
- *   POST /v2/post/publish/video/init/         — Initiate a direct post
- *   POST /v2/post/publish/status/fetch/       — Poll publish status
- */
-
-const TIKTOK_API_BASE = 'https://open.tiktokapis.com';
-
-const POLL_INTERVAL_MS = 5000;
-const DEFAULT_TIMEOUT_MS = 120000;
-
-/**
- * Initiate a TikTok video post via URL pull.
- *
- * @param {string} token - TikTok OAuth access token
- * @param {{ title: string, videoUrl: string, privacyLevel?: string }} options
- * @returns {Promise<string>} publish_id
- */
-async function initDirectPost(token, { title, videoUrl, privacyLevel }) {
-  if (!token) throw new Error('token is required');
-  if (!videoUrl) throw new Error('videoUrl is required');
-  if (!title) throw new Error('title is required');
-
-  const url = `${TIKTOK_API_BASE}/v2/post/publish/video/init/`;
-  const body = {
-    post_info: {
-      title,
-      privacy_level: privacyLevel || 'PUBLIC_TO_EVERYONE',
-    },
-    source_info: {
-      source: 'PULL_FROM_URL',
-      video_url: videoUrl,
-    },
-  };
-
-  console.log(`[tiktok:publisher] Initiating post: title="${title}" url=${videoUrl}`);
-
-  const res = await fetch(url, {
-    method: 'POST',
-    headers: {
-      Authorization: `Bearer ${token}`,
-      'Content-Type': 'application/json',
-    },
-    body: JSON.stringify(body),
-  });
-
-  if (!res.ok) {
-    const text = await res.text().catch(() => '');
-    throw new Error(`TikTok API ${res.status} for ${url}: ${text}`);
-  }
-
-  const json = await res.json();
-
-  if (json.error && json.error.code !== 'ok') {
-    throw new Error(`TikTok API error: ${json.error.code} — ${json.error.message}`);
-  }
-
-  const publishId = json.data?.publish_id;
-  if (!publishId) {
-    throw new Error(`TikTok init post returned no publish_id. Response: ${JSON.stringify(json)}`);
-  }
-
-  console.log(`[tiktok:publisher] Post initiated. publish_id=${publishId}`);
-  return publishId;
-}
-
-/**
- * Check the publish status of a previously initiated post.
- *
- * @param {string} token - TikTok OAuth access token
- * @param {string} publishId - publish_id returned from initDirectPost
- * @returns {Promise<object>} Status object from TikTok API
- */
-async function checkPublishStatus(token, publishId) {
-  if (!token) throw new Error('token is required');
-  if (!publishId) throw new Error('publishId is required');
-
-  const url = `${TIKTOK_API_BASE}/v2/post/publish/status/fetch/`;
-  const body = { publish_id: publishId };
-
-  const res = await fetch(url, {
-    method: 'POST',
-    headers: {
-      Authorization: `Bearer ${token}`,
-      'Content-Type': 'application/json',
-    },
-    body: JSON.stringify(body),
-  });
-
-  if (!res.ok) {
-    const text = await res.text().catch(() => '');
-    throw new Error(`TikTok API ${res.status} for ${url}: ${text}`);
-  }
-
-  const json = await res.json();
-
-  if (json.error && json.error.code !== 'ok') {
-    throw new Error(`TikTok API error: ${json.error.code} — ${json.error.message}`);
-  }
-
-  return json.data ?? {};
-}
-
-/**
- * Poll publish status every 5 seconds until PUBLISH_COMPLETE or a terminal failure.
- * Rejects if the timeout is reached before completion.
- *
- * @param {string} token - TikTok OAuth access token
- * @param {string} publishId - publish_id to poll
- * @param {number} [timeoutMs=120000] - Maximum wait time in milliseconds
- * @returns {Promise<object>} Final status object
- */
-async function pollPublishStatus(token, publishId, timeoutMs = DEFAULT_TIMEOUT_MS) {
-  if (!token) throw new Error('token is required');
-  if (!publishId) throw new Error('publishId is required');
-
-  const deadline = Date.now() + timeoutMs;
-  let attempt = 0;
-
-  console.log(`[tiktok:publisher] Polling publish status for publish_id=${publishId} (timeout=${timeoutMs}ms)`);
-
-  while (Date.now() < deadline) {
-    attempt += 1;
-    const statusData = await checkPublishStatus(token, publishId);
-    const status = statusData.status ?? statusData.publish_status ?? 'UNKNOWN';
-
-    console.log(`[tiktok:publisher] Attempt ${attempt}: status=${status}`);
-
-    if (status === 'PUBLISH_COMPLETE') {
-      console.log(`[tiktok:publisher] Video published successfully. publish_id=${publishId}`);
-      return statusData;
-    }
-
-    // Terminal failure states reported by the TikTok API.
-    const failureStates = ['FAILED', 'PUBLISH_FAILED', 'CANCELLED', 'ERROR'];
-    if (failureStates.includes(status)) {
-      throw new Error(
-        `TikTok publish failed with status=${status}. publish_id=${publishId}. ` +
-          `Data: ${JSON.stringify(statusData)}`
-      );
-    }
-
-    // Not done yet — wait before the next poll.
-    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
-  }
-
-  throw new Error(
-    `TikTok publish timed out after ${timeoutMs}ms. publish_id=${publishId} ` +
-      `— video may still be processing.`
-  );
-}
-
-/**
- * Orchestrates the full TikTok video publish flow:
- *   1. Initiate post via URL pull
- *   2. Poll until PUBLISH_COMPLETE
- *
- * @param {{ videoUrl: string, title: string, token?: string, privacyLevel?: string }} options
- * @returns {Promise<{ publishId: string, status: object }>}
- */
-async function publishTikTokVideo({ videoUrl, title, token, privacyLevel }) {
-  const accessToken = token || process.env.TIKTOK_ACCESS_TOKEN;
-  if (!accessToken) {
-    throw new Error('TIKTOK_ACCESS_TOKEN environment variable (or token param) is required');
-  }
-  if (!videoUrl) throw new Error('videoUrl is required');
-  if (!title) throw new Error('title is required');
-
-  console.log(`[tiktok:publisher] Starting publish flow for "${title}"`);
-
-  const publishId = await initDirectPost(accessToken, { title, videoUrl, privacyLevel });
-  const statusResult = await pollPublishStatus(accessToken, publishId);
-
-  console.log(`[tiktok:publisher] Publish complete. publish_id=${publishId}`);
-  return { publishId, status: statusResult };
-}
-
-module.exports = { initDirectPost, checkPublishStatus, pollPublishStatus, publishTikTokVideo };
-
-// ---------------------------------------------------------------------------
-// Stand-alone execution
-// ---------------------------------------------------------------------------
-if (require.main === module) {
-  const args = process.argv.slice(2);
-
-  // Parse --video-url and --title from CLI args.
-  function getArg(flag) {
-    const prefix = `${flag}=`;
-    const entry = args.find((a) => a.startsWith(prefix));
-    return entry ? entry.slice(prefix.length) : null;
-  }
-
-  const videoUrl = getArg('--video-url');
-  const title = getArg('--title');
-
-  if (!videoUrl || !title) {
-    console.error('Usage: node tiktok.js --video-url=<url> --title=<title>');
-    process.exit(1);
-  }
-
-  publishTikTokVideo({ videoUrl, title })
-    .then(({ publishId, status }) => {
-      console.log(`[tiktok:publisher] Done. publish_id=${publishId} status=${JSON.stringify(status)}`);
-    })
-    .catch((err) => {
-      console.error('[tiktok:publisher] Publish failed:', err.message);
-      process.exit(1);
-    });
-}

package/scripts/social-analytics/publishers/x.js

@@ -1,259 +0,0 @@
-'use strict';
-
-/**
- * x.js
- * Publishes tweets to X (Twitter) via the X API v2.
- *
- * Required env vars for publishing (OAuth 1.0a user context):
- *   X_API_KEY             — Consumer/API key (required for posting)
- *   X_API_SECRET          — Consumer/API secret (required for posting)
- *   X_ACCESS_TOKEN        — User OAuth 1.0a access token (required for posting)
- *   X_ACCESS_TOKEN_SECRET — User OAuth 1.0a access token secret (required for posting)
- *
- * Optional env vars (read-only operations only):
- *   X_BEARER_TOKEN        — App-only Bearer Token. Suitable for GET endpoints only.
- *                           Tweet creation (POST /2/tweets) requires OAuth 1.0a user
- *                           context — a Bearer Token alone is not sufficient for posting.
- *
- * X API v2 reference:
- *   POST /2/tweets — https://developer.twitter.com/en/docs/twitter-api/tweets/manage-tweets/api-reference/post-tweets
- *
- * OAuth 1.0a reference:
- *   https://developer.twitter.com/en/docs/authentication/oauth-1-0a
- */
-
-const crypto = require('crypto');
-
-const X_TWEETS_URL = 'https://api.twitter.com/2/tweets';
-
-// ---------------------------------------------------------------------------
-// OAuth 1.0a helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Percent-encodes a string per RFC 3986 (replaces characters that
- * URLSearchParams does not encode, such as '!', "'", '(', ')', '*').
- *
- * @param {string} str
- * @returns {string}
- */
-function rfc3986Encode(str) {
-  return encodeURIComponent(String(str)).replace(/[!'()*]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
-}
-
-/**
- * Builds an OAuth 1.0a Authorization header using HMAC-SHA1 signing.
- *
- * Steps:
- *   1. Collect OAuth parameters (oauth_consumer_key, oauth_nonce,
- *      oauth_signature_method, oauth_timestamp, oauth_token, oauth_version).
- *   2. Merge with any extra request params (query/body), sort, percent-encode.
- *   3. Build the Signature Base String: METHOD&url&params.
- *   4. Build the signing key: consumerSecret&tokenSecret.
- *   5. HMAC-SHA1 sign; base64-encode the digest.
- *   6. Return the Authorization header value.
- *
- * @param {string} method          - HTTP method in uppercase (e.g. 'POST')
- * @param {string} url             - Base URL without query string
- * @param {Record<string, string>} params - Additional request parameters to include in the signature
- * @param {string} consumerKey     - X_API_KEY
- * @param {string} consumerSecret  - X_API_SECRET
- * @param {string} tokenKey        - X_ACCESS_TOKEN
- * @param {string} tokenSecret     - X_ACCESS_TOKEN_SECRET
- * @returns {string} Value for the Authorization HTTP header
- */
-function buildOAuth1Header(method, url, params, consumerKey, consumerSecret, tokenKey, tokenSecret) {
-  if (!method) throw new Error('buildOAuth1Header: method is required');
-  if (!url) throw new Error('buildOAuth1Header: url is required');
-  if (!consumerKey) throw new Error('buildOAuth1Header: consumerKey is required');
-  if (!consumerSecret) throw new Error('buildOAuth1Header: consumerSecret is required');
-  if (!tokenKey) throw new Error('buildOAuth1Header: tokenKey is required');
-  if (!tokenSecret) throw new Error('buildOAuth1Header: tokenSecret is required');
-
-  const oauthNonce = crypto.randomBytes(16).toString('hex');
-  const oauthTimestamp = String(Math.floor(Date.now() / 1000));
-
-  const oauthParams = {
-    oauth_consumer_key: consumerKey,
-    oauth_nonce: oauthNonce,
-    oauth_signature_method: 'HMAC-SHA1',
-    oauth_timestamp: oauthTimestamp,
-    oauth_token: tokenKey,
-    oauth_version: '1.0',
-  };
-
-  // Merge oauth params with any additional request params for signature computation.
-  const allParams = { ...params, ...oauthParams };
-
-  // Sort by encoded key, then by encoded value.
-  const sortedPairs = Object.entries(allParams)
-    .map(([k, v]) => [rfc3986Encode(k), rfc3986Encode(v)])
-    .sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : a[1] < b[1] ? -1 : 1))
-    .map(([k, v]) => `${k}=${v}`)
-    .join('&');
-
-  // Signature Base String: METHOD & encoded-url & encoded-params
-  const signatureBase = [
-    method.toUpperCase(),
-    rfc3986Encode(url),
-    rfc3986Encode(sortedPairs),
-  ].join('&');
-
-  // Signing key: encoded consumer secret & encoded token secret
-  const signingKey = `${rfc3986Encode(consumerSecret)}&${rfc3986Encode(tokenSecret)}`;
-
-  // HMAC-SHA1 digest, base64-encoded.
-  const signature = crypto
-    .createHmac('sha1', signingKey)
-    .update(signatureBase)
-    .digest('base64');
-
-  // Build Authorization header — only include oauth_* params, not request params.
-  const headerParams = { ...oauthParams, oauth_signature: signature };
-  const headerValue =
-    'OAuth ' +
-    Object.entries(headerParams)
-      .map(([k, v]) => `${rfc3986Encode(k)}="${rfc3986Encode(v)}"`)
-      .join(', ');
-
-  return headerValue;
-}
-
-// ---------------------------------------------------------------------------
-// Publishing functions
-// ---------------------------------------------------------------------------
-
-/**
- * Publishes a single tweet using OAuth 1.0a user context.
- *
- * @param {string} text - Tweet text (max 280 characters)
- * @param {{ reply?: { in_reply_to_tweet_id: string }, media?: { media_ids: string[] } }} [options]
- * @returns {Promise<{ id: string, text: string }>} Created tweet object
- */
-async function publishTweet(text, options = {}) {
-  if (!text) throw new Error('publishTweet: text is required');
-
-  const consumerKey = process.env.X_API_KEY;
-  const consumerSecret = process.env.X_API_SECRET;
-  const accessToken = process.env.X_ACCESS_TOKEN;
-  const accessTokenSecret = process.env.X_ACCESS_TOKEN_SECRET;
-
-  if (!consumerKey) throw new Error('X_API_KEY environment variable is required for posting');
-  if (!consumerSecret) throw new Error('X_API_SECRET environment variable is required for posting');
-  if (!accessToken) throw new Error('X_ACCESS_TOKEN environment variable is required for posting');
-  if (!accessTokenSecret) throw new Error('X_ACCESS_TOKEN_SECRET environment variable is required for posting');
-
-  const body = { text };
-
-  if (options.reply?.in_reply_to_tweet_id) {
-    body.reply = { in_reply_to_tweet_id: options.reply.in_reply_to_tweet_id };
-  }
-
-  if (options.media?.media_ids?.length) {
-    body.media = { media_ids: options.media.media_ids };
-  }
-
-  // OAuth 1.0a header — no extra request params for a JSON body POST.
-  const authHeader = buildOAuth1Header(
-    'POST',
-    X_TWEETS_URL,
-    {},
-    consumerKey,
-    consumerSecret,
-    accessToken,
-    accessTokenSecret
-  );
-
-  console.log(`[x:publisher] Posting tweet: "${text.slice(0, 60)}${text.length > 60 ? '…' : ''}"`);
-
-  const res = await fetch(X_TWEETS_URL, {
-    method: 'POST',
-    headers: {
-      Authorization: authHeader,
-      'Content-Type': 'application/json',
-    },
-    body: JSON.stringify(body),
-  });
-
-  if (!res.ok) {
-    const errorText = await res.text().catch(() => '');
-    throw new Error(`X API ${res.status} for POST /2/tweets: ${errorText}`);
-  }
-
-  const json = await res.json();
-
-  if (json.errors && !json.data) {
-    throw new Error(`X API errors: ${JSON.stringify(json.errors)}`);
-  }
-
-  const tweet = json.data;
-  console.log(`[x:publisher] Tweet published. id=${tweet.id}`);
-  return tweet;
-}
-
-/**
- * Publishes an array of tweet texts as a thread.
- * Each tweet after the first replies to the previous tweet in the thread.
- *
- * @param {string[]} tweets - Array of tweet text strings in thread order
- * @returns {Promise<Array<{ id: string, text: string }>>} Array of created tweet objects
- */
-async function publishThread(tweets) {
-  if (!Array.isArray(tweets) || tweets.length === 0) {
-    throw new Error('publishThread: tweets must be a non-empty array');
-  }
-
-  console.log(`[x:publisher] Publishing thread of ${tweets.length} tweets`);
-
-  const published = [];
-  let previousTweetId = null;
-
-  for (let i = 0; i < tweets.length; i++) {
-    const text = tweets[i];
-    const options = {};
-
-    if (previousTweetId) {
-      options.reply = { in_reply_to_tweet_id: previousTweetId };
-    }
-
-    const tweet = await publishTweet(text, options);
-    published.push(tweet);
-    previousTweetId = tweet.id;
-
-    console.log(`[x:publisher] Thread tweet ${i + 1}/${tweets.length} published. id=${tweet.id}`);
-  }
-
-  console.log(`[x:publisher] Thread complete. ${published.length} tweets published.`);
-  return published;
-}
-
-module.exports = { buildOAuth1Header, publishTweet, publishThread };
-
-// ---------------------------------------------------------------------------
-// Stand-alone execution
-// ---------------------------------------------------------------------------
-if (require.main === module) {
-  const args = process.argv.slice(2);
-
-  function getArg(flag) {
-    const prefix = `${flag}=`;
-    const entry = args.find((a) => a.startsWith(prefix));
-    return entry ? entry.slice(prefix.length) : null;
-  }
-
-  const text = getArg('--text');
-
-  if (!text) {
-    console.error('Usage: node x.js --text=<tweet text>');
-    process.exit(1);
-  }
-
-  publishTweet(text)
-    .then((tweet) => {
-      console.log(`[x:publisher] Done. id=${tweet.id} text="${tweet.text}"`);
-    })
-    .catch((err) => {
-      console.error('[x:publisher] Publish failed:', err.message);
-      process.exit(1);
-    });
-}

package/scripts/social-analytics/publishers/youtube.js

@@ -1,223 +0,0 @@
-'use strict';
-
-/**
- * youtube.js
- * Publishes YouTube Shorts via the YouTube Data API v3 resumable upload protocol.
- *
- * Required env vars:
- *   YOUTUBE_ACCESS_TOKEN — OAuth2 bearer token with youtube.upload scope (required)
- *
- * Note: YouTube uploads require OAuth2, not just an API key.
- * The access token must have the scope:
- *   https://www.googleapis.com/auth/youtube.upload
- *
- * API reference:
- *   POST https://www.googleapis.com/upload/youtube/v3/videos?uploadType=resumable&part=snippet,status
- *   PUT  {resumableUploadUri}  — upload binary chunk
- */
-
-const fs = require('fs');
-const path = require('path');
-
-const YOUTUBE_UPLOAD_BASE = 'https://www.googleapis.com/upload/youtube/v3';
-
-/**
- * Initiates a YouTube resumable upload session.
- * Returns the upload URI from the Location response header.
- *
- * @param {string} token                   - OAuth2 bearer token
- * @param {object} options                 - Video metadata
- * @param {string} options.title           - Video title
- * @param {string} [options.description]   - Video description
- * @param {string[]} [options.tags]        - Array of tags
- * @param {string} [options.categoryId]    - YouTube category ID (e.g. '22' = People & Blogs)
- * @param {string} [options.privacyStatus] - 'public' | 'private' | 'unlisted' (default: 'public')
- * @returns {Promise<string>} Resumable upload URI
- */
-async function initResumableUpload(token, { title, description, tags, categoryId, privacyStatus }) {
-  if (!token) throw new Error('token is required');
-  if (!title) throw new Error('title is required');
-
-  const url =
-    `${YOUTUBE_UPLOAD_BASE}/videos` +
-    `?uploadType=resumable&part=snippet,status`;
-
-  const body = {
-    snippet: {
-      title,
-      description: description || '',
-      tags: tags || [],
-      categoryId: categoryId || '22',
-    },
-    status: {
-      privacyStatus: privacyStatus || 'public',
-      selfDeclaredMadeForKids: false,
-    },
-  };
-
-  console.log(`[youtube:publisher] Initiating resumable upload: title="${title}"`);
-
-  const res = await fetch(url, {
-    method: 'POST',
-    headers: {
-      Authorization: `Bearer ${token}`,
-      'Content-Type': 'application/json; charset=UTF-8',
-      'X-Upload-Content-Type': 'video/*',
-    },
-    body: JSON.stringify(body),
-  });
-
-  if (!res.ok) {
-    const text = await res.text().catch(() => '');
-    throw new Error(`YouTube API ${res.status} for resumable upload init: ${text}`);
-  }
-
-  const uploadUri = res.headers.get('Location');
-  if (!uploadUri) {
-    throw new Error(
-      'YouTube resumable upload init did not return a Location header. ' +
-        `Status: ${res.status}`
-    );
-  }
-
-  console.log(`[youtube:publisher] Resumable upload URI obtained`);
-  return uploadUri;
-}
-
-/**
- * Uploads the video binary to the resumable upload URI.
- * Uses a single PUT request (suitable for files up to ~5 GB).
- *
- * @param {string} uploadUri      - Resumable upload URI from initResumableUpload
- * @param {Buffer} videoBuffer    - Raw video file buffer
- * @param {string} [contentType]  - MIME type (default: 'video/mp4')
- * @returns {Promise<object>} Created video resource from YouTube API
- */
-async function uploadVideoChunk(uploadUri, videoBuffer, contentType) {
-  if (!uploadUri) throw new Error('uploadUri is required');
-  if (!Buffer.isBuffer(videoBuffer)) throw new Error('videoBuffer must be a Buffer');
-
-  const mimeType = contentType || 'video/mp4';
-
-  console.log(
-    `[youtube:publisher] Uploading video chunk: ` +
-      `size=${videoBuffer.length} bytes contentType=${mimeType}`
-  );
-
-  const res = await fetch(uploadUri, {
-    method: 'PUT',
-    headers: {
-      'Content-Type': mimeType,
-      'Content-Length': String(videoBuffer.length),
-    },
-    body: videoBuffer,
-  });
-
-  if (!res.ok) {
-    const text = await res.text().catch(() => '');
-    throw new Error(`YouTube upload chunk failed ${res.status}: ${text}`);
-  }
-
-  const json = await res.json();
-
-  if (json.error) {
-    throw new Error(`YouTube API error after upload: ${json.error.code} — ${json.error.message}`);
-  }
-
-  const videoId = json.id;
-  console.log(`[youtube:publisher] Video uploaded successfully. videoId=${videoId}`);
-
-  return json;
-}
-
-/**
- * Orchestrates the full YouTube Shorts publish flow:
- *   1. Read video file from disk
- *   2. Ensure #Shorts is in the description
- *   3. Initiate resumable upload session
- *   4. Upload video binary
- *
- * @param {object} options
- * @param {string} options.videoPath      - Absolute or relative path to the local video file
- * @param {string} options.title          - Video title
- * @param {string} [options.description]  - Video description (will have #Shorts appended if missing)
- * @param {string[]} [options.tags]       - Array of tags
- * @param {string} [options.token]        - OAuth2 token (falls back to YOUTUBE_ACCESS_TOKEN env var)
- * @param {string} [options.privacyStatus] - 'public' | 'private' | 'unlisted' (default: 'public')
- * @param {string} [options.categoryId]   - YouTube category ID (default: '22')
- * @returns {Promise<{ videoId: string, url: string }>}
- */
-async function publishYouTubeShort({ videoPath, title, description, tags, token, privacyStatus, categoryId }) {
-  const accessToken = token || process.env.YOUTUBE_ACCESS_TOKEN;
-  if (!accessToken) {
-    throw new Error('YOUTUBE_ACCESS_TOKEN environment variable (or token param) is required');
-  }
-  if (!videoPath) throw new Error('videoPath is required');
-  if (!title) throw new Error('title is required');
-
-  const resolvedPath = path.resolve(videoPath);
-
-  console.log(`[youtube:publisher] Starting YouTube Shorts publish flow`);
-  console.log(`[youtube:publisher] Reading video file: ${resolvedPath}`);
-
-  const videoBuffer = fs.readFileSync(resolvedPath);
-  console.log(`[youtube:publisher] Video file loaded: ${videoBuffer.length} bytes`);
-
-  // Ensure #Shorts is present in the description for YouTube to classify as a Short.
-  let finalDescription = description || '';
-  if (!finalDescription.includes('#Shorts')) {
-    finalDescription = finalDescription
-      ? `${finalDescription}\n\n#Shorts`
-      : '#Shorts';
-  }
-
-  const uploadUri = await initResumableUpload(accessToken, {
-    title,
-    description: finalDescription,
-    tags: tags || [],
-    categoryId: categoryId || '22',
-    privacyStatus: privacyStatus || 'public',
-  });
-
-  const videoResource = await uploadVideoChunk(uploadUri, videoBuffer, 'video/mp4');
-
-  const videoId = videoResource.id;
-  const url = `https://youtube.com/shorts/${videoId}`;
-
-  console.log(`[youtube:publisher] Short published: videoId=${videoId} url=${url}`);
-
-  return { videoId, url };
-}
-
-module.exports = { initResumableUpload, uploadVideoChunk, publishYouTubeShort };
-
-// ---------------------------------------------------------------------------
-// Stand-alone execution
-// ---------------------------------------------------------------------------
-if (require.main === module) {
-  const args = process.argv.slice(2);
-
-  function getArg(flag) {
-    const prefix = `${flag}=`;
-    const entry = args.find((a) => a.startsWith(prefix));
-    return entry ? entry.slice(prefix.length) : null;
-  }
-
-  const videoPath = getArg('--video');
-  const title = getArg('--title');
-  const description = getArg('--description');
-
-  if (!videoPath || !title) {
-    console.error('Usage: node youtube.js --video=<path> --title=<title> [--description=<desc>]');
-    process.exit(1);
-  }
-
-  publishYouTubeShort({ videoPath, title, description: description || '' })
-    .then(({ videoId, url }) => {
-      console.log(`[youtube:publisher] Done. videoId=${videoId} url=${url}`);
-    })
-    .catch((err) => {
-      console.error('[youtube:publisher] Publish failed:', err.message);
-      process.exit(1);
-    });
-}