publishport-opencli 1.8.4-pp.1

package/clis/instagram/post.js

@@ -0,0 +1,1497 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { installInstagramProtocolCapture, readInstagramProtocolCapture, } from './_shared/protocol-capture.js';
+import { publishMediaViaPrivateApi, publishImagesViaPrivateApi, resolveInstagramPrivatePublishConfig, } from './_shared/private-publish.js';
+import { resolveInstagramRuntimeInfo } from './_shared/runtime-info.js';
+const INSTAGRAM_HOME_URL = 'https://www.instagram.com/';
+const SUPPORTED_IMAGE_EXTENSIONS = new Set(['.jpg', '.jpeg', '.png', '.webp']);
+const SUPPORTED_VIDEO_EXTENSIONS = new Set(['.mp4']);
+const MAX_MEDIA_ITEMS = 10;
+const INSTAGRAM_PROTOCOL_TRACE_OUTPUT_PATH = '/tmp/instagram_post_protocol_trace.json';
+async function gotoInstagramHome(page, forceReload = false) {
+    if (forceReload) {
+        await page.goto(`${INSTAGRAM_HOME_URL}?__opencli_reset=${Date.now()}`);
+        await page.wait({ time: 1 });
+    }
+    await page.goto(INSTAGRAM_HOME_URL);
+}
+export function buildEnsureComposerOpenJs() {
+    return `
+    (() => {
+      const path = window.location?.pathname || '';
+      const onLoginRoute = /\\/accounts\\/login\\/?/.test(path);
+      const hasLoginField = !!document.querySelector('input[name="username"], input[name="password"]');
+      const hasLoginButton = Array.from(document.querySelectorAll('button, div[role="button"]')).some((el) => {
+        const text = (el.textContent || '').replace(/\\s+/g, ' ').trim().toLowerCase();
+        return text === 'log in' || text === 'login' || text === '登录';
+      });
+
+      if (onLoginRoute || (hasLoginField && hasLoginButton)) {
+        return { ok: false, reason: 'auth' };
+      }
+
+      const alreadyOpen = document.querySelector('input[type="file"]');
+      if (alreadyOpen) return { ok: true };
+
+      const labels = ['Create', 'New post', 'Post', '创建', '新帖子'];
+      const nodes = Array.from(document.querySelectorAll('a, button, div[role="button"], svg[aria-label], [aria-label]'));
+      for (const node of nodes) {
+        const text = ((node.textContent || '') + ' ' + (node.getAttribute?.('aria-label') || '')).trim();
+        if (labels.some((label) => text.toLowerCase().includes(label.toLowerCase()))) {
+          const clickable = node.closest('a, button, div[role="button"]') || node;
+          if (clickable instanceof HTMLElement) {
+            clickable.click();
+            return { ok: true };
+          }
+        }
+      }
+
+      return { ok: true };
+    })()
+  `;
+}
+export function buildPublishStatusProbeJs() {
+    return `
+    (() => {
+      const isVisible = (el) => {
+        if (!(el instanceof HTMLElement)) return false;
+        const style = window.getComputedStyle(el);
+        const rect = el.getBoundingClientRect();
+        return style.display !== 'none'
+          && style.visibility !== 'hidden'
+          && rect.width > 0
+          && rect.height > 0;
+      };
+      const dialogs = Array.from(document.querySelectorAll('[role="dialog"]')).filter((el) => isVisible(el));
+      const dialogText = dialogs
+        .map((el) => (el.textContent || '').replace(/\\s+/g, ' ').trim())
+        .join(' ');
+      const url = window.location.href;
+      const visibleText = dialogText.toLowerCase();
+      const sharingVisible = /sharing/.test(visibleText);
+      const shared = /post shared|your post has been shared|已分享|已发布/.test(visibleText)
+        || /\\/p\\//.test(url);
+      const failed = !shared && !sharingVisible && (
+        /couldn['’]t be shared|could not be shared|failed to share|share failed|无法分享|分享失败/.test(visibleText)
+        || (/something went wrong/.test(visibleText) && /try again/.test(visibleText))
+      );
+      const composerOpen = dialogs.some((dialog) =>
+        !!dialog.querySelector('textarea, [contenteditable="true"], input[type="file"]')
+        || /write a caption|add location|advanced settings|select from computer|crop|filters|adjustments|sharing/.test((dialog.textContent || '').toLowerCase())
+      );
+      const settled = !shared && !composerOpen && !/sharing/.test(visibleText);
+      return { ok: shared, failed, settled, url: /\\/p\\//.test(url) ? url : '' };
+    })()
+  `;
+}
+function requirePage(page) {
+    if (!page)
+        throw new CommandExecutionError('Browser session required for instagram post');
+    return page;
+}
+function validateMixedMediaItems(inputs) {
+    if (!inputs.length) {
+        throw new ArgumentError('Argument "media" is required.', 'Provide --media /path/to/file.jpg or --media /path/a.jpg,/path/b.mp4');
+    }
+    if (inputs.length > MAX_MEDIA_ITEMS) {
+        throw new ArgumentError(`Too many media items: ${inputs.length}`, `Instagram carousel posts support at most ${MAX_MEDIA_ITEMS} items`);
+    }
+    const items = inputs.map((input) => {
+        const resolved = path.resolve(String(input || '').trim());
+        if (!resolved) {
+            throw new ArgumentError('Media path cannot be empty');
+        }
+        if (!fs.existsSync(resolved)) {
+            throw new ArgumentError(`Media file not found: ${resolved}`);
+        }
+        const ext = path.extname(resolved).toLowerCase();
+        if (SUPPORTED_IMAGE_EXTENSIONS.has(ext)) {
+            return { type: 'image', filePath: resolved };
+        }
+        if (SUPPORTED_VIDEO_EXTENSIONS.has(ext)) {
+            return { type: 'video', filePath: resolved };
+        }
+        throw new ArgumentError(`Unsupported media format: ${ext}`, 'Supported formats: images (.jpg, .jpeg, .png, .webp) and videos (.mp4)');
+    });
+    return items;
+}
+function normalizePostMediaItems(kwargs) {
+    const media = String(kwargs.media ?? '').trim();
+    return validateMixedMediaItems(media.split(',').map((part) => part.trim()).filter(Boolean));
+}
+function validateInstagramPostArgs(kwargs) {
+    const media = kwargs.media;
+    if (media === undefined) {
+        throw new ArgumentError('Argument "media" is required.', 'Provide --media /path/to/file.jpg or --media /path/a.jpg,/path/b.mp4');
+    }
+}
+function isSafePrivateRouteFallbackError(error) {
+    if (!(error instanceof CommandExecutionError))
+        return false;
+    return error.message.startsWith('Instagram private publish')
+        || error.message.startsWith('Instagram private route');
+}
+function buildInstagramSuccessResult(mediaItems, url) {
+    return [{
+            status: '✅ Posted',
+            detail: describePostDetail(mediaItems),
+            url,
+        }];
+}
+function buildFallbackHint(privateError, uiError) {
+    const privateMessage = privateError instanceof Error ? privateError.message : String(privateError);
+    const uiMessage = uiError instanceof Error ? uiError.message : String(uiError);
+    return `Private route failed first: ${privateMessage}. UI fallback then failed: ${uiMessage}`;
+}
+async function executePrivateInstagramPost(input) {
+    const privateConfig = await resolveInstagramPrivatePublishConfig(input.page);
+    const privateResult = input.mediaItems.every((item) => item.type === 'image')
+        ? await publishImagesViaPrivateApi({
+            page: input.page,
+            imagePaths: input.mediaItems.map((item) => item.filePath),
+            caption: input.content,
+            apiContext: privateConfig.apiContext,
+            jazoest: privateConfig.jazoest,
+        })
+        : await publishMediaViaPrivateApi({
+            page: input.page,
+            mediaItems: input.mediaItems,
+            caption: input.content,
+            apiContext: privateConfig.apiContext,
+            jazoest: privateConfig.jazoest,
+        });
+    const url = privateResult.code
+        ? new URL(`/p/${privateResult.code}/`, INSTAGRAM_HOME_URL).toString()
+        : await resolveLatestPostUrl(input.page, input.existingPostPaths);
+    return buildInstagramSuccessResult(input.mediaItems, url);
+}
+async function executeUiInstagramPost(input) {
+    let lastError;
+    let lastSpecificCommandError = null;
+    for (let attempt = 0; attempt < input.commandAttemptBudget; attempt++) {
+        let shareClicked = false;
+        try {
+            await gotoInstagramHome(input.page, input.forceFreshStart || attempt > 0);
+            await input.installProtocolCapture();
+            await input.page.wait({ time: 2 });
+            await dismissResidualDialogs(input.page);
+            await ensureComposerOpen(input.page);
+            const uploadSelectors = await resolveUploadSelectors(input.page, input.mediaItems);
+            if (input.preUploadDelaySeconds > 0) {
+                await input.page.wait({ time: input.preUploadDelaySeconds });
+            }
+            let uploaded = false;
+            let uploadFailure = null;
+            for (const selector of uploadSelectors) {
+                let activeSelector = selector;
+                for (let uploadAttempt = 0; uploadAttempt < input.uploadAttemptBudget; uploadAttempt++) {
+                    await uploadMedia(input.page, input.mediaItems, activeSelector);
+                    const uploadState = await waitForPreviewMaybe(input.page, input.previewProbeWindowSeconds);
+                    if (uploadState.state === 'preview') {
+                        uploaded = true;
+                        break;
+                    }
+                    if (uploadState.state === 'failed') {
+                        uploadFailure = makeUploadFailure(uploadState.detail);
+                        for (let inlineRetry = 0; inlineRetry < input.inlineUploadRetryBudget; inlineRetry++) {
+                            const clickedRetry = await clickVisibleUploadRetry(input.page);
+                            if (!clickedRetry)
+                                break;
+                            await input.page.wait({ time: 3 });
+                            const retriedState = await waitForPreviewMaybe(input.page, Math.max(3, Math.floor(input.previewProbeWindowSeconds / 2)));
+                            if (retriedState.state === 'preview') {
+                                uploaded = true;
+                                break;
+                            }
+                            if (retriedState.state !== 'failed')
+                                break;
+                        }
+                        if (uploaded)
+                            break;
+                        await dismissUploadErrorDialog(input.page);
+                        await dismissResidualDialogs(input.page);
+                        if (uploadAttempt < input.uploadAttemptBudget - 1) {
+                            try {
+                                await input.drainProtocolCapture();
+                                await gotoInstagramHome(input.page, true);
+                                await input.installProtocolCapture();
+                                await input.page.wait({ time: 2 });
+                                await dismissResidualDialogs(input.page);
+                                await ensureComposerOpen(input.page);
+                                activeSelector = await resolveFreshUploadSelector(input.page, activeSelector, input.mediaItems);
+                                if (input.preUploadDelaySeconds > 0) {
+                                    await input.page.wait({ time: input.preUploadDelaySeconds });
+                                }
+                            }
+                            catch {
+                                throw uploadFailure;
+                            }
+                            await input.page.wait({ time: 1.5 });
+                            continue;
+                        }
+                        break;
+                    }
+                    break;
+                }
+                if (uploaded)
+                    break;
+            }
+            if (!uploaded) {
+                if (uploadFailure)
+                    throw uploadFailure;
+                await waitForPreview(input.page, input.finalPreviewWaitSeconds);
+            }
+            try {
+                await advanceToCaptionEditor(input.page);
+            }
+            catch (error) {
+                await rethrowUploadFailureIfPresent(input.page, error);
+            }
+            if (input.content) {
+                await fillCaption(input.page, input.content);
+                await ensureCaptionFilled(input.page, input.content);
+            }
+            if (input.preShareDelaySeconds > 0) {
+                await input.page.wait({ time: input.preShareDelaySeconds });
+            }
+            await clickAction(input.page, ['Share', '分享'], 'caption');
+            shareClicked = true;
+            let url = '';
+            try {
+                url = await waitForPublishSuccess(input.page);
+            }
+            catch (error) {
+                if (error instanceof CommandExecutionError
+                    && error.message === 'Instagram post share failed'
+                    && await clickVisibleShareRetry(input.page)) {
+                    await input.page.wait({ time: Math.max(2, input.preShareDelaySeconds) });
+                    url = await waitForPublishSuccess(input.page);
+                }
+                else {
+                    throw error;
+                }
+            }
+            await input.drainProtocolCapture();
+            if (!url) {
+                url = await resolveLatestPostUrl(input.page, input.existingPostPaths);
+            }
+            return buildInstagramSuccessResult(input.mediaItems, url);
+        }
+        catch (error) {
+            lastError = error;
+            if (error instanceof CommandExecutionError && error.message !== 'Failed to open Instagram post composer') {
+                lastSpecificCommandError = error;
+            }
+            if (error instanceof AuthRequiredError)
+                throw error;
+            if (shareClicked) {
+                throw error;
+            }
+            if (!(error instanceof CommandExecutionError) || attempt === input.commandAttemptBudget - 1) {
+                if (error instanceof CommandExecutionError && error.message === 'Failed to open Instagram post composer' && lastSpecificCommandError) {
+                    throw lastSpecificCommandError;
+                }
+                throw error;
+            }
+            let resetWindow = false;
+            if (input.mediaItems.length >= 10 && input.page.closeWindow) {
+                try {
+                    await input.drainProtocolCapture();
+                    await input.page.closeWindow();
+                    resetWindow = true;
+                }
+                catch {
+                    // Best-effort: a fresh automation window is safer than reusing a polluted one.
+                }
+            }
+            if (!resetWindow) {
+                await dismissResidualDialogs(input.page);
+                await input.page.wait({ time: 1 });
+            }
+        }
+    }
+    throw lastError instanceof Error ? lastError : new CommandExecutionError('Instagram post failed');
+}
+async function ensureComposerOpen(page) {
+    const result = await page.evaluate(buildEnsureComposerOpenJs());
+    if (!result?.ok) {
+        if (result?.reason === 'auth')
+            throw new AuthRequiredError('www.instagram.com', 'Instagram login required before posting');
+        throw new CommandExecutionError('Failed to open Instagram post composer');
+    }
+}
+async function dismissResidualDialogs(page) {
+    for (let attempt = 0; attempt < 4; attempt++) {
+        const result = await page.evaluate(`
+      (() => {
+        const isVisible = (el) => {
+          if (!(el instanceof HTMLElement)) return false;
+          const style = window.getComputedStyle(el);
+          const rect = el.getBoundingClientRect();
+          return style.display !== 'none'
+            && style.visibility !== 'hidden'
+            && rect.width > 0
+            && rect.height > 0;
+        };
+
+        const dialogs = Array.from(document.querySelectorAll('[role="dialog"]'))
+          .filter((el) => el instanceof HTMLElement && isVisible(el));
+        for (const dialog of dialogs) {
+          const text = (dialog.textContent || '').replace(/\\s+/g, ' ').trim().toLowerCase();
+          if (!text) continue;
+          if (
+            text.includes('post shared')
+            || text.includes('your post has been shared')
+            || text.includes('something went wrong')
+            || text.includes('sharing')
+            || text.includes('create new post')
+            || text.includes('crop')
+            || text.includes('edit')
+          ) {
+            const close = dialog.querySelector('[aria-label="Close"], button[aria-label="Close"], div[role="button"][aria-label="Close"]');
+            if (close instanceof HTMLElement && isVisible(close)) {
+              close.click();
+              return { ok: true };
+            }
+            const closeByText = Array.from(dialog.querySelectorAll('button, div[role="button"]')).find((el) => {
+              const buttonText = (el.textContent || '').replace(/\\s+/g, ' ').trim().toLowerCase();
+              return isVisible(el) && (buttonText === 'close' || buttonText === 'cancel' || buttonText === '取消');
+            });
+            if (closeByText instanceof HTMLElement) {
+              closeByText.click();
+              return { ok: true };
+            }
+          }
+        }
+
+        return { ok: false };
+      })()
+    `);
+        if (!result?.ok)
+            return;
+        await page.wait({ time: 0.5 });
+    }
+}
+async function findUploadSelectors(page, mediaItems) {
+    const includesVideo = mediaItems.some((item) => item.type === 'video');
+    const result = await page.evaluate(`
+    ((includesVideo) => {
+      const isVisible = (el) => {
+        if (!(el instanceof HTMLElement)) return false;
+        const style = window.getComputedStyle(el);
+        const rect = el.getBoundingClientRect();
+        return style.display !== 'none'
+          && style.visibility !== 'hidden'
+          && rect.width > 0
+          && rect.height > 0;
+      };
+      const hasButtonText = (root, labels) => {
+        if (!root || !(root instanceof Element)) return false;
+        return Array.from(root.querySelectorAll('button, div[role="button"], span'))
+          .some((el) => {
+            const text = (el.textContent || '').replace(/\\s+/g, ' ').trim().toLowerCase();
+            return labels.some((label) => text === label.toLowerCase());
+          });
+      };
+
+      const inputs = Array.from(document.querySelectorAll('input[type="file"]'));
+      const candidates = inputs.filter((el) => {
+        if (!(el instanceof HTMLInputElement)) return false;
+        if (el.disabled) return false;
+        const accept = (el.getAttribute('accept') || '').toLowerCase();
+        if (!accept) return true;
+        if (includesVideo) return true;
+        return accept.includes('image') || accept.includes('.jpg') || accept.includes('.jpeg') || accept.includes('.png') || accept.includes('.webp');
+      });
+
+      const dialogInputs = candidates.filter((el) => {
+        const dialog = el.closest('[role="dialog"]');
+        return hasButtonText(dialog, ['Select from computer', '从电脑中选择']);
+      });
+
+      const visibleDialogInputs = dialogInputs.filter((el) => {
+        const dialog = el.closest('[role="dialog"]');
+        return dialog instanceof HTMLElement && isVisible(dialog);
+      });
+
+      const pickerInputs = candidates.filter((el) => {
+        return hasButtonText(el.parentElement, ['Select from computer', '从电脑中选择']);
+      });
+
+      const primary = visibleDialogInputs.length
+        ? [visibleDialogInputs[visibleDialogInputs.length - 1]]
+        : dialogInputs.length
+          ? [dialogInputs[dialogInputs.length - 1]]
+          : [];
+      const ordered = [...primary, ...pickerInputs, ...candidates]
+        .filter((el, index, arr) => arr.indexOf(el) === index);
+      if (!ordered.length) return { ok: false };
+
+      document.querySelectorAll('[data-opencli-ig-upload-index]').forEach((el) => el.removeAttribute('data-opencli-ig-upload-index'));
+      const selectors = ordered.map((input, index) => {
+        input.setAttribute('data-opencli-ig-upload-index', String(index));
+        return '[data-opencli-ig-upload-index="' + index + '"]';
+      });
+      return { ok: true, selectors };
+    })(${JSON.stringify(includesVideo)})
+  `);
+    if (!result?.ok || !result.selectors?.length) {
+        throw new CommandExecutionError('Instagram upload input not found', 'Open the new-post composer in a logged-in browser session and retry');
+    }
+    return result.selectors;
+}
+async function resolveUploadSelectors(page, mediaItems) {
+    try {
+        return await findUploadSelectors(page, mediaItems);
+    }
+    catch (error) {
+        if (!(error instanceof CommandExecutionError) || !error.message.includes('upload input not found')) {
+            throw error;
+        }
+        await ensureComposerOpen(page);
+        await page.wait({ time: 1.5 });
+        try {
+            return await findUploadSelectors(page, mediaItems);
+        }
+        catch (retryError) {
+            if (!(retryError instanceof CommandExecutionError) || !retryError.message.includes('upload input not found')) {
+                throw retryError;
+            }
+            await gotoInstagramHome(page, true);
+            await page.wait({ time: 2 });
+            await dismissResidualDialogs(page);
+            await ensureComposerOpen(page);
+            await page.wait({ time: 2 });
+            return findUploadSelectors(page, mediaItems);
+        }
+    }
+}
+function extractSelectorIndex(selector) {
+    const match = selector.match(/data-opencli-ig-upload-index="(\d+)"/);
+    if (!match)
+        return null;
+    const index = Number.parseInt(match[1] || '', 10);
+    return Number.isNaN(index) ? null : index;
+}
+async function resolveFreshUploadSelector(page, previousSelector, mediaItems) {
+    const selectors = await resolveUploadSelectors(page, mediaItems);
+    const index = extractSelectorIndex(previousSelector);
+    if (index !== null && selectors[index])
+        return selectors[index];
+    return selectors[0] || previousSelector;
+}
+async function injectImageViaBrowser(page, imagePaths, selector) {
+    const images = imagePaths.map((imagePath) => {
+        const ext = path.extname(imagePath).toLowerCase();
+        const mimeType = ext === '.png'
+            ? 'image/png'
+            : ext === '.webp'
+                ? 'image/webp'
+                : 'image/jpeg';
+        return {
+            name: path.basename(imagePath),
+            type: mimeType,
+            base64: fs.readFileSync(imagePath).toString('base64'),
+        };
+    });
+    const chunkKey = `__opencliInstagramUpload_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+    const chunkSize = 256 * 1024;
+    await page.evaluate(`
+    (() => {
+      window[${JSON.stringify(chunkKey)}] = [];
+      return { ok: true };
+    })()
+  `);
+    const payload = JSON.stringify(images);
+    for (let offset = 0; offset < payload.length; offset += chunkSize) {
+        const chunk = payload.slice(offset, offset + chunkSize);
+        await page.evaluate(`
+      (() => {
+        const key = ${JSON.stringify(chunkKey)};
+        const chunk = ${JSON.stringify(chunk)};
+        const parts = Array.isArray(window[key]) ? window[key] : [];
+        parts.push(chunk);
+        window[key] = parts;
+        return { ok: true, count: parts.length };
+      })()
+    `);
+    }
+    const result = await page.evaluate(`
+    (() => {
+      const selector = ${JSON.stringify(selector)};
+      const key = ${JSON.stringify(chunkKey)};
+      const payload = JSON.parse(Array.isArray(window[key]) ? window[key].join('') : '[]');
+
+      const cleanup = () => { try { delete window[key]; } catch {} };
+      const input = document.querySelector(selector);
+      if (!(input instanceof HTMLInputElement)) {
+        cleanup();
+        return { ok: false, error: 'File input not found for fallback injection' };
+      }
+
+      try {
+        const dt = new DataTransfer();
+        for (const img of payload) {
+          const binary = atob(img.base64);
+          const bytes = new Uint8Array(binary.length);
+          for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+          const blob = new Blob([bytes], { type: img.type });
+          const file = new File([blob], img.name, { type: img.type });
+          dt.items.add(file);
+        }
+        Object.defineProperty(input, 'files', { value: dt.files, configurable: true });
+        input.dispatchEvent(new Event('change', { bubbles: true }));
+        input.dispatchEvent(new Event('input', { bubbles: true }));
+        cleanup();
+        return { ok: true, count: dt.files.length };
+      } catch (error) {
+        cleanup();
+        return { ok: false, error: String(error) };
+      }
+    })()
+  `);
+    if (!result?.ok) {
+        throw new CommandExecutionError(result?.error || 'Instagram fallback file injection failed');
+    }
+}
+async function dispatchUploadEvents(page, selector) {
+    await page.evaluate(`
+    (() => {
+      const input = document.querySelector(${JSON.stringify(selector)});
+      if (!(input instanceof HTMLInputElement)) return { ok: false };
+      input.dispatchEvent(new Event('input', { bubbles: true }));
+      input.dispatchEvent(new Event('change', { bubbles: true }));
+      return { ok: true };
+    })()
+  `);
+}
+export function buildInspectUploadStageJs() {
+    return `
+    (() => {
+      const isVisible = (el) => {
+        if (!(el instanceof HTMLElement)) return false;
+        const style = window.getComputedStyle(el);
+        const rect = el.getBoundingClientRect();
+        return style.display !== 'none'
+          && style.visibility !== 'hidden'
+          && rect.width > 0
+          && rect.height > 0;
+      };
+      const dialogs = Array.from(document.querySelectorAll('[role="dialog"]')).filter((el) => isVisible(el));
+      const visibleTexts = dialogs.map((el) => (el.textContent || '').replace(/\\s+/g, ' ').trim());
+      const dialogText = visibleTexts.join(' ');
+      const combined = dialogText.toLowerCase();
+      const hasVisibleButtonInDialogs = (labels) => {
+        return dialogs.some((dialog) =>
+          Array.from(dialog.querySelectorAll('button, div[role="button"]')).some((el) => {
+            const text = (el.textContent || '').replace(/\\s+/g, ' ').trim();
+            const aria = (el.getAttribute?.('aria-label') || '').replace(/\\s+/g, ' ').trim();
+            return isVisible(el) && (labels.includes(text) || labels.includes(aria));
+          })
+        );
+      };
+      const hasCaption = dialogs.some((dialog) => !!dialog.querySelector('textarea, [contenteditable="true"]'));
+      const hasPicker = hasVisibleButtonInDialogs(['Select from computer', '从电脑中选择']);
+      const hasNext = hasVisibleButtonInDialogs(['Next', '下一步']);
+      const hasPreviewUi = hasCaption
+        || (!hasPicker && hasNext)
+        || /crop|select crop|select zoom|open media gallery|filters|adjustments|裁剪|缩放|滤镜|调整/.test(combined);
+      const failed = /something went wrong|please try again|couldn['’]t upload|could not upload|upload failed|try again|出错|失败/.test(combined);
+      if (hasPreviewUi) return { state: 'preview', detail: dialogText || '' };
+      if (failed) return { state: 'failed', detail: dialogText || 'Something went wrong' };
+      return { state: 'pending', detail: dialogText || '' };
+    })()
+  `;
+}
+async function inspectUploadStage(page) {
+    const result = await page.evaluate(buildInspectUploadStageJs());
+    if (result?.state)
+        return result;
+    if (result?.ok === true)
+        return { state: 'preview', detail: result.detail };
+    return { state: 'pending', detail: result?.detail };
+}
+function makeUploadFailure(detail) {
+    return new CommandExecutionError('Instagram image upload failed', detail ? `Instagram rejected the upload: ${detail}` : 'Instagram rejected the upload before the preview stage');
+}
+async function uploadMedia(page, mediaItems, selector) {
+    const mediaPaths = mediaItems.map((item) => item.filePath);
+    if (!page.setFileInput) {
+        throw new CommandExecutionError('Instagram posting requires Browser Bridge file upload support', 'Use Browser Bridge or another browser mode that supports setFileInput');
+    }
+    let activeSelector = selector;
+    for (let attempt = 0; attempt < 2; attempt++) {
+        try {
+            await page.setFileInput(mediaPaths, activeSelector);
+            await dispatchUploadEvents(page, activeSelector);
+            return;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const staleSelector = message.includes('No element found matching selector')
+                || message.includes('Could not find node with given id')
+                || message.includes('No node with given id found');
+            if (staleSelector && attempt === 0) {
+                activeSelector = await resolveFreshUploadSelector(page, activeSelector, mediaItems);
+                continue;
+            }
+            if (!message.includes('Unknown action') && !message.includes('set-file-input') && !message.includes('not supported')) {
+                throw error;
+            }
+            if (mediaItems.some((item) => item.type === 'video')) {
+                throw new CommandExecutionError('Instagram mixed-media posting requires Browser Bridge file upload support', 'Use Browser Bridge or another browser mode that supports setFileInput for image/video uploads');
+            }
+            await injectImageViaBrowser(page, mediaPaths, activeSelector);
+            return;
+        }
+    }
+}
+function describePostDetail(mediaItems) {
+    if (mediaItems.every((item) => item.type === 'image')) {
+        return mediaItems.length === 1
+            ? 'Single image post shared successfully'
+            : `${mediaItems.length}-image carousel post shared successfully`;
+    }
+    return mediaItems.length === 1
+        ? 'Single mixed-media post shared successfully'
+        : `${mediaItems.length}-item mixed-media carousel post shared successfully`;
+}
+function getCommandAttemptBudget(mediaItems) {
+    if (mediaItems.length >= 10)
+        return 6;
+    if (mediaItems.length >= 5)
+        return 4;
+    return 3;
+}
+function getPreUploadDelaySeconds(mediaItems) {
+    if (mediaItems.length >= 10)
+        return 3;
+    if (mediaItems.length >= 5)
+        return 1.5;
+    return 0;
+}
+function getUploadAttemptBudget(mediaItems) {
+    if (mediaItems.length >= 10)
+        return 3;
+    if (mediaItems.length >= 5)
+        return 3;
+    return 2;
+}
+function getPreviewProbeWindowSeconds(mediaItems) {
+    if (mediaItems.length >= 10)
+        return 6;
+    if (mediaItems.length >= 5)
+        return 6;
+    return 4;
+}
+function getFinalPreviewWaitSeconds(mediaItems) {
+    if (mediaItems.length >= 10)
+        return 12;
+    if (mediaItems.length >= 5)
+        return 16;
+    return 12;
+}
+function getPreShareDelaySeconds(mediaItems) {
+    if (mediaItems.length >= 10)
+        return 4;
+    if (mediaItems.length >= 5)
+        return 3;
+    return 0;
+}
+function getInlineUploadRetryBudget(mediaItems) {
+    if (mediaItems.length >= 10)
+        return 3;
+    if (mediaItems.length >= 5)
+        return 2;
+    return 1;
+}
+async function dismissUploadErrorDialog(page) {
+    const result = await page.evaluate(`
+    (() => {
+      const isVisible = (el) => {
+        if (!(el instanceof HTMLElement)) return false;
+        const style = window.getComputedStyle(el);
+        const rect = el.getBoundingClientRect();
+        return style.display !== 'none'
+          && style.visibility !== 'hidden'
+          && rect.width > 0
+          && rect.height > 0;
+      };
+      const dialogs = Array.from(document.querySelectorAll('[role="dialog"]')).filter((el) => isVisible(el));
+      for (const dialog of dialogs) {
+        const text = (dialog.textContent || '').replace(/\\s+/g, ' ').trim().toLowerCase();
+        if (!text.includes('something went wrong') && !text.includes('try again') && !text.includes('失败') && !text.includes('出错')) continue;
+        const close = dialog.querySelector('[aria-label="Close"], button[aria-label="Close"], div[role="button"][aria-label="Close"]');
+        if (close instanceof HTMLElement && isVisible(close)) {
+          close.click();
+          return { ok: true };
+        }
+      }
+      return { ok: false };
+    })()
+  `);
+    return !!result?.ok;
+}
+async function clickVisibleUploadRetry(page) {
+    const result = await page.evaluate(`
+    (() => {
+      const isVisible = (el) => {
+        if (!(el instanceof HTMLElement)) return false;
+        const style = window.getComputedStyle(el);
+        const rect = el.getBoundingClientRect();
+        return style.display !== 'none'
+          && style.visibility !== 'hidden'
+          && rect.width > 0
+          && rect.height > 0;
+      };
+      const dialogs = Array.from(document.querySelectorAll('[role="dialog"]')).filter((el) => isVisible(el));
+      for (const dialog of dialogs) {
+        const text = (dialog.textContent || '').replace(/\\s+/g, ' ').trim().toLowerCase();
+        if (!text.includes('something went wrong') && !text.includes('try again') && !text.includes('失败') && !text.includes('出错')) continue;
+        const retry = Array.from(dialog.querySelectorAll('button, div[role="button"]')).find((el) => {
+          const label = ((el.textContent || '') + ' ' + (el.getAttribute?.('aria-label') || ''))
+            .replace(/\\s+/g, ' ')
+            .trim()
+            .toLowerCase();
+          return isVisible(el) && (
+            label === 'try again'
+            || label === 'retry'
+            || label === '再试一次'
+            || label === '重试'
+          );
+        });
+        if (retry instanceof HTMLElement) {
+          retry.click();
+          return { ok: true };
+        }
+      }
+      return { ok: false };
+    })()
+  `);
+    return !!result?.ok;
+}
+async function waitForPreview(page, maxWaitSeconds = 12) {
+    const attempts = Math.max(1, Math.ceil(maxWaitSeconds));
+    for (let attempt = 0; attempt < attempts; attempt++) {
+        const state = await inspectUploadStage(page);
+        if (state.state === 'preview')
+            return;
+        if (state.state === 'failed') {
+            await page.screenshot({ path: '/tmp/instagram_post_preview_debug.png' });
+            throw makeUploadFailure('Inspect /tmp/instagram_post_preview_debug.png. ' + (state.detail || ''));
+        }
+        if (attempt < attempts - 1)
+            await page.wait({ time: 1 });
+    }
+    await page.screenshot({ path: '/tmp/instagram_post_preview_debug.png' });
+    throw new CommandExecutionError('Instagram image preview did not appear after upload', 'The selected file input may not match the active composer; inspect /tmp/instagram_post_preview_debug.png');
+}
+async function waitForPreviewMaybe(page, maxWaitSeconds = 4) {
+    const attempts = Math.max(1, Math.ceil(maxWaitSeconds * 2));
+    for (let attempt = 0; attempt < attempts; attempt++) {
+        const state = await inspectUploadStage(page);
+        if (state.state !== 'pending')
+            return state;
+        if (attempt < attempts - 1)
+            await page.wait({ time: 0.5 });
+    }
+    return { state: 'pending' };
+}
+export function buildClickActionJs(labels, scope = 'any') {
+    return `
+    ((labels, scope) => {
+      const isVisible = (el) => {
+        if (!(el instanceof HTMLElement)) return false;
+        const style = window.getComputedStyle(el);
+        const rect = el.getBoundingClientRect();
+        return style.display !== 'none'
+          && style.visibility !== 'hidden'
+          && rect.width > 0
+          && rect.height > 0;
+      };
+
+      const matchesScope = (dialog) => {
+        if (!(dialog instanceof HTMLElement) || !isVisible(dialog)) return false;
+        const text = (dialog.textContent || '').replace(/\\s+/g, ' ').trim().toLowerCase();
+        if (scope === 'caption') {
+          return !!dialog.querySelector('textarea, [contenteditable="true"]')
+            || text.includes('write a caption')
+            || text.includes('add location')
+            || text.includes('add collaborators')
+            || text.includes('accessibility')
+            || text.includes('advanced settings');
+        }
+        if (scope === 'media') {
+          return !!dialog.querySelector('input[type="file"]')
+            || text.includes('select from computer')
+            || text.includes('crop')
+            || text.includes('filters')
+            || text.includes('adjustments')
+            || text.includes('open media gallery')
+            || text.includes('select crop')
+            || text.includes('select zoom');
+        }
+        return true;
+      };
+
+      const containers = scope !== 'any'
+        ? Array.from(document.querySelectorAll('[role="dialog"]')).filter(matchesScope)
+        : [document.body];
+
+      for (const container of containers) {
+        const nodes = Array.from(container.querySelectorAll('button, div[role="button"]'));
+        for (const node of nodes) {
+          const text = (node.textContent || '').replace(/\\s+/g, ' ').trim();
+          const aria = (node.getAttribute?.('aria-label') || '').replace(/\\s+/g, ' ').trim();
+          if (!text && !aria) continue;
+          if (!labels.includes(text) && !labels.includes(aria)) continue;
+          if (node instanceof HTMLElement && isVisible(node) && node.getAttribute('aria-disabled') !== 'true') {
+            node.click();
+            return { ok: true, label: text || aria };
+          }
+        }
+      }
+      return { ok: false };
+    })(${JSON.stringify(labels)}, ${JSON.stringify(scope)})
+  `;
+}
+async function clickAction(page, labels, scope = 'any') {
+    const result = await page.evaluate(buildClickActionJs(labels, scope));
+    if (!result?.ok) {
+        throw new CommandExecutionError(`Instagram action button not found: ${labels.join(' / ')}`);
+    }
+    return result.label || labels[0];
+}
+async function clickVisibleShareRetry(page) {
+    const result = await page.evaluate(`
+    (() => {
+      const isVisible = (el) => {
+        if (!(el instanceof HTMLElement)) return false;
+        const style = window.getComputedStyle(el);
+        const rect = el.getBoundingClientRect();
+        return style.display !== 'none'
+          && style.visibility !== 'hidden'
+          && rect.width > 0
+          && rect.height > 0;
+      };
+
+      const dialogs = Array.from(document.querySelectorAll('[role="dialog"]')).filter((el) => isVisible(el));
+      for (const dialog of dialogs) {
+        const text = (dialog.textContent || '').replace(/\\s+/g, ' ').trim().toLowerCase();
+        if (!text.includes('post couldn') && !text.includes('could not be shared') && !text.includes('share failed')) continue;
+
+        const retry = Array.from(dialog.querySelectorAll('button, div[role="button"]')).find((el) => {
+          const label = ((el.textContent || '') + ' ' + (el.getAttribute?.('aria-label') || ''))
+            .replace(/\\s+/g, ' ')
+            .trim()
+            .toLowerCase();
+          return isVisible(el) && (
+            label === 'try again'
+            || label === 'retry'
+            || label === '再试一次'
+            || label === '重试'
+          );
+        });
+
+        if (retry instanceof HTMLElement) {
+          retry.click();
+          return { ok: true };
+        }
+      }
+
+      return { ok: false };
+    })()
+  `);
+    return !!result?.ok;
+}
+async function hasCaptionEditor(page) {
+    const result = await page.evaluate(`
+    (() => {
+      const editable = document.querySelector('textarea, [contenteditable="true"]');
+      return { ok: !!editable };
+    })()
+  `);
+    return !!result?.ok;
+}
+async function isCaptionStage(page) {
+    const result = await page.evaluate(`
+    (() => {
+      const editable = document.querySelector('textarea, [contenteditable="true"]');
+      const dialogText = Array.from(document.querySelectorAll('[role="dialog"]'))
+        .map((el) => (el.textContent || '').replace(/\\s+/g, ' ').trim().toLowerCase())
+        .join(' ');
+      return {
+        ok: !!editable
+          || dialogText.includes('write a caption')
+          || dialogText.includes('add location')
+          || dialogText.includes('add collaborators')
+          || dialogText.includes('advanced settings'),
+      };
+    })()
+  `);
+    return !!result?.ok;
+}
+async function advanceToCaptionEditor(page) {
+    for (let attempt = 0; attempt < 3; attempt++) {
+        if (await isCaptionStage(page)) {
+            return;
+        }
+        try {
+            await clickAction(page, ['Next', '下一步'], 'media');
+        }
+        catch (error) {
+            if (error instanceof CommandExecutionError) {
+                await page.wait({ time: 1.5 });
+                if (await isCaptionStage(page)) {
+                    return;
+                }
+                const uploadState = await inspectUploadStage(page);
+                if (uploadState.state === 'failed') {
+                    throw makeUploadFailure(uploadState.detail);
+                }
+                if (attempt < 2) {
+                    continue;
+                }
+            }
+            throw error;
+        }
+        await page.wait({ time: 1.5 });
+        if (await hasCaptionEditor(page)) {
+            return;
+        }
+        const uploadState = await inspectUploadStage(page);
+        if (uploadState.state === 'failed') {
+            throw makeUploadFailure(uploadState.detail);
+        }
+    }
+    await page.screenshot({ path: '/tmp/instagram_post_caption_debug.png' });
+    throw new CommandExecutionError('Instagram caption editor did not appear', 'Instagram may have changed the publish flow; inspect /tmp/instagram_post_caption_debug.png');
+}
+async function waitForCaptionEditor(page) {
+    if (!(await hasCaptionEditor(page))) {
+        await page.screenshot({ path: '/tmp/instagram_post_caption_debug.png' });
+        throw new CommandExecutionError('Instagram caption editor did not appear', 'Instagram may have changed the publish flow; inspect /tmp/instagram_post_caption_debug.png');
+    }
+}
+async function rethrowUploadFailureIfPresent(page, originalError) {
+    const uploadState = await inspectUploadStage(page);
+    if (uploadState.state === 'failed') {
+        throw makeUploadFailure(uploadState.detail);
+    }
+    throw originalError;
+}
+async function focusCaptionEditorForNativeInsert(page) {
+    const result = await page.evaluate(`
+    (() => {
+      const textarea = document.querySelector('[aria-label="Write a caption..."], textarea');
+      if (textarea instanceof HTMLTextAreaElement) {
+        textarea.focus();
+        textarea.select();
+        return { ok: true, kind: 'textarea' };
+      }
+
+      const editor = document.querySelector('[aria-label="Write a caption..."][contenteditable="true"]')
+        || document.querySelector('[contenteditable="true"]');
+      if (!(editor instanceof HTMLElement)) return { ok: false };
+
+      const lexical = editor.__lexicalEditor;
+      try {
+        if (lexical && typeof lexical.getEditorState === 'function' && typeof lexical.parseEditorState === 'function') {
+          const emptyState = {
+            root: {
+              children: [{
+                children: [],
+                direction: null,
+                format: '',
+                indent: 0,
+                textFormat: 0,
+                textStyle: '',
+                type: 'paragraph',
+                version: 1,
+              }],
+              direction: null,
+              format: '',
+              indent: 0,
+              type: 'root',
+              version: 1,
+            },
+          };
+          const nextState = lexical.parseEditorState(JSON.stringify(emptyState));
+          try {
+            lexical.setEditorState(nextState, { tag: 'history-merge', discrete: true });
+          } catch {
+            lexical.setEditorState(nextState);
+          }
+        } else {
+          editor.textContent = '';
+        }
+      } catch {
+        editor.textContent = '';
+      }
+
+      editor.focus();
+      const selection = window.getSelection();
+      if (selection) {
+        selection.removeAllRanges();
+        const range = document.createRange();
+        range.selectNodeContents(editor);
+        range.collapse(false);
+        selection.addRange(range);
+      }
+
+      return { ok: true, kind: 'contenteditable' };
+    })()
+  `);
+    return !!result?.ok;
+}
+async function fillCaption(page, content) {
+    if (page.insertText && await focusCaptionEditorForNativeInsert(page)) {
+        try {
+            await page.insertText(content);
+            await page.wait({ time: 0.3 });
+            await page.evaluate(`
+        (() => {
+          const textarea = document.querySelector('[aria-label="Write a caption..."], textarea');
+          if (textarea instanceof HTMLTextAreaElement) {
+            textarea.dispatchEvent(new InputEvent('input', { bubbles: true, composed: true, inputType: 'insertText' }));
+            textarea.dispatchEvent(new Event('change', { bubbles: true, composed: true }));
+            textarea.blur();
+            return { ok: true };
+          }
+
+          const editor = document.querySelector('[aria-label="Write a caption..."][contenteditable="true"]')
+            || document.querySelector('[contenteditable="true"]');
+          if (!(editor instanceof HTMLElement)) return { ok: false };
+          try {
+            editor.dispatchEvent(new InputEvent('input', { bubbles: true, composed: true, inputType: 'insertText' }));
+          } catch {
+            editor.dispatchEvent(new Event('input', { bubbles: true, composed: true }));
+          }
+          editor.dispatchEvent(new Event('change', { bubbles: true, composed: true }));
+          editor.blur();
+          return { ok: true };
+        })()
+      `);
+            return;
+        }
+        catch {
+            // Fall back to browser-side editor manipulation below.
+        }
+    }
+    const result = await page.evaluate(`
+    ((content) => {
+      const createParagraph = (text) => ({
+        children: text
+          ? [{ detail: 0, format: 0, mode: 'normal', style: '', text, type: 'text', version: 1 }]
+          : [],
+        direction: null,
+        format: '',
+        indent: 0,
+        textFormat: 0,
+        textStyle: '',
+        type: 'paragraph',
+        version: 1,
+      });
+
+      const textarea = document.querySelector('[aria-label="Write a caption..."], textarea');
+      if (textarea instanceof HTMLTextAreaElement) {
+        textarea.focus();
+        const dt = new DataTransfer();
+        dt.setData('text/plain', content);
+        textarea.dispatchEvent(new ClipboardEvent('paste', {
+          clipboardData: dt,
+          bubbles: true,
+          cancelable: true,
+        }));
+        const setter = Object.getOwnPropertyDescriptor(HTMLTextAreaElement.prototype, 'value')?.set;
+        setter?.call(textarea, content);
+        textarea.dispatchEvent(new Event('input', { bubbles: true, composed: true }));
+        textarea.dispatchEvent(new Event('change', { bubbles: true, composed: true }));
+        return { ok: true, mode: 'textarea' };
+      }
+
+      const editor = document.querySelector('[aria-label="Write a caption..."][contenteditable="true"]')
+        || document.querySelector('[contenteditable="true"]');
+      if (editor instanceof HTMLElement) {
+        editor.focus();
+        const lexical = editor.__lexicalEditor;
+        if (lexical && typeof lexical.getEditorState === 'function' && typeof lexical.parseEditorState === 'function') {
+          const currentState = lexical.getEditorState && lexical.getEditorState();
+          const base = currentState && typeof currentState.toJSON === 'function' ? currentState.toJSON() : {};
+          const lines = String(content).split(/\\r?\\n/);
+          const paragraphs = lines.map((line) => createParagraph(line));
+          base.root = {
+            children: paragraphs.length ? paragraphs : [createParagraph('')],
+            direction: null,
+            format: '',
+            indent: 0,
+            type: 'root',
+            version: 1,
+          };
+
+          const nextState = lexical.parseEditorState(JSON.stringify(base));
+          try {
+            lexical.setEditorState(nextState, { tag: 'history-merge', discrete: true });
+          } catch {
+            lexical.setEditorState(nextState);
+          }
+
+          editor.dispatchEvent(new Event('input', { bubbles: true, composed: true }));
+          editor.dispatchEvent(new Event('change', { bubbles: true, composed: true }));
+          const nextCurrentState = lexical.getEditorState && lexical.getEditorState();
+          const pendingState = lexical._pendingEditorState;
+          return {
+            ok: true,
+            mode: 'lexical',
+            value: editor.textContent || '',
+            current: nextCurrentState && typeof nextCurrentState.toJSON === 'function' ? nextCurrentState.toJSON() : null,
+            pending: pendingState && typeof pendingState.toJSON === 'function' ? pendingState.toJSON() : null,
+          };
+        }
+
+        const selection = window.getSelection();
+        if (selection) {
+          selection.removeAllRanges();
+          const range = document.createRange();
+          range.selectNodeContents(editor);
+          selection.addRange(range);
+        }
+        const dt = new DataTransfer();
+        dt.setData('text/plain', content);
+        editor.dispatchEvent(new ClipboardEvent('paste', {
+          clipboardData: dt,
+          bubbles: true,
+          cancelable: true,
+        }));
+        return { ok: true, mode: 'contenteditable', value: editor.textContent || '' };
+      }
+
+      return { ok: false };
+    })(${JSON.stringify(content)})
+  `);
+    if (!result?.ok) {
+        throw new CommandExecutionError('Failed to fill Instagram caption');
+    }
+}
+async function captionMatches(page, content) {
+    const result = await page.evaluate(`
+    ((content) => {
+      const normalized = content.trim();
+      const readLexicalText = (node) => {
+        if (!node || typeof node !== 'object') return '';
+        if (node.type === 'text' && typeof node.text === 'string') return node.text;
+        if (!Array.isArray(node.children)) return '';
+        if (node.type === 'root') {
+          return node.children.map((child) => readLexicalText(child)).join('\\n');
+        }
+        if (node.type === 'paragraph') {
+          return node.children.map((child) => readLexicalText(child)).join('');
+        }
+        return node.children.map((child) => readLexicalText(child)).join('');
+      };
+
+      const textarea = document.querySelector('[aria-label="Write a caption..."], textarea');
+      if (textarea instanceof HTMLTextAreaElement) {
+        return { ok: textarea.value.trim() === normalized };
+      }
+
+      const editor = document.querySelector('[aria-label="Write a caption..."][contenteditable="true"]')
+        || document.querySelector('[contenteditable="true"]');
+      if (editor instanceof HTMLElement) {
+        const lexical = editor.__lexicalEditor;
+        if (lexical && typeof lexical.getEditorState === 'function') {
+          const currentState = lexical.getEditorState();
+          const pendingState = lexical._pendingEditorState;
+          const current = currentState && typeof currentState.toJSON === 'function' ? currentState.toJSON() : null;
+          const pending = pendingState && typeof pendingState.toJSON === 'function' ? pendingState.toJSON() : null;
+          const currentText = readLexicalText(current && current.root).trim();
+          const pendingText = readLexicalText(pending && pending.root).trim();
+          if (currentText === normalized || pendingText === normalized) {
+            return { ok: true, currentText, pendingText };
+          }
+        }
+
+        const text = (editor.textContent || '').replace(/\\u00a0/g, ' ').trim();
+        if (text === normalized) return { ok: true };
+
+        const counters = Array.from(document.querySelectorAll('div, span'))
+          .map((el) => (el.textContent || '').replace(/\\s+/g, ' ').trim())
+          .filter(Boolean);
+        const counter = counters.find((value) => /\\d+\\s*\\/\\s*2,?200/.test(value));
+        if (counter) {
+          const match = counter.match(/(\\d+)\\s*\\/\\s*2,?200/);
+          if (match && Number(match[1]) >= normalized.length) return { ok: true };
+        }
+
+        return { ok: false, text, counter: counter || '' };
+      }
+
+      return { ok: false };
+    })(${JSON.stringify(content)})
+  `);
+    return !!result?.ok;
+}
+async function ensureCaptionFilled(page, content) {
+    for (let attempt = 0; attempt < 6; attempt++) {
+        if (await captionMatches(page, content)) {
+            return;
+        }
+        if (attempt < 5) {
+            await page.wait({ time: 0.5 });
+        }
+    }
+    await page.screenshot({ path: '/tmp/instagram_post_caption_fill_debug.png' });
+    throw new CommandExecutionError('Instagram caption did not stick before sharing', 'Inspect /tmp/instagram_post_caption_fill_debug.png for the caption editor state');
+}
+async function waitForPublishSuccess(page) {
+    let settledStreak = 0;
+    for (let attempt = 0; attempt < 90; attempt++) {
+        const result = await page.evaluate(buildPublishStatusProbeJs());
+        if (result?.failed) {
+            await page.screenshot({ path: '/tmp/instagram_post_share_debug.png' });
+            throw new CommandExecutionError('Instagram post share failed', 'Inspect /tmp/instagram_post_share_debug.png for the share failure state');
+        }
+        if (result?.ok) {
+            return result.url || '';
+        }
+        if (result?.settled) {
+            settledStreak += 1;
+            if (settledStreak >= 3)
+                return '';
+        }
+        else {
+            settledStreak = 0;
+        }
+        if (attempt < 89) {
+            await page.wait({ time: 1 });
+        }
+    }
+    await page.screenshot({ path: '/tmp/instagram_post_share_debug.png' });
+    throw new CommandExecutionError('Instagram post share confirmation did not appear', 'Inspect /tmp/instagram_post_share_debug.png for the final publish state');
+}
+async function resolveCurrentUserId(page) {
+    const cookies = await page.getCookies({ domain: 'instagram.com' });
+    return cookies.find((cookie) => cookie.name === 'ds_user_id')?.value || '';
+}
+async function resolveProfileUrl(page, currentUserId = '') {
+    if (currentUserId) {
+        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 };
+        }
+      })()
+    `);
+        if (apiResult?.ok && apiResult.username) {
+            return new URL(`/${apiResult.username}/`, INSTAGRAM_HOME_URL).toString();
+        }
+    }
+    const result = await page.evaluate(`
+    (() => {
+      const isVisible = (el) => {
+        if (!(el instanceof HTMLElement)) return false;
+        const style = window.getComputedStyle(el);
+        const rect = el.getBoundingClientRect();
+        return style.display !== 'none'
+          && style.visibility !== 'hidden'
+          && rect.width > 0
+          && rect.height > 0;
+      };
+
+      const anchors = Array.from(document.querySelectorAll('a[href]'))
+        .filter((el) => el instanceof HTMLAnchorElement && isVisible(el))
+        .map((el) => ({
+          href: el.getAttribute('href') || '',
+          text: (el.textContent || '').replace(/\\s+/g, ' ').trim().toLowerCase(),
+          aria: (el.getAttribute('aria-label') || '').replace(/\\s+/g, ' ').trim().toLowerCase(),
+        }))
+        .filter((el) => /^\\/[^/?#]+\\/$/.test(el.href));
+
+      const explicitProfile = anchors.find((el) => el.text === 'profile' || el.aria === 'profile')?.href || '';
+      const path = explicitProfile;
+      return { ok: !!path, path };
+    })()
+  `);
+    if (!result?.ok || !result.path)
+        return '';
+    return new URL(result.path, INSTAGRAM_HOME_URL).toString();
+}
+async function collectVisibleProfilePostPaths(page) {
+    const result = await page.evaluate(`
+    (() => {
+      const isVisible = (el) => {
+        if (!(el instanceof HTMLElement)) return false;
+        const style = window.getComputedStyle(el);
+        const rect = el.getBoundingClientRect();
+        return style.display !== 'none'
+          && style.visibility !== 'hidden'
+          && rect.width > 0
+          && rect.height > 0;
+      };
+
+      const hrefs = Array.from(document.querySelectorAll('a[href*="/p/"]'))
+        .filter((el) => el instanceof HTMLAnchorElement && isVisible(el))
+        .map((el) => el.getAttribute('href') || '')
+        .filter((href) => /^\\/(?:[^/?#]+\\/)?p\\/[^/?#]+\\/?$/.test(href))
+        .filter((href, index, arr) => arr.indexOf(href) === index);
+
+      return { ok: hrefs.length > 0, hrefs };
+    })()
+  `);
+    return Array.isArray(result?.hrefs) ? result.hrefs.filter(Boolean) : [];
+}
+async function captureExistingProfilePostPaths(page) {
+    const currentUserId = await resolveCurrentUserId(page);
+    if (!currentUserId)
+        return new Set();
+    const profileUrl = await resolveProfileUrl(page, currentUserId);
+    if (!profileUrl)
+        return new Set();
+    try {
+        await page.goto(profileUrl);
+        await page.wait({ time: 3 });
+        return new Set(await collectVisibleProfilePostPaths(page));
+    }
+    catch {
+        return new Set();
+    }
+}
+async function resolveLatestPostUrl(page, existingPostPaths) {
+    const currentUrl = await page.getCurrentUrl?.();
+    if (currentUrl && /\/p\//.test(currentUrl))
+        return currentUrl;
+    const currentUserId = await resolveCurrentUserId(page);
+    const profileUrl = await resolveProfileUrl(page, currentUserId);
+    if (!profileUrl)
+        return '';
+    await page.goto(profileUrl);
+    await page.wait({ time: 4 });
+    for (let attempt = 0; attempt < 8; attempt++) {
+        const hrefs = await collectVisibleProfilePostPaths(page);
+        const href = hrefs.find((candidate) => !existingPostPaths.has(candidate)) || '';
+        if (href) {
+            return new URL(href, INSTAGRAM_HOME_URL).toString();
+        }
+        if (attempt < 7)
+            await page.wait({ time: 1 });
+    }
+    return '';
+}
+cli({
+    site: 'instagram',
+    name: 'post',
+    access: 'write',
+    description: 'Post an Instagram feed image or mixed-media carousel',
+    domain: 'www.instagram.com',
+    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: '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)' },
+    ],
+    columns: ['status', 'detail', 'url'],
+    validateArgs: validateInstagramPostArgs,
+    func: async (page, kwargs) => {
+        const browserPage = requirePage(page);
+        const mediaItems = normalizePostMediaItems(kwargs);
+        const content = String(kwargs.content ?? '').trim();
+        const existingPostPaths = await captureExistingProfilePostPaths(browserPage);
+        const commandAttemptBudget = getCommandAttemptBudget(mediaItems);
+        const preUploadDelaySeconds = getPreUploadDelaySeconds(mediaItems);
+        const uploadAttemptBudget = getUploadAttemptBudget(mediaItems);
+        const previewProbeWindowSeconds = getPreviewProbeWindowSeconds(mediaItems);
+        const finalPreviewWaitSeconds = getFinalPreviewWaitSeconds(mediaItems);
+        const preShareDelaySeconds = getPreShareDelaySeconds(mediaItems);
+        const inlineUploadRetryBudget = getInlineUploadRetryBudget(mediaItems);
+        const protocolCaptureEnabled = process.env.OPENCLI_INSTAGRAM_CAPTURE === '1';
+        const protocolCaptureData = [];
+        const protocolCaptureErrors = [];
+        const installProtocolCapture = async () => {
+            if (!protocolCaptureEnabled)
+                return;
+            await installInstagramProtocolCapture(browserPage);
+        };
+        const drainProtocolCapture = async () => {
+            if (!protocolCaptureEnabled)
+                return;
+            const payload = await readInstagramProtocolCapture(browserPage);
+            if (payload.data.length)
+                protocolCaptureData.push(...payload.data);
+            if (payload.errors.length)
+                protocolCaptureErrors.push(...payload.errors);
+        };
+        try {
+            try {
+                return await executePrivateInstagramPost({
+                    page: browserPage,
+                    mediaItems,
+                    content,
+                    existingPostPaths,
+                });
+            }
+            catch (error) {
+                if (error instanceof AuthRequiredError || !isSafePrivateRouteFallbackError(error)) {
+                    throw error;
+                }
+                try {
+                    return await executeUiInstagramPost({
+                        page: browserPage,
+                        mediaItems,
+                        content,
+                        existingPostPaths,
+                        commandAttemptBudget,
+                        preUploadDelaySeconds,
+                        uploadAttemptBudget,
+                        previewProbeWindowSeconds,
+                        finalPreviewWaitSeconds,
+                        preShareDelaySeconds,
+                        inlineUploadRetryBudget,
+                        installProtocolCapture,
+                        drainProtocolCapture,
+                        forceFreshStart: true,
+                    });
+                }
+                catch (uiError) {
+                    if (uiError instanceof AuthRequiredError)
+                        throw uiError;
+                    if (uiError instanceof CommandExecutionError) {
+                        throw new CommandExecutionError(uiError.message, buildFallbackHint(error, uiError));
+                    }
+                    throw uiError;
+                }
+            }
+        }
+        finally {
+            if (protocolCaptureEnabled) {
+                try {
+                    await drainProtocolCapture();
+                }
+                catch {
+                    // Best-effort: capture export should not hide the main command result.
+                }
+                fs.writeFileSync(INSTAGRAM_PROTOCOL_TRACE_OUTPUT_PATH, JSON.stringify({
+                    data: protocolCaptureData,
+                    errors: protocolCaptureErrors,
+                }, null, 2));
+            }
+        }
+    },
+});