viruagent-cli 0.4.1 → 0.5.0

package/bin/index.js

@@ -212,6 +212,12 @@ analyzePostCmd
   .option('--post-id <shortcode>', 'Post shortcode')
   .action((opts) => execute('analyze-post', opts));
 
+const resolveChallengeCmd = program
+  .command('resolve-challenge')
+  .description('Resolve Instagram challenge (auto-verify identity)');
+addProviderOption(resolveChallengeCmd);
+resolveChallengeCmd.action((opts) => execute('resolve-challenge', opts));
+
 const rateLimitCmd = program
   .command('rate-limit-status')
   .description('Show current rate limit usage');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "viruagent-cli",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "AI-agent-optimized CLI for blog publishing (Tistory, Naver) and Instagram automation",
   "private": false,
   "type": "commonjs",

package/src/providers/insta/apiClient.js

@@ -8,40 +8,40 @@ const randomDelay = (minSec, maxSec) => {
 };
 
 // ──────────────────────────────────────────────────────────────
-// Instagram 안전 액션 규칙 (2026 기준, 리서치 기반)
+// Instagram Safe Action Rules (2026, research-based)
 //
-// [계정 나이별 시간당 한도]
-//   신규 (0~20일)    | 성숙 (20일+)
-//   좋아요    15/h   | 60/h
-//   댓글       5/h   | 20/h
-//   팔로우    15/h   | 60/h
-//   언팔로우  10/h   | 30/h
+// [Hourly limits by account age]
+//   New (0~20 days)  | Mature (20+ days)
+//   Like      15/h   | 60/h
+//   Comment    5/h   | 20/h
+//   Follow    15/h   | 60/h
+//   Unfollow  10/h   | 30/h
 //   DM         5/h   | 50/h
-//   게시물     3/h   | 10/h
+//   Publish    3/h   | 10/h
 //
-// [일일 한도]
-//   좋아요   500/일   댓글   100/일   팔로우  250/일
-//   언팔로우 200/일   DM      30/일   게시물   25/일
+// [Daily limits]
+//   Like   500/day   Comment 100/day   Follow  250/day
+//   Unfollow 200/day DM       30/day   Publish  25/day
 //
-// [최소 액션 간격 (신규 계정)]
-//   좋아요: 20~40초 | 댓글: 300~420초(5~7분) | 팔로우: 60~120초
-//   언팔로우: 60~120초 | DM: 120~300초 | 게시물: 60~120초
+// [Minimum action intervals (new accounts)]
+//   Like: 20~40s | Comment: 300~420s (5~7min) | Follow: 60~120s
+//   Unfollow: 60~120s | DM: 120~300s | Publish: 60~120s
 //
