sailfork / t3code-github / apps/ mobile/ src/ features/ sharing/ incoming-share-model.ts

import {
  clampFileAttachmentUploadBytes,
  fileAttachmentTooLargeMessage,
} from "@t3tools/client-runtime/state/attachments";
import {
  isProviderSendTurnSupportedImageMimeType,
  PROVIDER_SEND_TURN_MAX_ATTACHMENTS,
  PROVIDER_SEND_TURN_MAX_FILE_BYTES,
  PROVIDER_SEND_TURN_MAX_IMAGE_BYTES,
} from "@t3tools/contracts";
import * as Schema from "effect/Schema";
import type { ResolvedSharePayload, SharePayload } from "expo-sharing";

import { DraftComposerAttachmentSchema } from "../../lib/composer-image-schema";
import { fitComposerImage } from "../../lib/composerImageFit";
import type { DraftComposerAttachment } from "../../lib/composerImages";
import { estimateBase64ByteSize } from "../../lib/base64";

export interface IncomingShareDraft {
  readonly schemaVersion: 1;
  readonly id: string;
  readonly createdAt: string;
  readonly destination?: IncomingShareDestination;
  readonly text: string;
  readonly attachments: ReadonlyArray<DraftComposerAttachment>;
  readonly warnings: ReadonlyArray<string>;
}

export interface IncomingShareDestination {
  readonly environmentId: string;
  readonly projectId: string;
}

const IncomingShareDestinationSchema = Schema.Struct({
  environmentId: Schema.String,
  projectId: Schema.String,
});

export const IncomingShareDraftSchema = Schema.Struct({
  schemaVersion: Schema.Literal(1),
  id: Schema.String,
  createdAt: Schema.String,
  destination: Schema.optional(IncomingShareDestinationSchema),
  text: Schema.String,
  attachments: Schema.Array(DraftComposerAttachmentSchema),
  warnings: Schema.Array(Schema.String),
});

const decodeIncomingShareDraftSync = Schema.decodeUnknownSync(IncomingShareDraftSchema);

export function decodeIncomingShareDraft(value: unknown): IncomingShareDraft {
  return decodeIncomingShareDraftSync(value);
}

/** Strip iOS /private so /var and /private/var paths compare equally. */
function normalizedFileUriPath(uri: string): string | null {
  try {
    const url = new URL(uri);
    if (url.protocol !== "file:") {
      return null;
    }
    const path = decodeURIComponent(url.pathname);
    // URL parsing leaves encoded separators; reject decoded .. segments before lexical containment checks.
    if (path.split("/").includes("..")) {
      return null;
    }
    return path.startsWith("/private/var/") ? path.slice("/private".length) : path;
  } catch {
    return null;
  }
}

/** Delete only inside app-owned roots; iOS shares may reference the sender's original. */
export function isShareFileUriUnderOwnedRoots(
  uri: string,
  ownedRootUris: ReadonlyArray<string>,
): boolean {
  const path = normalizedFileUriPath(uri);
  if (path === null) {
    return false;
  }
  return ownedRootUris.some((rootUri) => {
    const rootPath = normalizedFileUriPath(rootUri);
    if (rootPath === null) {
      return false;
    }
    const root = rootPath.endsWith("/") ? rootPath : `${rootPath}/`;
    return path.startsWith(root) && path.length > root.length;
  });
}

export interface IncomingShareFileReader {
  readonly readBase64: (uri: string) => Promise<string>;
  readonly removeOwnedFile: (uri: string) => Promise<void> | void;
  readonly persistFile?: (uri: string, name: string) => Promise<string>;
  readonly readSize?: (uri: string) => Promise<number | null>;
}

