viruagent-cli 0.3.7 → 0.4.0

package/src/providers/insta/auth.js

@@ -0,0 +1,135 @@
+const fs = require('fs');
+const path = require('path');
+const { readInstaCredentials } = require('./utils');
+const { saveInstaSession } = require('./session');
+
+const IG_APP_ID = '936619743392459';
+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';
+
+const parseCookiesFromHeaders = (headers) => {
+  const cookies = [];
+  const setCookies = headers.getSetCookie?.() || [];
+  for (const raw of setCookies) {
+    const parts = raw.split(';').map((s) => s.trim());
+    const [nameValue, ...attrs] = parts;
+    const eqIndex = nameValue.indexOf('=');
+    if (eqIndex < 0) continue;
+
+    const name = nameValue.slice(0, eqIndex);
+    const value = nameValue.slice(eqIndex + 1);
+
+    const cookie = { name, value, domain: '.instagram.com', path: '/' };
+    for (const attr of attrs) {
+      const lower = attr.toLowerCase();
+      if (lower.startsWith('domain=')) cookie.domain = attr.slice(7);
+      if (lower.startsWith('path=')) cookie.path = attr.slice(5);
+      if (lower === 'httponly') cookie.httpOnly = true;
+      if (lower === 'secure') cookie.secure = true;
+    }
+    cookies.push(cookie);
+  }
+  return cookies;
+};
+
+const mergeCookies = (existing, incoming) => {
+  const map = new Map();
+  for (const c of [...existing, ...incoming]) {
+    map.set(c.name, c);
+  }
+  return [...map.values()];
+};
+
+const createAskForAuthentication = ({ sessionPath }) => async ({
+  username,
+  password,
+} = {}) => {
+  fs.mkdirSync(path.dirname(sessionPath), { recursive: true });
+
+  const resolvedUsername = username || readInstaCredentials().username;
+  const resolvedPassword = password || readInstaCredentials().password;
+
+  if (!resolvedUsername || !resolvedPassword) {
+    throw new Error(
+      '인스타그램 로그인에 username/password가 필요합니다. ' +
+      '환경변수 INSTA_USERNAME / INSTA_PASSWORD를 설정해 주세요.',
+    );
+  }
+
+  // Step 1: GET login page -> csrftoken + mid 쿠키 획득
+  const initRes = await fetch('https://www.instagram.com/accounts/login/', {
+    headers: { 'User-Agent': USER_AGENT },
+    redirect: 'manual',
+  });
+  let cookies = parseCookiesFromHeaders(initRes.headers);
+
+  const csrfCookie = cookies.find((c) => c.name === 'csrftoken');
+  if (!csrfCookie) {
+    throw new Error('Instagram 초기 페이지에서 csrftoken을 가져올 수 없습니다.');
+  }
+  const csrfToken = csrfCookie.value;
+  const cookieHeader = cookies.map((c) => `${c.name}=${c.value}`).join('; ');
+
+  // Step 2: POST login
+  const timestamp = Math.floor(Date.now() / 1000);
+  const body = new URLSearchParams({
+    username: resolvedUsername,
+    enc_password: `#PWD_INSTAGRAM_BROWSER:0:${timestamp}:${resolvedPassword}`,
+    queryParams: '{}',
+    optIntoOneTap: 'false',
+  });
+
+  const loginRes = await fetch('https://www.instagram.com/api/v1/web/accounts/login/ajax/', {
+    method: 'POST',
+    headers: {
+      'User-Agent': USER_AGENT,
+      'X-CSRFToken': csrfToken,
+      'X-Requested-With': 'XMLHttpRequest',
+      'X-IG-App-ID': IG_APP_ID,
+      'Content-Type': 'application/x-www-form-urlencoded',
+      Referer: 'https://www.instagram.com/accounts/login/',
+      Origin: 'https://www.instagram.com',
+      Cookie: cookieHeader,
+    },
+    body: body.toString(),
+    redirect: 'manual',
+  });
+
+  const loginCookies = parseCookiesFromHeaders(loginRes.headers);
+  cookies = mergeCookies(cookies, loginCookies);
+
+  const loginData = await loginRes.json();
+
+  if (loginData.checkpoint_url) {
+    throw new Error(
+      '2단계 인증(checkpoint)이 필요합니다. 브라우저에서 먼저 인증을 완료해 주세요.',
+    );
+  }
+
+  if (loginData.two_factor_required) {
+    throw new Error(
+      '2단계 인증(2FA)이 필요합니다. 브라우저에서 먼저 인증을 완료해 주세요.',
+    );
+  }
+
+  if (!loginData.authenticated) {
+    const reason = loginData.message || loginData.status || 'unknown';
+    throw new Error(`인스타그램 로그인 실패: ${reason}`);
+  }
+
+  // 세션 저장
+  saveInstaSession(sessionPath, cookies);
+
+  return {
+    provider: 'insta',
+    loggedIn: true,
+    userId: loginData.userId || null,
+    username: resolvedUsername,
+    sessionPath,
+  };
+};
+
+module.exports = {
+  createAskForAuthentication,
+  IG_APP_ID,
+  USER_AGENT,
+};

