@editframe/cli 0.8.0-beta.1 → 0.8.0-beta.10

package/dist/VERSION.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.8.0-beta.1";
+export declare const VERSION = "0.8.0-beta.10";

package/dist/VERSION.js

@@ -1,4 +1,4 @@
-const VERSION = "0.8.0-beta.1";
+const VERSION = "0.8.0-beta.10";
 export {
   VERSION
 };

package/dist/commands/process-file.js

@@ -1,23 +1,26 @@
 import { basename } from "node:path";
+import { stat } from "node:fs/promises";
+import { createReadStream } from "node:fs";
 import { program } from "commander";
 import { withSpinner } from "../utils/withSpinner.js";
 import { getClient } from "../utils/index.js";
-import { createReadStream } from "node:fs";
 import { createUnprocessedFile, uploadUnprocessedFile, updateUnprocessedFile } from "@editframe/api";
 import { md5FilePath } from "@editframe/assets";
 program.command("process-file <file>").description("Upload a audio/video to Editframe for processing.").action(async (path) => {
   const client = getClient();
   const fileId = await md5FilePath(path);
+  const byte_size = (await stat(path)).size;
   await withSpinner("Creating unprocessed file record", async () => {
     await createUnprocessedFile(client, {
       id: fileId,
       processes: [],
-      filename: basename(path)
+      filename: basename(path),
+      byte_size
     });
   });
   const readStream = createReadStream(path);
   await withSpinner("Uploading file", async () => {
-    await uploadUnprocessedFile(client, fileId, readStream);
+    await uploadUnprocessedFile(client, fileId, readStream, byte_size);
   });
   const unprocessedFile = await withSpinner(
     "Marking for processing",

package/dist/commands/render.js

@@ -16,6 +16,7 @@ import { getClient } from "../utils/index.js";
 import { getRenderInfo } from "../operations/getRenderInfo.js";
 import { processRenderInfo } from "../operations/processRenderInfo.js";
 import { validateVideoResolution } from "../utils/validateVideoResolution.js";
+import { getFolderSize } from "../utils/getFolderSize.js";
 const buildProductionUrl = async (origin, tagName, assetPath) => {
   const md5Sum = await md5FilePath(assetPath);
   const basename = path.basename(assetPath);
@@ -142,7 +143,8 @@ program.command("render [directory]").description(
       );
       const readable = new PassThrough();
       tarStream.pipe(readable);
-      await uploadRender(getClient(), md5, readable);
+      const folderSize = await getFolderSize(distDir);
+      await uploadRender(getClient(), md5, readable, folderSize);
       process.stderr.write("Render assets uploaded\n");
       process.stderr.write(inspect(render));
       process.stderr.write("\n");

package/dist/commands/webhook.d.ts

@@ -0,0 +1,7 @@
+export interface APITestWebhhokResult {
+    message: string;
+}
+export declare const testWebhookURL: ({ webhookURL, topic, }: {
+    webhookURL: string;
+    topic: string;
+}) => Promise<APITestWebhhokResult>;

package/dist/commands/webhook.js

@@ -0,0 +1,61 @@
+import { program, Option } from "commander";
+import ora from "ora";
+import chalk from "chalk";
+import debug from "debug";
+import { input, select } from "@inquirer/prompts";
+import { getClient } from "../utils/index.js";
+const log = debug("ef:cli:auth");
+const topics = [
+  "render.created",
+  "render.rendering",
+  "render.pending",
+  "render.failed",
+  "render.completed"
+];
+const testWebhookURL = async ({
+  webhookURL,
+  topic
+}) => {
+  const response = await getClient().authenticatedFetch(
+    "/api/v1/test_webhook",
+    {
+      method: "POST",
+      body: JSON.stringify({
+        webhookURL,
+        topic
+      })
+    }
+  );
+  return response.json();
+};
+const webhookCommand = program.command("webhook").description("Test webhook URL with a topic").option("-u, --webhookURL <webhookURL>", "Webhook URL").addOption(new Option("-t, --topic <topic>", "Topic").choices(topics)).action(async () => {
+  const options = webhookCommand.opts();
+  log("Options:", options);
+  let { webhookURL, topic } = options;
+  if (!webhookURL) {
+    const answer = await input({ message: "Enter a webhook URL:" });
+    webhookURL = answer;
+  }
+  if (!topic) {
+    const answer = await select({
+      message: "Select a topic:",
+      choices: [...topics.map((topic2) => ({ title: topic2, value: topic2 }))]
+    });
+    topic = answer;
+  }
+  const spinner = ora("Testing...").start();
+  try {
+    const apiData = await testWebhookURL({ webhookURL, topic });
+    spinner.succeed("Webhook URL is working! 🎉");
+    process.stderr.write(chalk.green(`${apiData.message}
+`));
+  } catch (error) {
+    spinner.fail("Webhook URL is not working!");
+    process.stderr.write(error?.message);
+    process.stderr.write("\n");
+    log("Error:", error);
+  }
+});
+export {
+  testWebhookURL
+};

package/dist/index.d.ts

@@ -1 +0,0 @@
-

package/dist/index.js

@@ -9,6 +9,7 @@ import "./commands/preview.js";
 import "./commands/process.js";
 import "./commands/process-file.js";
 import "./commands/check.js";
+import "./commands/webhook.js";
 program.name("editframe").addOption(new Option("-t, --token <token>", "API Token").env("EF_TOKEN")).addOption(
   new Option("--ef-host <host>", "Editframe Host").env("EF_HOST").default("https://editframe.dev")
 ).addOption(

package/dist/operations/processRenderInfo.d.ts

@@ -1,3 +1,2 @@
 import { getRenderInfo } from './getRenderInfo.ts';
-
 export declare const processRenderInfo: (renderInfo: Awaited<ReturnType<typeof getRenderInfo>>) => Promise<void>;

package/dist/operations/syncAssetsDirectory.js

@@ -2,7 +2,7 @@ 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 } from "node:fs";
+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;
@@ -49,13 +49,27 @@ const syncAssetDirectory = async (projectDirectory) => {
   const assets = await fs.readdir(fullPath);
   process.stderr.write(`Syncing asset dir: ${fullPath}
 `);
-  for (const asset of assets) {
-    process.stderr.write(`Syncing asset: ${asset}
+  const errors = {};
+  const reportError = (path2, message) => {
+    errors[path2] ||= [];
+    errors[path2].push(message);
+    process.stderr.write(` 🚫 ${message}
+`);
+  };
+  const reportSuccess = (_path, message) => {
+    process.stderr.write(` ✅ ${message}
 `);
+  };
+  const reportInfo = (_path, message) => {
+    process.stderr.write(` ${message}
+`);
+  };
+  for (const asset of assets) {
+    reportInfo(asset, `Syncing asset: ${asset}`);
     const assetDir = path.join(fullPath, asset);
     const stat2 = await fs.stat(assetDir);
     if (!stat2.isDirectory()) {
-      process.stderr.write("Invalid asset. Did not find asset directory.\n");
+      reportError(asset, "Invalid asset. Did not find asset directory.");
       return;
     }
     const subAssets = await fs.readdir(assetDir);
@@ -66,9 +80,9 @@ const syncAssetDirectory = async (projectDirectory) => {
       const subAssetPath = path.join(assetDir, subAsset);
       const syncStatus = new SyncStatus(subAssetPath);
       if (await syncStatus.isSynced()) {
-        process.stderr.write(
-          `  ✔ Sub-asset has already been synced: ${subAsset}
-`
+        reportInfo(
+          subAsset,
+          `✔ Sub-asset has already been synced: ${subAsset}`
         );
         continue;
       }
@@ -76,46 +90,50 @@ const syncAssetDirectory = async (projectDirectory) => {
         case imageMatch.test(subAsset): {
           const probeResult = await Probe.probePath(subAssetPath);
           const [videoProbe] = probeResult.videoStreams;
+          const { format } = probeResult;
           if (!videoProbe) {
-            process.stderr.write(
-              `🚫 No video stream found in image: ${subAsset}
-`
-            );
+            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")) {
-            process.stderr.write(`🚫 Invalid image format: ${subAsset}
-`);
+            reportError(subAsset, `Invalid image format: ${subAsset}`);
             break;
           }
-          process.stderr.write(`🖼️  Syncing image: ${subAsset}
-`);
+          reportInfo(subAsset, `🖼️  Syncing image: ${subAsset}`);
           const created = await createImageFile(getClient(), {
             id: asset,
             filename: subAsset,
             width: videoProbe.width,
             height: videoProbe.height,
-            mime_type: `image/${ext}`
+            mime_type: `image/${ext}`,
+            byte_size: (await fs.stat(subAssetPath)).size
           });
           if (created) {
             if (created.complete) {
-              process.stderr.write("  ✔ Image has already been synced.\n");
+              reportInfo(subAsset, " ✔ Image has already been synced");
+              await syncStatus.markSynced();
             } else {
               await uploadImageFile(
                 getClient(),
                 created.id,
-                createReadStream(subAssetPath)
-              );
-              process.stderr.write("  ✅ Image has been synced.\n");
+                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}`
+                );
+              });
             }
-            await syncStatus.markSynced();
           }
           break;
         }
         case trackMatch.test(subAsset): {
-          process.stderr.write(`📼 Syncing a/v track: ${subAsset}
-`);
+          reportInfo(subAsset, `📼 Syncing a/v track: ${subAsset}`);
           const createdFile = await createISOBMFFFile(getClient(), {
             id: asset,
             filename: subAsset.replace(/\.track-[\d]+.mp4$/, "")
@@ -124,25 +142,19 @@ const syncAssetDirectory = async (projectDirectory) => {
             const probe = await Probe.probePath(subAssetPath);
             const trackId = subAsset.match(/track-([\d]+).mp4/)?.[1];
             if (!trackId) {
-              process.stderr.write(
-                `🚫 No track ID found for track: ${subAsset}
-`
-              );
+              reportError(subAsset, `No track ID found for track: ${subAsset}`);
               break;
             }
             const [track] = probe.streams;
             if (!track) {
-              process.stderr.write(
-                `🚫 No track stream found in track: ${subAsset}
-`
+              reportError(
+                subAsset,
+                `No track stream found in track: ${subAsset}`
               );
               break;
             }
             if (track.duration === void 0) {
-              process.stderr.write(
-                `🚫 No duration found in track: ${subAsset}
-`
-              );
+              reportError(subAsset, `No duration found in track: ${subAsset}`);
               break;
             }
             const stat3 = await fs.stat(subAssetPath);
@@ -168,82 +180,122 @@ const syncAssetDirectory = async (projectDirectory) => {
               createPayload
             );
             if (createdTrack) {
-              if (createdTrack.last_received_byte === createdTrack.byte_size - 1) {
-                process.stderr.write("  ✔ Track has already been synced.\n");
+              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)
-                );
-                process.stderr.write("  ✅ Track has been synced.\n");
+                  createReadStream(subAssetPath),
+                  createdTrack.byte_size
+                ).then(() => {
+                  reportSuccess(subAsset, "Track has been synced.");
+                  return syncStatus.markSynced();
+                }).catch((error) => {
+                  reportError(
+                    subAsset,
+                    `Error uploading track: ${error.message}`
+                  );
+                });
               }
-              await syncStatus.markSynced();
             }
           }
           break;
         }
         case fragmentIndexMatch.test(subAsset): {
-          process.stderr.write(`📋 Syncing fragment index: ${subAsset}
-`);
+          reportInfo(subAsset, `📋 Syncing fragment index: ${subAsset}`);
           const createdFile = await createISOBMFFFile(getClient(), {
             id: asset,
             filename: subAsset.replace(/\.tracks.json$/, "")
           });
           if (createdFile) {
             if (createdFile.fragment_index_complete) {
-              process.stderr.write(
-                "  ✔ Fragment index has already been synced.\n"
-              );
+              reportInfo(subAsset, "✔ Fragment index has already been synced.");
+              await syncStatus.markSynced();
             } else {
+              const stats = statSync(subAssetPath);
               const readStream = createReadStream(subAssetPath);
-              await uploadFragmentIndex(getClient(), asset, readStream);
-              process.stderr.write("  ✅ Fragment index has been synced.\n");
+              await uploadFragmentIndex(
+                getClient(),
+                asset,
+                readStream,
+                stats.size
+              ).then(() => {
+                reportSuccess(subAsset, "Fragment index has been synced.");
+                return syncStatus.markSynced();
+              }).catch((error) => {
+                reportError(
+                  subAsset,
+                  `Error uploading fragment index: ${error.message}`
+                );
+              });
             }
-            await syncStatus.markSynced();
           } else {
-            process.stderr.write(
-              `🚫 No file found for fragment index: ${subAsset}
-`
+            reportError(
+              subAsset,
+              `No file found for fragment index: ${subAsset}`
             );
             break;
           }
           break;
         }
         case captionsMatch.test(subAsset): {
-          process.stderr.write(`📝 Syncing captions: ${subAsset}
-`);
+          reportInfo(subAsset, `📝 Syncing captions: ${subAsset}`);
           const createdFile = await createCaptionFile(getClient(), {
             id: asset,
-            filename: subAsset.replace(/\.captions.json$/, "")
+            filename: subAsset.replace(/\.captions.json$/, ""),
+            byte_size: (await fs.stat(subAsset)).size
           });
           if (createdFile) {
             if (createdFile.complete) {
-              process.stderr.write("  ✔ Captions have already been synced.\n");
+              reportInfo(subAsset, "✔ Captions have already been synced.");
+              await syncStatus.markSynced();
             } else {
               const readStream = createReadStream(subAssetPath);
-              await uploadCaptionFile(getClient(), asset, readStream);
-              process.stderr.write("  ✅ Captions have been synced.\n");
+              const stats = statSync(subAssetPath);
+              await uploadCaptionFile(
+                getClient(),
+                asset,
+                readStream,
+                stats.size
+              ).then(() => {
+                reportSuccess(subAsset, "Captions have been synced.");
+                return syncStatus.markSynced();
+              }).catch((error) => {
+                reportError(
+                  subAsset,
+                  `Error uploading captions: ${error.message}`
+                );
+              });
             }
-            await syncStatus.markSynced();
           } else {
-            process.stderr.write(
-              `🚫 No file found for captions: ${subAsset}
-`
-            );
+            reportError(subAsset, `No file found for captions: ${subAsset}`);
             break;
           }
           break;
         }
         default: {
-          process.stderr.write(`🚫 Unknown sub-asset: ${subAsset}
-`);
+          reportError(subAsset, `Unknown sub-asset: ${subAsset}`);
           break;
         }
       }
     }
   }