-// [주의사항]
-//   - 시간당 총 액션 15개 이하 (신규) / 40개 이하 (성숙)
-//   - 균일 간격은 봇 감지 → 랜덤 딜레이 필수
-//   - 동일 유저에게 반복 액션 금지
-//   - challenge 발생 시 브라우저에서 본인 인증 필요
-//   - challenge 후 24~48시간 대기 권장
+// [Notes]
+//   - Max 15 total actions/hour (new) / 40 (mature)
+//   - Uniform intervals trigger bot detection → random delay required
+//   - Repeated actions on the same user are prohibited
+//   - Challenge requires manual verification in the browser
+//   - Wait 24~48 hours after a challenge is recommended
 // ──────────────────────────────────────────────────────────────
 
 const DELAY = {
-  like:     [20, 40],    // 20~40초
-  comment:  [300, 420],  // 5~7분
-  follow:   [60, 120],   // 1~2분
-  unfollow: [60, 120],   // 1~2분
-  dm:       [120, 300],  // 2~5분
-  publish:  [60, 120],   // 1~2분
+  like:     [20, 40],    // 20~40s
+  comment:  [300, 420],  // 5~7min
+  follow:   [60, 120],   // 1~2min
+  unfollow: [60, 120],   // 1~2min
+  dm:       [120, 300],  // 2~5min
+  publish:  [60, 120],   // 1~2min
 };
 
 const HOURLY_LIMIT = {
@@ -69,7 +69,7 @@ const createInstaApiClient = ({ sessionPath }) => {
   let cachedUserId = null;
   let countersCache = null;
 
-  // ── 세션 파일 기반 Rate Limit 카운터 ──
+  // ── Session file-based Rate Limit counters ──
 
   const loadCounters = () => {
     if (countersCache) return countersCache;
@@ -90,7 +90,7 @@ const createInstaApiClient = ({ sessionPath }) => {
       if (!userId || !countersCache) return;
       saveRateLimits(sessionPath, userId, countersCache);
     } catch {
-      // 저장 실패해도 동작에 영향 없음
+      // Save failure does not affect operation
     }
   };
 
@@ -112,10 +112,10 @@ const createInstaApiClient = ({ sessionPath }) => {
     const dailyMax = DAILY_LIMIT[type];
     if (hourlyMax && c.hourly >= hourlyMax) {
       const waitMin = Math.ceil((3600000 - (Date.now() - c.hourStart)) / 60000);
-      throw new Error(`hourly_limit: ${type} 시간당 한도 ${hourlyMax}개 초과. ${waitMin}분 후 재시도하세요.`);
+      throw new Error(`hourly_limit: ${type} exceeded hourly limit of ${hourlyMax}. Retry in ${waitMin} minutes.`);
     }
     if (dailyMax && c.daily >= dailyMax) {
-      throw new Error(`daily_limit: ${type} 일일 한도 ${dailyMax}개 초과. 내일 다시 시도하세요.`);
+      throw new Error(`daily_limit: ${type} exceeded daily limit of ${dailyMax}. Try again tomorrow.`);
     }
   };
 
@@ -130,11 +130,11 @@ const createInstaApiClient = ({ sessionPath }) => {
     if (cachedCookies) return cachedCookies;
     const cookies = loadInstaSession(sessionPath);
     if (!cookies) {
-      throw new Error('세션 파일이 없습니다. 먼저 로그인해 주세요.');
+      throw new Error('No session file found. Please log in first.');
     }
     const sessionid = cookies.find((c) => c.name === 'sessionid');
     if (!sessionid?.value) {
-      throw new Error('세션에 유효한 쿠키가 없습니다. 다시 로그인해 주세요.');
+      throw new Error('No valid cookies in session. Please log in again.');
     }
     cachedCookies = cookies;
     return cookies;
@@ -172,17 +172,44 @@ const createInstaApiClient = ({ sessionPath }) => {
     if (res.status === 302 || res.status === 301) {
       const location = res.headers.get('location') || '';
       if (location.includes('/accounts/login')) {
-        throw new Error('세션이 만료되었습니다. 다시 로그인해 주세요.');
+        throw new Error('Session expired. Please log in again.');
+      }
+      if (location.includes('/challenge')) {
+        // Attempt automatic challenge resolution
+        const resolved = await resolveChallenge();
+        if (resolved) {
+          // Retry original request after resolution
+          return fetch(url, { ...options, headers, redirect: 'manual' });
+        }
+        throw new Error('challenge_required: Identity verification required. Please complete it manually in the browser.');
+      }
+      throw new Error(`Redirect occurred: ${res.status} → ${location}`);
+    }
+
+    // Handle challenge_required JSON response
+    if (res.status === 400 && !options.allowError) {
+      const cloned = res.clone();
+      try {
+        const data = await cloned.json();
+        if (data.message === 'challenge_required') {
+          const resolved = await resolveChallenge();
+          if (resolved) {
+            return fetch(url, { ...options, headers, redirect: 'manual' });
+          }
+          throw new Error('challenge_required: Identity verification required.');
+        }
+      } catch (e) {
+        if (e.message.includes('challenge_required')) throw e;
+        // Ignore JSON parse failure and continue original flow
       }
-      throw new Error(`리다이렉트 발생: ${res.status} → ${location}`);
     }
 
     if (res.status === 401 || res.status === 403) {
-      throw new Error(`인증 오류 (${res.status}). 다시 로그인해 주세요.`);
+      throw new Error(`Authentication error (${res.status}). Please log in again.`);
     }
 
     if (!res.ok && !options.allowError) {
-      throw new Error(`Instagram API 오류: ${res.status} ${res.statusText}`);
+      throw new Error(`Instagram API error: ${res.status} ${res.statusText}`);
     }
 
     return res;
@@ -194,7 +221,7 @@ const createInstaApiClient = ({ sessionPath }) => {
     );
     const data = await res.json();
     const user = data?.data?.user;
-    if (!user) throw new Error(`프로필을 찾을 수 없습니다: ${username}`);
+    if (!user) throw new Error(`Profile not found: ${username}`);
     return {
       id: user.id,
       username: user.username,
@@ -295,7 +322,7 @@ const createInstaApiClient = ({ sessionPath }) => {
       has_threaded_comments: true,
     });
     const media = data?.data?.xdt_shortcode_media || data?.data?.shortcode_media;
-    if (!media) throw new Error(`게시물을 찾을 수 없습니다: ${shortcode}`);
+    if (!media) throw new Error(`Post not found: ${shortcode}`);
     return {
       id: media.id,
       code: media.shortcode,
@@ -316,6 +343,35 @@ const createInstaApiClient = ({ sessionPath }) => {
     };
   };
 
+  // ── Automatic Challenge Resolution ──
+
+  const resolveChallenge = async () => {
+    try {
+      const cookies = getCookies();
+      const res = await fetch('https://www.instagram.com/api/v1/challenge/web/action/', {
+        method: 'POST',
+        headers: {
+          'User-Agent': USER_AGENT,
+          'X-IG-App-ID': IG_APP_ID,
+          'X-CSRFToken': getCsrfToken(),
+          'X-Requested-With': 'XMLHttpRequest',
+          'X-Instagram-AJAX': '1',
+          Referer: 'https://www.instagram.com/challenge/',
+          Origin: 'https://www.instagram.com',
+          'Content-Type': 'application/x-www-form-urlencoded',
+          Cookie: cookiesToHeader(cookies),
+        },
+        body: 'choice=0',
+        redirect: 'manual',
+      });
+      if (!res.ok) return false;
+      const data = await res.json();
+      return data.status === 'ok';
+    } catch {
+      return false;
+    }
+  };
+
   const parseLikeResponse = async (res) => {
     if (res.ok) return res.json();
     if (res.status === 400) {
@@ -323,17 +379,17 @@ const createInstaApiClient = ({ sessionPath }) => {
       if (data.spam) {
         throw new Error(`rate_limit: ${data.feedback_title || 'Try Again Later'}`);
       }
-      // 이미 좋아요/취소 상태
+      // Already liked/unliked state
       return { status: 'already', message: data.message };
     }
-    throw new Error(`Instagram API 오류: ${res.status}`);
+    throw new Error(`Instagram API error: ${res.status}`);
   };
 
   const withDelay = async (type, fn) => {
-    // 한도 체크
+    // Check limits
     checkLimit(type);
 
-    // 랜덤 딜레이
+    // Random delay
     const [min, max] = DELAY[type] || [20, 40];
     const elapsed = (Date.now() - lastActionTime) / 1000;
     if (lastActionTime > 0 && elapsed < min) {
@@ -519,7 +575,7 @@ const createInstaApiClient = ({ sessionPath }) => {
     );
     const data = await res.json();
     if (data.status !== 'ok') {
-      throw new Error(`이미지 업로드 실패: ${data.message || 'unknown'}`);
+      throw new Error(`Image upload failed: ${data.message || 'unknown'}`);
     }
     return uploadId;
   };
@@ -545,7 +601,7 @@ const createInstaApiClient = ({ sessionPath }) => {
     });
     const data = await res.json();
     if (data.status !== 'ok') {
-      throw new Error(`게시물 생성 실패: ${data.message || 'unknown'}`);
+      throw new Error(`Post creation failed: ${data.message || 'unknown'}`);
     }
     return {
       id: data.media?.pk,
@@ -561,10 +617,10 @@ const createInstaApiClient = ({ sessionPath }) => {
       imageBuffer = fs.readFileSync(imagePath);
     } else if (imageUrl) {
       const res = await fetch(imageUrl);
-      if (!res.ok) throw new Error(`이미지 다운로드 실패: ${res.status}`);
+      if (!res.ok) throw new Error(`Image download failed: ${res.status}`);
       imageBuffer = Buffer.from(await res.arrayBuffer());
     } else {
-      throw new Error('imageUrl 또는 imagePath가 필요합니다.');
+      throw new Error('Either imageUrl or imagePath is required.');
     }
 
     const uploadId = await uploadPhoto(imageBuffer);
@@ -611,6 +667,7 @@ const createInstaApiClient = ({ sessionPath }) => {
     configurePost,
     publishPost,
     deletePost,
+    resolveChallenge,
     resetState,
     getRateLimitStatus: () => {
       const status = {};
@@ -619,7 +676,7 @@ const createInstaApiClient = ({ sessionPath }) => {
         status[type] = {
           hourly: `${c.hourly}/${HOURLY_LIMIT[type]}`,
           daily: `${c.daily}/${DAILY_LIMIT[type]}`,
-          delay: `${DELAY[type]?.[0]}~${DELAY[type]?.[1]}초`,
+          delay: `${DELAY[type]?.[0]}~${DELAY[type]?.[1]}s`,
         };
       }
       return status;

package/src/providers/insta/auth.js

@@ -50,12 +50,12 @@ const createAskForAuthentication = ({ sessionPath }) => async ({
 
   if (!resolvedUsername || !resolvedPassword) {
     throw new Error(
-      '인스타그램 로그인에 username/password가 필요합니다. ' +
-      '환경변수 INSTA_USERNAME / INSTA_PASSWORD를 설정해 주세요.',
+      'Instagram login requires username/password. ' +
+      'Please set the INSTA_USERNAME / INSTA_PASSWORD environment variables.',
     );
   }
 
-  // Step 1: GET login page -> csrftoken + mid 쿠키 획득
+  // Step 1: GET login page -> obtain csrftoken + mid cookies
   const initRes = await fetch('https://www.instagram.com/accounts/login/', {
     headers: { 'User-Agent': USER_AGENT },
     redirect: 'manual',
@@ -64,7 +64,7 @@ const createAskForAuthentication = ({ sessionPath }) => async ({
 
   const csrfCookie = cookies.find((c) => c.name === 'csrftoken');
   if (!csrfCookie) {
-    throw new Error('Instagram 초기 페이지에서 csrftoken을 가져올 수 없습니다.');
+    throw new Error('Failed to retrieve csrftoken from the Instagram login page.');
   }
   const csrfToken = csrfCookie.value;
   const cookieHeader = cookies.map((c) => `${c.name}=${c.value}`).join('; ');
@@ -99,24 +99,75 @@ const createAskForAuthentication = ({ sessionPath }) => async ({
 
   const loginData = await loginRes.json();
 
-  if (loginData.checkpoint_url) {
-    throw new Error(
-      '2단계 인증(checkpoint)이 필요합니다. 브라우저에서 먼저 인증을 완료해 주세요.',
-    );
+  if (loginData.checkpoint_url || loginData.message === 'challenge_required') {
+    // Attempt automatic challenge resolution (choice=0 = "This was me")
+    const challengeRes = await fetch('https://www.instagram.com/api/v1/challenge/web/action/', {
+      method: 'POST',
+      headers: {
+        'User-Agent': USER_AGENT,
+        'X-CSRFToken': csrfToken,
+        'X-Requested-With': 'XMLHttpRequest',
+        'X-Instagram-AJAX': '1',
+        'X-IG-App-ID': IG_APP_ID,
+        Referer: 'https://www.instagram.com/challenge/',
+        Origin: 'https://www.instagram.com',
+        'Content-Type': 'application/x-www-form-urlencoded',
+        Cookie: cookieHeader,
+      },
+      body: 'choice=0',
+      redirect: 'manual',
+    });
+    const challengeData = await challengeRes.json().catch(() => ({}));
+    if (challengeData.status !== 'ok') {
+      throw new Error(
+        'challenge_required: Automatic resolution failed. Please complete identity verification in the browser. ' +
+        (loginData.checkpoint_url || ''),
+      );
+    }
+    // Re-login after challenge resolution
+    const retryRes = 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 retryCookies = parseCookiesFromHeaders(retryRes.headers);
+    cookies = mergeCookies(cookies, retryCookies);
+    const retryData = await retryRes.json().catch(() => ({}));
+    if (retryData.authenticated) {
+      saveInstaSession(sessionPath, cookies);
+      return {
+        provider: 'insta',
+        loggedIn: true,
+        userId: retryData.userId || null,
+        username: resolvedUsername,
+        sessionPath,
+        challengeResolved: true,
+      };
+    }
   }
 
   if (loginData.two_factor_required) {
     throw new Error(
-      '2단계 인증(2FA)이 필요합니다. 브라우저에서 먼저 인증을 완료해 주세요.',
+      'Two-factor authentication (2FA) is required. Please complete verification in the browser first.',
     );
   }
 
   if (!loginData.authenticated) {
     const reason = loginData.message || loginData.status || 'unknown';
-    throw new Error(`인스타그램 로그인 실패: ${reason}`);
+    throw new Error(`Instagram login failed: ${reason}`);
   }
 
-  // 세션 저장
+  // Save session
   saveInstaSession(sessionPath, cookies);
 
   return {

package/src/providers/insta/index.js

@@ -52,8 +52,8 @@ const createInstaProvider = ({ sessionPath }) => {
 
       if (!resolved.username || !resolved.password) {
         throw new Error(
-          '인스타그램 로그인에 username/password가 필요합니다. ' +
-          '환경변수 INSTA_USERNAME / INSTA_PASSWORD를 설정해 주세요.',
+          'Instagram login requires username/password. ' +
+          'Please set the INSTA_USERNAME / INSTA_PASSWORD environment variables.',
         );
       }
 
@@ -73,7 +73,7 @@ const createInstaProvider = ({ sessionPath }) => {
     async getProfile({ username } = {}) {
       return withProviderSession(async () => {
         if (!username) {
-          throw new Error('username이 필요합니다.');
+          throw new Error('username is required.');
         }
         const profile = await instaApi.getProfile(username);
         return {
@@ -99,7 +99,7 @@ const createInstaProvider = ({ sessionPath }) => {
     async listPosts({ username, limit = 12 } = {}) {
       return withProviderSession(async () => {
         if (!username) {
-          throw new Error('username이 필요합니다.');
+          throw new Error('username is required.');
         }
         const posts = await instaApi.getUserPosts(username, limit);
         return {
@@ -120,7 +120,7 @@ const createInstaProvider = ({ sessionPath }) => {
             provider: 'insta',
             mode: 'post',
             status: 'invalid_post_id',
-            message: 'postId(shortcode)가 필요합니다.',
+            message: 'postId (shortcode) is required.',
           };
         }
         const post = await instaApi.getPostDetail(shortcode);
@@ -134,7 +134,7 @@ const createInstaProvider = ({ sessionPath }) => {
 
     async follow({ username } = {}) {
       return withProviderSession(async () => {
-        if (!username) throw new Error('username이 필요합니다.');
+        if (!username) throw new Error('username is required.');
         const profile = await instaApi.getProfile(username);
         const result = await instaApi.followUser(profile.id);
         return {
@@ -151,7 +151,7 @@ const createInstaProvider = ({ sessionPath }) => {
 
     async unfollow({ username } = {}) {
       return withProviderSession(async () => {
-        if (!username) throw new Error('username이 필요합니다.');
+        if (!username) throw new Error('username is required.');
         const profile = await instaApi.getProfile(username);
         const result = await instaApi.unfollowUser(profile.id);
         return {
@@ -168,7 +168,7 @@ const createInstaProvider = ({ sessionPath }) => {
     async like({ postId } = {}) {
       return withProviderSession(async () => {
         const shortcode = String(postId || '').trim();
-        if (!shortcode) throw new Error('postId(shortcode)가 필요합니다.');
+        if (!shortcode) throw new Error('postId (shortcode) is required.');
         const mediaId = await instaApi.getMediaIdFromShortcode(shortcode);
         const result = await instaApi.likePost(mediaId);
         return { provider: 'insta', mode: 'like', postId: shortcode, status: result.status };
@@ -178,7 +178,7 @@ const createInstaProvider = ({ sessionPath }) => {
     async unlike({ postId } = {}) {
       return withProviderSession(async () => {
         const shortcode = String(postId || '').trim();
-        if (!shortcode) throw new Error('postId(shortcode)가 필요합니다.');
+        if (!shortcode) throw new Error('postId (shortcode) is required.');
         const mediaId = await instaApi.getMediaIdFromShortcode(shortcode);
         const result = await instaApi.unlikePost(mediaId);
         return { provider: 'insta', mode: 'unlike', postId: shortcode, status: result.status };
@@ -187,7 +187,7 @@ const createInstaProvider = ({ sessionPath }) => {
 
     async likeComment({ commentId } = {}) {
       return withProviderSession(async () => {
-        if (!commentId) throw new Error('commentId가 필요합니다.');
+        if (!commentId) throw new Error('commentId is required.');
         const result = await instaApi.likeComment(commentId);
         return { provider: 'insta', mode: 'likeComment', commentId, status: result.status };
       });
@@ -195,7 +195,7 @@ const createInstaProvider = ({ sessionPath }) => {
 
     async unlikeComment({ commentId } = {}) {
       return withProviderSession(async () => {
-        if (!commentId) throw new Error('commentId가 필요합니다.');
+        if (!commentId) throw new Error('commentId is required.');
         const result = await instaApi.unlikeComment(commentId);
         return { provider: 'insta', mode: 'unlikeComment', commentId, status: result.status };
       });
@@ -206,10 +206,10 @@ const createInstaProvider = ({ sessionPath }) => {
         const shortcode = String(postId || '').trim();
         const commentText = String(text || '').trim();
         if (!shortcode) {
-          throw new Error('postId(shortcode)가 필요합니다.');
+          throw new Error('postId (shortcode) is required.');
         }
         if (!commentText) {
-          throw new Error('댓글 내용(text)이 필요합니다.');
+          throw new Error('Comment text is required.');
         }
         const mediaId = await instaApi.getMediaIdFromShortcode(shortcode);
         const result = await instaApi.addComment(mediaId, commentText);
@@ -228,7 +228,7 @@ const createInstaProvider = ({ sessionPath }) => {
     async publish({ imageUrl, imagePath, caption = '' } = {}) {
       return withProviderSession(async () => {
         if (!imageUrl && !imagePath) {
-          throw new Error('imageUrl 또는 imagePath가 필요합니다.');
+          throw new Error('Either imageUrl or imagePath is required.');
         }
         const result = await instaApi.publishPost({ imageUrl, imagePath, caption });
         return {
@@ -243,7 +243,7 @@ const createInstaProvider = ({ sessionPath }) => {
       return withProviderSession(async () => {
         const shortcode = String(postId || '').trim();
         if (!shortcode) {
-          throw new Error('postId(shortcode)가 필요합니다.');
+          throw new Error('postId (shortcode) is required.');
         }
         const analysis = await smart.analyzePost({ shortcode });
         return {
@@ -258,7 +258,7 @@ const createInstaProvider = ({ sessionPath }) => {
       return withProviderSession(async () => {
         const shortcode = String(postId || '').trim();
         if (!shortcode) {
-          throw new Error('postId(shortcode)가 필요합니다.');
+          throw new Error('postId (shortcode) is required.');
         }
         const mediaId = await instaApi.getMediaIdFromShortcode(shortcode);
         const result = await instaApi.deletePost(mediaId);
@@ -271,6 +271,16 @@ const createInstaProvider = ({ sessionPath }) => {
       });
     },
 
+    async resolveChallenge() {
+      const resolved = await instaApi.resolveChallenge();
+      return {
+        provider: 'insta',
+        mode: 'resolveChallenge',
+        resolved,
+        message: resolved ? 'Challenge resolved successfully.' : 'Challenge resolution failed. Please handle it manually in the browser.',
+      };
+    },
+
     rateLimitStatus() {
       return {
         provider: 'insta',

package/src/providers/insta/session.js

@@ -33,7 +33,7 @@ const loadInstaSession = (sessionPath) => {
   return Array.isArray(raw?.cookies) ? raw.cookies : null;
 };
 
-// ── Rate Limit 영속화 (userId별) ──
+// ── Rate Limit persistence (per userId) ──
 
 const loadRateLimits = (sessionPath, userId) => {
   const raw = readSessionFile(sessionPath);
@@ -92,7 +92,7 @@ const createInstaWithProviderSession = (askForAuthentication) => async (fn) => {
       });
 
       if (!loginResult.loggedIn) {
-        throw new Error(loginResult.message || '세션 갱신 후 로그인 상태가 확인되지 않았습니다.');
+        throw new Error(loginResult.message || 'Login status could not be confirmed after session refresh.');
       }
 
       return fn();

package/src/providers/insta/smartComment.js

@@ -1,6 +1,6 @@
 const createSmartComment = (instaApi) => {
   const analyzePost = async ({ shortcode }) => {
-    // 1. 게시물 상세
+    // 1. Post detail
     const post = await instaApi.getPostDetail(shortcode);
     const caption = post.caption || '';
     const isVideo = post.isVideo;
@@ -8,15 +8,15 @@ const createSmartComment = (instaApi) => {
     const thumbnailUrl = post.imageUrl;
     const ownerUsername = post.owner?.username || '';
 
-    // 2. 작성자 프로필
+    // 2. Owner profile
     let ownerProfile = null;
     try {
       ownerProfile = await instaApi.getProfile(ownerUsername);
     } catch {
-      // 비공개 등 실패 무시
+      // Ignore failures (e.g., private account)
     }
 
-    // 3. 썸네일 이미지 base64 (Claude Code Vision용)
+    // 3. Thumbnail image base64 (for Claude Code Vision)
     let thumbnailBase64 = null;
     let thumbnailMediaType = 'image/jpeg';
     if (thumbnailUrl) {
@@ -29,15 +29,15 @@ const createSmartComment = (instaApi) => {
           if (ct) thumbnailMediaType = ct;
         }
       } catch {
-        // 실패해도 캡션만으로 진행
+        // Proceed with caption only on failure
       }
     }
 
     const contentType = isVideo
-      ? '영상(릴스)'
+      ? 'video (reel)'
       : mediaType?.includes('Sidecar')
-        ? '캐러셀(다중 이미지)'
-        : '사진';
+        ? 'carousel (multiple images)'
+        : 'photo';
 
     return {
       shortcode,

package/src/providers/insta/utils.js

@@ -10,10 +10,10 @@ const readInstaCredentials = () => {
 const parseInstaSessionError = (error) => {
   const message = String(error?.message || '').toLowerCase();
   return [
-    '세션 파일이 없습니다',
-    '세션에 유효한 쿠키',
-    '세션이 만료',
-    '로그인이 필요합니다',
+    'no session file found',
+    'no valid cookies in session',
+    'session expired',
+    'login required',
     'login_required',
     'checkpoint_required',
     '401',
@@ -22,7 +22,7 @@ const parseInstaSessionError = (error) => {
   ].some((token) => message.includes(token.toLowerCase()));
 };
 
-const buildLoginErrorMessage = (error) => String(error?.message || '세션 검증에 실패했습니다.');
+const buildLoginErrorMessage = (error) => String(error?.message || 'Session validation failed.');
 
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));