viruagent-cli 0.8.0 → 0.9.0

package/src/providers/threads/index.js

@@ -0,0 +1,248 @@
+const fs = require('fs');
+const { saveProviderMeta, clearProviderMeta, getProviderMeta } = require('../../storage/sessionStore');
+const createThreadsApiClient = require('./apiClient');
+const { readThreadsCredentials } = require('./utils');
+const { createThreadsWithProviderSession } = require('./session');
+const { createAskForAuthentication } = require('./auth');
+
+const createThreadsProvider = ({ sessionPath, account }) => {
+  const api = createThreadsApiClient({ sessionPath });
+
+  const askForAuthentication = createAskForAuthentication({ sessionPath });
+
+  const withProviderSession = createThreadsWithProviderSession(askForAuthentication, account);
+
+  return {
+    id: 'threads',
+    name: 'Threads',
+
+    async authStatus() {
+      return withProviderSession(async () => {
+        try {
+          const session = api.getSession();
+          return {
+            provider: 'threads',
+            loggedIn: true,
+            userId: session.userId,
+            hasSession: Boolean(session.token),
+            sessionPath,
+            metadata: getProviderMeta('threads', account) || {},
+          };
+        } catch (error) {
+          return {
+            provider: 'threads',
+            loggedIn: false,
+            sessionPath,
+            error: error.message,
+            metadata: getProviderMeta('threads', account) || {},
+          };
+        }
+      });
+    },
+
+    async login({ username, password } = {}) {
+      const creds = readThreadsCredentials();
+      const resolved = {
+        username: username || creds.username,
+        password: password || creds.password,
+      };
+
+      if (!resolved.username || !resolved.password) {
+        throw new Error(
+          'Threads login requires username/password. ' +
+          'Please set the THREADS_USERNAME / THREADS_PASSWORD (or INSTA_USERNAME / INSTA_PASSWORD) environment variables.',
+        );
+      }
+
+      const result = await askForAuthentication(resolved);
+      api.resetState();
+
+      saveProviderMeta('threads', {
+        loggedIn: result.loggedIn,
+        userId: result.userId,
+        username: result.username,
+        sessionPath: result.sessionPath,
+      }, account);
+
+      return result;
+    },
+
+    async publish({ content, imageUrls, imageUrl, imagePath, replyTo, caption } = {}) {
+      return withProviderSession(async () => {
+        const text = content || caption || '';
+
+        // Image thread
+        let resolvedImageUrl = imageUrl;
+        if (!resolvedImageUrl && !imagePath && imageUrls?.length > 0) {
+          resolvedImageUrl = imageUrls[0];
+        }
+
+        if (resolvedImageUrl || imagePath) {
+          let imageBuffer;
+          if (imagePath) {
+            imageBuffer = fs.readFileSync(imagePath);
+          } else {
+            const res = await fetch(resolvedImageUrl);
+            if (!res.ok) throw new Error(`Image download failed: ${res.status}`);
+            imageBuffer = Buffer.from(await res.arrayBuffer());
+          }
+          const uploadId = await api.uploadImage(imageBuffer);
+          const result = await api.publishImageThread(uploadId, text);
+          return { provider: 'threads', mode: 'publish', ...result };
+        }
+
+        // Text-only thread
+        if (!text) {
+          throw new Error('content is required for text threads.');
+        }
+        const result = await api.publishTextThread(text, replyTo);
+        return { provider: 'threads', mode: 'publish', ...result };
+      });
+    },
+
+    async comment({ postId, text } = {}) {
+      return withProviderSession(async () => {
+        if (!postId) throw new Error('postId is required.');
+        if (!text) throw new Error('text is required.');
+        const result = await api.publishTextThread(text, postId);
+        return {
+          provider: 'threads',
+          mode: 'comment',
+          replyTo: postId,
+          ...result,
+        };
+      });
+    },
+
+    async like({ postId } = {}) {
+      return withProviderSession(async () => {
+        if (!postId) throw new Error('postId is required.');
+        const result = await api.likeThread(postId);
+        return { provider: 'threads', mode: 'like', postId, status: result.status };
+      });
+    },
+
+    async unlike({ postId } = {}) {
+      return withProviderSession(async () => {
+        if (!postId) throw new Error('postId is required.');
+        const result = await api.unlikeThread(postId);
+        return { provider: 'threads', mode: 'unlike', postId, status: result.status };
+      });
+    },
+
+    async follow({ username } = {}) {
+      return withProviderSession(async () => {
+        if (!username) throw new Error('username is required.');
+        const userId = await api.getUserId(username);
+        const result = await api.followUser(userId);
+        return {
+          provider: 'threads',
+          mode: 'follow',
+          username,
+          userId,
+          following: result.following,
+          outgoingRequest: result.outgoingRequest,
+          status: result.status,
+        };
+      });
+    },
+
+    async unfollow({ username } = {}) {
+      return withProviderSession(async () => {
+        if (!username) throw new Error('username is required.');
+        const userId = await api.getUserId(username);
+        const result = await api.unfollowUser(userId);
+        return {
+          provider: 'threads',
+          mode: 'unfollow',
+          username,
+          userId,
+          following: result.following,
+          status: result.status,
+        };
+      });
+    },
+
+    async getProfile({ username } = {}) {
+      return withProviderSession(async () => {
+        if (!username) throw new Error('username is required.');
+        const userId = await api.getUserId(username);
+        const profile = await api.getUserProfile(userId);
+        return { provider: 'threads', mode: 'profile', ...profile };
+      });
+    },
+
+    async getFeed() {
+      return withProviderSession(async () => {
+        const items = await api.getTimeline();
+        return {
+          provider: 'threads',
+          mode: 'feed',
+          count: items.length,
+          items,
+        };
+      });
+    },
+
+    async listPosts({ username, limit = 20 } = {}) {
+      return withProviderSession(async () => {
+        if (!username) throw new Error('username is required.');
+        const userId = await api.getUserId(username);
+        const posts = await api.getUserThreads(userId, limit);
+        return {
+          provider: 'threads',
+          mode: 'posts',
+          username,
+          totalCount: posts.length,
+          posts,
+        };
+      });
+    },
+
+    async search({ query, limit = 20 } = {}) {
+      return withProviderSession(async () => {
+        if (!query) throw new Error('query is required.');
+        const users = await api.searchUsers(query, limit);
+        return {
+          provider: 'threads',
+          mode: 'search',
+          query,
+          totalCount: users.length,
+          users,
+        };
+      });
+    },
+
+    async deletePost({ postId } = {}) {
+      return withProviderSession(async () => {
+        if (!postId) throw new Error('postId is required.');
+        const result = await api.deleteThread(postId);
+        return {
+          provider: 'threads',
+          mode: 'delete',
+          postId,
+          status: result.status,
+        };
+      });
+    },
+
+    rateLimitStatus() {
+      return {
+        provider: 'threads',
+        mode: 'rateLimitStatus',
+        ...api.getRateLimitStatus(),
+      };
+    },
+
+    async logout() {
+      clearProviderMeta('threads', account);
+      return {
+        provider: 'threads',
+        loggedOut: true,
+        sessionPath,
+      };
+    },
+  };
+};
+
+module.exports = createThreadsProvider;

