@huyuan-ai/cli 1.0.0 → 1.0.1

package/vendor/opencli/dist/clis/instagram/reel.test.d.ts

@@ -0,0 +1 @@
+import './reel.js';

package/vendor/opencli/dist/clis/instagram/reel.test.js

@@ -0,0 +1,167 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { afterAll, afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { ArgumentError } from '../../errors.js';
+import { getRegistry } from '../../registry.js';
+import './reel.js';
+const tempDirs = [];
+function createTempVideo(name = 'demo.mp4', bytes = Buffer.from('video')) {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-instagram-reel-'));
+    tempDirs.push(dir);
+    const filePath = path.join(dir, name);
+    fs.writeFileSync(filePath, bytes);
+    return filePath;
+}
+function createPageMock(evaluateResults, overrides = {}) {
+    const evaluate = vi.fn();
+    for (const result of evaluateResults) {
+        evaluate.mockResolvedValueOnce(result);
+    }
+    return {
+        goto: vi.fn().mockResolvedValue(undefined),
+        evaluate,
+        getCookies: vi.fn().mockResolvedValue([]),
+        snapshot: vi.fn().mockResolvedValue(undefined),
+        click: vi.fn().mockResolvedValue(undefined),
+        typeText: vi.fn().mockResolvedValue(undefined),
+        pressKey: vi.fn().mockResolvedValue(undefined),
+        scrollTo: vi.fn().mockResolvedValue(undefined),
+        getFormState: vi.fn().mockResolvedValue({ forms: [], orphanFields: [] }),
+        wait: vi.fn().mockResolvedValue(undefined),
+        tabs: vi.fn().mockResolvedValue([]),
+        closeTab: vi.fn().mockResolvedValue(undefined),
+        newTab: vi.fn().mockResolvedValue(undefined),
+        selectTab: vi.fn().mockResolvedValue(undefined),
+        networkRequests: vi.fn().mockResolvedValue([]),
+        consoleMessages: vi.fn().mockResolvedValue([]),
+        scroll: vi.fn().mockResolvedValue(undefined),
+        autoScroll: vi.fn().mockResolvedValue(undefined),
+        installInterceptor: vi.fn().mockResolvedValue(undefined),
+        getInterceptedRequests: vi.fn().mockResolvedValue([]),
+        waitForCapture: vi.fn().mockResolvedValue(undefined),
+        screenshot: vi.fn().mockResolvedValue(''),
+        setFileInput: vi.fn().mockResolvedValue(undefined),
+        insertText: vi.fn().mockResolvedValue(undefined),
+        getCurrentUrl: vi.fn().mockResolvedValue(null),
+        ...overrides,
+    };
+}
+afterAll(() => {
+    for (const dir of tempDirs) {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+});
+describe('instagram reel registration', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('registers the reel command with a required-value video arg', () => {
+        const cmd = getRegistry().get('instagram/reel');
+        expect(cmd).toBeDefined();
+        expect(cmd?.browser).toBe(true);
+        expect(cmd?.args.some((arg) => arg.name === 'video' && !arg.required && arg.valueRequired)).toBe(true);
+        expect(cmd?.args.some((arg) => arg.name === 'content' && arg.positional && !arg.required)).toBe(true);
+    });
+    it('rejects missing --video before browser work', async () => {
+        const page = createPageMock([]);
+        const cmd = getRegistry().get('instagram/reel');
+        await expect(cmd.func(page, { content: 'hello reel' })).rejects.toThrow(ArgumentError);
+        expect(page.goto).not.toHaveBeenCalled();
+    });
+    it('rejects unsupported video formats', async () => {
+        const videoPath = createTempVideo('demo.mov');
+        const page = createPageMock([]);
+        const cmd = getRegistry().get('instagram/reel');
+        await expect(cmd.func(page, { video: videoPath })).rejects.toThrow('Unsupported video format');
+        expect(page.goto).not.toHaveBeenCalled();
+    });
+    it('uploads a reel video without caption and shares it', async () => {
+        const videoPath = createTempVideo();
+        const page = createPageMock([
+            { ok: false }, // dismiss residual dialogs
+            { ok: true }, // ensure composer open
+            { ok: true }, // composer upload input ready
+            { ok: true, selectors: ['[data-opencli-reel-upload-index="0"]', '[data-opencli-reel-upload-index="1"]'] }, // resolve upload selector
+            { count: 1 }, // file bound to input
+            { state: 'preview', detail: 'Crop Back Next' }, // preview detected
+            { ok: true, label: 'OK' }, // dismiss reels nux
+            { ok: true, label: 'Next' }, // move from crop to edit
+            { state: 'edit' }, // edit stage
+            { ok: true, label: 'Next' }, // move from edit to composer
+            { state: 'composer' }, // composer stage
+            { ok: true, label: 'Share' }, // share
+            { ok: true, url: 'https://www.instagram.com/reel/REEL123/' }, // success
+        ]);
+        const cmd = getRegistry().get('instagram/reel');
+        const result = await cmd.func(page, { video: videoPath });
+        expect(page.setFileInput).toHaveBeenCalledWith([videoPath], '[data-opencli-reel-upload-index="0"]');
+        expect(page.insertText).not.toHaveBeenCalled();
+        expect(result).toEqual([
+            {
+                status: '✅ Posted',
+                detail: 'Single reel shared successfully',
+                url: 'https://www.instagram.com/reel/REEL123/',
+            },
+        ]);
+    });
+    it('copies query-style local video filenames to a safe temp upload path before setFileInput', async () => {
+        const videoPath = createTempVideo('demo.mp4?sign=abc&t=123video.MP4');
+        const page = createPageMock([
+            { ok: false },
+            { ok: true },
+            { ok: true },
+            { ok: true, selectors: ['[data-opencli-reel-upload-index="0"]'] },
+            { count: 1 },
+            { state: 'preview', detail: 'Crop Back Next' },
+            { ok: true, label: 'OK' },
+            { ok: true, label: 'Next' },
+            { state: 'edit' },
+            { ok: true, label: 'Next' },
+            { state: 'composer' },
+            { ok: true, label: 'Share' },
+            { ok: true, url: 'https://www.instagram.com/reel/REELSAFE123/' },
+        ]);
+        const cmd = getRegistry().get('instagram/reel');
+        await cmd.func(page, { video: videoPath });
+        const uploadPaths = page.setFileInput.mock.calls[0]?.[0] ?? [];
+        expect(uploadPaths).toHaveLength(1);
+        expect(uploadPaths[0]).not.toBe(videoPath);
+        expect(String(uploadPaths[0])).toContain('opencli-instagram-video-real');
+        expect(String(uploadPaths[0]).toLowerCase()).toContain('.mp4');
+    });
+    it('uploads a reel video with caption and shares it', async () => {
+        const videoPath = createTempVideo('captioned.mp4');
+        const page = createPageMock([
+            { ok: false }, // dismiss residual dialogs
+            { ok: true }, // ensure composer open
+            { ok: true }, // composer upload input ready
+            { ok: true, selectors: ['[data-opencli-reel-upload-index="0"]'] }, // resolve upload selector
+            { count: 1 }, // file bound to input
+            { state: 'preview', detail: 'Crop Back Next' }, // preview detected
+            { ok: true, label: 'OK' }, // dismiss reels nux
+            { ok: true, label: 'Next' }, // move from crop to edit
+            { state: 'edit' }, // edit stage
+            { ok: true, label: 'Next' }, // move from edit to composer
+            { state: 'composer' }, // composer stage
+            { ok: true }, // focus caption editor
+            { ok: true }, // post-insert event dispatch
+            { ok: true }, // caption matches
+            { ok: true, label: 'Share' }, // share
+            { ok: true, url: 'https://www.instagram.com/reel/REEL456/' }, // success
+        ]);
+        const cmd = getRegistry().get('instagram/reel');
+        const result = await cmd.func(page, { video: videoPath, content: 'hello reel' });
+        expect(page.insertText).toHaveBeenCalledWith('hello reel');
+        expect(result).toEqual([
+            {
+                status: '✅ Posted',
+                detail: 'Single reel shared successfully',
+                url: 'https://www.instagram.com/reel/REEL456/',
+            },
+        ]);
+    });
+});

package/vendor/opencli/dist/clis/instagram/save.yaml

@@ -0,0 +1,46 @@
+site: instagram
+name: save
+description: Save (bookmark) 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');
+        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/save/' + pk + '/save/', {
+          method: 'POST', credentials: 'include',
+          headers: { ...headers, 'X-CSRFToken': csrf, 'Content-Type': 'application/x-www-form-urlencoded' },
+        });
+        if (!r3.ok) throw new Error('Failed to save: HTTP ' + r3.status);
+        return [{ status: 'Saved', user: username, post: caption || '(post #' + (idx+1) + ')' }];
+      })()
+
+columns: [status, user, post]

