@jackwener/opencli 1.1.1 → 1.2.1

package/dist/clis/grok/ask.js

@@ -1,4 +1,246 @@
 import { cli, Strategy } from '../../registry.js';
+const GROK_URL = 'https://grok.com/';
+const RESPONSE_SELECTOR = 'div.message-bubble, [data-testid="message-bubble"]';
+const BLOCKED_PREFIX = '[BLOCKED]';
+const NO_RESPONSE_PREFIX = '[NO RESPONSE]';
+const SESSION_HINT = 'Likely login/auth/challenge/session issue in the existing grok.com browser session.';
+function blocked(message) {
+    return [{ response: `${BLOCKED_PREFIX} ${message} ${SESSION_HINT}` }];
+}
+function normalizeBubbleText(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+function normalizeBooleanFlag(value) {
+    if (typeof value === 'boolean')
+        return value;
+    const normalized = String(value ?? '').trim().toLowerCase();
+    return normalized === 'true' || normalized === '1' || normalized === 'yes' || normalized === 'on';
+}
+function pickLatestAssistantCandidate(bubbles, baselineCount, prompt) {
+    const normalizedPrompt = prompt.trim();
+    const freshBubbles = bubbles
+        .slice(Math.max(0, baselineCount))
+        .map(normalizeBubbleText)
+        .filter(Boolean);
+    for (let i = freshBubbles.length - 1; i >= 0; i -= 1) {
+        if (freshBubbles[i] !== normalizedPrompt)
+            return freshBubbles[i];
+    }
+    return '';
+}
+function updateStableState(previousText, stableCount, nextText) {
+    if (!nextText)
+        return { previousText: '', stableCount: 0 };
+    if (nextText === previousText)
+        return { previousText, stableCount: stableCount + 1 };
+    return { previousText: nextText, stableCount: 0 };
+}
+async function runDefaultAsk(page, prompt, timeoutMs, newChat) {
+    if (newChat) {
+        await page.goto(GROK_URL);
+        await page.wait(2);
+        await page.evaluate(`(() => {
+      const btn = [...document.querySelectorAll('a, button')].find(b => {
+        const t = (b.textContent || '').trim().toLowerCase();
+        return t.includes('new') || b.getAttribute('href') === '/';
+      });
+      if (btn) btn.click();
+    })()`);
+        await page.wait(2);
+    }
+    await page.goto(GROK_URL);
+    await page.wait(3);
+    const promptJson = JSON.stringify(prompt);
+    const sendResult = await page.evaluate(`(async () => {
+    try {
+      const box = document.querySelector('textarea');
+      if (!box) return { ok: false, msg: 'no textarea' };
+      box.focus(); box.value = '';
+      document.execCommand('selectAll');
+      document.execCommand('insertText', false, ${promptJson});
+      await new Promise(r => setTimeout(r, 1500));
+      const btn = document.querySelector('button[aria-label="\\u63d0\\u4ea4"]');
+      if (btn && !btn.disabled) { btn.click(); return { ok: true, msg: 'clicked' }; }
+      const sub = [...document.querySelectorAll('button[type="submit"]')].find(b => !b.disabled);
+      if (sub) { sub.click(); return { ok: true, msg: 'clicked-submit' }; }
+      box.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', code: 'Enter', keyCode: 13, bubbles: true }));
+      return { ok: true, msg: 'enter' };
+    } catch (e) { return { ok: false, msg: e.toString() }; }
+  })()`);
+    if (!sendResult || !sendResult.ok) {
+        return [{ response: '[SEND FAILED] ' + JSON.stringify(sendResult) }];
+    }
+    const startTime = Date.now();
+    let lastText = '';
+    let stableCount = 0;
+    while (Date.now() - startTime < timeoutMs) {
+        await page.wait(3);
+        const response = await page.evaluate(`(() => {
+      const bubbles = document.querySelectorAll('div.message-bubble, [data-testid="message-bubble"]');
+      if (bubbles.length < 2) return '';
+      const last = bubbles[bubbles.length - 1];
+      const text = (last.innerText || '').trim();
+      if (!text || text.length < 2) return '';
+      return text;
+    })()`);
+        if (response && response.length > 2) {
+            if (response === lastText) {
+                stableCount++;
+                if (stableCount >= 2)
+                    return [{ response }];
+            }
+            else {
+                stableCount = 0;
+            }
+        }
+        lastText = response || '';
+    }
+    if (lastText)
+        return [{ response: lastText }];
+    return [{ response: NO_RESPONSE_PREFIX }];
+}
+async function getBubbleTexts(page) {
+    const result = await page.evaluate(`(() => {
+    return Array.from(document.querySelectorAll(${JSON.stringify(RESPONSE_SELECTOR)}))
+      .map(node => (node instanceof HTMLElement ? node.innerText : node?.textContent || ''))
+      .map(text => (typeof text === 'string' ? text.trim() : ''))
+      .filter(Boolean);
+  })()`);
+    return Array.isArray(result) ? result.map(normalizeBubbleText).filter(Boolean) : [];
+}
+async function tryStartFreshChat(page) {
+    await page.evaluate(`(() => {
+    const isVisible = (node) => {
+      if (!(node instanceof HTMLElement)) return false;
+      const rect = node.getBoundingClientRect();
+      const style = window.getComputedStyle(node);
+      return rect.width > 0 && rect.height > 0 && style.visibility !== 'hidden' && style.display !== 'none';
+    };
+
+    const candidates = Array.from(document.querySelectorAll('a, button')).filter(node => {
+      if (!isVisible(node)) return false;
+      const text = (node.textContent || '').trim().toLowerCase();
+      const aria = (node.getAttribute('aria-label') || '').trim().toLowerCase();
+      const href = node.getAttribute('href') || '';
+      return text.includes('new chat')
+        || text.includes('new conversation')
+        || aria.includes('new chat')
+        || aria.includes('new conversation')
+        || href === '/';
+    });
+
+    const target = candidates[0];
+    if (target instanceof HTMLElement) target.click();
+  })()`);
+}
+async function sendPromptViaExplicitWeb(page, prompt) {
+    return page.evaluate(`(async () => {
+    const waitFor = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+    const composerSelector = '.ProseMirror[contenteditable="true"]';
+    let composer = null;
+
+    for (let attempt = 0; attempt < 12; attempt += 1) {
+      const candidate = document.querySelector(composerSelector);
+      if (candidate instanceof HTMLElement) {
+        composer = candidate;
+        break;
+      }
+
+      await waitFor(1000);
+    }
+
+    if (!(composer instanceof HTMLElement)) {
+      return {
+        ok: false,
+        reason: 'Grok composer was not found on grok.com.',
+      };
+    }
+
+    const editor = composer.editor;
+    if (!editor?.commands?.focus || !editor?.commands?.insertContent) {
+      return {
+        ok: false,
+        reason: 'Grok composer editor API was unavailable.',
+      };
+    }
+
+    const isVisibleEnabledSubmit = (node) => {
+      if (!(node instanceof HTMLButtonElement)) return false;
+      const rect = node.getBoundingClientRect();
+      const style = window.getComputedStyle(node);
+      return !node.disabled
+        && rect.width > 0
+        && rect.height > 0
+        && style.visibility !== 'hidden'
+        && style.display !== 'none';
+    };
+
+    try {
+      if (editor.commands.clearContent) editor.commands.clearContent();
+      editor.commands.focus();
+      editor.commands.insertContent(${JSON.stringify(prompt)});
+    } catch (error) {
+      return {
+        ok: false,
+        reason: 'Failed to insert the prompt into the Grok composer.',
+        detail: error instanceof Error ? error.message : String(error),
+      };
+    }
+
+    let submit = null;
+    for (let attempt = 0; attempt < 6; attempt += 1) {
+      const candidate = Array.from(document.querySelectorAll('button[aria-label="Submit"]'))
+        .find(isVisibleEnabledSubmit);
+
+      if (candidate instanceof HTMLButtonElement) {
+        submit = candidate;
+        break;
+      }
+
+      await waitFor(500);
+    }
+
+    if (!(submit instanceof HTMLButtonElement)) {
+      return {
+        ok: false,
+        reason: 'Grok submit button did not reach a clickable ready state after prompt insertion.',
+      };
+    }
+
+    submit.click();
+    return { ok: true };
+  })()`);
+}
+async function runExplicitWebAsk(page, prompt, timeoutMs, newChat) {
+    await page.goto(GROK_URL, { settleMs: 2000 });
+    if (newChat) {
+        await tryStartFreshChat(page);
+        await page.wait(2);
+    }
+    const baselineBubbles = await getBubbleTexts(page);
+    const sendResult = await sendPromptViaExplicitWeb(page, prompt);
+    if (!sendResult?.ok) {
+        const details = sendResult?.detail ? ` ${sendResult.detail}` : '';
+        return blocked(`${sendResult?.reason || 'Unable to send the prompt to Grok.'}${details}`);
+    }
+    const startTime = Date.now();
+    let lastText = '';
+    let stableCount = 0;
+    while (Date.now() - startTime < timeoutMs) {
+        await page.wait(2);
+        const bubbleTexts = await getBubbleTexts(page);
+        const candidate = pickLatestAssistantCandidate(bubbleTexts, baselineBubbles.length, prompt);
+        const nextState = updateStableState(lastText, stableCount, candidate);
+        lastText = nextState.previousText;
+        stableCount = nextState.stableCount;
+        if (candidate && stableCount >= 2) {
+            return [{ response: candidate }];
+        }
+    }
+    if (lastText)
+        return [{ response: lastText }];
+    return [{ response: `${NO_RESPONSE_PREFIX} No new assistant message bubble appeared within ${Math.round(timeoutMs / 1000)}s.` }];
+}
 export const askCommand = cli({
     site: 'grok',
     name: 'ask',
@@ -7,76 +249,26 @@ export const askCommand = cli({
     strategy: Strategy.COOKIE,
     browser: true,
     args: [
-        { name: 'prompt', type: 'string', required: true },
-        { name: 'timeout', type: 'int', default: 120 },
-        { name: 'new', type: 'boolean', default: false },
+        { name: 'prompt', positional: true, type: 'string', required: true, help: 'Prompt to send to Grok' },
+        { name: 'timeout', type: 'int', default: 120, help: 'Max seconds to wait for response (default: 120)' },
+        { name: 'new', type: 'boolean', default: false, help: 'Start a new chat before sending (default: false)' },
+        { name: 'web', type: 'boolean', default: false, help: 'Use the explicit grok.com consumer web flow (default: false)' },
     ],
     columns: ['response'],
     func: async (page, kwargs) => {
         const prompt = kwargs.prompt;
         const timeoutMs = (kwargs.timeout || 120) * 1000;
-        const newChat = kwargs.new;
-        if (newChat) {
-            await page.goto('https://grok.com');
-            await page.wait(2);
-            await page.evaluate(`(() => {
-        const btn = [...document.querySelectorAll('a, button')].find(b => {
-          const t = (b.textContent || '').trim().toLowerCase();
-          return t.includes('new') || b.getAttribute('href') === '/';
-        });
-        if (btn) btn.click();
-      })()`);
-            await page.wait(2);
-        }
-        await page.goto('https://grok.com');
-        await page.wait(3);
-        const promptJson = JSON.stringify(prompt);
-        const sendResult = await page.evaluate(`(async () => {
-      try {
-        const box = document.querySelector('textarea');
-        if (!box) return { ok: false, msg: 'no textarea' };
-        box.focus(); box.value = '';
-        document.execCommand('selectAll');
-        document.execCommand('insertText', false, ${promptJson});
-        await new Promise(r => setTimeout(r, 1500));
-        const btn = document.querySelector('button[aria-label="\\u63d0\\u4ea4"]');
-        if (btn && !btn.disabled) { btn.click(); return { ok: true, msg: 'clicked' }; }
-        const sub = [...document.querySelectorAll('button[type="submit"]')].find(b => !b.disabled);
-        if (sub) { sub.click(); return { ok: true, msg: 'clicked-submit' }; }
-        box.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', code: 'Enter', keyCode: 13, bubbles: true }));
-        return { ok: true, msg: 'enter' };
-      } catch (e) { return { ok: false, msg: e.toString() }; }
-    })()`);
-        if (!sendResult || !sendResult.ok) {
-            return [{ response: '[SEND FAILED] ' + JSON.stringify(sendResult) }];
-        }
-        const startTime = Date.now();
-        let lastText = '';
-        let stableCount = 0;
-        while (Date.now() - startTime < timeoutMs) {
-            await page.wait(3);
-            const response = await page.evaluate(`(() => {
-        const bubbles = document.querySelectorAll('div.message-bubble, [data-testid="message-bubble"]');
-        if (bubbles.length < 2) return '';
-        const last = bubbles[bubbles.length - 1];
-        const text = (last.innerText || '').trim();
-        if (!text || text.length < 2) return '';
-        return text;
-      })()`);
-            if (response && response.length > 2) {
-                if (response === lastText) {
-                    stableCount++;
-                    if (stableCount >= 2)
-                        return [{ response }];
-                }
-                else {
-                    stableCount = 0;
-                }
-            }
-            lastText = response || '';
+        const newChat = normalizeBooleanFlag(kwargs.new);
+        const useExplicitWeb = normalizeBooleanFlag(kwargs.web);
+        if (useExplicitWeb) {
+            return runExplicitWebAsk(page, prompt, timeoutMs, newChat);
         }
-        if (lastText)
-            return [{ response: lastText }];
-        return [{ response: '[NO RESPONSE]' }];
+        return runDefaultAsk(page, prompt, timeoutMs, newChat);
     },
 });
+export const __test__ = {
+    pickLatestAssistantCandidate,
+    updateStableState,
+    normalizeBooleanFlag,
+    normalizeBubbleText,
+};

package/dist/clis/grok/ask.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/grok/ask.test.js

@@ -0,0 +1,36 @@
+import { describe, expect, it } from 'vitest';
+import { __test__ } from './ask.js';
+describe('grok ask helpers', () => {
+    it('normalizes boolean flags for explicit web routing', () => {
+        expect(__test__.normalizeBooleanFlag(true)).toBe(true);
+        expect(__test__.normalizeBooleanFlag('true')).toBe(true);
+        expect(__test__.normalizeBooleanFlag('1')).toBe(true);
+        expect(__test__.normalizeBooleanFlag('yes')).toBe(true);
+        expect(__test__.normalizeBooleanFlag('on')).toBe(true);
+        expect(__test__.normalizeBooleanFlag(false)).toBe(false);
+        expect(__test__.normalizeBooleanFlag('false')).toBe(false);
+        expect(__test__.normalizeBooleanFlag(undefined)).toBe(false);
+    });
+    it('ignores baseline bubbles and the echoed prompt when choosing the latest assistant candidate', () => {
+        const candidate = __test__.pickLatestAssistantCandidate(['older assistant answer', 'Prompt text', 'Assistant draft', 'Assistant final'], 1, 'Prompt text');
+        expect(candidate).toBe('Assistant final');
+    });
+    it('returns empty when only the echoed prompt appeared after send', () => {
+        const candidate = __test__.pickLatestAssistantCandidate(['older assistant answer', 'Prompt text'], 1, 'Prompt text');
+        expect(candidate).toBe('');
+    });
+    it('tracks stabilization by incrementing repeats and resetting on changes', () => {
+        expect(__test__.updateStableState('', 0, 'First chunk')).toEqual({
+            previousText: 'First chunk',
+            stableCount: 0,
+        });
+        expect(__test__.updateStableState('First chunk', 0, 'First chunk')).toEqual({
+            previousText: 'First chunk',
+            stableCount: 1,
+        });
+        expect(__test__.updateStableState('First chunk', 1, 'Second chunk')).toEqual({
+            previousText: 'Second chunk',
+            stableCount: 0,
+        });
+    });
+});

package/dist/clis/instagram/comment.yaml

@@ -0,0 +1,52 @@
+site: instagram
+name: comment
+description: Comment on an Instagram post
+domain: www.instagram.com
+
+args:
+  username:
+    type: str
+    required: true
+    positional: true
+    description: Username of the post author
+  text:
+    positional: true
+    type: str
+    required: true
+    description: Comment text
+  index:
+    type: int
+    default: 1
+    description: Post index (1 = most recent)
+
+pipeline:
+  - navigate: https://www.instagram.com
+
+  - evaluate: |
+      (async () => {
+        const username = ${{ args.username | json }};
+        const commentText = ${{ args.text | json }};
+        const idx = ${{ args.index }} - 1;
+        const headers = { 'X-IG-App-ID': '936619743392459' };
+        const opts = { credentials: 'include', headers };
+
+        const r1 = await fetch('https://www.instagram.com/api/v1/users/web_profile_info/?username=' + encodeURIComponent(username), opts);
+        if (!r1.ok) throw new Error('User not found: ' + username);
+        const userId = (await r1.json())?.data?.user?.id;
+
+        const r2 = await fetch('https://www.instagram.com/api/v1/feed/user/' + userId + '/?count=' + (idx + 1), opts);
+        const posts = (await r2.json())?.items || [];
+        if (idx >= posts.length) throw new Error('Post index ' + (idx + 1) + ' not found');
+        const pk = posts[idx].pk;
+
+        const csrf = document.cookie.match(/csrftoken=([^;]+)/)?.[1] || '';
+        const r3 = await fetch('https://www.instagram.com/api/v1/web/comments/' + pk + '/add/', {
+          method: 'POST', credentials: 'include',
+          headers: { ...headers, 'X-CSRFToken': csrf, 'Content-Type': 'application/x-www-form-urlencoded' },
+          body: 'comment_text=' + encodeURIComponent(commentText),
+        });
+        if (!r3.ok) throw new Error('Failed to comment: HTTP ' + r3.status);
+        return [{ status: 'Commented', user: username, text: commentText }];
+      })()
+
+columns: [status, user, text]

package/dist/clis/instagram/explore.yaml

@@ -0,0 +1,43 @@
+site: instagram
+name: explore
+description: Instagram explore/discover trending posts
+domain: www.instagram.com
+
+args:
+  limit:
+    type: int
+    default: 20
+    description: Number of posts
+
+pipeline:
+  - navigate: https://www.instagram.com
+
+  - evaluate: |
+      (async () => {
+        const limit = ${{ args.limit }};
+        const res = await fetch(
+          'https://www.instagram.com/api/v1/discover/web/explore_grid/',
+          {
+            credentials: 'include',
+            headers: { 'X-IG-App-ID': '936619743392459' }
+          }
+        );
+        if (!res.ok) throw new Error('HTTP ' + res.status + ' - make sure you are logged in to Instagram');
+        const data = await res.json();
+        const posts = [];
+        for (const sec of (data?.sectional_items || [])) {
+          for (const m of (sec?.layout_content?.medias || [])) {
+            const media = m?.media;
+            if (media) posts.push({
+              user: media.user?.username || '',
+              caption: (media.caption?.text || '').replace(/\n/g, ' ').substring(0, 100),
+              likes: media.like_count ?? 0,
+              comments: media.comment_count ?? 0,
+              type: media.media_type === 1 ? 'photo' : media.media_type === 2 ? 'video' : 'carousel',
+            });
+          }
+        }
+        return posts.slice(0, limit).map((p, i) => ({ rank: i + 1, ...p }));
+      })()
+
+columns: [rank, user, caption, likes, comments, type]

package/dist/clis/instagram/follow.yaml

@@ -0,0 +1,41 @@
+site: instagram
+name: follow
+description: Follow an Instagram user
+domain: www.instagram.com
+
+args:
+  username:
+    type: str
+    required: true
+    positional: true
+    description: Instagram username to follow
+
+pipeline:
+  - navigate: https://www.instagram.com
+
+  - evaluate: |
+      (async () => {
+        const username = ${{ args.username | json }};
+        const headers = { 'X-IG-App-ID': '936619743392459' };
+        const opts = { credentials: 'include', headers };
+
+        // Get user ID
+        const r1 = await fetch('https://www.instagram.com/api/v1/users/web_profile_info/?username=' + encodeURIComponent(username), opts);
+        if (!r1.ok) throw new Error('User not found: ' + username);
+        const d1 = await r1.json();
+        const userId = d1?.data?.user?.id;
+        if (!userId) throw new Error('User not found: ' + username);
+
+        const csrf = document.cookie.match(/csrftoken=([^;]+)/)?.[1] || '';
+        const r2 = await fetch('https://www.instagram.com/api/v1/friendships/create/' + userId + '/', {
+          method: 'POST',
+          credentials: 'include',
+          headers: { ...headers, 'X-CSRFToken': csrf, 'Content-Type': 'application/x-www-form-urlencoded' },
+        });
+        if (!r2.ok) throw new Error('Failed to follow: HTTP ' + r2.status);
+        const d2 = await r2.json();
+        const status = d2?.friendship_status?.following ? 'Following' : d2?.friendship_status?.outgoing_request ? 'Request sent' : 'Followed';
+        return [{ status, username }];
+      })()
+
+columns: [status, username]

package/dist/clis/instagram/followers.yaml

@@ -0,0 +1,51 @@
+site: instagram
+name: followers
+description: List followers of an Instagram user
+domain: www.instagram.com
+
+args:
+  username:
+    type: str
+    required: true
+    positional: true
+    description: Instagram username
+  limit:
+    type: int
+    default: 20
+    description: Number of followers
+
+pipeline:
+  - navigate: https://www.instagram.com
+
+  - evaluate: |
+      (async () => {
+        const username = ${{ args.username | json }};
+        const limit = ${{ args.limit }};
+        const headers = { 'X-IG-App-ID': '936619743392459' };
+        const opts = { credentials: 'include', headers };
+
+        const r1 = await fetch(
+          'https://www.instagram.com/api/v1/users/web_profile_info/?username=' + encodeURIComponent(username),
+          opts
+        );
+        if (!r1.ok) throw new Error('HTTP ' + r1.status + ' - make sure you are logged in to Instagram');
+        const d1 = await r1.json();
+        const userId = d1?.data?.user?.id;
+        if (!userId) throw new Error('User not found: ' + username);
+
+        const r2 = await fetch(
+          'https://www.instagram.com/api/v1/friendships/' + userId + '/followers/?count=' + limit,
+          opts
+        );
+        if (!r2.ok) throw new Error('Failed to fetch followers: HTTP ' + r2.status);
+        const d2 = await r2.json();
+        return (d2?.users || []).slice(0, limit).map((u, i) => ({
+          rank: i + 1,
+          username: u.username || '',
+          name: u.full_name || '',
+          verified: u.is_verified ? 'Yes' : 'No',
+          private: u.is_private ? 'Yes' : 'No',
+        }));
+      })()
+
+columns: [rank, username, name, verified, private]

package/dist/clis/instagram/following.yaml

@@ -0,0 +1,51 @@
+site: instagram
+name: following
+description: List accounts an Instagram user is following
+domain: www.instagram.com
+
+args:
+  username:
+    type: str
+    required: true
+    positional: true
+    description: Instagram username
+  limit:
+    type: int
+    default: 20
+    description: Number of accounts
+
+pipeline:
+  - navigate: https://www.instagram.com
+
+  - evaluate: |
+      (async () => {
+        const username = ${{ args.username | json }};
+        const limit = ${{ args.limit }};
+        const headers = { 'X-IG-App-ID': '936619743392459' };
+        const opts = { credentials: 'include', headers };
+
+        const r1 = await fetch(
+          'https://www.instagram.com/api/v1/users/web_profile_info/?username=' + encodeURIComponent(username),
+          opts
+        );
+        if (!r1.ok) throw new Error('HTTP ' + r1.status + ' - make sure you are logged in to Instagram');
+        const d1 = await r1.json();
+        const userId = d1?.data?.user?.id;
+        if (!userId) throw new Error('User not found: ' + username);
+
+        const r2 = await fetch(
+          'https://www.instagram.com/api/v1/friendships/' + userId + '/following/?count=' + limit,
+          opts
+        );
+        if (!r2.ok) throw new Error('Failed to fetch following: HTTP ' + r2.status);
+        const d2 = await r2.json();
+        return (d2?.users || []).slice(0, limit).map((u, i) => ({
+          rank: i + 1,
+          username: u.username || '',
+          name: u.full_name || '',
+          verified: u.is_verified ? 'Yes' : 'No',
+          private: u.is_private ? 'Yes' : 'No',
+        }));
+      })()
+
+columns: [rank, username, name, verified, private]

package/dist/clis/instagram/like.yaml

@@ -0,0 +1,46 @@
+site: instagram
+name: like
+description: Like an Instagram post
+domain: www.instagram.com
+
+args:
+  username:
+    type: str
+    required: true
+    positional: true
+    description: Username of the post author
+  index:
+    type: int
+    default: 1
+    description: Post index (1 = most recent)
+
+pipeline:
+  - navigate: https://www.instagram.com
+
+  - evaluate: |
+      (async () => {
+        const username = ${{ args.username | json }};
+        const idx = ${{ args.index }} - 1;
+        const headers = { 'X-IG-App-ID': '936619743392459' };
+        const opts = { credentials: 'include', headers };
+
+        const r1 = await fetch('https://www.instagram.com/api/v1/users/web_profile_info/?username=' + encodeURIComponent(username), opts);
+        if (!r1.ok) throw new Error('User not found: ' + username);
+        const userId = (await r1.json())?.data?.user?.id;
+
+        const r2 = await fetch('https://www.instagram.com/api/v1/feed/user/' + userId + '/?count=' + (idx + 1), opts);
+        const posts = (await r2.json())?.items || [];
+        if (idx >= posts.length) throw new Error('Post index ' + (idx + 1) + ' not found, user has ' + posts.length + ' recent posts');
+        const pk = posts[idx].pk;
+        const caption = (posts[idx].caption?.text || '').substring(0, 60);
+
+        const csrf = document.cookie.match(/csrftoken=([^;]+)/)?.[1] || '';
+        const r3 = await fetch('https://www.instagram.com/api/v1/web/likes/' + pk + '/like/', {
+          method: 'POST', credentials: 'include',
+          headers: { ...headers, 'X-CSRFToken': csrf, 'Content-Type': 'application/x-www-form-urlencoded' },
+        });
+        if (!r3.ok) throw new Error('Failed to like: HTTP ' + r3.status);
+        return [{ status: 'Liked', user: username, post: caption || '(post #' + (idx+1) + ')' }];
+      })()
+
+columns: [status, user, post]