viruagent-cli 0.6.2 → 0.7.0

package/src/providers/x/graphqlSync.js

@@ -0,0 +1,140 @@
+const fs = require('fs');
+const path = require('path');
+
+const CACHE_TTL_MS = 3600000; // 1 hour
+
+const X_BASE_URL = 'https://x.com';
+const USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36';
+
+let memoryCache = null;
+let memoryCacheTime = 0;
+
+const getCachePath = () => {
+  const dir = path.join(require('os').homedir(), '.viruagent-cli');
+  return path.join(dir, 'x-graphql-cache.json');
+};
+
+const loadFileCache = () => {
+  const cachePath = getCachePath();
+  if (!fs.existsSync(cachePath)) return null;
+  try {
+    const raw = JSON.parse(fs.readFileSync(cachePath, 'utf-8'));
+    if (Date.now() - raw.syncedAt > CACHE_TTL_MS) return null;
+    return raw;
+  } catch {
+    return null;
+  }
+};
+
+const saveFileCache = (data) => {
+  const cachePath = getCachePath();
+  fs.mkdirSync(path.dirname(cachePath), { recursive: true });
+  fs.writeFileSync(cachePath, JSON.stringify(data, null, 2), 'utf-8');
+};
+
+const fetchMainJsUrl = async () => {
+  const res = await fetch(X_BASE_URL, {
+    headers: { 'User-Agent': USER_AGENT },
+    redirect: 'follow',
+  });
+  const html = await res.text();
+  const match = html.match(/main\.[a-f0-9]+\.js/);
+  if (!match) throw new Error('Failed to find main.js URL from x.com');
+  return `https://abs.twimg.com/responsive-web/client-web/${match[0]}`;
+};
+
+const parseOperations = (jsContent) => {
+  const operations = new Map();
+
+  // Pattern: queryId:"...",operationName:"...",operationType:"...",metadata:{featureSwitches:[...],fieldToggles:[...]}
+  const regex = /queryId:"([^"]+)",operationName:"([^"]+)",operationType:"([^"]+)",metadata:\{featureSwitches:\[([^\]]*)\],fieldToggles:\[([^\]]*)\]\}/g;
+  let match;
+  while ((match = regex.exec(jsContent)) !== null) {
+    const [, queryId, operationName, operationType, featureSwitchesRaw, fieldTogglesRaw] = match;
+
+    const parseStringArray = (raw) =>
+      raw ? raw.match(/"([^"]+)"/g)?.map((s) => s.slice(1, -1)) || [] : [];
+
+    operations.set(operationName, {
+      queryId,
+      operationType,
+      featureSwitches: parseStringArray(featureSwitchesRaw),
+      fieldToggles: parseStringArray(fieldTogglesRaw),
+    });
+  }
+
+  return operations;
+};
+
+const syncGraphqlOperations = async ({ force = false } = {}) => {
+  // Check memory cache
+  if (!force && memoryCache && Date.now() - memoryCacheTime < CACHE_TTL_MS) {
+    return memoryCache;
+  }
+
+  // Check file cache
+  if (!force) {
+    const fileCache = loadFileCache();
+    if (fileCache?.operations) {
+      memoryCache = new Map(Object.entries(fileCache.operations));
+      memoryCacheTime = fileCache.syncedAt;
+      return memoryCache;
+    }
+  }
+
+  // Fetch and parse from x.com
+  const mainJsUrl = await fetchMainJsUrl();
+  const res = await fetch(mainJsUrl, {
+    headers: { 'User-Agent': USER_AGENT },
+  });
+  const jsContent = await res.text();
+  const operations = parseOperations(jsContent);
+
+  if (operations.size === 0) {
+    throw new Error('Failed to parse any GraphQL operations from main.js');
+  }
+
+  // Cache
+  memoryCache = operations;
+  memoryCacheTime = Date.now();
+
+  const cacheObj = {
+    syncedAt: Date.now(),
+    mainJsUrl,
+    operationCount: operations.size,
+    operations: Object.fromEntries(operations),
+  };
+  saveFileCache(cacheObj);
+
+  return operations;
+};
+
+const getOperation = async (operationName) => {
+  let ops = await syncGraphqlOperations();
+  let op = ops.get(operationName);
+
+  // If not found, force re-sync (queryId may have changed)
+  if (!op) {
+    ops = await syncGraphqlOperations({ force: true });
+    op = ops.get(operationName);
+  }
+
+  if (!op) {
+    throw new Error(`GraphQL operation not found: ${operationName}`);
+  }
+
+  return op;
+};
+
+const invalidateCache = () => {
+  memoryCache = null;
+  memoryCacheTime = 0;
+  const cachePath = getCachePath();
+  if (fs.existsSync(cachePath)) fs.unlinkSync(cachePath);
+};
+
+module.exports = {
+  syncGraphqlOperations,
+  getOperation,
+  invalidateCache,
+};

