@editframe/cli 0.10.0-beta.5 → 0.10.0-beta.7

package/dist/operations/syncAssetsDirectory/SyncTrack.d.ts

@@ -0,0 +1,70 @@
+import { CreateISOBMFFFileResult, CreateISOBMFFTrackResult } from '../../../../api/src';
+import { Probe } from '../../../../assets/src';
+import { SubAssetSync } from './SubAssetSync.ts';
+import { SyncStatus } from './SyncStatus.ts';
+export declare class SyncTrack implements SubAssetSync<CreateISOBMFFTrackResult> {
+    path: string;
+    md5: string;
+    icon: string;
+    label: string;
+    syncStatus: SyncStatus;
+    fileSyncStatus: SyncStatus;
+    created: CreateISOBMFFTrackResult | null;
+    constructor(path: string, md5: string);
+    private _isoFile;
+    get isoFile(): CreateISOBMFFFileResult;
+    byteSize(): Promise<number>;
+    private _probeResult;
+    get probeResult(): Probe;
+    get track(): {
+        index: number;
+        codec_name: string;
+        codec_long_name: string;
+        codec_type: "audio";
+        codec_tag_string: string;
+        codec_tag: string;
+        sample_fmt: string;
+        sample_rate: string;
+        channels: number;
+        channel_layout: string;
+        bits_per_sample: number;
+        r_frame_rate: string;
+        avg_frame_rate: string;
+        time_base: string;
+        start_pts: number;
+        start_time: number;
+        duration_ts: number;
+        duration: number;
+        bit_rate: string;
+        disposition: Record<string, unknown>;
+        initial_padding?: number | undefined;
+    } | {
+        height: number;
+        width: number;
+        index: number;
+        codec_name: string;
+        codec_long_name: string;
+        codec_type: "video";
+        codec_tag_string: string;
+        codec_tag: string;
+        r_frame_rate: string;
+        avg_frame_rate: string;
+        time_base: string;
+        disposition: Record<string, unknown>;
+        coded_width: number;
+        coded_height: number;
+        start_pts?: number | undefined;
+        start_time?: number | undefined;
+        duration_ts?: number | undefined;
+        duration?: number | undefined;
+        bit_rate?: string | undefined;
+    };
+    prepare(): Promise<void>;
+    get trackId(): string;
+    get trackDuration(): number;
+    validate(): Promise<void>;
+    create(): Promise<void>;
+    isComplete(): boolean;
+    upload(): Promise<void>;
+    markSynced(): Promise<void>;
+}

package/dist/operations/syncAssetsDirectory/SyncTrack.js

