@jackwener/opencli 1.6.2 → 1.6.4

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

@@ -1,1303 +0,0 @@
-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]);
-  }
-}