@huyuan-ai/cli 1.0.0 → 1.0.2

package/vendor/opencli/dist/clis/instagram/_shared/protocol-capture.d.ts

@@ -0,0 +1,26 @@
+import type { IPage } from '../../../types.js';
+export interface InstagramProtocolCaptureEntry {
+    kind: 'fetch' | 'xhr';
+    url: string;
+    method: string;
+    requestHeaders?: Record<string, string>;
+    requestBodyKind?: string;
+    requestBodyPreview?: string;
+    responseStatus?: number;
+    responseContentType?: string;
+    responsePreview?: string;
+    timestamp: number;
+}
+export declare function buildInstallInstagramProtocolCaptureJs(captureVar?: string, captureErrorsVar?: string): string;
+export declare function buildReadInstagramProtocolCaptureJs(captureVar?: string, captureErrorsVar?: string): string;
+export declare function installInstagramProtocolCapture(page: IPage): Promise<void>;
+export declare function readInstagramProtocolCapture(page: IPage): Promise<{
+    data: InstagramProtocolCaptureEntry[];
+    errors: string[];
+}>;
+export declare function dumpInstagramProtocolCaptureIfEnabled(page: IPage): Promise<void>;
+export declare function instagramPrivateApiFetch(page: IPage, input: string | URL, init?: {
+    method?: 'GET' | 'POST';
+    headers?: Record<string, string>;
+    body?: unknown;
+}): Promise<Response>;

package/vendor/opencli/dist/clis/instagram/_shared/protocol-capture.js