@@ -0,0 +1,138 @@
+import { createReadStream } from "node:fs";
+import fs from "node:fs/promises";
+import { join, dirname } from "node:path";
+import { createISOBMFFFile, createISOBMFFTrack, uploadISOBMFFTrack } from "@editframe/api";
+import { Probe } from "@editframe/assets";
+import { getClient } from "../../utils/index.js";
+import { SyncStatus } from "./SyncStatus.js";
+class SyncTrack {
+  constructor(path, md5) {
+    this.path = path;
+    this.md5 = md5;
+    this.icon = "📼";
+    this.label = "track";
+    this.syncStatus = new SyncStatus(this.path);
+    this.fileSyncStatus = new SyncStatus(
+      join(dirname(this.path), "isobmff")
+    );
+    this.created = null;
+    this._isoFile = null;
+    this._probeResult = null;
+  }
+  get isoFile() {
+    if (this._isoFile) {
+      return this._isoFile;
+    }
+    throw new Error("ISOBMFF file not found. Call prepare() first.");
+  }
+  async byteSize() {
+    return (await fs.stat(this.path)).size;
+  }
+  get probeResult() {
+    if (this._probeResult) {
+      return this._probeResult;
+    }
+    throw new Error("Probe result not found. Call prepare() first.");
+  }
+  get track() {
+    const [track] = this.probeResult.streams;
+    if (track) {
+      return track;
+    }
+    throw new Error(`No track found in track: ${this.path}`);
+  }
+  async prepare() {
+    this._isoFile = await createISOBMFFFile(getClient(), {
+      md5: this.md5,
+      filename: this.path.replace(/\.track-[\d]+.mp4$/, "")
+    });
+    this._probeResult = await Probe.probePath(this.path);
+  }
+  get trackId() {
+    const trackId = this.path.match(/track-([\d]+).mp4/)?.[1];
+    if (!trackId) {
+      throw new Error(`No track ID  found for track: ${this.path}`);
+    }
+    return trackId;
+  }
+  get trackDuration() {
+    const track = this.track;
+    if (!track.duration) {
+      throw new Error(`No duration found in track: ${this.path}`);
+    }
+    return track.duration;
+  }
+  async validate() {
+    this.trackId;
+    this.isoFile;
+    this.trackDuration;
+  }
+  async create() {
+    const track = this.track;
+    const isoFile = this.isoFile;
+    const createPayload = track.codec_type === "audio" ? {
+      type: track.codec_type,
+      file_id: isoFile.id,
+      track_id: Number(this.trackId),
+      probe_info: track,
+      duration_ms: Math.round(this.trackDuration * 1e3),
+      codec_name: track.codec_name,
+      byte_size: await this.byteSize()
+    } : {
+      type: track.codec_type,
+      file_id: isoFile.id,
+      track_id: Number(this.trackId),
+      probe_info: track,
+      duration_ms: Math.round(this.trackDuration * 1e3),
+      codec_name: track.codec_name,
+      byte_size: await this.byteSize()
+    };
+    this.created = await createISOBMFFTrack(getClient(), createPayload);
+  }
+  isComplete() {
+    return !!this.created?.complete;
+  }
+  async upload() {
+    if (!this.created) {
+      throw new Error(
+        "Track not created. Should have been prevented by .isComplete()"
+      );
+    }
+    return uploadISOBMFFTrack(
+      getClient(),
+      this.isoFile.id,
+      Number(this.trackId),
+      createReadStream(this.path),
+      this.created?.byte_size
+    );
+  }
+  async markSynced() {
+    if (!this.created) {
+      throw new Error(
+        "Track not created. Should have been prevented by .isComplete()"
+      );
+    }
+    const byteSize = await this.byteSize();
+    await Promise.all([
+      this.syncStatus.markSynced({
+        version: "1",
+        complete: true,
+        id: `${this.created.file_id}:${this.created.track_id}`,
+        md5: this.md5,
+        asset_id: this.created.asset_id,
+        byte_size: byteSize
+      }),
+      this.fileSyncStatus.markSynced({
+        version: "1",
+        complete: true,
+        id: this.created.file_id,
+        md5: this.md5,
+        asset_id: this.created.asset_id,
+        byte_size: byteSize
+      })
+    ]);
+  }
+}
+export {
+  SyncTrack
+};

package/dist/operations/syncAssetsDirectory/SyncTrack.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/operations/syncAssetsDirectory/doAssetSync.d.ts

@@ -0,0 +1,5 @@
+import { SubAssetSync } from './SubAssetSync.ts';
+export declare const doAssetSync: (assetSync: SubAssetSync<unknown>) => AsyncGenerator<{
+    status: "info" | "success";
+    message: string;
+}>;

package/dist/operations/syncAssetsDirectory/doAssetSync.js

@@ -0,0 +1,48 @@
+const doAssetSync = async function* (assetSync) {
+  if (await assetSync.syncStatus.isSynced()) {
+    yield {
+      status: "info",
+      message: `Sub-asset has already been synced: ${assetSync.path}`
+    };
+    return;
+  }
+  try {
+    await assetSync.prepare();
+    await assetSync.validate();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    throw new Error(`Error validating ${assetSync.label}: ${message}`);
+  }
+  yield {
+    status: "info",
+    message: `${assetSync.icon}  Syncing ${assetSync.label}: ${assetSync.path}`
+  };
+  try {
+    await assetSync.create();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    throw new Error(`Error creating ${assetSync.label}: ${message}`);
+  }
+  if (!assetSync.isComplete()) {
+    try {
+      await assetSync.upload();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      throw new Error(`Error uploading ${assetSync.label}: ${message}`);
+    }
+  }
+  try {
+    await assetSync.markSynced();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    throw new Error(`Error marking ${assetSync.label} as synced: ${message}`);
+  }
+  yield {
+    status: "success",
+    message: `Synced ${assetSync.label}: ${assetSync.path}`
+  };
+  return;
+};
+export {
+  doAssetSync
+};

package/dist/operations/syncAssetsDirectory/doAssetSync.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/operations/syncAssetsDirectory.d.ts

@@ -1 +1 @@
-export declare const syncAssetDirectory: (projectDirectory: string) => Promise<void>;
+export declare const syncAssetDirectory: (cacheDir: string) => Promise<void>;

