@jackwener/opencli 1.1.1 → 1.2.1

package/src/clis/google/utils.ts

@@ -0,0 +1,24 @@
+/**
+ * Google adapter utilities.
+ * Shared RSS parser for news and trends commands.
+ */
+
+/**
+ * Parse RSS XML by splitting into <item> blocks, then extracting fields per block.
+ * Handles both plain text and CDATA-wrapped content.
+ */
+export function parseRssItems(xml: string, fields: string[]): Record<string, string>[] {
+  const items = xml.match(/<item>([\s\S]*?)<\/item>/g) || [];
+  return items.map(block => {
+    const record: Record<string, string> = {};
+    for (const field of fields) {
+      // Escape regex special characters in field name (e.g. ht:approx_traffic is safe, but defensive)
+      const escaped = field.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+      // Handle tags with attributes (e.g. <source url="...">text</source>) and CDATA wrapping
+      // (?:\s[^>]*)? ensures we don't match prefix tags (e.g. <sourceUrl> when looking for <source>)
+      const match = block.match(new RegExp(`<${escaped}(?:\\s[^>]*)?>(?:<!\\[CDATA\\[)?([\\s\\S]*?)(?:\\]\\]>)?</${escaped}>`));
+      record[field] = match ? match[1].trim() : '';
+    }
+    return record;
+  });
+}

package/src/clis/grok/ask.test.ts

@@ -0,0 +1,53 @@
+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/src/clis/grok/ask.ts

@@ -1,6 +1,290 @@
 import { cli, Strategy } from '../../registry.js';
 import type { IPage } from '../../types.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.';
+
+type GrokSendResult = {
+  ok?: boolean;
+  msg?: string;
+  reason?: string;
+  detail?: string;
+};
+
+function blocked(message: string) {
+  return [{ response: `${BLOCKED_PREFIX} ${message} ${SESSION_HINT}` }];
+}
+
+function normalizeBubbleText(value: unknown): string {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function normalizeBooleanFlag(value: unknown): boolean {
+  if (typeof value === 'boolean') return value;
+
+  const normalized = String(value ?? '').trim().toLowerCase();
+  return normalized === 'true' || normalized === '1' || normalized === 'yes' || normalized === 'on';
+}
+
+function pickLatestAssistantCandidate(
+  bubbles: unknown[],
+  baselineCount: number,
+  prompt: string,
+): string {
+  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: string, stableCount: number, nextText: string) {
+  if (!nextText) return { previousText: '', stableCount: 0 };
+  if (nextText === previousText) return { previousText, stableCount: stableCount + 1 };
+  return { previousText: nextText, stableCount: 0 };
+}
+
+async function runDefaultAsk(
+  page: IPage,
+  prompt: string,
+  timeoutMs: number,
+  newChat: boolean,
+) {
+  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() }; }
+  })()`) as GrokSendResult;
+
+  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: IPage): Promise<string[]> {
+  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: IPage): Promise<void> {
+  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: IPage, prompt: string) {
+  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: IPage,
+  prompt: string,
+  timeoutMs: number,
+  newChat: boolean,
+) {
+  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) as GrokSendResult;
+
+  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',
@@ -9,82 +293,29 @@ 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: IPage, kwargs: Record<string, any>) => {
     const prompt = kwargs.prompt as string;
     const timeoutMs = ((kwargs.timeout as number) || 120) * 1000;
-    const newChat = kwargs.new as boolean;
-
-    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);
-    }
+    const newChat = normalizeBooleanFlag(kwargs.new);
+    const useExplicitWeb = normalizeBooleanFlag(kwargs.web);
 
-    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) }];
+    if (useExplicitWeb) {
+      return runExplicitWebAsk(page, prompt, timeoutMs, newChat);
     }
 
-    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]' }];
+    return runDefaultAsk(page, prompt, timeoutMs, newChat);
   },
 });
+
+export const __test__ = {
+  pickLatestAssistantCandidate,
+  updateStableState,
+  normalizeBooleanFlag,
+  normalizeBubbleText,
+};

package/src/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/src/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/src/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/src/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]