viruagent-cli 0.6.2 → 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,
 };