package/src/providers/x/index.js

@@ -0,0 +1,251 @@
+const fs = require('fs');
+const path = require('path');
+const { saveProviderMeta, clearProviderMeta, getProviderMeta } = require('../../storage/sessionStore');
+const createXApiClient = require('./apiClient');
+const { readXCredentials } = require('./utils');
+const { createXWithProviderSession } = require('./session');
+const { createSetCredentials } = require('./auth');
+const { syncGraphqlOperations } = require('./graphqlSync');
+
+const createXProvider = ({ sessionPath, account }) => {
+  const xApi = createXApiClient({ sessionPath });
+
+  const setCredentials = createSetCredentials({ sessionPath });
+
+  const withProviderSession = createXWithProviderSession(setCredentials, account);
+
+  return {
+    id: 'x',
+    name: 'X (Twitter)',
+
+    async authStatus() {
+      return withProviderSession(async () => {
+        try {
+          const viewer = await xApi.getViewer();
+          return {
+            provider: 'x',
+            loggedIn: true,
+            username: viewer.username,
+            name: viewer.name,
+            followerCount: viewer.followerCount,
+            tweetCount: viewer.tweetCount,
+            sessionPath,
+            metadata: getProviderMeta('x', account) || {},
+          };
+        } catch (error) {
+          return {
+            provider: 'x',
+            loggedIn: false,
+            sessionPath,
+            error: error.message,
+            metadata: getProviderMeta('x', account) || {},
+          };
+        }
+      });
+    },
+
+    async login({ authToken, ct0 } = {}) {
+      const creds = readXCredentials();
+      const resolved = {
+        authToken: authToken || creds.authToken,
+        ct0: ct0 || creds.ct0,
+      };
+
+      if (!resolved.authToken || !resolved.ct0) {
+        throw new Error(
+          'X login requires auth_token and ct0 cookies. ' +
+          'Please set X_AUTH_TOKEN / X_CT0 environment variables.',
+        );
+      }
+
+      const result = await setCredentials(resolved);
+      xApi.resetState();
+
+      saveProviderMeta('x', {
+        loggedIn: result.loggedIn,
+        username: result.username,
+        sessionPath: result.sessionPath,
+      }, account);
+
+      return result;
+    },
+
+    async getProfile({ username } = {}) {
+      return withProviderSession(async () => {
+        if (!username) throw new Error('username is required.');
+        const profile = await xApi.getUserByScreenName(username);
+        return { provider: 'x', mode: 'profile', ...profile };
+      });
+    },
+
+    async getFeed({ count = 20 } = {}) {
+      return withProviderSession(async () => {
+        const items = await xApi.getHomeTimeline(count);
+        return {
+          provider: 'x',
+          mode: 'feed',
+          count: items.length,
+          items,
+        };
+      });
+    },
+
+    async listPosts({ username, limit = 20 } = {}) {
+      return withProviderSession(async () => {
+        if (!username) throw new Error('username is required.');
+        const user = await xApi.getUserByScreenName(username);
+        const posts = await xApi.getUserTweets(user.id, limit);
+        return {
+          provider: 'x',
+          mode: 'posts',
+          username,
+          totalCount: posts.length,
+          posts,
+        };
+      });
+    },
+
+    async getPost({ postId } = {}) {
+      return withProviderSession(async () => {
+        const tweetId = String(postId || '').trim();
+        if (!tweetId) throw new Error('postId (tweet ID) is required.');
+        const tweet = await xApi.getTweetDetail(tweetId);
+        return { provider: 'x', mode: 'post', ...tweet };
+      });
+    },
+
+    async search({ query, limit = 20 } = {}) {
+      return withProviderSession(async () => {
+        if (!query) throw new Error('query is required.');
+        const results = await xApi.searchTimeline(query, limit);
+        return {
+          provider: 'x',
+          mode: 'search',
+          query,
+          totalCount: results.length,
+          results,
+        };
+      });
+    },
+
+    async publish({ text, content, mediaUrl, mediaPath, replyTo } = {}) {
+      return withProviderSession(async () => {
+        const tweetText = text || content || '';
+        if (!tweetText) throw new Error('Tweet text is required.');
+
+        let mediaIds;
+        if (mediaUrl || mediaPath) {
+          let buffer;
+          if (mediaPath) {
+            buffer = fs.readFileSync(path.resolve(mediaPath));
+          } else {
+            const res = await fetch(mediaUrl);
+            if (!res.ok) throw new Error(`Image download failed: ${res.status}`);
+            buffer = Buffer.from(await res.arrayBuffer());
+          }
+          const mediaId = await xApi.uploadMedia(buffer);
+          mediaIds = [mediaId];
+        }
+
+        const result = await xApi.createTweet(tweetText, { mediaIds, replyTo });
+        return {
+          provider: 'x',
+          mode: 'publish',
+          ...result,
+        };
+      });
+    },
+
+    async delete({ postId } = {}) {
+      return withProviderSession(async () => {
+        const tweetId = String(postId || '').trim();
+        if (!tweetId) throw new Error('postId (tweet ID) is required.');
+        const result = await xApi.deleteTweet(tweetId);
+        return { provider: 'x', mode: 'delete', postId: tweetId, ...result };
+      });
+    },
+
+    async like({ postId } = {}) {
+      return withProviderSession(async () => {
+        const tweetId = String(postId || '').trim();
+        if (!tweetId) throw new Error('postId (tweet ID) is required.');
+        const result = await xApi.likeTweet(tweetId);
+        return { provider: 'x', mode: 'like', postId: tweetId, ...result };
+      });
+    },
+
+    async unlike({ postId } = {}) {
+      return withProviderSession(async () => {
+        const tweetId = String(postId || '').trim();
+        if (!tweetId) throw new Error('postId (tweet ID) is required.');
+        const result = await xApi.unlikeTweet(tweetId);
+        return { provider: 'x', mode: 'unlike', postId: tweetId, ...result };
+      });
+    },
+
+    async follow({ username } = {}) {
+      return withProviderSession(async () => {
+        if (!username) throw new Error('username is required.');
+        const user = await xApi.getUserByScreenName(username);
+        const result = await xApi.followUser(user.id);
+        return { provider: 'x', mode: 'follow', username, userId: user.id, ...result };
+      });
+    },
+
+    async unfollow({ username } = {}) {
+      return withProviderSession(async () => {
+        if (!username) throw new Error('username is required.');
+        const user = await xApi.getUserByScreenName(username);
+        const result = await xApi.unfollowUser(user.id);
+        return { provider: 'x', mode: 'unfollow', username, userId: user.id, ...result };
+      });
+    },
+
+    async retweet({ postId } = {}) {
+      return withProviderSession(async () => {
+        const tweetId = String(postId || '').trim();
+        if (!tweetId) throw new Error('postId (tweet ID) is required.');
+        const result = await xApi.retweet(tweetId);
+        return { provider: 'x', mode: 'retweet', postId: tweetId, ...result };
+      });
+    },
+
+    async unretweet({ postId } = {}) {
+      return withProviderSession(async () => {
+        const tweetId = String(postId || '').trim();
+        if (!tweetId) throw new Error('postId (tweet ID) is required.');
+        const result = await xApi.unretweet(tweetId);
+        return { provider: 'x', mode: 'unretweet', postId: tweetId, ...result };
+      });
+    },
+
+    rateLimitStatus() {
+      return {
+        provider: 'x',
+        mode: 'rateLimitStatus',
+        ...xApi.getRateLimitStatus(),
+      };
+    },
+
+    async syncOperations() {
+      const ops = await syncGraphqlOperations({ force: true });
+      return {
+        provider: 'x',
+        mode: 'syncOperations',
+        operationCount: ops.size,
+        message: `Synced ${ops.size} GraphQL operations from x.com`,
+      };
+    },
+
+    async logout() {
+      clearProviderMeta('x', account);
+      return {
+        provider: 'x',
+        loggedOut: true,
+        sessionPath,
+      };
+    },
+  };
+};
+
+module.exports = createXProvider;

