viruagent-cli 0.5.0 → 0.5.1

package/bin/index.js

@@ -204,6 +204,32 @@ unlikeCommentCmd
   .option('--comment-id <id>', 'Comment ID')
   .action((opts) => execute('unlike-comment', opts));
 
+const sendDmCmd = program
+  .command('send-dm')
+  .description('Send a direct message to a user');
+addProviderOption(sendDmCmd);
+sendDmCmd
+  .option('--username <username>', 'Recipient username')
+  .option('--thread-id <threadId>', 'Existing thread ID')
+  .option('--text <message>', 'Message text')
+  .action((opts) => execute('send-dm', opts));
+
+const listMessagesCmd = program
+  .command('list-messages')
+  .description('List messages in a DM thread (via browser)');
+addProviderOption(listMessagesCmd);
+listMessagesCmd
+  .option('--thread-id <threadId>', 'Thread ID')
+  .action((opts) => execute('list-messages', opts));
+
+const listCommentsCmd = program
+  .command('list-comments')
+  .description('List comments on a post');
+addProviderOption(listCommentsCmd);
+listCommentsCmd
+  .option('--post-id <shortcode>', 'Post shortcode')
+  .action((opts) => execute('list-comments', opts));
+
 const analyzePostCmd = program
   .command('analyze-post')
   .description('Analyze a post (thumbnail + caption + profile)');

package/package.json

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

package/src/providers/insta/apiClient.js

@@ -545,6 +545,43 @@ const createInstaApiClient = ({ sessionPath }) => {
     return res.json();
   });
 
+  const sendDm = (recipientUserId, text) => withDelay('dm', async () => {
+    const cookies = getCookies();
+    const csrf = getCsrfToken();
+    const body = new URLSearchParams({
+      action: 'send_item',
+      recipient_users: `[[${recipientUserId}]]`,
+      client_context: `6${Date.now()}_${Math.floor(Math.random() * 1000000000)}`,
+      offline_threading_id: Date.now().toString(),
+      text,
+    });
+    const res = await fetch('https://i.instagram.com/api/v1/direct_v2/threads/broadcast/text/', {
+      method: 'POST',
+      headers: {
+        'User-Agent': 'Instagram 317.0.0.34.109 Android (30/11; 420dpi; 1080x2220; samsung; SM-A515F; a51; exynos9611; en_US; 562940699)',
+        'X-IG-App-ID': '567067343352427',
+        'X-CSRFToken': csrf,
+        'Content-Type': 'application/x-www-form-urlencoded',
+        Cookie: cookiesToHeader(cookies),
+      },
+      body: body.toString(),
+      redirect: 'manual',
+    });
+    const data = await res.json();
+    if (data.status !== 'ok') {
+      const errCode = data.content?.error_code;
+      if (errCode === 4415001) {
+        throw new Error('DM restricted: Account DM feature is limited. Please open Instagram in browser, go to Direct Messages, and resolve any pending prompts or challenges.');
+      }
+      throw new Error(`DM failed: ${JSON.stringify(data)}`);
+    }
+    return {
+      status: data.status,
+      threadId: data.payload?.thread_id || null,
+      itemId: data.payload?.item_id || null,
+    };
+  });
+
   const getMediaIdFromShortcode = async (shortcode) => {
     const detail = await getPostDetail(shortcode);
     return detail.id;
@@ -666,6 +703,7 @@ const createInstaApiClient = ({ sessionPath }) => {
     uploadPhoto,
     configurePost,
     publishPost,
+    sendDm,
     deletePost,
     resolveChallenge,
     resetState,

package/src/providers/insta/index.js

@@ -239,6 +239,204 @@ const createInstaProvider = ({ sessionPath }) => {
       });
     },
 