package/src/providers/insta/index.js

@@ -0,0 +1,293 @@
+const { saveProviderMeta, clearProviderMeta, getProviderMeta } = require('../../storage/sessionStore');
+const createInstaApiClient = require('./apiClient');
+const createSmartComment = require('./smartComment');
+const { readInstaCredentials } = require('./utils');
+const { createInstaWithProviderSession } = require('./session');
+const { createAskForAuthentication } = require('./auth');
+
+const createInstaProvider = ({ sessionPath }) => {
+  const instaApi = createInstaApiClient({ sessionPath });
+
+  const askForAuthentication = createAskForAuthentication({ sessionPath });
+
+  const withProviderSession = createInstaWithProviderSession(askForAuthentication);
+  const smart = createSmartComment(instaApi);
+
+  return {
+    id: 'insta',
+    name: 'Instagram',
+
+    async authStatus() {
+      return withProviderSession(async () => {
+        try {
+          const userId = instaApi.getUserId();
+          const cookies = instaApi.getCookies();
+          const sessionid = cookies.find((c) => c.name === 'sessionid');
+          return {
+            provider: 'insta',
+            loggedIn: true,
+            userId,
+            hasSession: Boolean(sessionid?.value),
+            sessionPath,
+            metadata: getProviderMeta('insta') || {},
+          };
+        } catch (error) {
+          return {
+            provider: 'insta',
+            loggedIn: false,
+            sessionPath,
+            error: error.message,
+            metadata: getProviderMeta('insta') || {},
+          };
+        }
+      });
+    },
+
+    async login({ username, password } = {}) {
+      const creds = readInstaCredentials();
+      const resolved = {
+        username: username || creds.username,
+        password: password || creds.password,
+      };
+
+      if (!resolved.username || !resolved.password) {
+        throw new Error(
+          '인스타그램 로그인에 username/password가 필요합니다. ' +
+          '환경변수 INSTA_USERNAME / INSTA_PASSWORD를 설정해 주세요.',
+        );
+      }
+
+      const result = await askForAuthentication(resolved);
+      instaApi.resetState();
+
+      saveProviderMeta('insta', {
+        loggedIn: result.loggedIn,
+        userId: result.userId,
+        username: result.username,
+        sessionPath: result.sessionPath,
+      });
+
+      return result;
+    },
+
+    async getProfile({ username } = {}) {
+      return withProviderSession(async () => {
+        if (!username) {
+          throw new Error('username이 필요합니다.');
+        }
+        const profile = await instaApi.getProfile(username);
+        return {
+          provider: 'insta',
+          mode: 'profile',
+          ...profile,
+        };
+      });
+    },
+
+    async getFeed() {
+      return withProviderSession(async () => {
+        const items = await instaApi.getFeed();
+        return {
+          provider: 'insta',
+          mode: 'feed',
+          count: items.length,
+          items,
+        };
+      });
+    },
+
+    async listPosts({ username, limit = 12 } = {}) {
+      return withProviderSession(async () => {
+        if (!username) {
+          throw new Error('username이 필요합니다.');
+        }
+        const posts = await instaApi.getUserPosts(username, limit);
+        return {
+          provider: 'insta',
+          mode: 'posts',
+          username,
+          totalCount: posts.length,
+          posts,
+        };
+      });
+    },
+
+    async getPost({ postId } = {}) {
+      return withProviderSession(async () => {
+        const shortcode = String(postId || '').trim();
+        if (!shortcode) {
+          return {
+            provider: 'insta',
+            mode: 'post',
+            status: 'invalid_post_id',
+            message: 'postId(shortcode)가 필요합니다.',
+          };
+        }
+        const post = await instaApi.getPostDetail(shortcode);
+        return {
+          provider: 'insta',
+          mode: 'post',
+          ...post,
+        };
+      });
+    },
+
+    async follow({ username } = {}) {
+      return withProviderSession(async () => {
+        if (!username) throw new Error('username이 필요합니다.');
+        const profile = await instaApi.getProfile(username);
+        const result = await instaApi.followUser(profile.id);
+        return {
+          provider: 'insta',
+          mode: 'follow',
+          username,
+          userId: profile.id,
+          following: result.following,
+          outgoingRequest: result.outgoingRequest,
+          status: result.status,
+        };
+      });
+    },
+
+    async unfollow({ username } = {}) {
+      return withProviderSession(async () => {
+        if (!username) throw new Error('username이 필요합니다.');
+        const profile = await instaApi.getProfile(username);
+        const result = await instaApi.unfollowUser(profile.id);
+        return {
+          provider: 'insta',
+          mode: 'unfollow',
+          username,
+          userId: profile.id,
+          following: result.following,
+          status: result.status,
+        };
+      });
+    },
+
+    async like({ postId } = {}) {
+      return withProviderSession(async () => {
+        const shortcode = String(postId || '').trim();
+        if (!shortcode) throw new Error('postId(shortcode)가 필요합니다.');
+        const mediaId = await instaApi.getMediaIdFromShortcode(shortcode);
+        const result = await instaApi.likePost(mediaId);
+        return { provider: 'insta', mode: 'like', postId: shortcode, status: result.status };
+      });
+    },
+
+    async unlike({ postId } = {}) {
+      return withProviderSession(async () => {
+        const shortcode = String(postId || '').trim();
+        if (!shortcode) throw new Error('postId(shortcode)가 필요합니다.');
+        const mediaId = await instaApi.getMediaIdFromShortcode(shortcode);
+        const result = await instaApi.unlikePost(mediaId);
+        return { provider: 'insta', mode: 'unlike', postId: shortcode, status: result.status };
+      });
+    },
+
+    async likeComment({ commentId } = {}) {
+      return withProviderSession(async () => {
+        if (!commentId) throw new Error('commentId가 필요합니다.');
+        const result = await instaApi.likeComment(commentId);
+        return { provider: 'insta', mode: 'likeComment', commentId, status: result.status };
+      });
+    },
+
+    async unlikeComment({ commentId } = {}) {
+      return withProviderSession(async () => {
+        if (!commentId) throw new Error('commentId가 필요합니다.');
+        const result = await instaApi.unlikeComment(commentId);
+        return { provider: 'insta', mode: 'unlikeComment', commentId, status: result.status };
+      });
+    },
+
+    async comment({ postId, text } = {}) {
+      return withProviderSession(async () => {
+        const shortcode = String(postId || '').trim();
+        const commentText = String(text || '').trim();
+        if (!shortcode) {
+          throw new Error('postId(shortcode)가 필요합니다.');
+        }
+        if (!commentText) {
+          throw new Error('댓글 내용(text)이 필요합니다.');
+        }
+        const mediaId = await instaApi.getMediaIdFromShortcode(shortcode);
+        const result = await instaApi.addComment(mediaId, commentText);
+        return {
+          provider: 'insta',
+          mode: 'comment',
+          postId: shortcode,
+          commentId: result.id,
+          text: result.text,
+          from: result.from?.username,
+          status: result.status,
+        };
+      });
+    },
+
+    async publish({ imageUrl, imagePath, caption = '' } = {}) {
+      return withProviderSession(async () => {
+        if (!imageUrl && !imagePath) {
+          throw new Error('imageUrl 또는 imagePath가 필요합니다.');
+        }
+        const result = await instaApi.publishPost({ imageUrl, imagePath, caption });
+        return {
+          provider: 'insta',
+          mode: 'publish',
+          ...result,
+        };
+      });
+    },
+
+    async analyzePost({ postId } = {}) {
+      return withProviderSession(async () => {
+        const shortcode = String(postId || '').trim();
+        if (!shortcode) {
+          throw new Error('postId(shortcode)가 필요합니다.');
+        }
+        const analysis = await smart.analyzePost({ shortcode });
+        return {
+          provider: 'insta',
+          mode: 'analyze',
+          ...analysis,
+        };
+      });
+    },
+
+    async deletePost({ postId } = {}) {
+      return withProviderSession(async () => {
+        const shortcode = String(postId || '').trim();
+        if (!shortcode) {
+          throw new Error('postId(shortcode)가 필요합니다.');
+        }
+        const mediaId = await instaApi.getMediaIdFromShortcode(shortcode);
+        const result = await instaApi.deletePost(mediaId);
+        return {
+          provider: 'insta',
+          mode: 'delete',
+          postId: shortcode,
+          status: result.status,
+        };
+      });
+    },
+
+    rateLimitStatus() {
+      return {
+        provider: 'insta',
+        mode: 'rateLimitStatus',
+        ...instaApi.getRateLimitStatus(),
+      };
+    },
+
+    async logout() {
+      clearProviderMeta('insta');
+      return {
+        provider: 'insta',
+        loggedOut: true,
+        sessionPath,
+      };
+    },
+  };
+};
+
+module.exports = createInstaProvider;

