viruagent-cli 0.7.0 → 0.7.1

package/src/providers/reddit/session.js

@@ -0,0 +1,174 @@
+const fs = require('fs');
+const path = require('path');
+const { saveProviderMeta } = require('../../storage/sessionStore');
+const { readRedditCredentials, parseRedditSessionError, buildLoginErrorMessage } = require('./utils');
+
+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 saveRedditSession = (sessionPath, tokenData) => {
+  const existing = readSessionFile(sessionPath) || {};
+  const sessionData = {
+    ...existing,
+    authMode: tokenData.authMode || existing.authMode || 'oauth',
+    username: tokenData.username,
+    updatedAt: new Date().toISOString(),
+  };
+
+  if (tokenData.authMode === 'browser') {
+    sessionData.cookies = tokenData.cookies || [];
+    // Clean up other auth fields
+    delete sessionData.accessToken;
+    delete sessionData.expiresAt;
+    delete sessionData.redditSession;
+    delete sessionData.modhash;
+  } else if (tokenData.authMode === 'cookie') {
+    sessionData.redditSession = tokenData.redditSession;
+    sessionData.modhash = tokenData.modhash;
+    delete sessionData.accessToken;
+    delete sessionData.expiresAt;
+    delete sessionData.cookies;
+  } else {
+    sessionData.accessToken = tokenData.accessToken;
+    sessionData.expiresAt = tokenData.expiresAt;
+    delete sessionData.cookies;
+  }
+
+  writeSessionFile(sessionPath, sessionData);
+};
+
+const loadRedditSession = (sessionPath) => {
+  const raw = readSessionFile(sessionPath);
+  if (!raw) return null;
+
+  if (raw.authMode === 'browser') {
+    if (!raw.cookies || raw.cookies.length === 0) return null;
+    return {
+      authMode: 'browser',
+      cookies: raw.cookies,
+      username: raw.username,
+    };
+  }
+
+  if (raw.authMode === 'cookie') {
+    if (!raw.redditSession) return null;
+    return {
+      authMode: 'cookie',
+      redditSession: raw.redditSession,
+      modhash: raw.modhash || '',
+      username: raw.username,
+    };
+  }
+
+  // OAuth mode
+  if (!raw.accessToken) return null;
+  return {
+    authMode: 'oauth',
+    accessToken: raw.accessToken,
+    expiresAt: raw.expiresAt,
+    username: raw.username,
+  };
+};
+
+const cookiesToHeader = (cookies) =>
+  cookies.map((c) => `${c.name}=${c.value}`).join('; ');
+
+const isTokenExpired = (sessionPath) => {
+  const session = loadRedditSession(sessionPath);
+  if (!session) return true;
+  // Browser and cookie sessions don't expire via token
+  if (session.authMode === 'cookie' || session.authMode === 'browser') return false;
+  if (!session.expiresAt) return true;
+  // Consider expired 60 seconds before actual expiry
+  return Date.now() >= session.expiresAt - 60000;
+};
+
+// ── 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 validateRedditSession = (sessionPath) => {
+  const session = loadRedditSession(sessionPath);
+  if (!session) return false;
+  if (session.authMode === 'browser') return session.cookies?.length > 0;
+  if (session.authMode === 'cookie') return Boolean(session.redditSession);
+  if (!session.accessToken) return false;
+  return !isTokenExpired(sessionPath);
+};
+
+const createRedditWithProviderSession = (loginFn, account) => async (fn) => {
+  const credentials = readRedditCredentials();
+  const hasCredentials = Boolean(
+    (credentials.clientId && credentials.clientSecret && credentials.username && credentials.password) ||
+    (credentials.username && credentials.password),
+  );
+
+  try {
+    const result = await fn();
+    saveProviderMeta('reddit', { loggedIn: true, lastValidatedAt: new Date().toISOString() }, account);
+    return result;
+  } catch (error) {
+    if (!parseRedditSessionError(error) || !hasCredentials) {
+      throw error;
+    }
+
+    try {
+      const loginResult = await loginFn(credentials);
+
+      saveProviderMeta('reddit', {
+        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('reddit', {
+        loggedIn: false,
+        lastError: buildLoginErrorMessage(reloginError),
+        lastValidatedAt: new Date().toISOString(),
+      }, account);
+      throw reloginError;
+    }
+  }
+};
+
+module.exports = {
+  saveRedditSession,
+  loadRedditSession,
+  isTokenExpired,
+  cookiesToHeader,
+  loadRateLimits,
+  saveRateLimits,
+  validateRedditSession,
+  createRedditWithProviderSession,
+};

package/src/providers/reddit/utils.js

@@ -0,0 +1,49 @@
+const readRedditCredentials = () => {
+  const clientId = process.env.REDDIT_CLIENT_ID;
+  const clientSecret = process.env.REDDIT_CLIENT_SECRET;
+  const username = process.env.REDDIT_USERNAME;
+  const password = process.env.REDDIT_PASSWORD;
+  const env = (v) => typeof v === 'string' && v.trim() ? v.trim() : null;
+  return {
+    clientId: env(clientId),
+    clientSecret: env(clientSecret),
+    username: env(username),
+    password: env(password),
+    hasOAuth: Boolean(env(clientId) && env(clientSecret)),
+    hasPassword: Boolean(env(username) && env(password)),
+  };
+};
+
+const parseRedditSessionError = (error) => {
+  const message = String(error?.message || '').toLowerCase();
+  return [
+    'no session file found',
+    'no valid token in session',
+    'session expired',
+    'authentication error',
+    'token expired',
+    'unauthorized',
+    '401',
+    '403',
+  ].some((token) => message.includes(token.toLowerCase()));
+};
+
+const buildLoginErrorMessage = (error) => String(error?.message || 'Session validation failed.');
+
+const parseRedditError = (data) => {
+  if (data?.json?.errors?.length) {
+    const [code, message] = data.json.errors[0];
+    return { ok: false, error: code, message, hint: `Reddit API error: ${code}` };
+  }
+  if (data?.error) {
+    return { ok: false, error: String(data.error), message: data.message || data.error_description || '', hint: '' };
+  }
+  return null;
+};
+
+module.exports = {
+  readRedditCredentials,
+  parseRedditSessionError,
+  buildLoginErrorMessage,
+  parseRedditError,
+};

package/src/providers/tistory/auth.js

@@ -13,6 +13,7 @@ const {
   KAKAO_TRIGGER_SELECTORS,
   KAKAO_LOGIN_SELECTORS,
   KAKAO_2FA_SELECTORS,
+  KAKAO_SIMPLE_LOGIN_SELECTORS,
 } = require('./selectors');
 const {
   CHROME_PROFILE_DIR,
@@ -79,6 +80,16 @@ const createAskForAuthentication = ({ sessionPath, tistoryApi, pending2faResult
     await page.waitForLoadState('domcontentloaded').catch(() => {});
     await page.waitForTimeout(800);
 
+    // Handle "간편로그인 계정 선택" screen — click "새로운 계정으로 로그인"
+    if (page.url().includes('login/simple') || page.url().includes('#simpleLogin')) {
+      const newAccountSelector = await pickValue(page, KAKAO_SIMPLE_LOGIN_SELECTORS.newAccountButton);
+      if (newAccountSelector) {
+        await page.locator(newAccountSelector).click({ timeout: 5000 }).catch(() => {});
+        await page.waitForLoadState('domcontentloaded').catch(() => {});
+        await page.waitForTimeout(800);
+      }
+    }
+
     let finalLoginStatus = false;
     let pendingTwoFactorAction = false;
 

package/src/providers/tistory/selectors.js

@@ -25,6 +25,14 @@ const KAKAO_2FA_SELECTORS = {
   rememberDevice: ['#isRememberBrowser--5', 'input[name="isRememberBrowser"]'],
 };
 
+const KAKAO_SIMPLE_LOGIN_SELECTORS = {
+  newAccountButton: [
+    'a:has-text("새로운 계정으로 로그인")',
+    'span.tit_profile:has-text("새로운 계정으로 로그인")',
+    'a[href*="login_type=simple"]',
+  ],
+};
+
 const KAKAO_ACCOUNT_CONFIRM_SELECTORS = {
   textMarker: [
     'text=해당 카카오 계정으로',
@@ -47,5 +55,6 @@ module.exports = {
   KAKAO_TRIGGER_SELECTORS,
   KAKAO_LOGIN_SELECTORS,
   KAKAO_2FA_SELECTORS,
+  KAKAO_SIMPLE_LOGIN_SELECTORS,
   KAKAO_ACCOUNT_CONFIRM_SELECTORS,
 };

package/src/providers/x/apiClient.js

@@ -2,6 +2,36 @@ const fs = require('fs');
 const { loadXSession, cookiesToHeader, loadRateLimits, saveRateLimits } = require('./session');
 const { USER_AGENT, BEARER_TOKEN } = require('./auth');
 const { getOperation, invalidateCache } = require('./graphqlSync');
+const { ClientTransaction, handleXMigration } = require('x-client-transaction-id');
+
+// ── x-client-transaction-id singleton (cached, auto-refreshes on error) ──
+let _ctInstance = null;
+let _ctInitTime = 0;
+const CT_TTL_MS = 3600000; // 1 hour
+
+const getClientTransaction = async () => {
+  if (_ctInstance && Date.now() - _ctInitTime < CT_TTL_MS) return _ctInstance;
+  const document = await handleXMigration();
+  _ctInstance = await ClientTransaction.create(document);
+  _ctInitTime = Date.now();
+  return _ctInstance;
+};
+
+const generateTransactionId = async (method, path) => {
+  try {
+    const ct = await getClientTransaction();
+    return await ct.generateTransactionId(method, path);
+  } catch {
+    // If generation fails, invalidate and retry once
+    _ctInstance = null;
+    try {
+      const ct = await getClientTransaction();
+      return await ct.generateTransactionId(method, path);
+    } catch {
+      return undefined; // Proceed without the header if generation fails
+    }
+  }
+};
 
 const randomDelay = (minSec, maxSec) => {
   const ms = (minSec + Math.random() * (maxSec - minSec)) * 1000;
@@ -166,10 +196,28 @@ const createXApiClient = ({ sessionPath }) => {
     'x-twitter-active-user': 'yes',
     'x-twitter-client-language': 'ko',
     Cookie: cookiesToHeader(getCookies()),
+    // Browser fingerprint headers
+    Origin: 'https://x.com',
+    Referer: 'https://x.com/',
+    'sec-ch-ua': '"Chromium";v="146", "Google Chrome";v="146", "Not=A?Brand";v="99"',
+    'sec-ch-ua-mobile': '?0',
+    'sec-ch-ua-platform': '"macOS"',
+    'sec-fetch-dest': 'empty',
+    'sec-fetch-mode': 'cors',
+    'sec-fetch-site': 'same-origin',
   });
 
   const request = async (url, options = {}) => {
     const headers = { ...buildHeaders(), ...options.headers };
+
+    // Generate x-client-transaction-id for the request
+    const method = (options.method || 'GET').toUpperCase();
+    const urlPath = new URL(url).pathname;
+    const transactionId = await generateTransactionId(method, urlPath);
+    if (transactionId) {
+      headers['x-client-transaction-id'] = transactionId;
+    }
+
     const res = await fetch(url, { ...options, headers, redirect: 'manual' });
 
     if (res.status === 401 || res.status === 403) {

package/src/runner.js

@@ -118,12 +118,14 @@ const runCommand = async (command, opts = {}) => {
           twoFactorCode: opts.twoFactorCode || undefined,
           authToken: opts.authToken || undefined,
           ct0: opts.ct0 || undefined,
+          clientId: opts.clientId || undefined,
+          clientSecret: opts.clientSecret || undefined,
         })
       )();
 
     case 'publish': {
       const content = readContent(opts);
-      if (!content && providerName !== 'insta' && providerName !== 'x') {
+      if (!content && providerName !== 'insta' && providerName !== 'x' && providerName !== 'reddit') {
         throw createError('MISSING_CONTENT', 'publish requires --content or --content-file', 'viruagent-cli publish --spec');
       }
       return withProvider(() =>
@@ -140,6 +142,9 @@ const runCommand = async (command, opts = {}) => {
           imageUploadLimit: parseIntOrNull(opts.imageUploadLimit) || 1,
           minimumImageCount: parseIntOrNull(opts.minimumImageCount) || 1,
           autoUploadImages: opts.autoUploadImages !== false,
+          subreddit: opts.subreddit || undefined,
+          kind: opts.kind || undefined,
+          flair: opts.flair || undefined,
         })
       )();
     }
@@ -304,6 +309,18 @@ const runCommand = async (command, opts = {}) => {
       }
       return withProvider(() => provider.delete ? provider.delete({ postId: opts.postId }) : provider.deletePost({ postId: opts.postId }))();
 
+    case 'subscribe':
+      if (!opts.subreddit) {
+        throw createError('MISSING_PARAM', 'subscribe requires --subreddit');
+      }
+      return withProvider(() => provider.subscribe({ subreddit: opts.subreddit }))();
+
+    case 'unsubscribe':
+      if (!opts.subreddit) {
+        throw createError('MISSING_PARAM', 'unsubscribe requires --subreddit');
+      }
+      return withProvider(() => provider.unsubscribe({ subreddit: opts.subreddit }))();
+
     case 'sync-operations':
       return withProvider(() => provider.syncOperations())();
 

package/src/services/providerManager.js

@@ -4,15 +4,17 @@ const createTistoryProvider = require('../providers/tistory');
 const createNaverProvider = require('../providers/naver');
 const createInstaProvider = require('../providers/insta');
 const createXProvider = require('../providers/x');
+const createRedditProvider = require('../providers/reddit');
 
 const providerFactory = {
   tistory: createTistoryProvider,
   naver: createNaverProvider,
   insta: createInstaProvider,
   x: createXProvider,
+  reddit: createRedditProvider,
 };
 
-const providers = ['tistory', 'naver', 'insta', 'x'];
+const providers = ['tistory', 'naver', 'insta', 'x', 'reddit'];
 
 const createProviderManager = () => {
   const cache = new Map();
@@ -38,7 +40,7 @@ const createProviderManager = () => {
     return cache.get(cacheKey);
   };
 
-  const providerNames = { tistory: 'Tistory', naver: 'Naver Blog', insta: 'Instagram', x: 'X (Twitter)' };
+  const providerNames = { tistory: 'Tistory', naver: 'Naver Blog', insta: 'Instagram', x: 'X (Twitter)', reddit: 'Reddit' };
   const getAvailableProviders = () => providers.map((provider) => ({
     id: provider,
     name: providerNames[provider] || provider,