package/src/providers/x/session.js

@@ -0,0 +1,114 @@
+const fs = require('fs');
+const path = require('path');
+const { saveProviderMeta } = require('../../storage/sessionStore');
+const { readXCredentials, parseXSessionError, buildLoginErrorMessage } = require('./utils');
+
+const ESSENTIAL_COOKIES = ['auth_token', 'ct0'];
+
+const readSessionFile = (sessionPath) => {
+  if (!fs.existsSync(sessionPath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(sessionPath, 'utf-8'));
+  } catch {
+    return null;
+  }
+};
+
+const writeSessionFile = (sessionPath, data) => {
+  fs.mkdirSync(path.dirname(sessionPath), { recursive: true });
+  fs.writeFileSync(sessionPath, JSON.stringify(data, null, 2), 'utf-8');
+};
+
+const saveXSession = (sessionPath, cookies) => {
+  const existing = readSessionFile(sessionPath) || {};
+  writeSessionFile(sessionPath, {
+    ...existing,
+    cookies,
+    updatedAt: new Date().toISOString(),
+  });
+};
+
+const loadXSession = (sessionPath) => {
+  const raw = readSessionFile(sessionPath);
+  return Array.isArray(raw?.cookies) ? raw.cookies : null;
+};
+
+// ── Rate Limit persistence ──
+
+const loadRateLimits = (sessionPath) => {
+  const raw = readSessionFile(sessionPath);
+  return raw?.rateLimits || null;
+};
+
+const saveRateLimits = (sessionPath, counters) => {
+  const raw = readSessionFile(sessionPath) || {};
+  raw.rateLimits = {
+    ...counters,
+    savedAt: new Date().toISOString(),
+  };
+  writeSessionFile(sessionPath, raw);
+};
+
+const validateXSession = (sessionPath) => {
+  const cookies = loadXSession(sessionPath);
+  if (!cookies) return false;
+  return ESSENTIAL_COOKIES.every((name) =>
+    cookies.some((c) => c.name === name && c.value),
+  );
+};
+
+const cookiesToHeader = (cookies) =>
+  cookies.map((c) => `${c.name}=${c.value}`).join('; ');
+
+const createXWithProviderSession = (setCredentials, account) => async (fn) => {
+  const credentials = readXCredentials();
+  const hasCredentials = Boolean(credentials.authToken && credentials.ct0);
+
+  try {
+    const result = await fn();
+    saveProviderMeta('x', { loggedIn: true, lastValidatedAt: new Date().toISOString() }, account);
+    return result;
+  } catch (error) {
+    if (!parseXSessionError(error) || !hasCredentials) {
+      throw error;
+    }
+
+    try {
+      const loginResult = await setCredentials({
+        authToken: credentials.authToken,
+        ct0: credentials.ct0,
+      });
+
+      saveProviderMeta('x', {
+        loggedIn: loginResult.loggedIn,
+        username: loginResult.username,
+        sessionPath: loginResult.sessionPath,
+        lastRefreshedAt: new Date().toISOString(),
+        lastError: null,
+      }, account);
+
+      if (!loginResult.loggedIn) {
+        throw new Error(loginResult.message || 'Login status could not be confirmed after session refresh.');
+      }
+
+      return fn();
+    } catch (reloginError) {
+      saveProviderMeta('x', {
+        loggedIn: false,
+        lastError: buildLoginErrorMessage(reloginError),
+        lastValidatedAt: new Date().toISOString(),
+      }, account);
+      throw reloginError;
+    }
+  }
+};
+
+module.exports = {
+  saveXSession,
+  loadXSession,
+  validateXSession,
+  cookiesToHeader,
+  loadRateLimits,
+  saveRateLimits,
+  createXWithProviderSession,
+};

