@agentrhq/webcmd 0.2.5 → 0.3.1

package/clis/facebook/feed.test.js

@@ -166,4 +166,66 @@ describe('facebook feed', () => {
     await expect(__test__.command.func(createPage({ rows: null }), { limit: 1 }))
       .rejects.toBeInstanceOf(CommandExecutionError);
   });
+
+  it('extracts modern feed posts anchored on the Actions for this post menu', () => {
+    const payload = runExtract(`
+      <main role="main">
+        <div>
+          <div>
+            <h3><a role="link" href="https://www.facebook.com/carol">Carol Poster</a></h3>
+            <div dir="auto">A modern feed post with no article wrapper anywhere on it.</div>
+            <a href="https://www.facebook.com/carol/posts/999">2h</a>
+            <div aria-label="Actions for this post" role="button"></div>
+          </div>
+          <div>
+            <h3><a role="link" href="https://www.facebook.com/dave">Dave Danger</a></h3>
+            <div dir="auto">Second streamed post body that should also be extracted.</div>
+            <div aria-label="Actions for this post" role="button"></div>
+          </div>
+        </div>
+      </main>
+    `);
+
+    expect(payload.status).toBe('ok');
+    expect(payload.diagnostics.actionMenuCount).toBe(2);
+    expect(payload.rows.map((row) => row.author)).toEqual(['Carol Poster', 'Dave Danger']);
+    expect(payload.rows[0].content).toContain('modern feed post');
+  });
+
+  it('does not climb to the main landmark on a single-post page', () => {
+    const payload = runExtract(`
+      <main role="main">
+        <div>
+          <div>
+            <h3><a role="link" href="https://www.facebook.com/solo">Solo Poster</a></h3>
+            <div dir="auto">The only post on the page must remain bounded to its own card.</div>
+            <div aria-label="Actions for this post" role="button"></div>
+          </div>
+        </div>
+      </main>
+    `);
+
+    expect(payload.rows).toHaveLength(1);
+    expect(payload.rows[0].author).toBe('Solo Poster');
+  });
+
+  it('keeps legitimate numeric names while dropping hidden and numeric decoys', () => {
+    const payload = runExtract(`
+      <main role="main">
+        <div>
+          <div>
+            <h3><a role="link" href="https://www.facebook.com/class2024">Class of 2024</a></h3>
+            <span>\u200b\u200b\u200b</span>
+            <div dir="auto">Genuine reunion post content that survives decoy filtering.</div>
+            <div dir="auto">1234567890123</div>
+            <div aria-label="Actions for this post" role="button"></div>
+          </div>
+        </div>
+      </main>
+    `);
+
+    expect(payload.status).toBe('ok');
+    expect(payload.rows[0].author).toBe('Class of 2024');
+    expect(payload.rows[0].content).not.toContain('1234567890123');
+  });
 });

package/clis/facebook/search.js