export function selectIncomingShareAttachments(input: {
  readonly attachments: ReadonlyArray<DraftComposerAttachment>;
  readonly maxFileAttachmentBytes: number | null;
}): {
  readonly attachments: ReadonlyArray<DraftComposerAttachment>;
  readonly warnings: ReadonlyArray<string>;
} {
  const attachments: DraftComposerAttachment[] = [];
  const warnings: string[] = [];

  for (const attachment of input.attachments) {
    if (attachment.type === "image") {
      attachments.push(attachment);
      continue;
    }
    if (input.maxFileAttachmentBytes === null) {
      warnings.push(`'${attachment.name}' was skipped because this server does not support files.`);
      continue;
    }
    const maxFileAttachmentBytes = clampFileAttachmentUploadBytes(input.maxFileAttachmentBytes);
    if (attachment.sizeBytes > maxFileAttachmentBytes) {
      warnings.push(fileAttachmentTooLargeMessage(attachment.name, maxFileAttachmentBytes));
      continue;
    }
    attachments.push(attachment);
  }

  return { attachments, warnings };
}

export function selectIncomingShareAttachmentsForServer(input: {
  readonly attachments: ReadonlyArray<DraftComposerAttachment>;
  readonly serverConfig: {
    readonly environment: {
      readonly capabilities: {
        readonly fileAttachments?: { readonly maxUploadBytes: number };
      };
    };
  } | null;
}):
  | { readonly status: "pending" }
  | {
      readonly status: "ready";
      readonly attachments: ReadonlyArray<DraftComposerAttachment>;
      readonly warnings: ReadonlyArray<string>;
    } {
  const hasFiles = input.attachments.some((attachment) => attachment.type === "file");
  if (hasFiles && input.serverConfig === null) {
    return { status: "pending" };
  }
  const capabilities = input.serverConfig?.environment.capabilities;
  const maxFileAttachmentBytes = capabilities?.fileAttachments?.maxUploadBytes ?? null;
  return {
    status: "ready",
    ...selectIncomingShareAttachments({
      attachments: input.attachments,
      maxFileAttachmentBytes,
    }),
  };
}

function sharedText(payloads: ReadonlyArray<SharePayload>): string {
  const seen = new Set<string>();
  const values: string[] = [];
  for (const payload of payloads) {
    if (payload.shareType !== "text" && payload.shareType !== "url") {
      continue;
    }
    const value = payload.value.trim();
    if (!value || seen.has(value)) {
      continue;
    }
    seen.add(value);
    values.push(value);
  }
  return values.join("\n\n");
}

function resolvedImageFor(
  payload: SharePayload,
  index: number,
  resolvedPayloads: ReadonlyArray<ResolvedSharePayload>,
  consumedIndexes: Set<number>,
): ResolvedSharePayload | undefined {
  const sameIndex = resolvedPayloads[index];
  if (
    !consumedIndexes.has(index) &&
    sameIndex?.shareType === payload.shareType &&
    sameIndex.value === payload.value
  ) {
    consumedIndexes.add(index);
    return sameIndex;
  }
  const matchingIndex = resolvedPayloads.findIndex(
    (candidate, candidateIndex) =>
      !consumedIndexes.has(candidateIndex) &&
      candidate.shareType === payload.shareType &&
      candidate.value === payload.value,
  );
  if (matchingIndex < 0) {
    return undefined;
  }
  consumedIndexes.add(matchingIndex);
  return resolvedPayloads[matchingIndex];
}

async function releaseOwnedFiles(
  fileReader: IncomingShareFileReader,
  uris: ReadonlyArray<string | undefined>,
): Promise<void> {
  for (const uri of new Set(uris.filter((candidate): candidate is string => Boolean(candidate)))) {
    try {
      await fileReader.removeOwnedFile(uri);
    } catch {}
  }
}

function fallbackName(uri: string, index: number, mimeType: string): string {
  try {
    const pathName = new URL(uri).pathname.split("/").findLast((segment) => segment.length > 0);
    if (pathName) {
      return decodeURIComponent(pathName);
    }
  } catch {}
  const family = mimeType.split("/")[0]?.toLowerCase();
  const kind = family === "image" || family === "audio" || family === "video" ? family : "file";
  const extension =
    mimeType.split("/")[1]?.replace(/[^a-z0-9.+-]/gi, "") || (kind === "image" ? "png" : "bin");
  return `shared-${kind}-${index + 1}.${extension}`;
}