package/src/providers/x/utils.js

@@ -0,0 +1,32 @@
+const readXCredentials = () => {
+  const authToken = process.env.X_AUTH_TOKEN || process.env.TWITTER_AUTH_TOKEN;
+  const ct0 = process.env.X_CT0 || process.env.TWITTER_CT0;
+  return {
+    authToken: typeof authToken === 'string' && authToken.trim() ? authToken.trim() : null,
+    ct0: typeof ct0 === 'string' && ct0.trim() ? ct0.trim() : null,
+  };
+};
+
+const parseXSessionError = (error) => {
+  const message = String(error?.message || '').toLowerCase();
+  return [
+    'no session file found',
+    'no valid cookies in session',
+    'session expired',
+    'authentication error',
+    'unauthorized',
+    '401',
+    '403',
+  ].some((token) => message.includes(token.toLowerCase()));
+};
+
+const buildLoginErrorMessage = (error) => String(error?.message || 'Session validation failed.');
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+module.exports = {
+  readXCredentials,
+  parseXSessionError,
+  buildLoginErrorMessage,
+  sleep,
+};

package/src/runner.js

@@ -116,12 +116,14 @@ const runCommand = async (command, opts = {}) => {
           username: opts.username || undefined,
           password: opts.password || undefined,
           twoFactorCode: opts.twoFactorCode || undefined,
+          authToken: opts.authToken || undefined,
+          ct0: opts.ct0 || undefined,
         })
       )();
 
     case 'publish': {
       const content = readContent(opts);
-      if (!content && providerName !== 'insta') {
+      if (!content && providerName !== 'insta' && providerName !== 'x') {
         throw createError('MISSING_CONTENT', 'publish requires --content or --content-file', 'viruagent-cli publish --spec');
       }
       return withProvider(() =>
@@ -275,6 +277,36 @@ const runCommand = async (command, opts = {}) => {
     case 'rate-limit-status':
       return withProvider(() => Promise.resolve(provider.rateLimitStatus()))();
 
+    // ── X (Twitter)-specific commands ──
+
+    case 'search':
+      if (!opts.query) {
+        throw createError('MISSING_PARAM', 'search requires --query');
+      }
+      return withProvider(() => provider.search({ query: opts.query, limit: parseIntOrNull(opts.limit) || 20 }))();
+
+    case 'retweet':
+      if (!opts.postId) {
+        throw createError('MISSING_PARAM', 'retweet requires --post-id');
+      }
+      return withProvider(() => provider.retweet({ postId: opts.postId }))();
+
+    case 'unretweet':
+      if (!opts.postId) {
+        throw createError('MISSING_PARAM', 'unretweet requires --post-id');
+      }
+      return withProvider(() => provider.unretweet({ postId: opts.postId }))();
+
+    case 'delete':
+    case 'delete-post':
+      if (!opts.postId) {
+        throw createError('MISSING_PARAM', 'delete requires --post-id');
+      }
+      return withProvider(() => provider.delete ? provider.delete({ postId: opts.postId }) : provider.deletePost({ postId: opts.postId }))();
+
+    case 'sync-operations':
+      return withProvider(() => provider.syncOperations())();
+
     default:
       throw createError('UNKNOWN_COMMAND', `Unknown command: ${command}`, 'viruagent-cli --spec');
   }

package/src/services/providerManager.js

@@ -3,14 +3,16 @@ const { getSessionPath } = require('../storage/sessionStore');
 const createTistoryProvider = require('../providers/tistory');
 const createNaverProvider = require('../providers/naver');
 const createInstaProvider = require('../providers/insta');
+const createXProvider = require('../providers/x');
 
 const providerFactory = {
   tistory: createTistoryProvider,
   naver: createNaverProvider,
   insta: createInstaProvider,
+  x: createXProvider,
 };
 
-const providers = ['tistory', 'naver', 'insta'];
+const providers = ['tistory', 'naver', 'insta', 'x'];
 
 const createProviderManager = () => {
   const cache = new Map();
@@ -36,7 +38,7 @@ const createProviderManager = () => {
     return cache.get(cacheKey);
   };
 
-  const providerNames = { tistory: 'Tistory', naver: 'Naver Blog', insta: 'Instagram' };
+  const providerNames = { tistory: 'Tistory', naver: 'Naver Blog', insta: 'Instagram', x: 'X (Twitter)' };
   const getAvailableProviders = () => providers.map((provider) => ({
     id: provider,
     name: providerNames[provider] || provider,