@@ -1,39 +1,186 @@
-import { cli } from '@agentrhq/webcmd/registry';
-cli({
-    site: 'facebook',
-    name: 'search',
-    access: 'read',
-    description: 'Search Facebook for people, pages, or posts',
-    domain: 'www.facebook.com',
-    args: [
-        { name: 'query', required: true, positional: true, help: 'Search query' },
-        { name: 'limit', type: 'int', default: 10, help: 'Number of results' },
-    ],
-    columns: ['index', 'title', 'text', 'url'],
-    pipeline: [
-        { navigate: 'https://www.facebook.com' },
-        { navigate: { url: 'https://www.facebook.com/search/top?q=${{ args.query | urlencode }}', settleMs: 4000 } },
-        { evaluate: `(async () => {
-  const limit = \${{ args.limit }};
-  // Search results are typically in role="article" or role="listitem"
-  let items = document.querySelectorAll('[role="article"]');
-  if (items.length === 0) {
-    items = document.querySelectorAll('[role="listitem"]');
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@agentrhq/webcmd/errors';
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+
+const FACEBOOK_HOME = 'https://www.facebook.com';
+const MAX_LIMIT = 50;
+
+function requireLimit(value) {
+  const n = Number(value);
+  if (!Number.isInteger(n) || n < 1 || n > MAX_LIMIT) {
+    throw new ArgumentError(`facebook search --limit must be an integer between 1 and ${MAX_LIMIT}`);
   }
-  return Array.from(items)
-    .filter(el => el.textContent.trim().length > 20)
-    .slice(0, limit)
-    .map((el, i) => {
-      const link = el.querySelector('a[href*="facebook.com/"]');
-      const heading = el.querySelector('h2, h3, h4, strong');
-      return {
-        index: i + 1,
-        title: heading ? heading.textContent.trim().substring(0, 80) : '',
-        text: el.textContent.trim().replace(/\\s+/g, ' ').substring(0, 150),
-        url: link ? link.href.split('?')[0] : '',
-      };
-    });
-})()
-` },
-    ],
-});
+  return n;
+}
+
+function requireQuery(value) {
+  const q = String(value ?? '').trim();
+  if (!q) throw new ArgumentError('facebook search requires a non-empty query');
+  return q;
+}
+
+function unwrapBrowserResult(value) {
+  if (value && typeof value === 'object' && 'data' in value) return value.data;
+  return value;
+}
+
+// Modern facebook.com /search/top renders results inside [role="feed"] as
+// entity/content links (people, pages, groups, posts) — [role="article"] /
+// [role="listitem"] no longer wrap them — and FB seeds scrambled hidden-char
+// decoy links back to /search/top. Collect anchors inside the feed, keep only
+// real entity/content hrefs, and drop the decoys plus obfuscated text. See #2090.
+function buildSearchExtractScript(limit) {
+  return `(() => {
+    const limit = ${limit};
+
+    function clean(value) {
+      return String(value || '')
+        .replace(/[\\u200b-\\u200f\\u202a-\\u202e\\u2060\\ufeff]/g, '')
+        .replace(/\\s+/g, ' ')
+        .trim();
+    }
+
+    // FB anti-scrape obfuscation: long spaceless digit tokens and spaced
+    // single-char strings ("a b c d e"). Real titles never look like this.
+    function isObfuscated(text) {
+      if (!text) return true;
+      if (/^\\d{8,}$/.test(text)) return true;
+      if (/^(?:\\S ){4,}\\S$/.test(text) && text.replace(/\\s/g, '').length <= 12) return true;
+      return false;
+    }
+
+    function isEntityHref(href) {
+      if (!href) return false;
+      let u;
+      try { u = new URL(href, 'https://www.facebook.com'); } catch (e) { return false; }
+      // drop hidden-domain .com spam — real results stay on facebook.com
+      if (!/(^|\\.)facebook\\.com$/i.test(u.hostname)) return false;
+      const p = u.pathname;
+      if (/^\\/search(\\/|$)/i.test(p)) return false;                  // decoy links back to search (incl. bare /search)
+      // chrome / non-result destinations that the catch-all below would keep
+      if (/^\\/(login|checkpoint|help|policies|privacy|settings|bookmarks|messages|notifications|marketplace|gaming|friends|requests|saved|me)\\b/i.test(p)) return false;
+      return /^\\/(profile\\.php|groups\\/|events\\/|watch\\/|reel\\/|pages\\/|permalink\\.php|story\\.php|[^/]+\\/posts\\/|[^/]+\\/videos\\/|[A-Za-z0-9.\\-]{2,}\\/?$)/i.test(p);
+    }
+
+    function isAuthPage() {
+      const path = window.location && window.location.pathname ? window.location.pathname : '';
+      const body = clean(document.body && document.body.textContent);
+      return /^\\/(login|checkpoint)(\\/|$|\\.php)/.test(path)
+        || /^(Log in to Facebook|Facebook Log in|Log in Facebook)/i.test(body)
+        || /You must log in to continue/i.test(body);
+    }
+
+    if (isAuthPage()) return { status: 'auth', rows: [], diagnostics: {} };
+
+    const feed = document.querySelector('[role="feed"]')
+      || document.querySelector('[role="main"]')
+      || document.body;
+    const anchors = Array.from(feed.querySelectorAll('a[href]'));
+    const seen = new Set();
+    const rows = [];
+    for (const a of anchors) {
+      const rawHref = a.href || a.getAttribute('href') || '';
+      if (!isEntityHref(rawHref)) continue;
+      let key;
+      try { const u = new URL(rawHref, 'https://www.facebook.com'); key = u.origin + u.pathname; }
+      catch (e) { key = rawHref.split('?')[0].split('#')[0]; }
+      if (seen.has(key)) continue;
+
+      const title = clean(a.textContent).substring(0, 80);
+      if (!title || isObfuscated(title)) continue;
+
+      // climb a few levels for the surrounding card text
+      let card = a;
+      for (let i = 0; i < 4 && card.parentElement; i += 1) {
+        card = card.parentElement;
+        if (clean(card.textContent).length > title.length + 20) break;
+      }
+      const text = clean(card.textContent).substring(0, 150);
+      if (isObfuscated(text)) continue;
+
+      seen.add(key);
+      rows.push({ index: rows.length + 1, title, text, url: key });
+      if (rows.length >= limit) break;
+    }
+
+    return {
+      status: rows.length ? 'ok' : 'no_rows',
+      rows,
+      diagnostics: {
+        feedFound: !!document.querySelector('[role="feed"]'),
+        anchorCount: anchors.length,
+        mainTextLength: clean((document.querySelector('[role="main"]') || {}).textContent).length,
+      },
+    };
+  })()`;
+}
+
+async function searchFacebook(page, kwargs) {
+  const query = requireQuery(kwargs.query);
+  const limit = requireLimit(kwargs.limit ?? 10);
+
+  // Navigate home first so the SPA is warm, then to the search results.
+  // Regression guard for #625: extraction must run *after* this navigation.
+  try {
+    await page.goto(FACEBOOK_HOME);
+    await page.goto(`https://www.facebook.com/search/top?q=${encodeURIComponent(query)}`, { settleMs: 4000 });
+  } catch (err) {
+    throw new CommandExecutionError(
+      `Failed to open facebook search: ${err instanceof Error ? err.message : err}`,
+      'Check that facebook.com is reachable and the Cloak browser session is running.',
+    );
+  }
+
+  let payload;
+  try {
+    payload = unwrapBrowserResult(await page.evaluate(buildSearchExtractScript(limit)));
+  } catch (err) {
+    throw new CommandExecutionError(
+      `Failed to read facebook search results: ${err instanceof Error ? err.message : err}`,
+      'Facebook may not have rendered or the search markup may have changed.',
+    );
+  }
+
+  if (!payload || typeof payload !== 'object' || !Array.isArray(payload.rows)) {
+    throw new CommandExecutionError('facebook search returned malformed extraction payload');
+  }
+  if (payload.status === 'auth') {
+    throw new AuthRequiredError('www.facebook.com', 'Log in to Facebook in the active Cloak browser session before retrying.');
+  }
+  if (payload.rows.length > 0) return payload.rows;
+
+  const d = payload.diagnostics || {};
+  if (d.anchorCount || d.mainTextLength > 200) {
+    throw new CommandExecutionError(
+      'facebook search page rendered but no entity results could be extracted',
+      `Diagnostics: feed=${!!d.feedFound}, anchors=${d.anchorCount || 0}, mainTextLength=${d.mainTextLength || 0}.`,
+    );
+  }
+  throw new EmptyResultError('facebook search', `No Facebook results were visible for "${query}".`);
+}
+
+const command = {
+  site: 'facebook',
+  name: 'search',
+  access: 'read',
+  description: 'Search Facebook for people, pages, or posts',
+  domain: 'www.facebook.com',
+  strategy: Strategy.COOKIE,
+  browser: true,
+  navigateBefore: false,
+  args: [
+    { name: 'query', required: true, positional: true, help: 'Search query' },
+    { name: 'limit', type: 'int', default: 10, help: 'Number of results' },
+  ],
+  columns: ['index', 'title', 'text', 'url'],
+  func: searchFacebook,
+};
+
+cli(command);
+
+export const __test__ = {
+  buildSearchExtractScript,
+  command,
+  searchFacebook,
+  requireLimit,
+  requireQuery,
+};