@@ -0,0 +1,282 @@
+import * as fs from 'node:fs';
+import { resolveInstagramRuntimeInfo } from './runtime-info.js';
+const DEFAULT_CAPTURE_VAR = '__opencli_ig_protocol_capture';
+const DEFAULT_CAPTURE_ERRORS_VAR = '__opencli_ig_protocol_capture_errors';
+const TRACE_OUTPUT_PATH = '/tmp/instagram_post_protocol_trace.json';
+const INSTAGRAM_PROTOCOL_CAPTURE_PATTERN = [
+    '/rupload_igphoto/',
+    '/rupload_igvideo/',
+    '/api/v1/',
+    '/media/configure/',
+    '/media/configure_sidecar/',
+    '/media/configure_to_story/',
+    '/api/graphql/',
+].join('|');
+export function buildInstallInstagramProtocolCaptureJs(captureVar = DEFAULT_CAPTURE_VAR, captureErrorsVar = DEFAULT_CAPTURE_ERRORS_VAR) {
+    return `
+    (() => {
+      const CAPTURE_VAR = ${JSON.stringify(captureVar)};
+      const CAPTURE_ERRORS_VAR = ${JSON.stringify(captureErrorsVar)};
+      const PATCH_GUARD = CAPTURE_VAR + '_patched';
+      const FILTERS = [
+        '/rupload_igphoto/',
+        '/rupload_igvideo/',
+        '/api/v1/',
+        '/media/configure/',
+        '/media/configure_sidecar/',
+        '/media/configure_to_story/',
+        '/api/graphql/',
+      ];
+
+      const shouldCapture = (url) => {
+        const value = String(url || '');
+        return FILTERS.some((filter) => value.includes(filter));
+      };
+
+      const normalizeHeaders = (headersLike) => {
+        const out = {};
+        try {
+          if (!headersLike) return out;
+          if (headersLike instanceof Headers) {
+            headersLike.forEach((value, key) => { out[key] = value; });
+            return out;
+          }
+          if (Array.isArray(headersLike)) {
+            for (const pair of headersLike) {
+              if (Array.isArray(pair) && pair.length >= 2) out[String(pair[0])] = String(pair[1]);
+            }
+            return out;
+          }
+          if (typeof headersLike === 'object') {
+            for (const [key, value] of Object.entries(headersLike)) out[key] = String(value);
+          }
+        } catch {}
+        return out;
+      };
+
+      const summarizeBody = async (body) => {
+        if (body == null) return { kind: 'empty', preview: '' };
+        try {
+          if (typeof body === 'string') {
+            return { kind: 'string', preview: body.slice(0, 1000) };
+          }
+          if (body instanceof URLSearchParams) {
+            return { kind: 'urlencoded', preview: body.toString().slice(0, 1000) };
+          }
+          if (body instanceof FormData) {
+            const parts = [];
+            for (const [key, value] of body.entries()) {
+              if (value instanceof File) {
+                parts.push(key + '=File(' + value.name + ',' + value.type + ',' + value.size + ')');
+              } else {
+                parts.push(key + '=' + String(value));
+              }
+            }
+            return { kind: 'formdata', preview: parts.join('&').slice(0, 2000) };
+          }
+          if (body instanceof Blob) {
+            return { kind: 'blob', preview: 'Blob(' + body.type + ',' + body.size + ')' };
+          }
+          if (body instanceof ArrayBuffer) {
+            return { kind: 'arraybuffer', preview: 'ArrayBuffer(' + body.byteLength + ')' };
+          }
+          if (ArrayBuffer.isView(body)) {
+            return { kind: 'typed-array', preview: body.constructor.name + '(' + body.byteLength + ')' };
+          }
+          return { kind: typeof body, preview: String(body).slice(0, 1000) };
+        } catch (error) {
+          return { kind: 'unknown', preview: 'body-preview-error:' + String(error) };
+        }
+      };
+
+      const capture = async (kind, url, method, headers, body, response) => {
+        if (!shouldCapture(url)) return;
+        try {
+          const bodyInfo = await summarizeBody(body);
+          const contentType = response?.headers?.get?.('content-type') || '';
+          let responsePreview = '';
+          try {
+            if (response && typeof response.clone === 'function') {
+              const clone = response.clone();
+              responsePreview = (await clone.text()).slice(0, 4000);
+            }
+          } catch (error) {
+            responsePreview = 'response-preview-error:' + String(error);
+          }
+          window[CAPTURE_VAR].push({
+            kind,
+            url: String(url || ''),
+            method: String(method || 'GET').toUpperCase(),
+            requestHeaders: normalizeHeaders(headers),
+            requestBodyKind: bodyInfo.kind,
+            requestBodyPreview: bodyInfo.preview,
+            responseStatus: response?.status,
+            responseContentType: contentType,
+            responsePreview,
+            timestamp: Date.now(),
+          });
+        } catch (error) {
+          window[CAPTURE_ERRORS_VAR].push(String(error));
+        }
+      };
+
+      if (!Array.isArray(window[CAPTURE_VAR])) window[CAPTURE_VAR] = [];
+      if (!Array.isArray(window[CAPTURE_ERRORS_VAR])) window[CAPTURE_ERRORS_VAR] = [];
+      if (window[PATCH_GUARD]) return { ok: true };
+
+      const origFetch = window.fetch;
+      window.fetch = async function(...args) {
+        const input = args[0];
+        const init = args[1] || {};
+        const url = typeof input === 'string'
+          ? input
+          : input instanceof Request
+            ? input.url
+            : String(input || '');
+        const method = init.method || (input instanceof Request ? input.method : 'GET');
+        const headers = init.headers || (input instanceof Request ? input.headers : undefined);
+        const body = init.body || (input instanceof Request ? input.body : undefined);
+        const response = await origFetch.apply(this, args);
+        capture('fetch', url, method, headers, body, response);
+        return response;
+      };
+
+      const origOpen = XMLHttpRequest.prototype.open;
+      const origSend = XMLHttpRequest.prototype.send;
+      const origSetRequestHeader = XMLHttpRequest.prototype.setRequestHeader;
+
+      XMLHttpRequest.prototype.open = function(method, url) {
+        this.__opencli_method = method;
+        this.__opencli_url = url;
+        this.__opencli_headers = {};
+        return origOpen.apply(this, arguments);
+      };
+      XMLHttpRequest.prototype.setRequestHeader = function(name, value) {
+        try {
+          this.__opencli_headers = this.__opencli_headers || {};
+          this.__opencli_headers[String(name)] = String(value);
+        } catch {}
+        return origSetRequestHeader.apply(this, arguments);
+      };
+      XMLHttpRequest.prototype.send = function(body) {
+        this.addEventListener('load', () => {
+          if (!shouldCapture(this.__opencli_url)) return;
+          try {
+            window[CAPTURE_VAR].push({
+              kind: 'xhr',
+              url: String(this.__opencli_url || ''),
+              method: String(this.__opencli_method || 'GET').toUpperCase(),
+              requestHeaders: this.__opencli_headers || {},
+              requestBodyKind: body == null ? 'empty' : (body instanceof FormData ? 'formdata' : typeof body),
+              requestBodyPreview: body == null ? '' : (body instanceof FormData ? '[formdata]' : String(body).slice(0, 2000)),
+              responseStatus: this.status,
+              responseContentType: this.getResponseHeader('content-type') || '',
+              responsePreview: String(this.responseText || '').slice(0, 4000),
+              timestamp: Date.now(),
+            });
+          } catch (error) {
+            window[CAPTURE_ERRORS_VAR].push(String(error));
+          }
+        });
+        return origSend.apply(this, arguments);
+      };
+
+      window[PATCH_GUARD] = true;
+      return { ok: true };
+    })()
+  `;
+}
+export function buildReadInstagramProtocolCaptureJs(captureVar = DEFAULT_CAPTURE_VAR, captureErrorsVar = DEFAULT_CAPTURE_ERRORS_VAR) {
+    return `
+    (() => {
+      const data = Array.isArray(window[${JSON.stringify(captureVar)}]) ? window[${JSON.stringify(captureVar)}] : [];
+      const errors = Array.isArray(window[${JSON.stringify(captureErrorsVar)}]) ? window[${JSON.stringify(captureErrorsVar)}] : [];
+      window[${JSON.stringify(captureVar)}] = [];
+      window[${JSON.stringify(captureErrorsVar)}] = [];
+      return { data, errors };
+    })()
+  `;
+}
+export async function installInstagramProtocolCapture(page) {
+    if (typeof page.startNetworkCapture === 'function') {
+        try {
+            await page.startNetworkCapture(INSTAGRAM_PROTOCOL_CAPTURE_PATTERN);
+            return;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (!message.includes('Unknown action') && !message.includes('network-capture')) {
+                throw error;
+            }
+        }
+    }
+    await page.evaluate(buildInstallInstagramProtocolCaptureJs());
+}
+export async function readInstagramProtocolCapture(page) {
+    if (typeof page.readNetworkCapture === 'function') {
+        try {
+            const data = await page.readNetworkCapture();
+            return {
+                data: Array.isArray(data) ? data : [],
+                errors: [],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (!message.includes('Unknown action') && !message.includes('network-capture')) {
+                throw error;
+            }
+        }
+    }
+    const result = await page.evaluate(buildReadInstagramProtocolCaptureJs());
+    return {
+        data: Array.isArray(result?.data) ? result.data : [],
+        errors: Array.isArray(result?.errors) ? result.errors : [],
+    };
+}
+export async function dumpInstagramProtocolCaptureIfEnabled(page) {
+    if (process.env.OPENCLI_INSTAGRAM_CAPTURE !== '1')
+        return;
+    const payload = await readInstagramProtocolCapture(page);
+    fs.writeFileSync(TRACE_OUTPUT_PATH, JSON.stringify(payload, null, 2));
+}
+function buildCookieHeader(cookies) {
+    return cookies
+        .filter((cookie) => cookie?.name && cookie?.value)
+        .map((cookie) => `${cookie.name}=${cookie.value}`)
+        .join('; ');
+}
+export async function instagramPrivateApiFetch(page, input, init = {}) {
+    const url = String(input);
+    const [urlCookies, domainCookies] = await Promise.all([
+        page.getCookies({ url }),
+        page.getCookies({ domain: 'instagram.com' }),
+    ]);
+    const merged = new Map();
+    for (const cookie of domainCookies)
+        merged.set(cookie.name, cookie);
+    for (const cookie of urlCookies)
+        merged.set(cookie.name, cookie);
+    const cookieHeader = buildCookieHeader(Array.from(merged.values()));
+    const csrf = merged.get('csrftoken')?.value || '';
+    const initHeaders = init.headers ?? {};
+    const requestedAppIdHeader = Object.entries(initHeaders).find(([key]) => key.toLowerCase() === 'x-ig-app-id')?.[1] || '';
+    const runtimeInfo = requestedAppIdHeader ? null : await resolveInstagramRuntimeInfo(page);
+    const appId = requestedAppIdHeader || runtimeInfo?.appId || '';
+    const hasContentType = Object.keys(init.headers ?? {}).some((key) => key.toLowerCase() === 'content-type');
+    return fetch(url, {
+        method: init.method ?? 'GET',
+        headers: {
+            'Accept': 'application/json, text/plain, */*',
+            'X-CSRFToken': csrf,
+            'X-Requested-With': 'XMLHttpRequest',
+            'Origin': 'https://www.instagram.com',
+            'Referer': 'https://www.instagram.com/',
+            ...(appId ? { 'X-IG-App-ID': appId } : {}),
+            ...(cookieHeader ? { 'Cookie': cookieHeader } : {}),
+            ...(typeof init.body === 'string' && !hasContentType ? { 'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8' } : {}),
+            ...initHeaders,
+        },
+        ...(init.body !== undefined ? { body: init.body } : {}),
+    });
+}

package/vendor/opencli/dist/clis/instagram/_shared/protocol-capture.test.d.ts

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

package/vendor/opencli/dist/clis/instagram/_shared/protocol-capture.test.js

@@ -0,0 +1,114 @@
+import * as fs from 'node:fs';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { buildInstallInstagramProtocolCaptureJs, buildReadInstagramProtocolCaptureJs, dumpInstagramProtocolCaptureIfEnabled, instagramPrivateApiFetch, installInstagramProtocolCapture, readInstagramProtocolCapture, } from './protocol-capture.js';
+describe('instagram protocol capture helpers', () => {
+    afterEach(() => {
+        vi.restoreAllMocks();
+        delete process.env.OPENCLI_INSTAGRAM_CAPTURE;
+        try {
+            fs.rmSync('/tmp/instagram_post_protocol_trace.json', { force: true });
+        }
+        catch { }
+    });
+    it('installs the protocol capture patch in page context', async () => {
+        const evaluate = vi.fn().mockResolvedValue({ ok: true });
+        const page = { evaluate };
+        await installInstagramProtocolCapture(page);
+        expect(evaluate).toHaveBeenCalledTimes(1);
+        expect(String(evaluate.mock.calls[0]?.[0] || '')).toContain('__opencli_ig_protocol_capture');
+        expect(String(evaluate.mock.calls[0]?.[0] || '')).toContain('/media/configure_sidecar/');
+    });
+    it('prefers native page network capture when available', async () => {
+        const startNetworkCapture = vi.fn().mockResolvedValue(undefined);
+        const evaluate = vi.fn();
+        const page = { startNetworkCapture, evaluate };
+        await installInstagramProtocolCapture(page);
+        expect(startNetworkCapture).toHaveBeenCalledTimes(1);
+        expect(evaluate).not.toHaveBeenCalled();
+    });
+    it('reads and normalizes captured protocol entries', async () => {
+        const evaluate = vi.fn().mockResolvedValue({
+            data: [{ kind: 'fetch', url: 'https://www.instagram.com/api/v1/media/configure/' }],
+            errors: ['ignored'],
+        });
+        const page = { evaluate };
+        const result = await readInstagramProtocolCapture(page);
+        expect(String(evaluate.mock.calls[0]?.[0] || '')).toContain('__opencli_ig_protocol_capture');
+        expect(result).toEqual({
+            data: [{ kind: 'fetch', url: 'https://www.instagram.com/api/v1/media/configure/' }],
+            errors: ['ignored'],
+        });
+    });
+    it('prefers native page network capture reads when available', async () => {
+        const readNetworkCapture = vi.fn().mockResolvedValue([
+            { kind: 'cdp', url: 'https://www.instagram.com/rupload_igphoto/test', method: 'POST' },
+        ]);
+        const evaluate = vi.fn();
+        const page = { readNetworkCapture, evaluate };
+        const result = await readInstagramProtocolCapture(page);
+        expect(readNetworkCapture).toHaveBeenCalledTimes(1);
+        expect(evaluate).not.toHaveBeenCalled();
+        expect(result).toEqual({
+            data: [{ kind: 'cdp', url: 'https://www.instagram.com/rupload_igphoto/test', method: 'POST' }],
+            errors: [],
+        });
+    });
+    it('dumps protocol traces to /tmp only when capture env is enabled', async () => {
+        process.env.OPENCLI_INSTAGRAM_CAPTURE = '1';
+        const page = {
+            evaluate: vi.fn().mockResolvedValue({
+                data: [{ kind: 'fetch', url: 'https://www.instagram.com/rupload_igphoto/test' }],
+                errors: [],
+            }),
+        };
+        await dumpInstagramProtocolCaptureIfEnabled(page);
+        const raw = fs.readFileSync('/tmp/instagram_post_protocol_trace.json', 'utf8');
+        expect(raw).toContain('rupload_igphoto');
+    });
+    it('does not dump protocol traces when capture env is disabled', async () => {
+        const page = {
+            evaluate: vi.fn(),
+        };
+        await dumpInstagramProtocolCaptureIfEnabled(page);
+        expect(page.evaluate).not.toHaveBeenCalled();
+        expect(fs.existsSync('/tmp/instagram_post_protocol_trace.json')).toBe(false);
+    });
+});
+describe('instagram private api fetch', () => {
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('uses browser cookies to build instagram private api requests', async () => {
+        const getCookies = vi.fn()
+            .mockResolvedValueOnce([{ name: 'sessionid', value: 'sess', domain: '.instagram.com' }])
+            .mockResolvedValueOnce([
+            { name: 'csrftoken', value: 'csrf', domain: '.instagram.com' },
+            { name: 'sessionid', value: 'sess', domain: '.instagram.com' },
+        ]);
+        const evaluate = vi.fn().mockResolvedValue({
+            appId: 'dynamic-app-id',
+            csrfToken: 'csrf',
+            instagramAjax: 'dynamic-rollout',
+        });
+        const page = { getCookies, evaluate };
+        const fetchMock = vi.fn().mockResolvedValue(new Response('{}', { status: 200 }));
+        vi.stubGlobal('fetch', fetchMock);
+        await instagramPrivateApiFetch(page, 'https://www.instagram.com/api/v1/media/configure/', {
+            method: 'POST',
+            body: 'caption=test',
+        });
+        expect(fetchMock).toHaveBeenCalledWith('https://www.instagram.com/api/v1/media/configure/', expect.objectContaining({
+            method: 'POST',
+            headers: expect.objectContaining({
+                'X-CSRFToken': 'csrf',
+                'X-IG-App-ID': 'dynamic-app-id',
+                'Cookie': expect.stringContaining('sessionid=sess'),
+            }),
+            body: 'caption=test',
+        }));
+    });
+    it('exposes stable browser-side JS builders', () => {
+        expect(buildInstallInstagramProtocolCaptureJs()).toContain('/rupload_igphoto/');
+        expect(buildReadInstagramProtocolCaptureJs()).toContain('__opencli_ig_protocol_capture');
+    });
+});

package/vendor/opencli/dist/clis/instagram/_shared/runtime-info.d.ts

@@ -0,0 +1,9 @@
+import type { IPage } from '../../../types.js';
+export interface InstagramRuntimeInfo {
+    appId: string;
+    csrfToken: string;
+    instagramAjax: string;
+}
+export declare function extractInstagramRuntimeInfo(html: string): InstagramRuntimeInfo;
+export declare function buildReadInstagramRuntimeInfoJs(): string;
+export declare function resolveInstagramRuntimeInfo(page: IPage): Promise<InstagramRuntimeInfo>;

package/vendor/opencli/dist/clis/instagram/_shared/runtime-info.js

@@ -0,0 +1,81 @@
+function pickMatch(input, patterns) {
+    for (const pattern of patterns) {
+        const match = input.match(pattern);
+        if (!match)
+            continue;
+        for (let index = 1; index < match.length; index += 1) {
+            if (match[index])
+                return match[index];
+        }
+        return match[0] || '';
+    }
+    return '';
+}
+export function extractInstagramRuntimeInfo(html) {
+    return {
+        appId: pickMatch(html, [
+            /"X-IG-App-ID":"(\d+)"/,
+            /"appId":"(\d+)"/,
+            /"app_id":"(\d+)"/,
+            /"instagramWebAppId":"(\d+)"/,
+        ]),
+        csrfToken: pickMatch(html, [
+            /"csrf_token":"([^"]+)"/,
+            /"csrfToken":"([^"]+)"/,
+        ]),
+        instagramAjax: pickMatch(html, [
+            /"rollout_hash":"([^"]+)"/,
+            /"X-Instagram-AJAX":"([^"]+)"/,
+            /"Instagram-AJAX":"([^"]+)"/,
+        ]),
+    };
+}
+export function buildReadInstagramRuntimeInfoJs() {
+    return `
+    (() => {
+      const html = document.documentElement?.outerHTML || '';
+      const pick = (patterns) => {
+        for (const pattern of patterns) {
+          const match = html.match(new RegExp(pattern, 'i'));
+          if (!match) continue;
+          for (let index = 1; index < match.length; index += 1) {
+            if (match[index]) return match[index];
+          }
+          return match[0] || '';
+        }
+        return '';
+      };
+      return {
+        appId: pick([
+          '"X-IG-App-ID":"(\\\\d+)"',
+          '"appId":"(\\\\d+)"',
+          '"app_id":"(\\\\d+)"',
+          '"instagramWebAppId":"(\\\\d+)"',
+        ]),
+        csrfToken: pick([
+          '"csrf_token":"([^"]+)"',
+          '"csrfToken":"([^"]+)"',
+        ]),
+        instagramAjax: pick([
+          '"rollout_hash":"([^"]+)"',
+          '"X-Instagram-AJAX":"([^"]+)"',
+          '"Instagram-AJAX":"([^"]+)"',
+        ]),
+      };
+    })()
+  `;
+}
+function getCookieValue(cookies, name) {
+    return cookies.find((cookie) => cookie.name === name)?.value || '';
+}
+export async function resolveInstagramRuntimeInfo(page) {
+    const [runtime, cookies] = await Promise.all([
+        page.evaluate(buildReadInstagramRuntimeInfoJs()),
+        page.getCookies({ domain: 'instagram.com' }),
+    ]);
+    return {
+        appId: runtime?.appId || '',
+        csrfToken: runtime?.csrfToken || getCookieValue(cookies, 'csrftoken') || '',
+        instagramAjax: runtime?.instagramAjax || '',
+    };
+}

package/vendor/opencli/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/vendor/opencli/dist/clis/instagram/download.d.ts

@@ -0,0 +1,16 @@
+export interface InstagramMediaTarget {
+    kind: 'p' | 'reel' | 'tv';
+    shortcode: string;
+    canonicalUrl: string;
+}
+interface InstagramPageMediaItem {
+    type: 'image' | 'video';
+    url: string;
+}
+interface DownloadedMediaItem extends InstagramPageMediaItem {
+    filename: string;
+}
+export declare function parseInstagramMediaTarget(input: string): InstagramMediaTarget;
+export declare function buildInstagramDownloadItems(shortcode: string, items: InstagramPageMediaItem[]): DownloadedMediaItem[];
+export declare function buildInstagramFetchScript(shortcode: string): string;
+export {};