// Camera payload validation and artifact writers for node media commands.

import * as fs from "node:fs/promises";

import * as path from "node:path";

import { fetchWithSsrFGuard } from "../infra/net/fetch-guard.js";

const MAX_CAMERA_URL_DOWNLOAD_BYTES = 250 * 1024 * 1024;

const MAX_CAMERA_BASE64_BYTES = MAX_CAMERA_URL_DOWNLOAD_BYTES;

/** Camera orientation accepted by node camera commands. */

export type CameraFacing = "front" | "back";

/** Validated still-image payload from `nodes camera snap`. */

export type CameraSnapPayload = {

format: string;

base64?: string;

height: number;

};

/** Validated video payload from `nodes camera clip`. */

export type CameraClipPayload = {

format: string;

base64?: string;

hasAudio: boolean;

};

/** Validate and normalize an unknown camera still-image payload. */

export function parseCameraSnapPayload(value: unknown): CameraSnapPayload {

const obj = asRecord(value);

const format = asString(obj.format);

return { format, ...(base64 ? { base64 } : {}), ...(url ? { url } : {}), width, height };

}

/** Validate and normalize an unknown camera clip payload. */

export function parseCameraClipPayload(value: unknown): CameraClipPayload {

const obj = asRecord(value);

const format = asString(obj.format);

return { format, ...(base64 ? { base64 } : {}), ...(url ? { url } : {}), durationMs, hasAudio };

}

/** Build a deterministic temp path for a camera artifact. */

export function cameraTempPath(opts: {

kind: "snap" | "clip";

facing?: CameraFacing;

return path.join(tmpDir, `${cliName}-camera-${opts.kind}${facingPart}-${id}${ext}`);

}

/** Download a node-hosted media URL to disk after HTTPS, host, redirect, and size checks. */

export async function writeUrlToFile(

filePath: string,

url: string,

);

}

// The node host is allowed even when private because the RPC response supplied its remote IP.

const policy = {

allowPrivateNetwork: true,

allowedHostnames: [expectedHost],

return Math.floor((normalized.length * 3) / 4) - padding;

}

/** Decode a base64 media payload to disk with preflight and post-decode size checks. */

export async function writeBase64ToFile(

filePath: string,

base64: string,

return { path: filePath, bytes: buf.length };

}

/** Require the node remote IP needed to validate URL-backed camera payloads. */

export function requireNodeRemoteIp(remoteIp?: string): string {

const normalized = remoteIp?.trim();

if (!normalized) {

return normalized;

}

/** Write either a URL-backed or base64-backed camera payload to disk. */

export async function writeCameraPayloadToFile(params: {

filePath: string;

payload: { url?: string; base64?: string };

throw new Error(params.invalidPayloadMessage ?? "invalid camera payload");

}

/** Write a camera clip payload to a generated temp file and return its path. */

export async function writeCameraClipPayloadToFile(params: {

payload: CameraClipPayload;

facing: CameraFacing;