package/src/providers/insta/session.js

@@ -0,0 +1,118 @@
+const fs = require('fs');
+const path = require('path');
+const { saveProviderMeta } = require('../../storage/sessionStore');
+const { readInstaCredentials, parseInstaSessionError, buildLoginErrorMessage } = require('./utils');
+
+const ESSENTIAL_COOKIES = ['sessionid', 'csrftoken', 'ds_user_id'];
+
+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 saveInstaSession = (sessionPath, cookies) => {
+  const existing = readSessionFile(sessionPath) || {};
+  writeSessionFile(sessionPath, {
+    ...existing,
+    cookies,
+    updatedAt: new Date().toISOString(),
+  });
+};
+
+const loadInstaSession = (sessionPath) => {
+  const raw = readSessionFile(sessionPath);
+  return Array.isArray(raw?.cookies) ? raw.cookies : null;
+};
+
+// ── Rate Limit 영속화 (userId별) ──
+
+const loadRateLimits = (sessionPath, userId) => {
+  const raw = readSessionFile(sessionPath);
+  return raw?.rateLimits?.[userId] || null;
+};
+
+const saveRateLimits = (sessionPath, userId, counters) => {
+  const raw = readSessionFile(sessionPath) || {};
+  if (!raw.rateLimits) raw.rateLimits = {};
+  raw.rateLimits[userId] = {
+    ...counters,
+    savedAt: new Date().toISOString(),
+  };
+  writeSessionFile(sessionPath, raw);
+};
+
+const validateInstaSession = (sessionPath) => {
+  const cookies = loadInstaSession(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 createInstaWithProviderSession = (askForAuthentication) => async (fn) => {
+  const credentials = readInstaCredentials();
+  const hasCredentials = Boolean(credentials.username && credentials.password);
+
+  try {
+    const result = await fn();
+    saveProviderMeta('insta', {
+      loggedIn: true,
+      lastValidatedAt: new Date().toISOString(),
+    });
+    return result;
+  } catch (error) {
+    if (!parseInstaSessionError(error) || !hasCredentials) {
+      throw error;
+    }
+
+    try {
+      const loginResult = await askForAuthentication({
+        username: credentials.username,
+        password: credentials.password,
+      });
+
+      saveProviderMeta('insta', {
+        loggedIn: loginResult.loggedIn,
+        userId: loginResult.userId,
+        sessionPath: loginResult.sessionPath,
+        lastRefreshedAt: new Date().toISOString(),
+        lastError: null,
+      });
+
+      if (!loginResult.loggedIn) {
+        throw new Error(loginResult.message || '세션 갱신 후 로그인 상태가 확인되지 않았습니다.');
+      }
+
+      return fn();
+    } catch (reloginError) {
+      saveProviderMeta('insta', {
+        loggedIn: false,
+        lastError: buildLoginErrorMessage(reloginError),
+        lastValidatedAt: new Date().toISOString(),
+      });
+      throw reloginError;
+    }
+  }
+};
+
+module.exports = {
+  saveInstaSession,
+  loadInstaSession,
+  validateInstaSession,
+  cookiesToHeader,
+  loadRateLimits,
+  saveRateLimits,
+  createInstaWithProviderSession,
+};

package/src/providers/insta/smartComment.js

@@ -0,0 +1,67 @@
+const createSmartComment = (instaApi) => {
+  const analyzePost = async ({ shortcode }) => {
+    // 1. 게시물 상세
+    const post = await instaApi.getPostDetail(shortcode);
+    const caption = post.caption || '';
+    const isVideo = post.isVideo;
+    const mediaType = post.mediaType;
+    const thumbnailUrl = post.imageUrl;
+    const ownerUsername = post.owner?.username || '';
+
+    // 2. 작성자 프로필
+    let ownerProfile = null;
+    try {
+      ownerProfile = await instaApi.getProfile(ownerUsername);
+    } catch {
+      // 비공개 등 실패 무시
+    }
+
+    // 3. 썸네일 이미지 base64 (Claude Code Vision용)
+    let thumbnailBase64 = null;
+    let thumbnailMediaType = 'image/jpeg';
+    if (thumbnailUrl) {
+      try {
+        const res = await fetch(thumbnailUrl);
+        if (res.ok) {
+          const buffer = Buffer.from(await res.arrayBuffer());
+          thumbnailBase64 = buffer.toString('base64');
+          const ct = res.headers.get('content-type');
+          if (ct) thumbnailMediaType = ct;
+        }
+      } catch {
+        // 실패해도 캡션만으로 진행
+      }
+    }
+
+    const contentType = isVideo
+      ? '영상(릴스)'
+      : mediaType?.includes('Sidecar')
+        ? '캐러셀(다중 이미지)'
+        : '사진';
+
+    return {
+      shortcode,
+      contentType,
+      caption,
+      isVideo,
+      owner: {
+        username: ownerUsername,
+        fullName: ownerProfile?.fullName || '',
+        biography: ownerProfile?.biography || '',
+        followerCount: ownerProfile?.followerCount || 0,
+      },
+      engagement: {
+        likeCount: post.likeCount,
+        commentCount: post.commentCount,
+      },
+      thumbnailUrl,
+      thumbnailBase64,
+      thumbnailMediaType,
+      postUrl: post.url,
+    };
+  };
+
+  return { analyzePost };
+};
+
+module.exports = createSmartComment;

package/src/providers/insta/utils.js

@@ -0,0 +1,34 @@
+const readInstaCredentials = () => {
+  const username = process.env.INSTA_USERNAME || process.env.INSTAGRAM_USERNAME || process.env.INSTA_USER;
+  const password = process.env.INSTA_PASSWORD || process.env.INSTAGRAM_PASSWORD || process.env.INSTA_PW;
+  return {
+    username: typeof username === 'string' && username.trim() ? username.trim() : null,
+    password: typeof password === 'string' && password.trim() ? password.trim() : null,
+  };
+};
+
+const parseInstaSessionError = (error) => {
+  const message = String(error?.message || '').toLowerCase();
+  return [
+    '세션 파일이 없습니다',
+    '세션에 유효한 쿠키',
+    '세션이 만료',
+    '로그인이 필요합니다',
+    'login_required',
+    'checkpoint_required',
+    '401',
+    '403',
+    '302',
+  ].some((token) => message.includes(token.toLowerCase()));
+};
+
+const buildLoginErrorMessage = (error) => String(error?.message || '세션 검증에 실패했습니다.');
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+module.exports = {
+  readInstaCredentials,
+  parseInstaSessionError,
+  buildLoginErrorMessage,
+  sleep,
+};