package/src/providers/threads/session.js

@@ -0,0 +1,109 @@
+const fs = require('fs');
+const path = require('path');
+const { saveProviderMeta } = require('../../storage/sessionStore');
+const { readThreadsCredentials, parseThreadsSessionError, 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 saveThreadsSession = (sessionPath, { token, userId, deviceId }) => {
+  const existing = readSessionFile(sessionPath) || {};
+  writeSessionFile(sessionPath, {
+    ...existing,
+    token,
+    userId,
+    deviceId,
+    updatedAt: new Date().toISOString(),
+  });
+};
+
+const loadThreadsSession = (sessionPath) => {
+  const raw = readSessionFile(sessionPath);
+  if (!raw?.token) return null;
+  return { token: raw.token, userId: raw.userId, deviceId: raw.deviceId };
+};
+
+const validateThreadsSession = (sessionPath) => {
+  const session = loadThreadsSession(sessionPath);
+  return Boolean(session?.token && session?.userId);
+};
+
+// ── Rate Limit persistence (per 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 createThreadsWithProviderSession = (askForAuthentication, account) => async (fn) => {
+  const credentials = readThreadsCredentials();
+  const hasCredentials = Boolean(credentials.username && credentials.password);
+
+  try {
+    const result = await fn();
+    saveProviderMeta('threads', { loggedIn: true, lastValidatedAt: new Date().toISOString() }, account);
+    return result;
+  } catch (error) {
+    if (!parseThreadsSessionError(error) || !hasCredentials) {
+      throw error;
+    }
+
+    try {
+      const loginResult = await askForAuthentication({
+        username: credentials.username,
+        password: credentials.password,
+      });
+
+      saveProviderMeta('threads', {
+        loggedIn: loginResult.loggedIn,
+        userId: loginResult.userId,
+        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('threads', {
+        loggedIn: false,
+        lastError: buildLoginErrorMessage(reloginError),
+        lastValidatedAt: new Date().toISOString(),
+      }, account);
+      throw reloginError;
+    }
+  }
+};
+
+module.exports = {
+  saveThreadsSession,
+  loadThreadsSession,
+  validateThreadsSession,
+  loadRateLimits,
+  saveRateLimits,
+  createThreadsWithProviderSession,
+};

package/src/providers/threads/utils.js

@@ -0,0 +1,33 @@
+const readThreadsCredentials = () => {
+  const username = process.env.THREADS_USERNAME || process.env.INSTA_USERNAME || process.env.INSTAGRAM_USERNAME;
+  const password = process.env.THREADS_PASSWORD || process.env.INSTA_PASSWORD || process.env.INSTAGRAM_PASSWORD;
+  return {
+    username: typeof username === 'string' && username.trim() ? username.trim() : null,
+    password: typeof password === 'string' && password.trim() ? password.trim() : null,
+  };
+};
+
+const parseThreadsSessionError = (error) => {
+  const message = String(error?.message || '').toLowerCase();
+  return [
+    'no session file found',
+    'no valid token in session',
+    'session expired',
+    'login required',
+    'login_required',
+    'checkpoint_required',
+    '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 = {
+  readThreadsCredentials,
+  parseThreadsSessionError,
+  buildLoginErrorMessage,
+  sleep,
+};

package/src/runner.js

@@ -132,7 +132,7 @@ const runCommand = async (command, opts = {}) => {
 
     case 'publish': {
       const content = readContent(opts);
-      if (!content && providerName !== 'insta' && providerName !== 'x' && providerName !== 'reddit') {
+      if (!content && providerName !== 'insta' && providerName !== 'x' && providerName !== 'reddit' && providerName !== 'threads') {
         throw createError('MISSING_CONTENT', 'publish requires --content or --content-file', 'viruagent-cli publish --spec');
       }
       return withProvider(() =>
@@ -346,7 +346,8 @@ const runCommand = async (command, opts = {}) => {
       return withProvider(() => provider.cafeJoin({
         cafeUrl: opts.cafeUrl,
         nickname: opts.nickname || undefined,
-        captchaApiKey: opts.captchaApiKey || undefined,
+        captchaValue: opts.captchaValue || undefined,
+        captchaKey: opts.captchaKey || undefined,
         answers: opts.answers ? parseList(opts.answers) : undefined,
       }))();
 

package/src/services/providerManager.js

@@ -5,6 +5,7 @@ const createNaverProvider = require('../providers/naver');
 const createInstaProvider = require('../providers/insta');
 const createXProvider = require('../providers/x');
 const createRedditProvider = require('../providers/reddit');
+const createThreadsProvider = require('../providers/threads');
 
 const providerFactory = {
   tistory: createTistoryProvider,
@@ -12,9 +13,10 @@ const providerFactory = {
   insta: createInstaProvider,
   x: createXProvider,
   reddit: createRedditProvider,
+  threads: createThreadsProvider,
 };
 
-const providers = ['tistory', 'naver', 'insta', 'x', 'reddit'];
+const providers = ['tistory', 'naver', 'insta', 'x', 'reddit', 'threads'];
 
 const createProviderManager = () => {
   const cache = new Map();
@@ -40,7 +42,7 @@ const createProviderManager = () => {
     return cache.get(cacheKey);
   };
 
-  const providerNames = { tistory: 'Tistory', naver: 'Naver Blog', insta: 'Instagram', x: 'X (Twitter)', reddit: 'Reddit' };
+  const providerNames = { tistory: 'Tistory', naver: 'Naver Blog', insta: 'Instagram', x: 'X (Twitter)', reddit: 'Reddit', threads: 'Threads' };
   const getAvailableProviders = () => providers.map((provider) => ({
     id: provider,
     name: providerNames[provider] || provider,