@jackwener/opencli 1.6.0 → 1.6.2

package/src/clis/instagram/_shared/private-publish.ts

@@ -0,0 +1,1303 @@
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+import { CommandExecutionError } from '../../../errors.js';
+import type { BrowserCookie, IPage } from '../../../types.js';
+import type { InstagramProtocolCaptureEntry } from './protocol-capture.js';
+import { instagramPrivateApiFetch } from './protocol-capture.js';
+import {
+  buildReadInstagramRuntimeInfoJs,
+  extractInstagramRuntimeInfo,
+  type InstagramRuntimeInfo,
+} from './runtime-info.js';
+export {
+  buildReadInstagramRuntimeInfoJs,
+  extractInstagramRuntimeInfo,
+  type InstagramRuntimeInfo,
+  resolveInstagramRuntimeInfo,
+} from './runtime-info.js';
+
+export interface InstagramPrivateApiContext {
+  asbdId: string;
+  csrfToken: string;
+  igAppId: string;
+  igWwwClaim: string;
+  instagramAjax: string;
+  webSessionId: string;
+}
+
+export interface InstagramImageAsset {
+  filePath: string;
+  fileName: string;
+  mimeType: string;
+  width: number;
+  height: number;
+  byteLength: number;
+  bytes: Buffer;
+}
+
+export interface PreparedInstagramImageAsset extends InstagramImageAsset {
+  cleanupPath?: string;
+}
+
+export type InstagramMediaKind = 'image' | 'video';
+
+export interface InstagramMediaItem {
+  type: InstagramMediaKind;
+  filePath: string;
+}
+
+export interface InstagramVideoAsset {
+  filePath: string;
+  fileName: string;
+  mimeType: string;
+  width: number;
+  height: number;
+  durationMs: number;
+  byteLength: number;
+  bytes: Buffer;
+  coverImage: PreparedInstagramImageAsset;
+  cleanupPaths?: string[];
+}
+
+export type PreparedInstagramMediaAsset =
+  | { type: 'image'; asset: PreparedInstagramImageAsset }
+  | { type: 'video'; asset: InstagramVideoAsset };
+
+type StoryPayloadInput = {
+  uploadId: string;
+  width: number;
+  height: number;
+  now?: () => number;
+  jazoest: string;
+};
+
+type StoryVideoPayloadInput = StoryPayloadInput & {
+  durationMs: number;
+};
+
+type PrivateApiFetchInit = {
+  method?: string;
+  headers?: Record<string, string>;
+  body?: unknown;
+};
+
+type PrivateApiFetchLike = (url: string | URL, init?: PrivateApiFetchInit) => Promise<Response>;
+
+const INSTAGRAM_MIN_FEED_ASPECT_RATIO = 4 / 5;
+const INSTAGRAM_MAX_FEED_ASPECT_RATIO = 1.91;
+const INSTAGRAM_MIN_STORY_ASPECT_RATIO = 9 / 16;
+const INSTAGRAM_MAX_STORY_ASPECT_RATIO = 3 / 4;
+const INSTAGRAM_PRIVATE_PAD_COLOR = 'FFFFFF';
+const INSTAGRAM_HOME_URL = 'https://www.instagram.com/';
+const INSTAGRAM_PRIVATE_CAPTURE_PATTERN = '/api/v1/|/graphql/';
+const INSTAGRAM_PRIVATE_CONFIG_RETRY_BUDGET = 2;
+const INSTAGRAM_PRIVATE_UPLOAD_RETRY_BUDGET = 2;
+const INSTAGRAM_PRIVATE_SIDECAR_TRANSCODE_ATTEMPTS = 20;
+const INSTAGRAM_PRIVATE_SIDECAR_TRANSCODE_WAIT_MS = 2000;
+const INSTAGRAM_MAX_STORY_VIDEO_DURATION_MS = 15_000;
+const INSTAGRAM_STORY_SIG_KEY = '19ce5f445dbfd9d29c59dc2a78c616a7fc090a8e018b9267bc4240a30244c53b';
+const INSTAGRAM_STORY_SIG_KEY_VERSION = '4';
+const INSTAGRAM_STORY_DEVICE = {
+  manufacturer: 'samsung',
+  model: 'SM-G930F',
+  android_version: 24,
+  android_release: '7.0',
+} as const;
+
+export function derivePrivateApiContextFromCapture(
+  entries: InstagramProtocolCaptureEntry[],
+): InstagramPrivateApiContext | null {
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    const headers = entries[index]?.requestHeaders ?? {};
+    const context = {
+      asbdId: String(headers['X-ASBD-ID'] || ''),
+      csrfToken: String(headers['X-CSRFToken'] || ''),
+      igAppId: String(headers['X-IG-App-ID'] || ''),
+      igWwwClaim: String(headers['X-IG-WWW-Claim'] || ''),
+      instagramAjax: String(headers['X-Instagram-AJAX'] || ''),
+      webSessionId: String(headers['X-Web-Session-ID'] || ''),
+    };
+    if (
+      context.asbdId
+      && context.csrfToken
+      && context.igAppId
+      && context.igWwwClaim
+      && context.instagramAjax
+      && context.webSessionId
+    ) {
+      return context;
+    }
+  }
+  return null;
+}
+
+function derivePartialPrivateApiContextFromCapture(
+  entries: InstagramProtocolCaptureEntry[],
+): Partial<InstagramPrivateApiContext> {
+  const context: Partial<InstagramPrivateApiContext> = {};
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    const headers = entries[index]?.requestHeaders ?? {};
+    if (!context.asbdId && headers['X-ASBD-ID']) context.asbdId = String(headers['X-ASBD-ID']);
+    if (!context.csrfToken && headers['X-CSRFToken']) context.csrfToken = String(headers['X-CSRFToken']);
+    if (!context.igAppId && headers['X-IG-App-ID']) context.igAppId = String(headers['X-IG-App-ID']);
+    if (!context.igWwwClaim && headers['X-IG-WWW-Claim']) context.igWwwClaim = String(headers['X-IG-WWW-Claim']);
+    if (!context.instagramAjax && headers['X-Instagram-AJAX']) context.instagramAjax = String(headers['X-Instagram-AJAX']);
+    if (!context.webSessionId && headers['X-Web-Session-ID']) context.webSessionId = String(headers['X-Web-Session-ID']);
+  }
+  return context;
+}
+
+export function deriveInstagramJazoest(value: string): string {
+  if (!value) return '';
+  const sum = Array.from(value).reduce((total, char) => total + char.charCodeAt(0), 0);
+  return `2${sum}`;
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function isTransientPrivateFetchError(error: unknown): boolean {
+  const message = error instanceof Error ? error.message : String(error);
+  return /fetch failed|network|socket hang up|econnreset|etimedout/i.test(message);
+}
+
+function getCookieValue(cookies: BrowserCookie[], name: string): string {
+  return cookies.find((cookie) => cookie.name === name)?.value || '';
+}
+
+export async function resolveInstagramPrivatePublishConfig(page: IPage): Promise<{
+  apiContext: InstagramPrivateApiContext;
+  jazoest: string;
+}> {
+  let lastError: unknown;
+  for (let attempt = 0; attempt < INSTAGRAM_PRIVATE_CONFIG_RETRY_BUDGET; attempt += 1) {
+    try {
+      if (typeof page.startNetworkCapture === 'function') {
+        await page.startNetworkCapture(INSTAGRAM_PRIVATE_CAPTURE_PATTERN);
+      }
+      await page.goto(`${INSTAGRAM_HOME_URL}?__opencli_private_probe=${Date.now()}`);
+      await page.wait({ time: 2 });
+
+      const [cookies, runtime, entries] = await Promise.all([
+        page.getCookies({ domain: 'instagram.com' }),
+        page.evaluate(buildReadInstagramRuntimeInfoJs()) as Promise<InstagramRuntimeInfo>,
+        typeof page.readNetworkCapture === 'function'
+          ? page.readNetworkCapture() as Promise<unknown[]>
+          : Promise.resolve([]),
+      ]);
+
+      const captureEntries = (Array.isArray(entries) ? entries : []) as InstagramProtocolCaptureEntry[];
+      const capturedContext = derivePrivateApiContextFromCapture(captureEntries)
+        ?? derivePartialPrivateApiContextFromCapture(captureEntries);
+
+      const csrfToken = runtime?.csrfToken || getCookieValue(cookies, 'csrftoken') || capturedContext.csrfToken || '';
+      const igAppId = runtime?.appId || capturedContext.igAppId || '';
+      const instagramAjax = runtime?.instagramAjax || capturedContext.instagramAjax || '';
+      if (!csrfToken) {
+        throw new CommandExecutionError('Instagram private route could not derive CSRF token from browser session');
+      }
+      if (!igAppId) {
+        throw new CommandExecutionError('Instagram private route could not derive X-IG-App-ID from instagram runtime');
+      }
+      if (!instagramAjax) {
+        throw new CommandExecutionError('Instagram private route could not derive X-Instagram-AJAX from instagram runtime');
+      }
+      const asbdId = capturedContext.asbdId || '';
+      const igWwwClaim = capturedContext.igWwwClaim || '';
+      const webSessionId = capturedContext.webSessionId || '';
+
+      return {
+        apiContext: {
+          asbdId,
+          csrfToken,
+          igAppId,
+          igWwwClaim,
+          instagramAjax,
+          webSessionId,
+        },
+        jazoest: deriveInstagramJazoest(csrfToken),
+      };
+    } catch (error) {
+      lastError = error;
+      if (!isTransientPrivateFetchError(error) || attempt >= INSTAGRAM_PRIVATE_CONFIG_RETRY_BUDGET - 1) {
+        throw error;
+      }
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+
+export function buildConfigureBody(input: {
+  uploadId: string;
+  caption: string;
+  jazoest: string;
+}): string {
+  const body = new URLSearchParams();
+  body.set('archive_only', 'false');
+  body.set('caption', input.caption);
+  body.set('clips_share_preview_to_feed', '1');
+  body.set('disable_comments', '0');
+  body.set('disable_oa_reuse', 'false');
+  body.set('igtv_share_preview_to_feed', '1');
+  body.set('is_meta_only_post', '0');
+  body.set('is_unified_video', '1');
+  body.set('like_and_view_counts_disabled', '0');
+  body.set('media_share_flow', 'creation_flow');
+  body.set('share_to_facebook', '');
+  body.set('share_to_fb_destination_type', 'USER');
+  body.set('source_type', 'library');
+  body.set('upload_id', input.uploadId);
+  body.set('video_subtitles_enabled', '0');
+  body.set('jazoest', input.jazoest);
+  return body.toString();
+}
+
+export function buildConfigureSidecarPayload(input: {
+  uploadIds: string[];
+  caption: string;
+  clientSidecarId: string;
+  jazoest: string;
+}): Record<string, unknown> {
+  return {
+    archive_only: false,
+    caption: input.caption,
+    children_metadata: input.uploadIds.map((uploadId) => ({ upload_id: uploadId })),
+    client_sidecar_id: input.clientSidecarId,
+    disable_comments: '0',
+    is_meta_only_post: false,
+    is_open_to_public_submission: false,
+    like_and_view_counts_disabled: 0,
+    media_share_flow: 'creation_flow',
+    share_to_facebook: '',
+    share_to_fb_destination_type: 'USER',
+    source_type: 'library',
+    jazoest: input.jazoest,
+  };
+}
+
+function inferMimeType(filePath: string): string {
+  const ext = path.extname(filePath).toLowerCase();
+  switch (ext) {
+    case '.png':
+      return 'image/png';
+    case '.webp':
+      return 'image/webp';
+    case '.jpg':
+    case '.jpeg':
+    default:
+      return 'image/jpeg';
+  }
+}
+
+function readPngDimensions(bytes: Buffer): { width: number; height: number } | null {
+  if (bytes.length < 24) return null;
+  if (bytes.subarray(0, 8).toString('hex').toUpperCase() !== '89504E470D0A1A0A') return null;
+  if (bytes.subarray(12, 16).toString('ascii') !== 'IHDR') return null;
+  return {
+    width: bytes.readUInt32BE(16),
+    height: bytes.readUInt32BE(20),
+  };
+}
+
+function readJpegDimensions(bytes: Buffer): { width: number; height: number } | null {
+  if (bytes.length < 4 || bytes[0] !== 0xff || bytes[1] !== 0xd8) return null;
+  let offset = 2;
+  while (offset + 9 < bytes.length) {
+    if (bytes[offset] !== 0xff) {
+      offset += 1;
+      continue;
+    }
+    const marker = bytes[offset + 1];
+    offset += 2;
+    if (marker === 0xd8 || marker === 0xd9) continue;
+    if (offset + 2 > bytes.length) break;
+    const segmentLength = bytes.readUInt16BE(offset);
+    if (segmentLength < 2 || offset + segmentLength > bytes.length) break;
+    const isStartOfFrame = marker >= 0xc0 && marker <= 0xcf && ![0xc4, 0xc8, 0xcc].includes(marker);
+    if (isStartOfFrame && segmentLength >= 7) {
+      return {
+        height: bytes.readUInt16BE(offset + 3),
+        width: bytes.readUInt16BE(offset + 5),
+      };
+    }
+    offset += segmentLength;
+  }
+  return null;
+}
+
+function readWebpDimensions(bytes: Buffer): { width: number; height: number } | null {
+  if (bytes.length < 30) return null;
+  if (bytes.subarray(0, 4).toString('ascii') !== 'RIFF' || bytes.subarray(8, 12).toString('ascii') !== 'WEBP') {
+    return null;
+  }
+
+  const chunkType = bytes.subarray(12, 16).toString('ascii');
+  if (chunkType === 'VP8X' && bytes.length >= 30) {
+    return {
+      width: 1 + bytes.readUIntLE(24, 3),
+      height: 1 + bytes.readUIntLE(27, 3),
+    };
+  }
+
+  if (chunkType === 'VP8 ' && bytes.length >= 30) {
+    return {
+      width: bytes.readUInt16LE(26) & 0x3fff,
+      height: bytes.readUInt16LE(28) & 0x3fff,
+    };
+  }
+
+  if (chunkType === 'VP8L' && bytes.length >= 25) {
+    const bits = bytes.readUInt32LE(21);
+    return {
+      width: (bits & 0x3fff) + 1,
+      height: ((bits >> 14) & 0x3fff) + 1,
+    };
+  }
+
+  return null;
+}
+
+function readImageDimensions(filePath: string, bytes: Buffer): { width: number; height: number } {
+  const ext = path.extname(filePath).toLowerCase();
+  const dimensions = ext === '.png'
+    ? readPngDimensions(bytes)
+    : ext === '.webp'
+      ? readWebpDimensions(bytes)
+      : readJpegDimensions(bytes);
+  if (!dimensions) {
+    throw new CommandExecutionError(`Failed to read image dimensions for ${filePath}`);
+  }
+  return dimensions;
+}
+
+export function readImageAsset(filePath: string): InstagramImageAsset {
+  const bytes = fs.readFileSync(filePath);
+  const { width, height } = readImageDimensions(filePath, bytes);
+  return {
+    filePath,
+    fileName: path.basename(filePath),
+    mimeType: inferMimeType(filePath),
+    width,
+    height,
+    byteLength: bytes.length,
+    bytes,
+  };
+}
+
+export function isInstagramFeedAspectRatioAllowed(width: number, height: number): boolean {
+  const ratio = width / Math.max(height, 1);
+  return ratio >= INSTAGRAM_MIN_FEED_ASPECT_RATIO - 0.001
+    && ratio <= INSTAGRAM_MAX_FEED_ASPECT_RATIO + 0.001;
+}
+
+export function getInstagramFeedNormalizedDimensions(
+  width: number,
+  height: number,
+): { width: number; height: number } | null {
+  const ratio = width / Math.max(height, 1);
+  if (ratio < INSTAGRAM_MIN_FEED_ASPECT_RATIO) {
+    return {
+      width: Math.ceil(height * INSTAGRAM_MIN_FEED_ASPECT_RATIO),
+      height,
+    };
+  }
+  if (ratio > INSTAGRAM_MAX_FEED_ASPECT_RATIO) {
+    return {
+      width,
+      height: Math.ceil(width / INSTAGRAM_MAX_FEED_ASPECT_RATIO),
+    };
+  }
+  return null;
+}
+
+export function isInstagramStoryAspectRatioAllowed(width: number, height: number): boolean {
+  const ratio = width / Math.max(height, 1);
+  return ratio >= INSTAGRAM_MIN_STORY_ASPECT_RATIO - 0.001
+    && ratio <= INSTAGRAM_MAX_STORY_ASPECT_RATIO + 0.001;
+}
+
+export function getInstagramStoryNormalizedDimensions(
+  width: number,
+  height: number,
+): { width: number; height: number } | null {
+  const ratio = width / Math.max(height, 1);
+  if (ratio < INSTAGRAM_MIN_STORY_ASPECT_RATIO) {
+    return {
+      width: Math.ceil(height * INSTAGRAM_MIN_STORY_ASPECT_RATIO),
+      height,
+    };
+  }
+  if (ratio > INSTAGRAM_MAX_STORY_ASPECT_RATIO) {
+    return {
+      width,
+      height: Math.ceil(width / INSTAGRAM_MAX_STORY_ASPECT_RATIO),
+    };
+  }
+  return null;
+}
+
+function buildPrivateNormalizedImagePath(filePath: string): string {
+  const parsed = path.parse(filePath);
+  return path.join(
+    os.tmpdir(),
+    `opencli-instagram-private-${parsed.name}-${crypto.randomUUID()}${parsed.ext || '.png'}`,
+  );
+}
+
+export function prepareImageAssetForPrivateUpload(filePath: string): PreparedInstagramImageAsset {
+  const asset = readImageAsset(filePath);
+  const normalizedDimensions = getInstagramFeedNormalizedDimensions(asset.width, asset.height);
+  if (!normalizedDimensions) {
+    return asset;
+  }
+
+  if (process.platform !== 'darwin') {
+    throw new CommandExecutionError(
+      `Instagram private publish does not support auto-normalizing ${asset.fileName} on ${process.platform}`,
+      `Use images within ${INSTAGRAM_MIN_FEED_ASPECT_RATIO.toFixed(2)}-${INSTAGRAM_MAX_FEED_ASPECT_RATIO.toFixed(2)} aspect ratio, or use the UI route`,
+    );
+  }
+
+  const outputPath = buildPrivateNormalizedImagePath(filePath);
+  const result = spawnSync('sips', [
+    '--padToHeightWidth',
+    String(normalizedDimensions.height),
+    String(normalizedDimensions.width),
+    '--padColor',
+    INSTAGRAM_PRIVATE_PAD_COLOR,
+    filePath,
+    '--out',
+    outputPath,
+  ], {
+    encoding: 'utf8',
+  });
+
+  if (result.error || result.status !== 0 || !fs.existsSync(outputPath)) {
+    const detail = [result.error?.message, result.stderr, result.stdout]
+      .map((value) => String(value || '').trim())
+      .filter(Boolean)
+      .join(' ');
+    throw new CommandExecutionError(
+      `Instagram private publish failed to normalize ${asset.fileName}`,
+      detail || 'sips padToHeightWidth failed',
+    );
+  }
+
+  return {
+    ...readImageAsset(outputPath),
+    cleanupPath: outputPath,
+  };
+}
+
+export function prepareImageAssetForPrivateStoryUpload(filePath: string): PreparedInstagramImageAsset {
+  const asset = readImageAsset(filePath);
+  const normalizedDimensions = getInstagramStoryNormalizedDimensions(asset.width, asset.height);
+  if (!normalizedDimensions) {
+    return asset;
+  }
+
+  if (process.platform !== 'darwin') {
+    throw new CommandExecutionError(
+      `Instagram private story publish does not support auto-normalizing ${asset.fileName} on ${process.platform}`,
+      `Use images within ${INSTAGRAM_MIN_STORY_ASPECT_RATIO.toFixed(2)}-${INSTAGRAM_MAX_STORY_ASPECT_RATIO.toFixed(2)} aspect ratio, or use the UI route`,
+    );
+  }
+
+  const outputPath = buildPrivateNormalizedImagePath(filePath);
+  const result = spawnSync('sips', [
+    '--padToHeightWidth',
+    String(normalizedDimensions.height),
+    String(normalizedDimensions.width),
+    '--padColor',
+    INSTAGRAM_PRIVATE_PAD_COLOR,
+    filePath,
+    '--out',
+    outputPath,
+  ], {
+    encoding: 'utf8',
+  });
+
+  if (result.error || result.status !== 0 || !fs.existsSync(outputPath)) {
+    const detail = [result.error?.message, result.stderr, result.stdout]
+      .map((value) => String(value || '').trim())
+      .filter(Boolean)
+      .join(' ');
+    throw new CommandExecutionError(
+      `Instagram private story publish failed to normalize ${asset.fileName}`,
+      detail || 'sips padToHeightWidth failed',
+    );
+  }
+
+  return {
+    ...readImageAsset(outputPath),
+    cleanupPath: outputPath,
+  };
+}
+
+function runSwiftJsonScript<T>(script: string, args: string[], stage: string): T {
+  const scriptPath = path.join(os.tmpdir(), `opencli-instagram-${crypto.randomUUID()}.swift`);
+  fs.writeFileSync(scriptPath, script);
+  try {
+    const result = spawnSync('swift', [scriptPath, ...args], {
+      encoding: 'utf8',
+    });
+    if (result.error || result.status !== 0) {
+      const detail = [result.error?.message, result.stderr, result.stdout]
+        .map((value) => String(value || '').trim())
+        .filter(Boolean)
+        .join(' ');
+      throw new CommandExecutionError(
+        `Instagram private publish failed to ${stage}`,
+        detail || 'swift helper failed',
+      );
+    }
+    return JSON.parse(String(result.stdout || '{}')) as T;
+  } catch (error) {
+    if (error instanceof CommandExecutionError) throw error;
+    throw new CommandExecutionError(
+      `Instagram private publish failed to ${stage}`,
+      error instanceof Error ? error.message : String(error),
+    );
+  } finally {
+    fs.rmSync(scriptPath, { force: true });
+  }
+}
+
+function readVideoMetadata(filePath: string): { width: number; height: number; durationMs: number } {
+  if (process.platform !== 'darwin') {
+    throw new CommandExecutionError(
+      `Instagram private mixed-media publish does not support reading video metadata on ${process.platform}`,
+      'Use macOS for private mixed-media publishing, or rely on the UI fallback',
+    );
+  }
+
+  const metadata = runSwiftJsonScript<{ width?: number; height?: number; durationMs?: number }>(`
+import AVFoundation
+import Foundation
+
+let path = CommandLine.arguments[1]
+let url = URL(fileURLWithPath: path)
+let asset = AVURLAsset(url: url)
+guard let track = asset.tracks(withMediaType: .video).first else {
+  fputs("{\\"error\\":\\"missing-video-track\\"}", stderr)
+  exit(1)
+}
+let transformed = track.naturalSize.applying(track.preferredTransform)
+let width = Int(abs(transformed.width.rounded()))
+let height = Int(abs(transformed.height.rounded()))
+let durationMs = Int((CMTimeGetSeconds(asset.duration) * 1000.0).rounded())
+let payload: [String: Int] = [
+  "width": width,
+  "height": height,
+  "durationMs": durationMs,
+]
+let data = try JSONSerialization.data(withJSONObject: payload, options: [])
+FileHandle.standardOutput.write(data)
+`, [filePath], 'read video metadata');
+
+  if (!metadata.width || !metadata.height || !metadata.durationMs) {
+    throw new CommandExecutionError(`Instagram private publish failed to read video metadata for ${filePath}`);
+  }
+  return {
+    width: metadata.width,
+    height: metadata.height,
+    durationMs: metadata.durationMs,
+  };
+}
+
+function buildPrivateVideoCoverPath(filePath: string): string {
+  const parsed = path.parse(filePath);
+  return path.join(
+    os.tmpdir(),
+    `opencli-instagram-private-video-cover-${parsed.name}-${crypto.randomUUID()}.jpg`,
+  );
+}
+
+function buildPrivateStoryVideoPath(filePath: string): string {
+  const parsed = path.parse(filePath);
+  return path.join(
+    os.tmpdir(),
+    `opencli-instagram-story-video-${parsed.name}-${crypto.randomUUID()}${parsed.ext || '.mp4'}`,
+  );
+}
+
+function generateVideoCoverImage(filePath: string): PreparedInstagramImageAsset {
+  if (process.platform !== 'darwin') {
+    throw new CommandExecutionError(
+      `Instagram private mixed-media publish does not support generating video covers on ${process.platform}`,
+      'Use macOS for private mixed-media publishing, or rely on the UI fallback',
+    );
+  }
+
+  const outputPath = buildPrivateVideoCoverPath(filePath);
+  runSwiftJsonScript<{ ok?: boolean }>(`
+import AVFoundation
+import AppKit
+import Foundation
+
+let inputPath = CommandLine.arguments[1]
+let outputPath = CommandLine.arguments[2]
+let asset = AVURLAsset(url: URL(fileURLWithPath: inputPath))
+let generator = AVAssetImageGenerator(asset: asset)
+generator.appliesPreferredTrackTransform = true
+let image = try generator.copyCGImage(at: CMTime(seconds: 0, preferredTimescale: 600), actualTime: nil)
+let rep = NSBitmapImageRep(cgImage: image)
+guard let data = rep.representation(using: .jpeg, properties: [.compressionFactor: 0.9]) else {
+  fputs("{\\"error\\":\\"jpeg-encode-failed\\"}", stderr)
+  exit(1)
+}
+try data.write(to: URL(fileURLWithPath: outputPath))
+let payload = ["ok": true]
+let json = try JSONSerialization.data(withJSONObject: payload, options: [])
+FileHandle.standardOutput.write(json)
+`, [filePath, outputPath], 'generate video cover');
+
+  return {
+    ...readImageAsset(outputPath),
+    cleanupPath: outputPath,
+  };
+}
+
+export function readVideoAsset(filePath: string): InstagramVideoAsset {
+  const bytes = fs.readFileSync(filePath);
+  const metadata = readVideoMetadata(filePath);
+  const coverImage = generateVideoCoverImage(filePath);
+  return {
+    filePath,
+    fileName: path.basename(filePath),
+    mimeType: 'video/mp4',
+    width: metadata.width,
+    height: metadata.height,
+    durationMs: metadata.durationMs,
+    byteLength: bytes.length,
+    bytes,
+    coverImage,
+    cleanupPaths: coverImage.cleanupPath ? [coverImage.cleanupPath] : [],
+  };
+}
+
+function trimVideoForInstagramStory(filePath: string, maxDurationMs: number): string {
+  if (process.platform !== 'darwin') {
+    throw new CommandExecutionError(
+      `Instagram private story publish does not support trimming long videos on ${process.platform}`,
+      'Use macOS for private story video publishing, or trim the video to 15 seconds first',
+    );
+  }
+
+  const outputPath = buildPrivateStoryVideoPath(filePath);
+  runSwiftJsonScript<{ ok?: boolean }>(`
+import AVFoundation
+import Foundation
+
+let inputPath = CommandLine.arguments[1]
+let outputPath = CommandLine.arguments[2]
+let durationMs = Int(CommandLine.arguments[3]) ?? 15000
+let asset = AVURLAsset(url: URL(fileURLWithPath: inputPath))
+guard let exportSession = AVAssetExportSession(asset: asset, presetName: AVAssetExportPresetHighestQuality) else {
+  fputs("{\\"error\\":\\"missing-export-session\\"}", stderr)
+  exit(1)
+}
+exportSession.outputURL = URL(fileURLWithPath: outputPath)
+exportSession.outputFileType = .mp4
+exportSession.shouldOptimizeForNetworkUse = true
+exportSession.timeRange = CMTimeRange(
+  start: .zero,
+  duration: CMTime(seconds: Double(durationMs) / 1000.0, preferredTimescale: 600)
+)
+let semaphore = DispatchSemaphore(value: 0)
+exportSession.exportAsynchronously {
+  semaphore.signal()
+}
+semaphore.wait()
+if exportSession.status != .completed {
+  let message = exportSession.error?.localizedDescription ?? "export-failed"
+  fputs(message, stderr)
+  exit(1)
+}
+let payload = ["ok": true]
+let json = try JSONSerialization.data(withJSONObject: payload, options: [])
+FileHandle.standardOutput.write(json)
+`, [filePath, outputPath, String(maxDurationMs)], 'trim story video');
+
+  return outputPath;
+}
+
+function prepareVideoAssetForPrivateStoryUpload(filePath: string): InstagramVideoAsset {
+  const asset = readVideoAsset(filePath);
+  if (asset.durationMs <= INSTAGRAM_MAX_STORY_VIDEO_DURATION_MS) {
+    return asset;
+  }
+
+  const trimmedPath = trimVideoForInstagramStory(filePath, INSTAGRAM_MAX_STORY_VIDEO_DURATION_MS);
+  const trimmedAsset = readVideoAsset(trimmedPath);
+  return {
+    ...trimmedAsset,
+    cleanupPaths: [
+      ...(trimmedAsset.cleanupPaths || []),
+      trimmedPath,
+    ],
+  };
+}
+
+function toUnixSeconds(now: () => number): number {
+  const value = now();
+  return value > 10_000_000_000 ? Math.floor(value / 1000) : Math.floor(value);
+}
+
+export function buildConfigureToStoryPhotoPayload(input: StoryPayloadInput): Record<string, unknown> {
+  const now = input.now ?? (() => Date.now());
+  const timestamp = toUnixSeconds(now);
+  return {
+    source_type: '4',
+    upload_id: input.uploadId,
+    story_media_creation_date: String(timestamp - 17),
+    client_shared_at: String(timestamp - 5),
+    client_timestamp: String(timestamp),
+    configure_mode: 1,
+    edits: {
+      crop_original_size: [input.width, input.height],
+      crop_center: [0, 0],
+      crop_zoom: 1.3333334,
+    },
+    extra: {
+      source_width: input.width,
+      source_height: input.height,
+    },
+    jazoest: input.jazoest,
+  };
+}
+
+export function buildConfigureToStoryVideoPayload(input: StoryVideoPayloadInput): Record<string, unknown> {
+  const now = input.now ?? (() => Date.now());
+  const timestamp = toUnixSeconds(now);
+  const durationSeconds = Number((input.durationMs / 1000).toFixed(3));
+  return {
+    source_type: '4',
+    upload_id: input.uploadId,
+    story_media_creation_date: String(timestamp - 17),
+    client_shared_at: String(timestamp - 5),
+    client_timestamp: String(timestamp),
+    configure_mode: 1,
+    poster_frame_index: 0,
+    length: durationSeconds,
+    audio_muted: false,
+    filter_type: '0',
+    video_result: 'deprecated',
+    extra: {
+      source_width: input.width,
+      source_height: input.height,
+    },
+    jazoest: input.jazoest,
+  };
+}
+
+function buildFormEncodedBodyFromPayload(payload: Record<string, unknown>): string {
+  const body = new URLSearchParams();
+  for (const [key, value] of Object.entries(payload)) {
+    if (value === undefined || value === null) continue;
+    if (typeof value === 'object') {
+      body.set(key, JSON.stringify(value));
+      continue;
+    }
+    body.set(key, String(value));
+  }
+  return body.toString();
+}
+
+function buildSignedBody(payload: Record<string, unknown>): string {
+  const jsonPayload = JSON.stringify(payload);
+  const signature = crypto
+    .createHmac('sha256', INSTAGRAM_STORY_SIG_KEY)
+    .update(jsonPayload)
+    .digest('hex');
+  const body = new URLSearchParams();
+  body.set('ig_sig_key_version', INSTAGRAM_STORY_SIG_KEY_VERSION);
+  body.set('signed_body', `${signature}.${jsonPayload}`);
+  return body.toString();
+}
+
+function buildPrivateApiHeaders(context: InstagramPrivateApiContext): Record<string, string> {
+  return Object.fromEntries(Object.entries({
+    'X-ASBD-ID': context.asbdId,
+    'X-CSRFToken': context.csrfToken,
+    'X-IG-App-ID': context.igAppId,
+    'X-IG-WWW-Claim': context.igWwwClaim,
+    'X-Instagram-AJAX': context.instagramAjax,
+    'X-Web-Session-ID': context.webSessionId,
+  }).filter(([, value]) => !!value));
+}
+
+function buildRuploadHeaders(
+  asset: InstagramImageAsset,
+  uploadId: string,
+  context: InstagramPrivateApiContext,
+): Record<string, string> {
+  return {
+    ...buildPrivateApiHeaders(context),
+    'Accept': '*/*',
+    'Content-Type': asset.mimeType,
+    'Offset': '0',
+    'X-Entity-Length': String(asset.byteLength),
+    'X-Entity-Name': `fb_uploader_${uploadId}`,
+    'X-Entity-Type': asset.mimeType,
+    'X-Instagram-Rupload-Params': JSON.stringify({
+      media_type: 1,
+      upload_id: uploadId,
+      upload_media_height: asset.height,
+      upload_media_width: asset.width,
+    }),
+  };
+}
+
+function buildVideoEditParams(asset: InstagramVideoAsset): Record<string, number | boolean> {
+  const cropSize = Math.min(asset.width, asset.height);
+  const trimEndSeconds = Number((asset.durationMs / 1000).toFixed(3));
+  return {
+    crop_height: cropSize,
+    crop_width: cropSize,
+    crop_x1: Math.max(0, Math.floor((asset.width - cropSize) / 2)),
+    crop_y1: Math.max(0, Math.floor((asset.height - cropSize) / 2)),
+    mute: false,
+    trim_end: trimEndSeconds,
+    trim_start: 0,
+  };
+}
+
+function buildVideoRuploadHeaders(
+  asset: InstagramVideoAsset,
+  uploadId: string,
+  context: InstagramPrivateApiContext,
+): Record<string, string> {
+  return {
+    ...buildPrivateApiHeaders(context),
+    'Accept': '*/*',
+    'Offset': '0',
+    'X-Entity-Length': String(asset.byteLength),
+    'X-Entity-Name': `fb_uploader_${uploadId}`,
+    'X-Instagram-Rupload-Params': JSON.stringify({
+      'client-passthrough': '1',
+      'is_unified_video': '0',
+      'is_sidecar': '1',
+      'media_type': 2,
+      'for_album': false,
+      'video_format': '',
+      'upload_id': uploadId,
+      'upload_media_duration_ms': asset.durationMs,
+      'upload_media_height': asset.height,
+      'upload_media_width': asset.width,
+      'video_transform': null,
+      'video_edit_params': buildVideoEditParams(asset),
+    }),
+  };
+}
+
+function buildStoryVideoRuploadHeaders(
+  asset: InstagramVideoAsset,
+  uploadId: string,
+  context: InstagramPrivateApiContext,
+): Record<string, string> {
+  return {
+    ...buildPrivateApiHeaders(context),
+    'Accept': '*/*',
+    'Offset': '0',
+    'X-Entity-Length': String(asset.byteLength),
+    'X-Entity-Name': `fb_uploader_${uploadId}`,
+    'X-Instagram-Rupload-Params': JSON.stringify({
+      'client-passthrough': '1',
+      'media_type': 2,
+      'upload_id': uploadId,
+      'upload_media_duration_ms': asset.durationMs,
+      'upload_media_height': asset.height,
+      'upload_media_width': asset.width,
+      'video_transform': null,
+      'video_edit_params': buildVideoEditParams(asset),
+    }),
+  };
+}
+
+function buildVideoCoverRuploadHeaders(
+  asset: InstagramVideoAsset,
+  uploadId: string,
+  context: InstagramPrivateApiContext,
+): Record<string, string> {
+  return {
+    ...buildPrivateApiHeaders(context),
+    'Accept': '*/*',
+    'Content-Type': asset.coverImage.mimeType,
+    'Offset': '0',
+    'X-Entity-Length': String(asset.coverImage.byteLength),
+    'X-Entity-Name': `fb_uploader_${uploadId}`,
+    'X-Entity-Type': asset.coverImage.mimeType,
+    'X-Instagram-Rupload-Params': JSON.stringify({
+      media_type: 2,
+      upload_id: uploadId,
+      upload_media_height: asset.height,
+      upload_media_width: asset.width,
+    }),
+  };
+}
+
+async function parseJsonResponse(response: Response, stage: string): Promise<any> {
+  const text = await response.text();
+  let data: any;
+  try {
+    data = text ? JSON.parse(text) : {};
+  } catch {
+    throw new CommandExecutionError(`Instagram private publish ${stage} returned invalid JSON`);
+  }
+  if (!response.ok) {
+    const detail = text ? ` ${text.slice(0, 500)}` : '';
+    throw new CommandExecutionError(`Instagram private publish ${stage} failed: ${response.status}${detail}`);
+  }
+  return data;
+}
+
+async function fetchPrivateUploadWithRetry(
+  fetcher: PrivateApiFetchLike,
+  url: string,
+  init: PrivateApiFetchInit,
+): Promise<Response> {
+  let lastError: unknown;
+  for (let attempt = 0; attempt < INSTAGRAM_PRIVATE_UPLOAD_RETRY_BUDGET; attempt += 1) {
+    try {
+      return await fetcher(url, init);
+    } catch (error) {
+      lastError = error;
+      if (!isTransientPrivateFetchError(error) || attempt >= INSTAGRAM_PRIVATE_UPLOAD_RETRY_BUDGET - 1) {
+        throw error;
+      }
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+
+async function prepareInstagramMediaAsset(item: InstagramMediaItem): Promise<PreparedInstagramMediaAsset> {
+  if (item.type === 'video') {
+    return {
+      type: 'video',
+      asset: readVideoAsset(item.filePath),
+    };
+  }
+  return {
+    type: 'image',
+    asset: prepareImageAssetForPrivateUpload(item.filePath),
+  };
+}
+
+function cleanupPreparedMediaAssets(assets: PreparedInstagramMediaAsset[]): void {
+  for (const prepared of assets) {
+    if (prepared.type === 'image') {
+      if (prepared.asset.cleanupPath) {
+        fs.rmSync(prepared.asset.cleanupPath, { force: true });
+      }
+      continue;
+    }
+    for (const cleanupPath of prepared.asset.cleanupPaths || []) {
+      fs.rmSync(cleanupPath, { force: true });
+    }
+    if (prepared.asset.coverImage.cleanupPath) {
+      fs.rmSync(prepared.asset.coverImage.cleanupPath, { force: true });
+    }
+  }
+}
+
+async function uploadPreparedMediaAsset(
+  fetcher: PrivateApiFetchLike,
+  prepared: PreparedInstagramMediaAsset,
+  uploadId: string,
+  context: InstagramPrivateApiContext,
+  mode: 'feed' | 'story' = 'feed',
+): Promise<void> {
+  if (prepared.type === 'image') {
+    const response = await fetchPrivateUploadWithRetry(fetcher, `https://i.instagram.com/rupload_igphoto/fb_uploader_${uploadId}`, {
+      method: 'POST',
+      headers: buildRuploadHeaders(prepared.asset, uploadId, context),
+      body: prepared.asset.bytes,
+    });
+    const json = await parseJsonResponse(response, 'upload');
+    if (String(json?.status || '') !== 'ok') {
+      throw new CommandExecutionError(`Instagram private publish upload failed for ${prepared.asset.fileName}`);
+    }
+    return;
+  }
+
+  const videoResponse = await fetchPrivateUploadWithRetry(fetcher, `https://i.instagram.com/rupload_igvideo/fb_uploader_${uploadId}`, {
+    method: 'POST',
+    headers: mode === 'story'
+      ? buildStoryVideoRuploadHeaders(prepared.asset, uploadId, context)
+      : buildVideoRuploadHeaders(prepared.asset, uploadId, context),
+    body: prepared.asset.bytes,
+  });
+  const videoJson = await parseJsonResponse(videoResponse, 'video upload');
+  if (String(videoJson?.status || '') !== 'ok') {
+    throw new CommandExecutionError(`Instagram private publish video upload failed for ${prepared.asset.fileName}`);
+  }
+
+  const coverResponse = await fetchPrivateUploadWithRetry(fetcher, `https://i.instagram.com/rupload_igphoto/fb_uploader_${uploadId}`, {
+    method: 'POST',
+    headers: buildVideoCoverRuploadHeaders(prepared.asset, uploadId, context),
+    body: prepared.asset.coverImage.bytes,
+  });
+  const coverJson = await parseJsonResponse(coverResponse, 'video cover upload');
+  if (String(coverJson?.status || '') !== 'ok') {
+    throw new CommandExecutionError(`Instagram private publish video cover upload failed for ${prepared.asset.fileName}`);
+  }
+}
+
+async function publishSidecarWithRetry(input: {
+  fetcher: PrivateApiFetchLike;
+  payload: Record<string, unknown>;
+  apiContext: InstagramPrivateApiContext;
+  waitMs?: (ms: number) => Promise<void>;
+}): Promise<{ code?: string }> {
+  const waitMs = input.waitMs ?? sleep;
+  const requestInit: PrivateApiFetchInit = {
+    method: 'POST',
+    headers: {
+      ...buildPrivateApiHeaders(input.apiContext),
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(input.payload),
+  };
+
+  for (let attempt = 0; attempt < INSTAGRAM_PRIVATE_SIDECAR_TRANSCODE_ATTEMPTS; attempt += 1) {
+    const response = await input.fetcher('https://www.instagram.com/api/v1/media/configure_sidecar/', requestInit);
+    const text = await response.text();
+    let json: any = {};
+    try {
+      json = text ? JSON.parse(text) : {};
+    } catch {
+      throw new CommandExecutionError('Instagram private publish configure_sidecar returned invalid JSON');
+    }
+
+    if (!response.ok) {
+      const detail = text ? ` ${text.slice(0, 500)}` : '';
+      throw new CommandExecutionError(`Instagram private publish configure_sidecar failed: ${response.status}${detail}`);
+    }
+
+    const message = String(json?.message || '');
+    if (
+      response.status === 202
+      || /transcode not finished yet/i.test(message)
+    ) {
+      if (attempt >= INSTAGRAM_PRIVATE_SIDECAR_TRANSCODE_ATTEMPTS - 1) {
+        throw new CommandExecutionError(
+          'Instagram private publish configure_sidecar timed out waiting for video transcode',
+          text.slice(0, 500),
+        );
+      }
+      await waitMs(INSTAGRAM_PRIVATE_SIDECAR_TRANSCODE_WAIT_MS);
+      continue;
+    }
+
+    if (String(json?.status || '').toLowerCase() === 'fail') {
+      throw new CommandExecutionError(
+        'Instagram private publish configure_sidecar failed',
+        message || text.slice(0, 500),
+      );
+    }
+
+    return { code: json?.media?.code };
+  }
+
+  throw new CommandExecutionError('Instagram private publish configure_sidecar failed');
+}
+
+export async function publishMediaViaPrivateApi(input: {
+  page: unknown;
+  mediaItems: InstagramMediaItem[];
+  caption: string;
+  apiContext: InstagramPrivateApiContext;
+  jazoest: string;
+  now?: () => number;
+  fetcher?: PrivateApiFetchLike;
+  prepareMediaAsset?: (item: InstagramMediaItem) => PreparedInstagramMediaAsset | Promise<PreparedInstagramMediaAsset>;
+  waitMs?: (ms: number) => Promise<void>;
+}): Promise<{ code?: string; uploadIds: string[] }> {
+  const now = input.now ?? (() => Date.now());
+  const clientSidecarId = String(now());
+  const uploadIds = input.mediaItems.length > 1
+    ? input.mediaItems.map((_, index) => String(now() + index + 1))
+    : [String(now())];
+  const fetcher: PrivateApiFetchLike = input.fetcher ?? ((url, init) => instagramPrivateApiFetch(input.page as any, url, init as any));
+  const prepareMediaAsset = input.prepareMediaAsset ?? prepareInstagramMediaAsset;
+  const assets = await Promise.all(input.mediaItems.map((item) => prepareMediaAsset(item)));
+
+  try {
+    for (let index = 0; index < assets.length; index += 1) {
+      const asset = assets[index]!;
+      const uploadId = uploadIds[index]!;
+    await uploadPreparedMediaAsset(fetcher, asset, uploadId, input.apiContext);
+    }
+
+    if (uploadIds.length === 1) {
+      if (assets[0]?.type !== 'image') {
+        throw new CommandExecutionError('Instagram private publish only supports single-video uploads through instagram reel');
+      }
+      const response = await fetcher('https://www.instagram.com/api/v1/media/configure/', {
+        method: 'POST',
+        headers: {
+          ...buildPrivateApiHeaders(input.apiContext),
+          'Content-Type': 'application/x-www-form-urlencoded',
+        },
+        body: buildConfigureBody({
+          uploadId: uploadIds[0]!,
+          caption: input.caption,
+          jazoest: input.jazoest,
+        }),
+      });
+      const json = await parseJsonResponse(response, 'configure');
+      return { code: json?.media?.code, uploadIds };
+    }
+
+    const result = await publishSidecarWithRetry({
+      fetcher,
+      payload: buildConfigureSidecarPayload({
+        uploadIds,
+        caption: input.caption,
+        clientSidecarId,
+        jazoest: input.jazoest,
+      }),
+      apiContext: input.apiContext,
+      waitMs: input.waitMs,
+    });
+    return { code: result.code, uploadIds };
+  } finally {
+    cleanupPreparedMediaAssets(assets);
+  }
+}
+
+export async function publishImagesViaPrivateApi(input: {
+  page: unknown;
+  imagePaths: string[];
+  caption: string;
+  apiContext: InstagramPrivateApiContext;
+  jazoest: string;
+  now?: () => number;
+  fetcher?: PrivateApiFetchLike;
+  prepareAsset?: (filePath: string) => PreparedInstagramImageAsset | Promise<PreparedInstagramImageAsset>;
+  waitMs?: (ms: number) => Promise<void>;
+}): Promise<{ code?: string; uploadIds: string[] }> {
+  return publishMediaViaPrivateApi({
+    page: input.page,
+    mediaItems: input.imagePaths.map((filePath) => ({ type: 'image' as const, filePath })),
+    caption: input.caption,
+    apiContext: input.apiContext,
+    jazoest: input.jazoest,
+    now: input.now,
+    fetcher: input.fetcher,
+    waitMs: input.waitMs,
+    prepareMediaAsset: input.prepareAsset
+      ? async (item) => ({
+          type: 'image' as const,
+          asset: await input.prepareAsset!(item.filePath),
+        })
+      : undefined,
+  });
+}
+
+export async function publishStoryViaPrivateApi(input: {
+  page: unknown;
+  mediaItem: InstagramMediaItem;
+  content: string;
+  apiContext: InstagramPrivateApiContext;
+  jazoest: string;
+  currentUserId?: string;
+  now?: () => number;
+  fetcher?: PrivateApiFetchLike;
+  prepareMediaAsset?: (item: InstagramMediaItem) => PreparedInstagramMediaAsset | Promise<PreparedInstagramMediaAsset>;
+}): Promise<{ mediaPk?: string; uploadId: string }> {
+  const now = input.now ?? (() => Date.now());
+  const uploadId = String(now());
+  const fetcher: PrivateApiFetchLike = input.fetcher ?? ((url, init) => instagramPrivateApiFetch(input.page as any, url, init as any));
+  const prepareMediaAsset = input.prepareMediaAsset ?? (async (item: InstagramMediaItem) => item.type === 'video'
+    ? { type: 'video' as const, asset: prepareVideoAssetForPrivateStoryUpload(item.filePath) }
+    : { type: 'image' as const, asset: prepareImageAssetForPrivateStoryUpload(item.filePath) });
+  const prepared = await prepareMediaAsset(input.mediaItem);
+  const currentUserId = input.currentUserId
+    || ('getCookies' in (input.page as any)
+      ? String((await ((input.page as IPage).getCookies?.({ domain: 'instagram.com' }) ?? Promise.resolve([] as BrowserCookie[])))
+        .find((cookie) => cookie.name === 'ds_user_id')?.value || '')
+      : '');
+  if (!currentUserId) {
+    throw new CommandExecutionError('Instagram story publish could not derive current user id from browser session');
+  }
+
+  const signedPayloadBase = {
+    _csrftoken: input.apiContext.csrfToken,
+    _uid: currentUserId,
+    _uuid: crypto.randomUUID(),
+    device: INSTAGRAM_STORY_DEVICE,
+  };
+  const buildSignedStoryPhotoBody = (width: number, height: number) => buildSignedBody({
+    ...buildConfigureToStoryPhotoPayload({
+      uploadId,
+      width,
+      height,
+      now,
+      jazoest: input.jazoest,
+    }),
+    ...signedPayloadBase,
+  });
+  const buildSignedStoryVideoBody = (width: number, height: number, durationMs: number) => buildSignedBody({
+    ...buildConfigureToStoryVideoPayload({
+      uploadId,
+      width,
+      height,
+      durationMs,
+      now,
+      jazoest: input.jazoest,
+    }),
+    ...signedPayloadBase,
+  });
+
+  try {
+    await uploadPreparedMediaAsset(fetcher, prepared, uploadId, input.apiContext, 'story');
+
+    if (prepared.type === 'image') {
+      const response = await fetcher('https://i.instagram.com/api/v1/media/configure_to_story/', {
+        method: 'POST',
+        headers: {
+          ...buildPrivateApiHeaders(input.apiContext),
+          'Content-Type': 'application/x-www-form-urlencoded',
+        },
+        body: buildSignedStoryPhotoBody(prepared.asset.width, prepared.asset.height),
+      });
+      const json = await parseJsonResponse(response, 'configure_to_story');
+      return {
+        mediaPk: String(json?.media?.pk || json?.media?.id || '').split('_')[0] || undefined,
+        uploadId,
+      };
+    }
+
+    await parseJsonResponse(await fetcher('https://i.instagram.com/api/v1/media/configure_to_story/', {
+      method: 'POST',
+      headers: {
+        ...buildPrivateApiHeaders(input.apiContext),
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+      body: buildSignedStoryPhotoBody(prepared.asset.width, prepared.asset.height),
+    }), 'configure_to_story cover');
+
+    const response = await fetcher('https://i.instagram.com/api/v1/media/configure_to_story/?video=1', {
+      method: 'POST',
+      headers: {
+        ...buildPrivateApiHeaders(input.apiContext),
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+      body: buildSignedStoryVideoBody(prepared.asset.width, prepared.asset.height, prepared.asset.durationMs),
+    });
+    const json = await parseJsonResponse(response, 'configure_to_story');
+    return {
+      mediaPk: String(json?.media?.pk || json?.media?.id || '').split('_')[0] || undefined,
+      uploadId,
+    };
+  } finally {
+    cleanupPreparedMediaAssets([prepared]);
+  }
+}