+    async sendDm({ username, threadId, text } = {}) {
+      const target = String(username || '').trim();
+      const tid = String(threadId || '').trim();
+      const msg = String(text || '').trim();
+      if (!target && !tid) throw new Error('username or threadId is required.');
+      if (!msg) throw new Error('text is required.');
+
+      const { chromium } = require('playwright');
+      const path = require('path');
+      const userDataDir = path.join(path.dirname(sessionPath), '..', 'browser-data', 'insta');
+      const fs = require('fs');
+      if (!fs.existsSync(userDataDir)) fs.mkdirSync(userDataDir, { recursive: true });
+
+      // Determine DM URL
+      let dmUrl;
+      if (tid) {
+        dmUrl = `https://www.instagram.com/direct/t/${tid}/`;
+      } else {
+        dmUrl = `https://www.instagram.com/direct/new/`;
+      }
+
+      const context = await chromium.launchPersistentContext(userDataDir, {
+        headless: true,
+        viewport: { width: 1280, height: 800 },
+      });
+
+      try {
+        const page = context.pages()[0] || await context.newPage();
+
+        if (!tid && target) {
+          // New DM: go to new message, search for user
+          await page.goto('https://www.instagram.com/direct/new/', { waitUntil: 'domcontentloaded' });
+          await page.waitForTimeout(3000);
+
+          // Search for recipient
+          const searchInput = page.locator('input[name="queryBox"]').or(page.getByPlaceholder(/검색|Search/i));
+          await searchInput.first().waitFor({ timeout: 10000 });
+          await searchInput.first().fill(target);
+          await page.waitForTimeout(2000);
+
+          // Click the user result
+          const userResult = page.locator(`text=${target}`).first();
+          await userResult.click();
+          await page.waitForTimeout(1000);
+
+          // Click chat/next button
+          const chatBtn = page.getByRole('button', { name: /채팅|Chat|다음|Next/i });
+          await chatBtn.first().click();
+          await page.waitForTimeout(2000);
+        } else {
+          await page.goto(dmUrl, { waitUntil: 'domcontentloaded' });
+          await page.waitForTimeout(3000);
+        }
+
+        // Dismiss popups
+        try {
+          const btn = page.getByRole('button', { name: /나중에|Not Now/i });
+          if (await btn.first().isVisible({ timeout: 2000 })) await btn.first().click();
+        } catch {}
+
+        // Send message
+        const input = page.locator('[role="textbox"]').first();
+        await input.waitFor({ timeout: 10000 });
+        await input.click();
+        await page.keyboard.type(msg);
+        await page.waitForTimeout(500);
+        await page.keyboard.press('Enter');
+        await page.waitForTimeout(3000);
+
+        return {
+          provider: 'insta',
+          mode: 'dm',
+          to: target || tid,
+          text: msg,
+          status: 'ok',
+        };
+      } finally {
+        await context.close();
+      }
+    },
+
+    async listMessages({ threadId } = {}) {
+      const tid = String(threadId || '').trim();
+      if (!tid) throw new Error('threadId is required.');
+
+      const { chromium } = require('playwright');
+      const path = require('path');
+      const fs = require('fs');
+      const userDataDir = path.join(path.dirname(sessionPath), '..', 'browser-data', 'insta');
+      if (!fs.existsSync(userDataDir)) fs.mkdirSync(userDataDir, { recursive: true });
+
+      const context = await chromium.launchPersistentContext(userDataDir, {
+        headless: true,
+        viewport: { width: 1280, height: 800 },
+      });
+
+      try {
+        const page = context.pages()[0] || await context.newPage();
+        await page.goto(`https://www.instagram.com/direct/t/${tid}/`, { waitUntil: 'domcontentloaded' });
+        await page.waitForTimeout(5000);
+
+        // Dismiss popups
+        try {
+          const btn = page.getByRole('button', { name: /나중에|Not Now/i });
+          if (await btn.first().isVisible({ timeout: 2000 })) await btn.first().click();
+        } catch {}
+        await page.waitForTimeout(1000);
+
+        // Extract messages from DOM
+        const messages = await page.evaluate(() => {
+          const result = [];
+          // Find message containers - Instagram uses div with role="row" or specific data attributes
+          const rows = document.querySelectorAll('div[role="row"]');
+          rows.forEach((row) => {
+            const textEl = row.querySelector('div[dir="auto"]');
+            if (!textEl) return;
+            const text = textEl.innerText?.trim();
+            if (!text) return;
+
+            // Determine if sent or received by checking position/style
+            const wrapper = row.closest('[class]');
+            const style = wrapper ? window.getComputedStyle(wrapper) : null;
+            const isSent = row.innerHTML.includes('rgb(99, 91, 255)') ||
+                           row.innerHTML.includes('#635BFF') ||
+                           row.querySelector('[style*="flex-end"]') !== null;
+
+            result.push({ text, isSent });
+          });
+          return result;
+        });
+
+        // If role="row" didn't work, try alternative extraction
+        if (messages.length === 0) {
+          const altMessages = await page.evaluate(() => {
+            const result = [];
+            const allDivs = document.querySelectorAll('div[dir="auto"]');
+            const seen = new Set();
+            allDivs.forEach((el) => {
+              const text = el.innerText?.trim();
+              if (!text || text.length > 500 || seen.has(text)) return;
+              // Skip UI elements
+              if (['메시지 입력...', '검색', 'Message...'].includes(text)) return;
+              if (el.closest('nav') || el.closest('header')) return;
+              seen.add(text);
+
+              // Check if element is in right-aligned (sent) bubble
+              const rect = el.getBoundingClientRect();
+              const isSent = rect.left > window.innerWidth / 2;
+
+              result.push({ text, isSent });
+            });
+            return result;
+          });
+          if (altMessages.length > 0) messages.push(...altMessages);
+        }
+
+        // Get thread participant name
+        const participant = await page.evaluate(() => {
+          const header = document.querySelector('header');
+          if (!header) return null;
+          const spans = header.querySelectorAll('span');
+          for (const s of spans) {
+            const t = s.innerText?.trim();
+            if (t && !['메시지', 'Direct', '뒤로'].includes(t) && t.length < 30) return t;
+          }
+          return null;
+        });
+
+        return {
+          provider: 'insta',
+          mode: 'messages',
+          threadId: tid,
+          participant,
+          totalCount: messages.length,
+          messages,
+        };
+      } finally {
+        await context.close();
+      }
+    },
+
+    async listComments({ postId } = {}) {
+      return withProviderSession(async () => {
+        const shortcode = String(postId || '').trim();
+        if (!shortcode) {
+          throw new Error('postId (shortcode) is required.');
+        }
+        const comments = await instaApi.getComments(shortcode);
+        return {
+          provider: 'insta',
+          mode: 'comments',
+          postId: shortcode,
+          totalCount: comments.length,
+          comments,
+        };
+      });
+    },
+
     async analyzePost({ postId } = {}) {
       return withProviderSession(async () => {
         const shortcode = String(postId || '').trim();

package/src/runner.js

@@ -231,6 +231,27 @@ const runCommand = async (command, opts = {}) => {
       }
       return withProvider(() => provider.unlikeComment({ commentId: opts.commentId }))();
 
+    case 'send-dm':
+      if (!opts.username && !opts.threadId) {
+        throw createError('MISSING_PARAM', 'send-dm requires --username or --thread-id');
+      }
+      if (!opts.text) {
+        throw createError('MISSING_PARAM', 'send-dm requires --text');
+      }
+      return withProvider(() => provider.sendDm({ username: opts.username, threadId: opts.threadId, text: opts.text }))();
+
+    case 'list-messages':
+      if (!opts.threadId) {
+        throw createError('MISSING_PARAM', 'list-messages requires --thread-id');
+      }
+      return withProvider(() => provider.listMessages({ threadId: opts.threadId }))();
+
+    case 'list-comments':
+      if (!opts.postId) {
+        throw createError('MISSING_PARAM', 'list-comments requires --post-id');
+      }
+      return withProvider(() => provider.listComments({ postId: opts.postId }))();
+
     case 'analyze-post':
       if (!opts.postId) {
         throw createError('MISSING_PARAM', 'analyze-post requires --post-id');