package/dist/operations/syncAssetsDirectory.js

@@ -1,53 +1,20 @@
-import { Probe } from "@editframe/assets";
 import fs from "node:fs/promises";
 import path from "node:path";
-import { createCaptionFile, uploadCaptionFile, createISOBMFFFile, uploadFragmentIndex, createISOBMFFTrack, uploadISOBMFFTrack, createImageFile, uploadImageFile } from "@editframe/api";
-import { createReadStream, statSync } from "node:fs";
-import { getClient } from "../utils/index.js";
-const imageMatch = /\.(png|jpe?g|gif|webp)$/i;
-const trackMatch = /\.track-[\d]+.mp4$/i;
-const fragmentIndexMatch = /\.tracks.json$/i;
-const captionsMatch = /\.captions.json$/i;
-class SyncStatus {
-  constructor(assetPath) {
-    this.assetPath = assetPath;
-    this.infoPath = `${this.assetPath}.info`;
-  }
-  async isSynced() {
-    const result = await fs.stat(this.infoPath).catch((error) => {
-      if (error.code === "ENOENT") {
-        return false;
-      }
-      throw error;
-    });
-    return !!result;
-  }
-  async markSynced() {
-    process.stderr.write(`✏️  Marking asset as synced: ${this.assetPath}
-`);
-    await fs.writeFile(this.infoPath, "{}", "utf-8");
-  }
-}
-const syncAssetDirectory = async (projectDirectory) => {
-  const fullPath = path.join(
-    process.cwd(),
-    projectDirectory,
-    "src",
-    "assets",
-    ".cache"
-  );
-  const stat = await fs.stat(fullPath).catch((error) => {
+import { getAssetSync } from "./syncAssetsDirectory/SubAssetSync.js";
+import { doAssetSync } from "./syncAssetsDirectory/doAssetSync.js";
+const syncAssetDirectory = async (cacheDir) => {
+  const stat = await fs.stat(cacheDir).catch((error) => {
     if (error.code === "ENOENT") {
       return;
     }
     throw error;
   });
   if (!stat?.isDirectory()) {
-    console.error(`No assets cache directory found at ${fullPath}`);
+    console.error(`No assets cache directory found at ${cacheDir}`);
     return;
   }
-  const assets = await fs.readdir(fullPath);
-  process.stderr.write(`Syncing asset dir: ${fullPath}
+  const assets = await fs.readdir(cacheDir);
+  process.stderr.write(`Syncing asset dir: ${cacheDir}
 `);
   const errors = {};
   const reportError = (path2, message) => {
@@ -66,7 +33,7 @@ const syncAssetDirectory = async (projectDirectory) => {
   };
   for (const assetMd5 of assets) {
     reportInfo(assetMd5, `Syncing asset: ${assetMd5}`);
-    const assetDir = path.join(fullPath, assetMd5);
+    const assetDir = path.join(cacheDir, assetMd5);
     const stat2 = await fs.stat(assetDir);
     if (!stat2.isDirectory()) {
       reportError(assetMd5, "Invalid asset. Did not find asset directory.");
@@ -78,207 +45,20 @@ const syncAssetDirectory = async (projectDirectory) => {
         continue;
       }
       const subAssetPath = path.join(assetDir, subAsset);
-      const syncStatus = new SyncStatus(subAssetPath);
-      if (await syncStatus.isSynced()) {
-        reportInfo(
-          subAsset,
-          `✔ Sub-asset has already been synced: ${subAsset}`
-        );
-        continue;
-      }
-      switch (true) {
-        case imageMatch.test(subAsset): {
-          const probeResult = await Probe.probePath(subAssetPath);
-          const [videoProbe] = probeResult.videoStreams;
-          const { format } = probeResult;
-          if (!videoProbe) {
-            reportError(subAsset, `No media info found in image: ${subAsset}`);
-            break;
-          }
-          const ext = path.extname(subAsset).slice(1);
-          if (!(ext === "jpg" || ext === "jpeg" || ext === "png" || ext === "webp")) {
-            reportError(subAsset, `Invalid image format: ${subAsset}`);
-            break;
-          }
-          reportInfo(subAsset, `🖼️  Syncing image: ${subAsset}`);
-          const created = await createImageFile(getClient(), {
-            md5: assetMd5,
-            filename: subAsset,
-            width: videoProbe.width,
-            height: videoProbe.height,
-            mime_type: `image/${ext}`,
-            byte_size: (await fs.stat(subAssetPath)).size
-          });
-          if (created) {
-            if (created.complete) {
-              reportInfo(subAsset, " ✔ Image has already been synced");
-              await syncStatus.markSynced();
-            } else {
-              await uploadImageFile(
-                getClient(),
-                created.id,
-                createReadStream(subAssetPath),
-                Number.parseInt(format.size || "0")
-              ).then(() => {
-                reportSuccess(subAsset, "Image has been synced.");
-                return syncStatus.markSynced();
-              }).catch((error) => {
-                reportError(
-                  subAsset,
-                  `Error uploading image: ${error.message}`
-                );
-              });
-            }
-          }
-          break;
-        }
-        case trackMatch.test(subAsset): {
-          reportInfo(subAsset, `📼 Syncing a/v track: ${subAsset}`);
-          const createdFile = await createISOBMFFFile(getClient(), {
-            md5: assetMd5,
-            filename: subAsset.replace(/\.track-[\d]+.mp4$/, "")
-          });
-          if (createdFile) {
-            const probe = await Probe.probePath(subAssetPath);
-            const trackId = subAsset.match(/track-([\d]+).mp4/)?.[1];
-            if (!trackId) {
-              reportError(subAsset, `No track ID found for track: ${subAsset}`);
-              break;
-            }
-            const [track] = probe.streams;
-            if (!track) {
-              reportError(
-                subAsset,
-                `No track stream found in track: ${subAsset}`
-              );
-              break;
-            }
-            if (track.duration === void 0) {
-              reportError(subAsset, `No duration found in track: ${subAsset}`);
-              break;
-            }
-            const stat3 = await fs.stat(subAssetPath);
-            const createPayload = track.codec_type === "audio" ? {
-              type: track.codec_type,
-              file_id: createdFile.id,
-              track_id: Number(trackId),
-              probe_info: track,
-              duration_ms: Math.round(track.duration * 1e3),
-              codec_name: track.codec_name,
-              byte_size: stat3.size
-            } : {
-              type: track.codec_type,
-              file_id: createdFile.id,
-              track_id: Number(trackId),
-              probe_info: track,
-              duration_ms: Math.round(track.duration * 1e3),
-              codec_name: track.codec_name,
-              byte_size: stat3.size
-            };
-            const createdTrack = await createISOBMFFTrack(
-              getClient(),
-              createPayload
-            );
-            if (createdTrack) {
-              if (createdTrack.next_byte === createdTrack.byte_size) {
-                reportInfo(subAsset, "✔ Track has already been synced.");
-                await syncStatus.markSynced();
-              } else {
-                await uploadISOBMFFTrack(
-                  getClient(),
-                  createdFile.id,
-                  Number(trackId),
-                  createReadStream(subAssetPath),
-                  createdTrack.byte_size
-                ).then(() => {
-                  reportSuccess(subAsset, "Track has been synced.");
-                  return syncStatus.markSynced();
-                }).catch((error) => {
-                  reportError(
-                    subAsset,
-                    `Error uploading track: ${error.message}`
-                  );
-                });
-              }
-            }
-          }
-          break;
-        }
-        case fragmentIndexMatch.test(subAsset): {
-          reportInfo(subAsset, `📋 Syncing fragment index: ${subAsset}`);
-          const createdFile = await createISOBMFFFile(getClient(), {
-            md5: assetMd5,
-            filename: subAsset.replace(/\.tracks.json$/, "")
-          });
-          if (createdFile) {
-            if (createdFile.fragment_index_complete) {
-              reportInfo(subAsset, "✔ Fragment index has already been synced.");
-              await syncStatus.markSynced();
-            } else {
-              const stats = statSync(subAssetPath);
-              const readStream = createReadStream(subAssetPath);
-              await uploadFragmentIndex(
-                getClient(),
-                createdFile.id,
-                readStream,
-                stats.size
-              ).then(() => {
-                reportSuccess(subAsset, "Fragment index has been synced.");
-                return syncStatus.markSynced();
-              }).catch((error) => {
-                reportError(
-                  subAsset,
-                  `Error uploading fragment index: ${error.message}`
-                );
-              });
-            }
-          } else {
-            reportError(
-              subAsset,
-              `No file found for fragment index: ${subAsset}`
-            );
-            break;
-          }
-          break;
-        }
-        case captionsMatch.test(subAsset): {
-          reportInfo(subAsset, `📝 Syncing captions: ${subAsset}`);
-          const createdFile = await createCaptionFile(getClient(), {
-            md5: assetMd5,
-            filename: subAsset.replace(/\.captions.json$/, ""),
-            byte_size: (await fs.stat(subAsset)).size
-          });
-          if (createdFile) {
-            if (createdFile.complete) {
-              reportInfo(subAsset, "✔ Captions have already been synced.");
-              await syncStatus.markSynced();
-            } else {
-              const readStream = createReadStream(subAssetPath);
-              const stats = statSync(subAssetPath);
-              await uploadCaptionFile(
-                getClient(),
-                createdFile.id,
-                readStream,
-                stats.size
-              ).then(() => {
-                reportSuccess(subAsset, "Captions have been synced.");
-                return syncStatus.markSynced();
-              }).catch((error) => {
-                reportError(
-                  subAsset,
-                  `Error uploading captions: ${error.message}`
-                );
-              });
-            }
-          } else {
-            reportError(subAsset, `No file found for captions: ${subAsset}`);
-            break;
+      try {
+        const assetSync = getAssetSync(subAssetPath, assetMd5);
+        for await (const { status, message } of doAssetSync(assetSync)) {
+          if (status === "success") {
+            reportSuccess(subAsset, message);
+          } else if (status === "info") {
+            reportInfo(subAsset, message);
           }
-          break;
         }
-        default: {
-          reportError(subAsset, `Unknown sub-asset: ${subAsset}`);
-          break;
+      } catch (error) {
+        if (error instanceof Error) {
+          reportError(subAsset, error.message);
+        } else {
+          reportError(subAsset, "Unknown error");
         }
       }
     }

package/dist/test-fixtures/fixture.d.ts

@@ -0,0 +1,26 @@
+import { SyncStatusInfo } from '../src/operations/syncAssetsDirectory/SyncStatus.ts';
+export declare const fixture: (fixture: string, name: string) => Promise<Fixture>;
+export interface Fixture {
+    name: string;
+    fixture: string;
+    md5: string;
+    content: Buffer;
+    originalPath: string;
+    write: (dir: string) => Promise<void>;
+}
+export declare const withFixtures: (fixtures: Promise<Fixture>[], fn: (props: {
+    files: Fixture[];
+    rootDir: string;
+    srcDir: string;
+    assetsDir: string;
+    cacheDir: string;
+    expectCacheFiles: (fixture: Fixture, files: string[]) => Promise<void>;
+    expectInfoFileContent: (fileName: string, fixture: Fixture, expectedContent: Pick<SyncStatusInfo, "complete" | "id"> & {
+        byte_size?: number;
+    }) => Promise<void>;
+    syncAssetsDirectory: () => Promise<void>;
+    cacheImage: (fixture: Fixture) => Promise<string>;
+    generateTrack: (fixture: Fixture, trackId: number) => Promise<string>;
+    generateTrackFragmentIndex: (fixture: Fixture) => Promise<string>;
+    generateCaptions: (fixture: Fixture) => Promise<string>;
+}) => Promise<void>) => Promise<void>;

package/dist/utils/index.js

@@ -5,7 +5,10 @@ let client;
 const getClient = () => {
   if (!client) {
     const programOpts = program.opts();
-    client = new Client(programOpts.token, programOpts.efHost);
+    client = new Client(
+      programOpts.token || process.env.EF_TOKEN,
+      programOpts.efHost || process.env.EF_HOST
+    );
   }
   return client;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@editframe/cli",
-  "version": "0.10.0-beta.5",
+  "version": "0.10.0-beta.7",
   "description": "Command line interface for EditFrame",
   "bin": {
     "editframe": "./dist/index.js"
@@ -23,10 +23,10 @@
     "vite-tsconfig-paths": "^4.3.2"
   },
   "dependencies": {
-    "@editframe/api": "0.10.0-beta.5",
-    "@editframe/assets": "0.10.0-beta.5",
-    "@editframe/elements": "0.10.0-beta.5",
-    "@editframe/vite-plugin": "0.10.0-beta.5",
+    "@editframe/api": "0.10.0-beta.7",
+    "@editframe/assets": "0.10.0-beta.7",
+    "@editframe/elements": "0.10.0-beta.7",
+    "@editframe/vite-plugin": "0.10.0-beta.7",
     "@inquirer/prompts": "^5.3.8",
     "axios": "^1.6.8",
     "chalk": "^5.3.0",