+  if (Object.keys(errors).length) {
+    process.stderr.write("\n\n❌ Encountered errors while syncing assets:\n");
+    for (const [asset, messages] of Object.entries(errors)) {
+      process.stderr.write(`
+🚫 ${asset}
+`);
+      for (const message of messages) {
+        process.stderr.write(`  - ${message}
+`);
+      }
+    }
+    throw new Error("Failed to sync assets");
+  }
 };
 export {
   syncAssetDirectory

package/dist/utils/attachWorkbench.d.ts

@@ -1,3 +1,2 @@
 import { Page } from 'playwright';
-
 export declare const attachWorkbench: (page: Page) => void;

package/dist/utils/getFolderSize.d.ts

@@ -0,0 +1 @@
+export declare const getFolderSize: (folderPath: string) => Promise<number>;

package/dist/utils/getFolderSize.js

@@ -0,0 +1,22 @@
+import { promises } from "node:fs";
+import path from "node:path";
+const getFolderSize = async (folderPath) => {
+  let totalSize = 0;
+  async function calculateSize(dir) {
+    const files = await promises.readdir(dir);
+    for (const file of files) {
+      const filePath = path.join(dir, file);
+      const stats = await promises.stat(filePath);
+      if (stats.isDirectory()) {
+        await calculateSize(filePath);
+      } else {
+        totalSize += stats.size;
+      }
+    }
+  }
+  await calculateSize(folderPath);
+  return totalSize;
+};
+export {
+  getFolderSize
+};

package/dist/utils/index.d.ts

@@ -1,3 +1,2 @@
 import { Client } from '../../../api/src';
-
 export declare const getClient: () => Client;

package/dist/utils/launchBrowserAndWaitForSDK.d.ts

@@ -1,5 +1,4 @@
 import { Page } from 'playwright';
-
 interface LaunchOptions {
     url: string;
     headless?: boolean;

package/dist/utils/startDevServer.d.ts

@@ -1,5 +1,4 @@
 import { ViteDevServer } from 'vite';
-
 export declare class DevServer {
     private devServer;
     static start(directory: string): Promise<DevServer>;

package/dist/utils/startPreviewServer.d.ts

@@ -1,5 +1,4 @@
 import { ViteDevServer } from 'vite';
-
 export declare class PreviewServer {
     private previewServer;
     static start(directory: string): Promise<PreviewServer>;

package/dist/utils/validateVideoResolution.d.ts

@@ -3,7 +3,7 @@ type VideoPayload = {
     height: number;
 };
 export declare const validateVideoResolution: (rawPayload: VideoPayload) => Promise<{
-    width: number;
     height: number;
+    width: number;
 }>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@editframe/cli",
-  "version": "0.8.0-beta.1",
+  "version": "0.8.0-beta.10",
   "description": "Command line interface for EditFrame",
   "bin": {
     "editframe": "./dist/index.js"
@@ -19,14 +19,15 @@
     "@types/promptly": "^3.0.5",
     "@types/tar": "^6.1.13",
     "typescript": "^5.5.4",
-    "vite-plugin-dts": "^3.9.1",
+    "vite-plugin-dts": "^4.0.3",
     "vite-tsconfig-paths": "^4.3.2"
   },
   "dependencies": {
-    "@editframe/api": "0.8.0-beta.1",
-    "@editframe/assets": "0.8.0-beta.1",
-    "@editframe/elements": "0.8.0-beta.1",
-    "@editframe/vite-plugin": "0.8.0-beta.1",
+    "@editframe/api": "0.8.0-beta.10",
+    "@editframe/assets": "0.8.0-beta.10",
+    "@editframe/elements": "0.8.0-beta.10",
+    "@editframe/vite-plugin": "0.8.0-beta.10",
+    "@inquirer/prompts": "^5.3.8",
     "axios": "^1.6.8",
     "chalk": "^5.3.0",
     "commander": "^12.0.0",

package/src/commands/process-file.ts

@@ -1,11 +1,12 @@
 import { basename } from "node:path";
+import { stat } from "node:fs/promises";
+import { createReadStream } from "node:fs";
 
 import { program } from "commander";
 
 import { withSpinner } from "../utils/withSpinner.ts";
 
 import { getClient } from "../utils/index.ts";
-import { createReadStream } from "node:fs";
 import {
   createUnprocessedFile,
   updateUnprocessedFile,
@@ -21,18 +22,21 @@ program
 
     const fileId = await md5FilePath(path);
 
+    const byte_size = (await stat(path)).size;
+
     await withSpinner("Creating unprocessed file record", async () => {
       await createUnprocessedFile(client, {
         id: fileId,
         processes: [],
         filename: basename(path),
+        byte_size,
       });
     });
 
     const readStream = createReadStream(path);
 
     await withSpinner("Uploading file", async () => {
-      await uploadUnprocessedFile(client, fileId, readStream);
+      await uploadUnprocessedFile(client, fileId, readStream, byte_size);
     });
 
     const unprocessedFile = await withSpinner(

package/src/commands/render.ts

@@ -19,6 +19,7 @@ import { getClient } from "../utils/index.ts";
 import { getRenderInfo } from "../operations/getRenderInfo.ts";
 import { processRenderInfo } from "../operations/processRenderInfo.ts";
 import { validateVideoResolution } from "../utils/validateVideoResolution.ts";
+import { getFolderSize } from "../utils/getFolderSize.ts";
 
 interface StrategyBuilder {
   buildProductionUrl: (tagName: string, assetPath: string) => Promise<string>;
@@ -179,7 +180,8 @@ program
         );
         const readable = new PassThrough();
         tarStream.pipe(readable);
-        await uploadRender(getClient(), md5, readable);
+        const folderSize = await getFolderSize(distDir);
+        await uploadRender(getClient(), md5, readable, folderSize);
         process.stderr.write("Render assets uploaded\n");
         process.stderr.write(inspect(render));
         process.stderr.write("\n");

package/src/commands/webhook.ts

@@ -0,0 +1,76 @@
+import { program, Option } from "commander";
+import ora from "ora";
+import chalk from "chalk";
+import debug from "debug";
+import { input, select } from "@inquirer/prompts";
+
+import { getClient } from "../utils/index.ts";
+
+const log = debug("ef:cli:auth");
+
+export interface APITestWebhhokResult {
+  message: string;
+}
+const topics = [
+  "render.created",
+  "render.rendering",
+  "render.pending",
+  "render.failed",
+  "render.completed",
+];
+
+export const testWebhookURL = async ({
+  webhookURL,
+  topic,
+}: {
+  webhookURL: string;
+  topic: string;
+}) => {
+  const response = await getClient().authenticatedFetch(
+    "/api/v1/test_webhook",
+    {
+      method: "POST",
+      body: JSON.stringify({
+        webhookURL,
+        topic,
+      }),
+    },
+  );
+  return response.json() as Promise<APITestWebhhokResult>;
+};
+
+const webhookCommand = program
+  .command("webhook")
+  .description("Test webhook URL with a topic")
+  .option("-u, --webhookURL <webhookURL>", "Webhook URL")
+  .addOption(new Option("-t, --topic <topic>", "Topic").choices(topics))
+  .action(async () => {
+    const options = webhookCommand.opts();
+    log("Options:", options);
+    let { webhookURL, topic } = options;
+
+    if (!webhookURL) {
+      const answer = await input({ message: "Enter a webhook URL:" });
+      webhookURL = answer;
+    }
+
+    if (!topic) {
+      const answer = await select({
+        message: "Select a topic:",
+        choices: [...topics.map((topic) => ({ title: topic, value: topic }))],
+      });
+      topic = answer;
+    }
+
+    const spinner = ora("Testing...").start();
+    try {
+      const apiData = await testWebhookURL({ webhookURL, topic });
+      spinner.succeed("Webhook URL is working! 🎉");
+      process.stderr.write(chalk.green(`${apiData.message}\n`));
+    } catch (error: any) {
+      spinner.fail("Webhook URL is not working!");
+      process.stderr.write(error?.message);
+      process.stderr.write("\n");
+      log("Error:", error);
+    }
+  });

package/src/operations/syncAssetsDirectory.ts

@@ -12,6 +12,7 @@ import {
   uploadISOBMFFTrack,
   type CreateISOBMFFTrackPayload,
 } from "@editframe/api";
+import { statSync } from "node:fs";
 
 import { createReadStream } from "node:fs";
 import type { z } from "zod";
@@ -62,6 +63,7 @@ export const syncAssetDirectory = async (
     }
     throw error;
   });
+
   if (!stat?.isDirectory()) {
     console.error(`No assets cache directory found at ${fullPath}`);
     return;
@@ -70,12 +72,28 @@ export const syncAssetDirectory = async (
 
   process.stderr.write(`Syncing asset dir: ${fullPath}\n`);
 
+  const errors: Record<string, string[]> = {};
+
+  const reportError = (path: string, message: string) => {
+    errors[path] ||= [];
+    errors[path].push(message);
+    process.stderr.write(` 🚫 ${message}\n`);
+  };
+
+  const reportSuccess = (_path: string, message: string) => {
+    process.stderr.write(` ✅ ${message}\n`);
+  };
+
+  const reportInfo = (_path: string, message: string) => {
+    process.stderr.write(` ${message}\n`);
+  };
+
   for (const asset of assets) {
-    process.stderr.write(`Syncing asset: ${asset}\n`);
+    reportInfo(asset, `Syncing asset: ${asset}`);
     const assetDir = path.join(fullPath, asset);
     const stat = await fs.stat(assetDir);
     if (!stat.isDirectory()) {
-      process.stderr.write("Invalid asset. Did not find asset directory.\n");
+      reportError(asset, "Invalid asset. Did not find asset directory.");
       return;
     }
     const subAssets = await fs.readdir(assetDir);
@@ -88,8 +106,9 @@ export const syncAssetDirectory = async (
       const subAssetPath = path.join(assetDir, subAsset);
       const syncStatus = new SyncStatus(subAssetPath);
       if (await syncStatus.isSynced()) {
-        process.stderr.write(
-          `  ✔ Sub-asset has already been synced: ${subAsset}\n`,
+        reportInfo(
+          subAsset,
+          `✔ Sub-asset has already been synced: ${subAsset}`,
         );
         continue;
       }
@@ -97,10 +116,9 @@ export const syncAssetDirectory = async (
         case imageMatch.test(subAsset): {
           const probeResult = await Probe.probePath(subAssetPath);
           const [videoProbe] = probeResult.videoStreams;
+          const { format } = probeResult;
           if (!videoProbe) {
-            process.stderr.write(
-              `🚫 No video stream found in image: ${subAsset}\n`,
-            );
+            reportError(subAsset, `No media info found in image: ${subAsset}`);
             break;
           }
           const ext = path.extname(subAsset).slice(1);
@@ -112,34 +130,45 @@ export const syncAssetDirectory = async (
               ext === "webp"
             )
           ) {
-            process.stderr.write(`🚫 Invalid image format: ${subAsset}\n`);
+            reportError(subAsset, `Invalid image format: ${subAsset}`);
             break;
           }
-          process.stderr.write(`🖼️  Syncing image: ${subAsset}\n`);
+          reportInfo(subAsset, `🖼️  Syncing image: ${subAsset}`);
           const created = await createImageFile(getClient(), {
             id: asset,
             filename: subAsset,
             width: videoProbe.width,
             height: videoProbe.height,
             mime_type: `image/${ext}`,
+            byte_size: (await fs.stat(subAssetPath)).size,
           });
           if (created) {
             if (created.complete) {
-              process.stderr.write("  ✔ Image has already been synced.\n");
+              reportInfo(subAsset, " ✔ Image has already been synced");
+              await syncStatus.markSynced();
             } else {
               await uploadImageFile(
                 getClient(),
                 created.id,
                 createReadStream(subAssetPath),
-              );
-              process.stderr.write("  ✅ Image has been synced.\n");
+                Number.parseInt(format.size || "0"),
+              )
+                .then(() => {
+                  reportSuccess(subAsset, "Image has been synced.");
+                  return syncStatus.markSynced();
+                })
+                .catch((error) => {
+                  reportError(
+                    subAsset,
+                    `Error uploading image: ${error.message}`,
+                  );
+                });
             }
-            await syncStatus.markSynced();
           }
           break;
         }
         case trackMatch.test(subAsset): {
-          process.stderr.write(`📼 Syncing a/v track: ${subAsset}\n`);
+          reportInfo(subAsset, `📼 Syncing a/v track: ${subAsset}`);
           const createdFile = await createISOBMFFFile(getClient(), {
             id: asset,
             filename: subAsset.replace(/\.track-[\d]+.mp4$/, ""),
@@ -148,29 +177,26 @@ export const syncAssetDirectory = async (
             const probe = await Probe.probePath(subAssetPath);
             const trackId = subAsset.match(/track-([\d]+).mp4/)?.[1];
             if (!trackId) {
-              process.stderr.write(
-                `🚫 No track ID found for track: ${subAsset}\n`,
-              );
+              reportError(subAsset, `No track ID found for track: ${subAsset}`);
               break;
             }
             const [track] = probe.streams;
             if (!track) {
-              process.stderr.write(
-                `🚫 No track stream found in track: ${subAsset}\n`,
+              reportError(
+                subAsset,
+                `No track stream found in track: ${subAsset}`,
               );
               break;
             }
             if (track.duration === undefined) {
-              process.stderr.write(
-                `🚫 No duration found in track: ${subAsset}\n`,
-              );
+              reportError(subAsset, `No duration found in track: ${subAsset}`);
               break;
             }
 
             const stat = await fs.stat(subAssetPath);
 
             /**
-             * Because the payload is a discriminated union, we nede to create these objects
+             * Because the payload is a discriminated union, we need to create these objects
              * only after the value for type has been narrowed, otherwise the object will
              * have type: "audio" | "video" which doesnt' match the payload type that
              * looks more like { type: "audio", ... } | { type: "video", ... }
@@ -201,79 +227,126 @@ export const syncAssetDirectory = async (
             );
 
             if (createdTrack) {
-              if (
-                createdTrack.last_received_byte ===
-                createdTrack.byte_size - 1
-              ) {
-                process.stderr.write("  ✔ Track has already been synced.\n");
+              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),
-                );
-                process.stderr.write("  ✅ Track has been synced.\n");
+                  createdTrack.byte_size,
+                )
+                  .then(() => {
+                    reportSuccess(subAsset, "Track has been synced.");
+                    return syncStatus.markSynced();
+                  })
+                  .catch((error) => {
+                    reportError(
+                      subAsset,
+                      `Error uploading track: ${error.message}`,
+                    );
+                  });
               }
-              await syncStatus.markSynced();
             }
           }
 
           break;
         }
         case fragmentIndexMatch.test(subAsset): {
-          process.stderr.write(`📋 Syncing fragment index: ${subAsset}\n`);
+          reportInfo(subAsset, `📋 Syncing fragment index: ${subAsset}`);
           const createdFile = await createISOBMFFFile(getClient(), {
             id: asset,
             filename: subAsset.replace(/\.tracks.json$/, ""),
           });
           if (createdFile) {
             if (createdFile.fragment_index_complete) {
-              process.stderr.write(
-                "  ✔ Fragment index has already been synced.\n",
-              );
+              reportInfo(subAsset, "✔ Fragment index has already been synced.");
+              await syncStatus.markSynced();
             } else {
+              const stats = statSync(subAssetPath);
               const readStream = createReadStream(subAssetPath);
-              await uploadFragmentIndex(getClient(), asset, readStream);
-              process.stderr.write("  ✅ Fragment index has been synced.\n");
+              await uploadFragmentIndex(
+                getClient(),
+                asset,
+                readStream,
+                stats.size,
+              )
+                .then(() => {
+                  reportSuccess(subAsset, "Fragment index has been synced.");
+                  return syncStatus.markSynced();
+                })
+                .catch((error) => {
+                  reportError(
+                    subAsset,
+                    `Error uploading fragment index: ${error.message}`,
+                  );
+                });
             }
-            await syncStatus.markSynced();
           } else {
-            process.stderr.write(
-              `🚫 No file found for fragment index: ${subAsset}\n`,
+            reportError(
+              subAsset,
+              `No file found for fragment index: ${subAsset}`,
             );
             break;
           }
           break;
         }
         case captionsMatch.test(subAsset): {
-          process.stderr.write(`📝 Syncing captions: ${subAsset}\n`);
+          reportInfo(subAsset, `📝 Syncing captions: ${subAsset}`);
           const createdFile = await createCaptionFile(getClient(), {
             id: asset,
             filename: subAsset.replace(/\.captions.json$/, ""),
+            byte_size: (await fs.stat(subAsset)).size,
           });
           if (createdFile) {
             if (createdFile.complete) {
-              process.stderr.write("  ✔ Captions have already been synced.\n");
+              reportInfo(subAsset, "✔ Captions have already been synced.");
+              await syncStatus.markSynced();
             } else {
               const readStream = createReadStream(subAssetPath);
-              await uploadCaptionFile(getClient(), asset, readStream);
-              process.stderr.write("  ✅ Captions have been synced.\n");
+              const stats = statSync(subAssetPath);
+              await uploadCaptionFile(
+                getClient(),
+                asset,
+                readStream,
+                stats.size,
+              )
+                .then(() => {
+                  reportSuccess(subAsset, "Captions have been synced.");
+                  return syncStatus.markSynced();
+                })
+                .catch((error) => {
+                  reportError(
+                    subAsset,
+                    `Error uploading captions: ${error.message}`,
+                  );
+                });
             }
-            await syncStatus.markSynced();
           } else {
-            process.stderr.write(
-              `🚫 No file found for captions: ${subAsset}\n`,
-            );
+            reportError(subAsset, `No file found for captions: ${subAsset}`);
             break;
           }
           break;
         }
         default: {
-          process.stderr.write(`🚫 Unknown sub-asset: ${subAsset}\n`);
+          reportError(subAsset, `Unknown sub-asset: ${subAsset}`);
           break;
         }
       }
     }
   }
+
+  if (Object.keys(errors).length) {
+    process.stderr.write("\n\n❌ Encountered errors while syncing assets:\n");
+    for (const [asset, messages] of Object.entries(errors)) {
+      process.stderr.write(`\n🚫 ${asset}\n`);
+      for (const message of messages) {
+        process.stderr.write(`  - ${message}\n`);
+      }
+    }
+
+    throw new Error("Failed to sync assets");
+  }
 };

package/src/utils/getFolderSize.ts

@@ -0,0 +1,24 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+
+export const getFolderSize = async (folderPath: string): Promise<number> => {
+  let totalSize = 0;
+
+  async function calculateSize(dir: string): Promise<void> {
+    const files = await fs.readdir(dir);
+
+    for (const file of files) {
+      const filePath = path.join(dir, file);
+      const stats = await fs.stat(filePath);
+
+      if (stats.isDirectory()) {
+        await calculateSize(filePath);
+      } else {
+        totalSize += stats.size;
+      }
+    }
+  }
+
+  await calculateSize(folderPath);
+  return totalSize;
+};