@localpulse/cli 0.0.1

package/src/lib/upload-client.ts

@@ -0,0 +1,353 @@
+import { access, readFile } from "node:fs/promises";
+import { basename, extname } from "node:path";
+
+import {
+  CliApiError,
+  type ApiResponseBody,
+  extractApiErrorMessage,
+  parseApiJsonBody,
+} from "./api-response";
+import { buildApiUrl, normalizeApiUrl } from "./api-url";
+
+export { CliApiError } from "./api-response";
+
+export type IngestUploadOptions = {
+  file: string;
+  urls?: string[];
+  city?: string;
+  venuePlaceId?: string;
+  context?: string;
+  ticketUrl?: string;
+  title?: string;
+  datetime?: string;
+  venue?: string;
+  extraMedia?: string[];
+  dryRun?: boolean;
+  /** When true, bypass drafts and upload directly to the ingestion pipeline. */
+  force?: boolean;
+};
+
+export type UploadDryRunResult = {
+  dry_run: true;
+  valid: true;
+  file: string;
+  extra_media_count: number;
+  api_url: string;
+};
+
+export type UploadPosterResult = {
+  success: boolean;
+  accepted: boolean;
+  run_id: string | null;
+  poster_id: string | null;
+  poster_url: string | null;
+  event_url: string | null;
+  existing_event_url: string | null;
+  event_title: string | null;
+  venue_name: string | null;
+  is_duplicate: boolean;
+  duplicate_similarity: number | null;
+  processing_time: number;
+  vision_completed: boolean;
+  message: string;
+};
+
+export type UploadResult = UploadDryRunResult | UploadPosterResult;
+
+export type VerifyCliTokenResult = {
+  email: string;
+  authenticated?: boolean;
+};
+
+export async function uploadPoster(
+  apiUrl: string,
+  token: string,
+  options: IngestUploadOptions,
+): Promise<UploadResult> {
+  await validateIngestOptions(options);
+  if (options.dryRun) {
+    return {
+      dry_run: true,
+      valid: true,
+      file: options.file,
+      extra_media_count: options.extraMedia?.length ?? 0,
+      api_url: normalizeApiUrl(apiUrl),
+    };
+  }
+
+  const form = new FormData();
+  form.set("file", await fileToUpload(options.file));
+  if (options.urls?.length) {
+    form.set("user_provided_urls", JSON.stringify(options.urls));
+  }
+  setOptionalField(form, "location_hint", options.city);
+  setOptionalField(form, "venue_place_id", options.venuePlaceId);
+  setOptionalField(form, "extra_context", options.context);
+  setOptionalField(form, "ticketing_url", options.ticketUrl);
+  setOptionalField(form, "event_title", options.title);
+  setOptionalField(form, "event_datetime", options.datetime);
+  setOptionalField(form, "venue_name", options.venue);
+  if (options.city) {
+    setOptionalField(form, "venue_city", options.city);
+  }
+
+  if (options.extraMedia?.length) {
+    const mediaTypes: string[] = [];
+    const mediaOrder: number[] = [];
+    for (const [index, path] of options.extraMedia.entries()) {
+      form.append("media_files", await fileToUpload(path));
+      mediaTypes.push(detectMediaType(path));
+      mediaOrder.push(index + 1);
+    }
+    form.set("media_types", JSON.stringify(mediaTypes));
+    form.set("media_order", JSON.stringify(mediaOrder));
+  }
+
+  const response = await fetch(buildApiUrl(apiUrl, "/api/v1/upload"), {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${token}`,
+      accept: "application/json",
+    },
+    body: form,
+  });
+
+  const payload = await parseApiJsonBody(response);
+  if (!response.ok) {
+    throw new CliApiError(extractApiErrorMessage(payload, `Upload failed (${response.status})`), {
+      httpStatus: response.status,
+      body: payload,
+    });
+  }
+
+  return parseUploadPosterResult(payload);
+}
+
+export async function verifyCliToken(
+  apiUrl: string,
+  token: string,
+): Promise<VerifyCliTokenResult> {
+  const response = await fetch(buildApiUrl(apiUrl, "/api/v1/token/verify"), {
+    method: "GET",
+    headers: {
+      authorization: `Bearer ${token}`,
+      accept: "application/json",
+    },
+  });
+
+  const payload = await parseApiJsonBody(response);
+  if (!response.ok) {
+    throw new CliApiError(extractApiErrorMessage(payload, `Token verification failed (${response.status})`), {
+      httpStatus: response.status,
+      body: payload,
+    });
+  }
+
+  return parseVerifyCliTokenResult(payload);
+}
+
+async function validateIngestOptions(options: IngestUploadOptions): Promise<void> {
+  await assertReadableFile(options.file, "file");
+
+  if (options.extraMedia && options.extraMedia.length > 2) {
+    throw new Error("`--extra-media` supports at most 2 files.");
+  }
+
+  for (const [index, file] of (options.extraMedia ?? []).entries()) {
+    await assertReadableFile(file, `extra-media[${index}]`);
+  }
+}
+
+async function assertReadableFile(path: string, label: string): Promise<void> {
+  if (!path.trim()) {
+    throw new Error(`\`${label}\` is required.`);
+  }
+
+  try {
+    await access(path);
+  } catch {
+    throw new Error(`File not found: ${path}`);
+  }
+}
+
+async function fileToUpload(path: string): Promise<File> {
+  const bytes = await readFile(path);
+  return new File([bytes], basename(path), { type: mimeTypeForPath(path) });
+}
+
+function setOptionalField(form: FormData, key: string, value: string | undefined): void {
+  if (value?.trim()) {
+    form.set(key, value.trim());
+  }
+}
+
+export function detectMediaType(path: string): "image" | "video" {
+  const extension = extname(path).toLowerCase();
+  return VIDEO_EXTENSIONS.has(extension) ? "video" : "image";
+}
+
+function mimeTypeForPath(path: string): string {
+  const extension = extname(path).toLowerCase();
+  return MIME_BY_EXTENSION[extension] ?? (
+    detectMediaType(path) === "video" ? "video/mp4" : "image/jpeg"
+  );
+}
+
+function parseUploadPosterResult(payload: ApiResponseBody): UploadPosterResult {
+  const result = payload as Partial<UploadPosterResult>;
+  if (
+    !isBoolean(result.success) ||
+    !isBoolean(result.accepted) ||
+    !isNullableString(result.run_id) ||
+    !isNullableString(result.poster_id) ||
+    !isNullableString(result.poster_url) ||
+    !isNullableString(result.event_url) ||
+    !isNullableString(result.existing_event_url) ||
+    !isNullableString(result.event_title) ||
+    !isNullableString(result.venue_name) ||
+    !isBoolean(result.is_duplicate) ||
+    !isNullableNumber(result.duplicate_similarity) ||
+    !isNumber(result.processing_time) ||
+    !isBoolean(result.vision_completed) ||
+    !isString(result.message)
+  ) {
+    throw new Error("Invalid API response: expected upload result payload.");
+  }
+  return result as UploadPosterResult;
+}
+
+function parseVerifyCliTokenResult(payload: ApiResponseBody): VerifyCliTokenResult {
+  const result = payload as Partial<VerifyCliTokenResult>;
+  if (!isString(result.email) || !isOptionalBoolean(result.authenticated)) {
+    throw new Error("Invalid API response: expected token verification payload.");
+  }
+  return result as VerifyCliTokenResult;
+}
+
+function isString(value: unknown): value is string {
+  return typeof value === "string";
+}
+
+function isNullableString(value: unknown): value is string | null {
+  return typeof value === "string" || value === null;
+}
+
+function isBoolean(value: unknown): value is boolean {
+  return typeof value === "boolean";
+}
+
+function isOptionalBoolean(value: unknown): value is boolean | undefined {
+  return typeof value === "boolean" || typeof value === "undefined";
+}
+
+function isNumber(value: unknown): value is number {
+  return typeof value === "number";
+}
+
+function isNullableNumber(value: unknown): value is number | null {
+  return typeof value === "number" || value === null;
+}
+
+// --- Draft flow ---
+
+export type DraftResult = {
+  id: string;
+  status: string;
+  created_at: string;
+  updated_at: string;
+};
+
+export type DraftMediaResult = {
+  id: string;
+  draft_id: string;
+  media_type: string;
+  storage_path: string;
+  sort_order: number;
+  is_primary: boolean;
+};
+
+export type DraftCreateOptions = Pick<IngestUploadOptions, "urls" | "city" | "venuePlaceId" | "context" | "ticketUrl" | "title" | "datetime" | "venue">;
+
+export async function createDraft(
+  apiUrl: string,
+  token: string,
+  options: DraftCreateOptions,
+): Promise<DraftResult> {
+  const body: Record<string, unknown> = {};
+  if (options.urls?.length) body.urls = options.urls;
+  if (options.ticketUrl) body.ticket_url = options.ticketUrl;
+  if (options.city) body.location_hint = options.city;
+  if (options.context) body.extra_context = options.context;
+  if (options.venuePlaceId) body.venue_place_id = options.venuePlaceId;
+  if (options.title || options.datetime || options.venue) {
+    body.metadata = {
+      ...(options.title ? { event_title: options.title } : {}),
+      ...(options.datetime ? { event_datetime: options.datetime } : {}),
+      ...(options.venue ? { venue_name: options.venue } : {}),
+    };
+  }
+
+  const response = await fetch(buildApiUrl(apiUrl, "/api/drafts"), {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${token}`,
+      "content-type": "application/json",
+      accept: "application/json",
+    },
+    body: JSON.stringify(body),
+  });
+
+  const payload = await parseApiJsonBody(response);
+  if (!response.ok) {
+    throw new CliApiError(extractApiErrorMessage(payload, `Draft creation failed (${response.status})`), {
+      httpStatus: response.status,
+      body: payload,
+    });
+  }
+  return payload as DraftResult;
+}
+
+export async function uploadDraftMedia(
+  apiUrl: string,
+  token: string,
+  draftId: string,
+  filePath: string,
+  options: { mediaType: "image" | "video"; sortOrder: number; isPrimary: boolean },
+): Promise<DraftMediaResult> {
+  const form = new FormData();
+  form.set("file", await fileToUpload(filePath));
+  form.set("media_type", options.mediaType);
+  form.set("sort_order", String(options.sortOrder));
+  form.set("is_primary", options.isPrimary ? "true" : "false");
+
+  const response = await fetch(buildApiUrl(apiUrl, `/api/drafts/${draftId}/media`), {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${token}`,
+      accept: "application/json",
+    },
+    body: form,
+  });
+
+  const payload = await parseApiJsonBody(response);
+  if (!response.ok) {
+    throw new CliApiError(extractApiErrorMessage(payload, `Draft media upload failed (${response.status})`), {
+      httpStatus: response.status,
+      body: payload,
+    });
+  }
+  return payload as DraftMediaResult;
+}
+
+const VIDEO_EXTENSIONS = new Set([".mp4", ".mov", ".m4v", ".webm"]);
+
+const MIME_BY_EXTENSION: Record<string, string> = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".webp": "image/webp",
+  ".mp4": "video/mp4",
+  ".mov": "video/quicktime",
+  ".m4v": "video/x-m4v",
+  ".webm": "video/webm",
+};