package/vendor/opencli/dist/clis/instagram/saved.yaml

@@ -0,0 +1,40 @@
+site: instagram
+name: saved
+description: Get your saved Instagram posts
+domain: www.instagram.com
+
+args:
+  limit:
+    type: int
+    default: 20
+    description: Number of saved posts
+
+pipeline:
+  - navigate: https://www.instagram.com
+
+  - evaluate: |
+      (async () => {
+        const limit = ${{ args.limit }};
+        const res = await fetch(
+          'https://www.instagram.com/api/v1/feed/saved/posts/',
+          {
+            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();
+        return (data?.items || []).slice(0, limit).map((item, i) => {
+          const m = item?.media;
+          return {
+            index: i + 1,
+            user: m?.user?.username || '',
+            caption: (m?.caption?.text || '').replace(/\n/g, ' ').substring(0, 100),
+            likes: m?.like_count ?? 0,
+            comments: m?.comment_count ?? 0,
+            type: m?.media_type === 1 ? 'photo' : m?.media_type === 2 ? 'video' : 'carousel',
+          };
+        });
+      })()
+
+columns: [index, user, caption, likes, comments, type]

package/vendor/opencli/dist/clis/instagram/search.yaml

@@ -0,0 +1,44 @@
+site: instagram
+name: search
+description: Search Instagram users
+domain: www.instagram.com
+
+args:
+  query:
+    type: str
+    required: true
+    positional: true
+    description: Search query
+  limit:
+    type: int
+    default: 10
+    description: Number of results
+
+pipeline:
+  - navigate: https://www.instagram.com
+
+  - evaluate: |
+      (async () => {
+        const query = ${{ args.query | json }};
+        const limit = ${{ args.limit }};
+        const res = await fetch(
+          'https://www.instagram.com/web/search/topsearch/?query=' + encodeURIComponent(query) + '&context=user',
+          {
+            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 users = (data?.users || []).slice(0, limit);
+        return users.map((item, i) => ({
+          rank: i + 1,
+          username: item.user?.username || '',
+          name: item.user?.full_name || '',
+          verified: item.user?.is_verified ? 'Yes' : 'No',
+          private: item.user?.is_private ? 'Yes' : 'No',
+          url: 'https://www.instagram.com/' + (item.user?.username || ''),
+        }));
+      })()
+
+columns: [rank, username, name, verified, private, url]

package/vendor/opencli/dist/clis/instagram/story.d.ts

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

package/vendor/opencli/dist/clis/instagram/story.js

@@ -0,0 +1,115 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { ArgumentError, CommandExecutionError } from '../../errors.js';
+import { cli, Strategy } from '../../registry.js';
+import { publishStoryViaPrivateApi, resolveInstagramPrivatePublishConfig, } from './_shared/private-publish.js';
+import { resolveInstagramRuntimeInfo } from './_shared/runtime-info.js';
+const INSTAGRAM_HOME_URL = 'https://www.instagram.com/';
+const SUPPORTED_STORY_IMAGE_EXTENSIONS = new Set(['.jpg', '.jpeg', '.png', '.webp']);
+const SUPPORTED_STORY_VIDEO_EXTENSIONS = new Set(['.mp4']);
+function requirePage(page) {
+    if (!page)
+        throw new CommandExecutionError('Browser session required for instagram story');
+    return page;
+}
+function validateInstagramStoryArgs(kwargs) {
+    if (kwargs.media === undefined) {
+        throw new ArgumentError('Argument "media" is required.', 'Provide --media /path/to/file.jpg or --media /path/to/file.mp4');
+    }
+}
+function normalizeStoryMediaItem(kwargs) {
+    const raw = String(kwargs.media ?? '').trim();
+    const parts = raw.split(',').map((part) => part.trim()).filter(Boolean);
+    if (parts.length === 0) {
+        throw new ArgumentError('Argument "media" is required.', 'Provide --media /path/to/file.jpg or --media /path/to/file.mp4');
+    }
+    if (parts.length > 1) {
+        throw new ArgumentError('Instagram story currently supports a single media item.', 'Provide one image or one video path with --media');
+    }
+    const resolved = path.resolve(parts[0]);
+    if (!fs.existsSync(resolved)) {
+        throw new ArgumentError(`Story media file not found: ${resolved}`);
+    }
+    const ext = path.extname(resolved).toLowerCase();
+    if (SUPPORTED_STORY_IMAGE_EXTENSIONS.has(ext)) {
+        return { type: 'image', filePath: resolved };
+    }
+    if (SUPPORTED_STORY_VIDEO_EXTENSIONS.has(ext)) {
+        return { type: 'video', filePath: resolved };
+    }
+    throw new ArgumentError(`Unsupported story media format: ${ext}`, 'Supported formats: images (.jpg, .jpeg, .png, .webp) and videos (.mp4)');
+}
+async function resolveCurrentUserId(page) {
+    const cookies = await page.getCookies({ domain: 'instagram.com' });
+    return cookies.find((cookie) => cookie.name === 'ds_user_id')?.value || '';
+}
+async function resolveCurrentUsername(page, currentUserId = '') {
+    if (!currentUserId)
+        return '';
+    const runtimeInfo = await resolveInstagramRuntimeInfo(page);
+    const apiResult = await page.evaluate(`
+    (async () => {
+      const userId = ${JSON.stringify(currentUserId)};
+      const appId = ${JSON.stringify(runtimeInfo.appId || '')};
+      try {
+        const res = await fetch(
+          'https://www.instagram.com/api/v1/users/' + encodeURIComponent(userId) + '/info/',
+          {
+            credentials: 'include',
+            headers: appId ? { 'X-IG-App-ID': appId } : {},
+          },
+        );
+        if (!res.ok) return { ok: false };
+        const data = await res.json();
+        const username = data?.user?.username || '';
+        return { ok: !!username, username };
+      } catch {
+        return { ok: false };
+      }
+    })()
+  `);
+    return apiResult?.ok && apiResult.username ? apiResult.username : '';
+}
+function buildStorySuccessResult(mediaItem, url) {
+    return [{
+            status: '✅ Posted',
+            detail: mediaItem.type === 'video'
+                ? 'Single video story shared successfully'
+                : 'Single story shared successfully',
+            url,
+        }];
+}
+cli({
+    site: 'instagram',
+    name: 'story',
+    description: 'Post a single Instagram story image or video',
+    domain: 'www.instagram.com',
+    strategy: Strategy.UI,
+    browser: true,
+    timeoutSeconds: 300,
+    args: [
+        { name: 'media', required: false, valueRequired: true, help: 'Path to a single story image or video file' },
+    ],
+    columns: ['status', 'detail', 'url'],
+    validateArgs: validateInstagramStoryArgs,
+    func: async (page, kwargs) => {
+        const browserPage = requirePage(page);
+        const mediaItem = normalizeStoryMediaItem(kwargs);
+        const currentUserId = await resolveCurrentUserId(browserPage);
+        const privateConfig = await resolveInstagramPrivatePublishConfig(browserPage);
+        const storyResult = await publishStoryViaPrivateApi({
+            page: browserPage,
+            mediaItem,
+            content: '',
+            apiContext: privateConfig.apiContext,
+            jazoest: privateConfig.jazoest,
+            currentUserId,
+        });
+        const username = await resolveCurrentUsername(browserPage, currentUserId);
+        const mediaPk = storyResult.mediaPk || storyResult.uploadId;
+        const url = username && mediaPk
+            ? new URL(`/stories/${username}/${mediaPk}/`, INSTAGRAM_HOME_URL).toString()
+            : '';
+        return buildStorySuccessResult(mediaItem, url);
+    },
+});

package/vendor/opencli/dist/clis/instagram/story.test.d.ts

@@ -0,0 +1 @@
+import './story.js';

package/vendor/opencli/dist/clis/instagram/story.test.js

@@ -0,0 +1,167 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { afterAll, afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { ArgumentError } from '../../errors.js';
+import { getRegistry } from '../../registry.js';
+import * as privatePublish from './_shared/private-publish.js';
+import './story.js';
+const tempDirs = [];
+function createTempFile(name, bytes = Buffer.from('story-media')) {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-instagram-story-'));
+    tempDirs.push(dir);
+    const filePath = path.join(dir, name);
+    fs.writeFileSync(filePath, bytes);
+    return filePath;
+}
+function createPageMock(evaluateResults = [], overrides = {}) {
+    const evaluate = vi.fn();
+    for (const result of evaluateResults) {
+        evaluate.mockResolvedValueOnce(result);
+    }
+    return {
+        goto: vi.fn().mockResolvedValue(undefined),
+        evaluate,
+        getCookies: vi.fn().mockResolvedValue([]),
+        snapshot: vi.fn().mockResolvedValue(undefined),
+        click: vi.fn().mockResolvedValue(undefined),
+        typeText: vi.fn().mockResolvedValue(undefined),
+        pressKey: vi.fn().mockResolvedValue(undefined),
+        scrollTo: vi.fn().mockResolvedValue(undefined),
+        getFormState: vi.fn().mockResolvedValue({ forms: [], orphanFields: [] }),
+        wait: vi.fn().mockResolvedValue(undefined),
+        tabs: vi.fn().mockResolvedValue([]),
+        closeTab: vi.fn().mockResolvedValue(undefined),
+        newTab: vi.fn().mockResolvedValue(undefined),
+        selectTab: vi.fn().mockResolvedValue(undefined),
+        networkRequests: vi.fn().mockResolvedValue([]),
+        consoleMessages: vi.fn().mockResolvedValue([]),
+        scroll: vi.fn().mockResolvedValue(undefined),
+        autoScroll: vi.fn().mockResolvedValue(undefined),
+        installInterceptor: vi.fn().mockResolvedValue(undefined),
+        getInterceptedRequests: vi.fn().mockResolvedValue([]),
+        waitForCapture: vi.fn().mockResolvedValue(undefined),
+        screenshot: vi.fn().mockResolvedValue(''),
+        setFileInput: vi.fn().mockResolvedValue(undefined),
+        insertText: vi.fn().mockResolvedValue(undefined),
+        getCurrentUrl: vi.fn().mockResolvedValue(null),
+        ...overrides,
+    };
+}
+afterAll(() => {
+    for (const dir of tempDirs) {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+});
+describe('instagram story registration', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('registers the story command with a required-value media arg', () => {
+        const cmd = getRegistry().get('instagram/story');
+        expect(cmd).toBeDefined();
+        expect(cmd?.browser).toBe(true);
+        expect(cmd?.args.some((arg) => arg.name === 'media' && !arg.required && arg.valueRequired)).toBe(true);
+        expect(cmd?.args.some((arg) => arg.name === 'content')).toBe(false);
+    });
+    it('rejects missing --media before browser work', async () => {
+        const page = createPageMock();
+        const cmd = getRegistry().get('instagram/story');
+        await expect(cmd.func(page, {})).rejects.toThrow(ArgumentError);
+        expect(page.goto).not.toHaveBeenCalled();
+    });
+    it('rejects multiple media inputs for a single story', async () => {
+        const first = createTempFile('one.jpg');
+        const second = createTempFile('two.mp4');
+        const page = createPageMock();
+        const cmd = getRegistry().get('instagram/story');
+        await expect(cmd.func(page, { media: `${first},${second}` })).rejects.toThrow('single media');
+        expect(page.goto).not.toHaveBeenCalled();
+    });
+    it('rejects unsupported story formats', async () => {
+        const filePath = createTempFile('story.mov');
+        const page = createPageMock();
+        const cmd = getRegistry().get('instagram/story');
+        await expect(cmd.func(page, { media: filePath })).rejects.toThrow('Unsupported story media format');
+        expect(page.goto).not.toHaveBeenCalled();
+    });
+    it('publishes a single image story through the private route', async () => {
+        const imagePath = createTempFile('story.jpg');
+        const page = createPageMock([
+            { appId: '936619743392459', csrfToken: '', instagramAjax: 'ajax' },
+            { ok: true, username: 'tsezi_ray' },
+        ], {
+            getCookies: vi.fn().mockResolvedValue([{ name: 'ds_user_id', value: '123', domain: 'instagram.com' }]),
+        });
+        const cmd = getRegistry().get('instagram/story');
+        vi.spyOn(privatePublish, 'resolveInstagramPrivatePublishConfig').mockResolvedValue({
+            apiContext: {
+                asbdId: '359341',
+                csrfToken: 'csrf-token',
+                igAppId: '936619743392459',
+                igWwwClaim: 'claim',
+                instagramAjax: 'ajax',
+                webSessionId: 'session',
+            },
+            jazoest: '22047',
+        });
+        vi.spyOn(privatePublish, 'publishStoryViaPrivateApi').mockResolvedValue({
+            mediaPk: '1234567890',
+            uploadId: '1234567890',
+        });
+        const result = await cmd.func(page, { media: imagePath });
+        expect(privatePublish.publishStoryViaPrivateApi).toHaveBeenCalledWith(expect.objectContaining({
+            page,
+            mediaItem: { type: 'image', filePath: imagePath },
+            content: '',
+        }));
+        expect(result).toEqual([
+            {
+                status: '✅ Posted',
+                detail: 'Single story shared successfully',
+                url: 'https://www.instagram.com/stories/tsezi_ray/1234567890/',
+            },
+        ]);
+    });
+    it('publishes a single video story through the private route', async () => {
+        const videoPath = createTempFile('story.mp4');
+        const page = createPageMock([
+            { appId: '936619743392459', csrfToken: '', instagramAjax: 'ajax' },
+            { ok: true, username: 'tsezi_ray' },
+        ], {
+            getCookies: vi.fn().mockResolvedValue([{ name: 'ds_user_id', value: '123', domain: 'instagram.com' }]),
+        });
+        const cmd = getRegistry().get('instagram/story');
+        vi.spyOn(privatePublish, 'resolveInstagramPrivatePublishConfig').mockResolvedValue({
+            apiContext: {
+                asbdId: '359341',
+                csrfToken: 'csrf-token',
+                igAppId: '936619743392459',
+                igWwwClaim: 'claim',
+                instagramAjax: 'ajax',
+                webSessionId: 'session',
+            },
+            jazoest: '22047',
+        });
+        vi.spyOn(privatePublish, 'publishStoryViaPrivateApi').mockResolvedValue({
+            mediaPk: '9988776655',
+            uploadId: '9988776655',
+        });
+        const result = await cmd.func(page, { media: videoPath });
+        expect(privatePublish.publishStoryViaPrivateApi).toHaveBeenCalledWith(expect.objectContaining({
+            page,
+            mediaItem: { type: 'video', filePath: videoPath },
+            content: '',
+        }));
+        expect(result).toEqual([
+            {
+                status: '✅ Posted',
+                detail: 'Single video story shared successfully',
+                url: 'https://www.instagram.com/stories/tsezi_ray/9988776655/',
+            },
+        ]);
+    });
+});

package/vendor/opencli/dist/clis/instagram/unfollow.yaml

@@ -0,0 +1,38 @@
+site: instagram
+name: unfollow
+description: Unfollow an Instagram user
+domain: www.instagram.com
+
+args:
+  username:
+    type: str
+    required: true
+    positional: true
+    description: Instagram username to unfollow
+
+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 };
+
+        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/destroy/' + 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 unfollow: HTTP ' + r2.status);
+        return [{ status: 'Unfollowed', username }];
+      })()
+
+columns: [status, username]