package/clis/facebook/search.test.js

@@ -1,55 +1,100 @@
-/**
- * Regression test for issue #625.
- * Facebook search must navigate in the pipeline before DOM extraction.
- */
 import { describe, expect, it, vi } from 'vitest';
+import { JSDOM } from 'jsdom';
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@agentrhq/webcmd/errors';
 import { getRegistry } from '@agentrhq/webcmd/registry';
-import { executePipeline } from '@agentrhq/webcmd/pipeline';
-// Import the adapter to register it
 import './search.js';
-/**
- * Minimal browser mock for pipeline execution tests.
- * Only methods touched by this adapter path are implemented.
- */
-function createMockPage() {
-    return {
-        goto: vi.fn(),
-        evaluate: vi.fn().mockResolvedValue([]),
-        getCookies: vi.fn().mockResolvedValue([]),
-        snapshot: vi.fn().mockResolvedValue(''),
-        click: vi.fn(),
-        typeText: vi.fn(),
-        pressKey: vi.fn(),
-        scrollTo: vi.fn(),
-        getFormState: vi.fn().mockResolvedValue({}),
-        wait: vi.fn(),
-        tabs: vi.fn().mockResolvedValue([]),
-        selectTab: vi.fn(),
-        networkRequests: vi.fn().mockResolvedValue([]),
-        consoleMessages: vi.fn().mockResolvedValue(''),
-        scroll: vi.fn(),
-        autoScroll: vi.fn(),
-        installInterceptor: vi.fn(),
-        getInterceptedRequests: vi.fn().mockResolvedValue([]),
-        waitForCapture: vi.fn().mockResolvedValue(undefined),
-        screenshot: vi.fn().mockResolvedValue(''),
-    };
+
+function createPage(payload) {
+  return {
+    goto: vi.fn().mockResolvedValue(undefined),
+    evaluate: vi.fn().mockResolvedValue(payload),
+  };
 }
-describe('facebook search pipeline', () => {
-    it('navigates to search results before extracting DOM data', async () => {
-        const cmd = getRegistry().get('facebook/search');
-        expect(cmd).toBeDefined();
-        const pipeline = cmd.pipeline ?? [];
-        const page = createMockPage();
-        await executePipeline(page, pipeline, {
-            args: { query: 'AI agent', limit: 3 },
-        });
-        expect(page.goto).toHaveBeenNthCalledWith(1, 'https://www.facebook.com');
-        expect(page.goto).toHaveBeenNthCalledWith(2, 'https://www.facebook.com/search/top?q=AI%20agent', {
-            waitUntil: undefined,
-            settleMs: 4000,
-        });
-        expect(page.evaluate).toHaveBeenCalledTimes(1);
-        expect(String(page.evaluate.mock.calls[0]?.[0] ?? '')).not.toContain('window.location.href');
-    });
+
+function createDomPage(html, url = 'https://www.facebook.com/search/top?q=ai') {
+  const dom = new JSDOM(html, { url });
+  return {
+    goto: vi.fn().mockResolvedValue(undefined),
+    evaluate: vi.fn().mockImplementation((script) => (
+      Function('window', 'document', `return ${script};`)(dom.window, dom.window.document)
+    )),
+  };
+}
+
+function searchCommand() {
+  return getRegistry().get('facebook/search');
+}
+
+describe('facebook search', () => {
+  it('registers a function command with the existing row contract', () => {
+    const command = searchCommand();
+    expect(command).toBeDefined();
+    expect(command.columns).toEqual(['index', 'title', 'text', 'url']);
+    expect(command.func).toBeTypeOf('function');
+  });
+
+  it('navigates home then to search results before extracting', async () => {
+    const page = createPage({ status: 'ok', rows: [{ index: 1, title: 'X', text: 'x', url: 'https://www.facebook.com/x' }] });
+    await searchCommand().func(page, { query: 'AI agent', limit: 3 });
+
+    expect(page.goto).toHaveBeenNthCalledWith(1, 'https://www.facebook.com');
+    expect(page.goto).toHaveBeenNthCalledWith(2, 'https://www.facebook.com/search/top?q=AI%20agent', { settleMs: 4000 });
+    expect(String(page.evaluate.mock.calls[0]?.[0] ?? '')).not.toContain('window.location.href');
+  });
+
+  it('extracts feed links while dropping search, chrome, and obfuscated decoys', async () => {
+    const page = createDomPage(`
+      <div role="feed">
+        <div><a role="link" href="https://www.facebook.com/carol.page">Carol's Page</a><span>Public figure · 12K followers</span></div>
+        <div><a role="link" href="https://www.facebook.com/groups/1234567/">AI Builders Group</a><span>Group · 3K members</span></div>
+        <div><a role="link" href="https://www.facebook.com/dave/posts/9988">Dave's post about AI agents</a></div>
+        <a role="link" href="https://www.facebook.com/search/top?q=aaaa">See more results</a>
+        <a role="link" href="https://www.facebook.com/search?q=bare">Bare search decoy</a>
+        <a role="link" href="https://www.facebook.com/marketplace">Marketplace</a>
+        <a role="link" href="https://www.facebook.com/messages/t/123">Messages</a>
+        <a role="link" href="https://evil-cdn.com/x">1234567890123456</a>
+        <a role="link" href="https://www.facebook.com/a.b.c">a b c d e f</a>
+      </div>
+    `);
+
+    const rows = await searchCommand().func(page, { query: 'ai', limit: 10 });
+    expect(rows.map((row) => row.url)).toEqual([
+      'https://www.facebook.com/carol.page',
+      'https://www.facebook.com/groups/1234567/',
+      'https://www.facebook.com/dave/posts/9988',
+    ]);
+    expect(rows[0].title).toBe("Carol's Page");
+  });
+
+  it('deduplicates result URLs and honours the limit', async () => {
+    const page = createDomPage(`
+      <div role="feed">
+        <div><a href="https://www.facebook.com/carol.page">Carol's Page</a></div>
+        <div><a href="https://www.facebook.com/carol.page?ref=xyz">Carol's Page again</a></div>
+        <div><a href="https://www.facebook.com/erin">Erin</a></div>
+      </div>
+    `);
+
+    const rows = await searchCommand().func(page, { query: 'ai', limit: 1 });
+    expect(rows).toHaveLength(1);
+    expect(rows[0].url).toBe('https://www.facebook.com/carol.page');
+  });
+
+  it('validates query and limit before navigation', async () => {
+    const page = createPage({ status: 'ok', rows: [] });
+    await expect(searchCommand().func(page, { query: '  ', limit: 3 })).rejects.toBeInstanceOf(ArgumentError);
+    await expect(searchCommand().func(page, { query: 'ok', limit: 0 })).rejects.toBeInstanceOf(ArgumentError);
+    expect(page.goto).not.toHaveBeenCalled();
+  });
+
+  it('maps auth, empty, drift, and malformed payloads to typed errors', async () => {
+    await expect(searchCommand().func(createPage({ status: 'auth', rows: [] }), { query: 'q', limit: 1 }))
+      .rejects.toBeInstanceOf(AuthRequiredError);
+    await expect(searchCommand().func(createPage({ status: 'no_rows', rows: [], diagnostics: {} }), { query: 'q', limit: 1 }))
+      .rejects.toBeInstanceOf(EmptyResultError);
+    await expect(searchCommand().func(createPage({ status: 'no_rows', rows: [], diagnostics: { anchorCount: 40, mainTextLength: 800 } }), { query: 'q', limit: 1 }))
+      .rejects.toBeInstanceOf(CommandExecutionError);
+    await expect(searchCommand().func(createPage({ rows: null }), { query: 'q', limit: 1 }))
+      .rejects.toBeInstanceOf(CommandExecutionError);
+  });
 });

package/clis/instagram/explore.js

@@ -22,19 +22,37 @@ cli({
   );
   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',
-      });
+
+  const seen = new Set();
+  const medias = [];
+  const collect = (node, depth) => {
+    if (!node || typeof node !== 'object' || depth > 8) return;
+    if (Array.isArray(node)) {
+      for (const item of node) collect(item, depth + 1);
+      return;
     }
-  }
+    const media = node.media;
+    if (media && typeof media === 'object' && !Array.isArray(media)) {
+      const key = media.pk ?? media.id ?? media.code;
+      if (key != null && !seen.has(key)) {
+        seen.add(key);
+        medias.push(media);
+      }
+    }
+    for (const [key, value] of Object.entries(node)) {
+      if (key === 'media') continue;
+      if (value && typeof value === 'object') collect(value, depth + 1);
+    }
+  };
+  for (const section of (data?.sectional_items || [])) collect(section, 0);
+
+  const posts = medias.map((media) => ({
+    user: media.user?.username || '',
+    caption: (media.caption?.text || '').replace(/\\n/g, ' ').substring(0, 100),
+    likes: media.like_count ?? media.play_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 }));
 })()
 ` },

package/clis/instagram/explore.test.js

@@ -0,0 +1,77 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@agentrhq/webcmd/registry';
+import './explore.js';
+
+async function runExplore(payload, limit = 20) {
+  const command = getRegistry().get('instagram/explore');
+  const source = command.pipeline.find((step) => step.evaluate).evaluate
+    .replace('${{ args.limit }}', String(limit));
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = vi.fn().mockResolvedValue({
+    ok: true,
+    json: vi.fn().mockResolvedValue(payload),
+  });
+  try {
+    return await eval(source);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+}
+
+describe('instagram explore', () => {
+  it('collects distinct identified media from nested Explore layouts', async () => {
+    const photo = {
+      pk: 'photo-1',
+      user: { username: 'photographer' },
+      caption: { text: 'First\nphoto' },
+      like_count: 12,
+      comment_count: 3,
+      media_type: 1,
+    };
+    const reel = {
+      id: 'reel-2',
+      user: { username: 'filmmaker' },
+      caption: { text: 'Nested reel' },
+      play_count: 99,
+      comment_count: 4,
+      media_type: 2,
+    };
+    const payload = {
+      sectional_items: [
+        { layout_content: { medias: [{ media: photo }] } },
+        { layout_content: { one_by_two_item: { clips: { items: [{ media: reel }] } } } },
+        { layout_content: { fill_items: [{ media: photo }] } },
+        {
+          layout_content: {
+            fill_items: [{
+              media: {
+                user: { username: 'missing-identity' },
+                like_count: 1,
+                media_type: 1,
+              },
+            }],
+          },
+        },
+      ],
+    };
+
+    await expect(runExplore(payload)).resolves.toEqual([
+      {
+        rank: 1,
+        user: 'photographer',
+        caption: 'First photo',
+        likes: 12,
+        comments: 3,
+        type: 'photo',
+      },
+      {
+        rank: 2,
+        user: 'filmmaker',
+        caption: 'Nested reel',
+        likes: 99,
+        comments: 4,
+        type: 'video',
+      },
+    ]);
+  });
+});

package/clis/instagram/post.js

@@ -1403,7 +1403,20 @@ cli({
     strategy: Strategy.UI,
     browser: true,
     args: [
-        { name: 'media', required: false, valueRequired: true, help: `Comma-separated media paths (images/videos, up to ${MAX_MEDIA_ITEMS})` },
+        {
+            name: 'media',
+            required: false,
+            valueRequired: true,
+            help: `Comma-separated media paths (images/videos, up to ${MAX_MEDIA_ITEMS})`,
+            file: {
+                direction: 'input',
+                pathKind: 'file',
+                multiple: true,
+                separator: ',',
+                contentTypes: ['image/jpeg', 'image/png', 'image/webp', 'video/mp4'],
+                maxBytes: 262_144_000,
+            },
+        },
         { name: 'content', positional: true, required: false, help: 'Caption text' },
         { name: 'timeout', type: 'int', required: false, default: 300, help: 'Max seconds for the overall command (default: 300)' },
     ],

package/clis/instagram/reel.js

@@ -738,7 +738,19 @@ cli({
     strategy: Strategy.UI,
     browser: true,
     args: [
-        { name: 'video', required: false, valueRequired: true, help: 'Path to a single .mp4 video file' },
+        {
+            name: 'video',
+            required: false,
+            valueRequired: true,
+            help: 'Path to a single .mp4 video file',
+            file: {
+                direction: 'input',
+                pathKind: 'file',
+                multiple: false,
+                contentTypes: ['video/mp4'],
+                maxBytes: 262_144_000,
+            },
+        },
         { name: 'content', positional: true, required: false, help: 'Caption text' },
         { name: 'timeout', type: 'int', required: false, default: INSTAGRAM_REEL_TIMEOUT_SECONDS, help: `Max seconds for the overall command (default: ${INSTAGRAM_REEL_TIMEOUT_SECONDS})` },
     ],