export async function buildIncomingShareDraft(input: {
  readonly payloads: ReadonlyArray<SharePayload>;
  readonly resolvedPayloads: ReadonlyArray<ResolvedSharePayload>;
  readonly fileReader: IncomingShareFileReader;
  readonly id: string;
  readonly createdAt: string;
}): Promise<IncomingShareDraft> {
  const attachments: DraftComposerAttachment[] = [];
  const warnings: string[] = [];
  const consumedResolvedPayloadIndexes = new Set<number>();
  let warnedAttachmentLimit = false;

  for (const [index, payload] of input.payloads.entries()) {
    if (
      payload.shareType !== "image" &&
      payload.shareType !== "file" &&
      payload.shareType !== "audio" &&
      payload.shareType !== "video"
    ) {
      continue;
    }
    const resolved = resolvedImageFor(
      payload,
      index,
      input.resolvedPayloads,
      consumedResolvedPayloadIndexes,
    );
    const uri = resolved?.contentUri ?? payload.value;
    if (attachments.length >= PROVIDER_SEND_TURN_MAX_ATTACHMENTS) {
      if (!warnedAttachmentLimit) {
        warnings.push(
          `Only the first ${PROVIDER_SEND_TURN_MAX_ATTACHMENTS} shared ${payload.shareType === "image" ? "images" : "files"} were attached.`,
        );
        warnedAttachmentLimit = true;
      }
      await releaseOwnedFiles(input.fileReader, [uri, payload.value]);
      continue;
    }

    const mimeType = (
      resolved?.contentMimeType ??
      payload.mimeType ??
      (payload.shareType === "image" ? "image/png" : "application/octet-stream")
    ).toLowerCase();
    if (payload.shareType !== "image") {
      const sharedFileName =
        typeof payload.originalName === "string" && payload.originalName.trim().length > 0
          ? payload.originalName
          : undefined;
      const name = resolved?.originalName ?? sharedFileName ?? fallbackName(uri, index, mimeType);
      if (!uri) {
        warnings.push("One shared file could not be read.");
        continue;
      }
      let persistedFileUri: string | undefined;
      let retainedFileUri: string | undefined;
      try {
        let sizeBytes = resolved?.contentSize ?? (await input.fileReader.readSize?.(uri)) ?? null;
        if (
          (sizeBytes === null || (sizeBytes === 0 && uri.startsWith("content:"))) &&
          input.fileReader.persistFile
        ) {
          persistedFileUri = await input.fileReader.persistFile(uri, name);
          sizeBytes = (await input.fileReader.readSize?.(persistedFileUri)) ?? null;
        }
        if (sizeBytes === null) {
          warnings.push(`The size of '${name}' could not be determined.`);
          if (persistedFileUri) {
            await releaseOwnedFiles(input.fileReader, [persistedFileUri]);
          }
          continue;
        }
        if (sizeBytes <= 0) {
          warnings.push(`'${name}' is empty or could not be read.`);
          if (persistedFileUri) {
            await releaseOwnedFiles(input.fileReader, [persistedFileUri]);
          }
          continue;
        }
        if (sizeBytes > PROVIDER_SEND_TURN_MAX_FILE_BYTES) {
          warnings.push(fileAttachmentTooLargeMessage(name, PROVIDER_SEND_TURN_MAX_FILE_BYTES));
          if (persistedFileUri) {
            await releaseOwnedFiles(input.fileReader, [persistedFileUri]);
          }
          continue;
        }
        if (persistedFileUri === undefined && input.fileReader.persistFile) {
          persistedFileUri = await input.fileReader.persistFile(uri, name);
          // Android content sources can misreport size; record the stored copy's measured size.
          const storedSize = (await input.fileReader.readSize?.(persistedFileUri)) ?? null;
          if (storedSize !== null) {
            sizeBytes = storedSize;
          }
          if (sizeBytes <= 0) {
            warnings.push(`'${name}' is empty or could not be read.`);
            await releaseOwnedFiles(input.fileReader, [persistedFileUri]);
            continue;
          }
          if (sizeBytes > PROVIDER_SEND_TURN_MAX_FILE_BYTES) {
            warnings.push(fileAttachmentTooLargeMessage(name, PROVIDER_SEND_TURN_MAX_FILE_BYTES));
            await releaseOwnedFiles(input.fileReader, [persistedFileUri]);
            continue;
          }
        }
        attachments.push({
          id: `${input.id}:file:${index}`,
          type: "file",
          name,
          mimeType,
          sizeBytes,
          fileUri: persistedFileUri ?? uri,
        });
        retainedFileUri = persistedFileUri ?? uri;
      } catch (error) {
        warnings.push(error instanceof Error ? error.message : `Could not read '${name}'.`);
        if (persistedFileUri !== undefined) {
          await releaseOwnedFiles(input.fileReader, [persistedFileUri]);
        }
      } finally {
        await releaseOwnedFiles(
          input.fileReader,
          [uri, payload.value].filter((candidate) => candidate !== retainedFileUri),
        );
      }
      continue;
    }
    if (!uri || !mimeType.startsWith("image/")) {
      warnings.push("One shared item was not a supported image.");
      await releaseOwnedFiles(input.fileReader, [uri, payload.value]);
      continue;
    }
    if (!isProviderSendTurnSupportedImageMimeType(mimeType)) {
      warnings.push(
        `'${resolved?.originalName ?? fallbackName(uri, index, mimeType)}' is not a supported image type.`,
      );
      await releaseOwnedFiles(input.fileReader, [uri, payload.value]);
      continue;
    }
    if (
      resolved?.contentSize !== null &&
      resolved?.contentSize !== undefined &&
      resolved.contentSize > PROVIDER_SEND_TURN_MAX_IMAGE_BYTES
    ) {
      warnings.push(
        `'${resolved.originalName ?? fallbackName(uri, index, mimeType)}' exceeds the 10 MB attachment limit.`,
      );
      await releaseOwnedFiles(input.fileReader, [uri, payload.value]);
      continue;
    }

    try {
      const sharedBase64 = await input.fileReader.readBase64(uri);
      // Use already-read bytes because native image loaders may not read the provider's file.
      const fitted = await fitComposerImage({
        uri: `data:${mimeType};base64,${sharedBase64}`,
        mimeType,
        base64: sharedBase64,
      });
      const base64 = fitted?.base64 ?? sharedBase64;
      const sizeBytes = fitted
        ? estimateBase64ByteSize(base64)
        : (resolved?.contentSize ?? estimateBase64ByteSize(base64));
      if (sizeBytes <= 0 || sizeBytes > PROVIDER_SEND_TURN_MAX_IMAGE_BYTES) {
        warnings.push(
          `'${resolved?.originalName ?? fallbackName(uri, index, mimeType)}' exceeds the 10 MB attachment limit.`,
        );
        continue;
      }
      const dataUrl = `data:${mimeType};base64,${base64}`;
      attachments.push({
        id: `${input.id}:image:${index}`,
        type: "image",
        name: resolved?.originalName ?? fallbackName(uri, index, mimeType),
        mimeType,
        sizeBytes,
        dataUrl,
        // Data-backed previews outlive temporary share files and App Group entries.
        previewUri: dataUrl,
      });
    } catch {
      warnings.push(`Could not read '${fallbackName(uri, index, mimeType)}'.`);
    } finally {
      await releaseOwnedFiles(input.fileReader, [uri, payload.value]);
    }
  }

  return {
    schemaVersion: 1,
    id: input.id,
    createdAt: input.createdAt,
    text: sharedText(input.payloads),
    attachments,
    warnings,
  };
}

export function hasIncomingShareContent(draft: IncomingShareDraft): boolean {
  return draft.text.trim().length > 0 || draft.attachments.length > 0;
}