vidup 1.0.18 → 1.0.20

package/dist/sync-ChGtXZ_b.js

@@ -1,543 +0,0 @@
-import { BunnyCdnStream } from 'bunnycdn-stream';
-import { hash } from 'hasha';
-import { createReadStream } from 'node:fs';
-import fs, { writeFile, rename, readFile } from 'node:fs/promises';
-import path, { join, dirname, basename } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { oraPromise } from 'ora';
-import { execa } from 'execa';
-import ffmpegPath from 'ffmpeg-static';
-
-function getDefaultExportFromCjs(x) {
-  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
-}
-
-var picocolors = {exports: {}};
-
-var hasRequiredPicocolors;
-
-function requirePicocolors () {
-	if (hasRequiredPicocolors) return picocolors.exports;
-	hasRequiredPicocolors = 1;
-	let p = process || {}, argv = p.argv || [], env = p.env || {};
-	let isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
-	let formatter = (open, close, replace = open) => (input) => {
-	  let string = "" + input, index = string.indexOf(close, open.length);
-	  return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
-	};
-	let replaceClose = (string, close, replace, index) => {
-	  let result = "", cursor = 0;
-	  do {
-	    result += string.substring(cursor, index) + replace;
-	    cursor = index + close.length;
-	    index = string.indexOf(close, cursor);
-	  } while (~index);
-	  return result + string.substring(cursor);
-	};
-	let createColors = (enabled = isColorSupported) => {
-	  let f = enabled ? formatter : () => String;
-	  return {
-	    isColorSupported: enabled,
-	    reset: f("\x1B[0m", "\x1B[0m"),
-	    bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
-	    dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
-	    italic: f("\x1B[3m", "\x1B[23m"),
-	    underline: f("\x1B[4m", "\x1B[24m"),
-	    inverse: f("\x1B[7m", "\x1B[27m"),
-	    hidden: f("\x1B[8m", "\x1B[28m"),
-	    strikethrough: f("\x1B[9m", "\x1B[29m"),
-	    black: f("\x1B[30m", "\x1B[39m"),
-	    red: f("\x1B[31m", "\x1B[39m"),
-	    green: f("\x1B[32m", "\x1B[39m"),
-	    yellow: f("\x1B[33m", "\x1B[39m"),
-	    blue: f("\x1B[34m", "\x1B[39m"),
-	    magenta: f("\x1B[35m", "\x1B[39m"),
-	    cyan: f("\x1B[36m", "\x1B[39m"),
-	    white: f("\x1B[37m", "\x1B[39m"),
-	    gray: f("\x1B[90m", "\x1B[39m"),
-	    bgBlack: f("\x1B[40m", "\x1B[49m"),
-	    bgRed: f("\x1B[41m", "\x1B[49m"),
-	    bgGreen: f("\x1B[42m", "\x1B[49m"),
-	    bgYellow: f("\x1B[43m", "\x1B[49m"),
-	    bgBlue: f("\x1B[44m", "\x1B[49m"),
-	    bgMagenta: f("\x1B[45m", "\x1B[49m"),
-	    bgCyan: f("\x1B[46m", "\x1B[49m"),
-	    bgWhite: f("\x1B[47m", "\x1B[49m"),
-	    blackBright: f("\x1B[90m", "\x1B[39m"),
-	    redBright: f("\x1B[91m", "\x1B[39m"),
-	    greenBright: f("\x1B[92m", "\x1B[39m"),
-	    yellowBright: f("\x1B[93m", "\x1B[39m"),
-	    blueBright: f("\x1B[94m", "\x1B[39m"),
-	    magentaBright: f("\x1B[95m", "\x1B[39m"),
-	    cyanBright: f("\x1B[96m", "\x1B[39m"),
-	    whiteBright: f("\x1B[97m", "\x1B[39m"),
-	    bgBlackBright: f("\x1B[100m", "\x1B[49m"),
-	    bgRedBright: f("\x1B[101m", "\x1B[49m"),
-	    bgGreenBright: f("\x1B[102m", "\x1B[49m"),
-	    bgYellowBright: f("\x1B[103m", "\x1B[49m"),
-	    bgBlueBright: f("\x1B[104m", "\x1B[49m"),
-	    bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
-	    bgCyanBright: f("\x1B[106m", "\x1B[49m"),
-	    bgWhiteBright: f("\x1B[107m", "\x1B[49m")
-	  };
-	};
-	picocolors.exports = createColors();
-	picocolors.exports.createColors = createColors;
-	return picocolors.exports;
-}
-
-var picocolorsExports = /*@__PURE__*/ requirePicocolors();
-var pc = /*@__PURE__*/getDefaultExportFromCjs(picocolorsExports);
-
-const isNode = process.versions.node !== void 0;
-const log = {
-  verbose: false,
-  // Intended for temporary logging
-  log(...data) {
-    if (!this.verbose) return;
-    const levelPrefix = pc.gray("[Log]");
-    if (isNode) {
-      console.warn(levelPrefix, ...data);
-    } else {
-      console.log(levelPrefix, ...data);
-    }
-  },
-  logPrefixed(prefix, ...data) {
-    this.info(pc.blue(`[${prefix}]`), ...data);
-  },
-  info(...data) {
-    if (!this.verbose) return;
-    const levelPrefix = pc.green("[Info]");
-    if (isNode) {
-      console.warn(levelPrefix, ...data);
-    } else {
-      console.info(levelPrefix, ...data);
-    }
-  },
-  infoPrefixed(prefix, ...data) {
-    this.info(pc.blue(`[${prefix}]`), ...data);
-  },
-  async infoSpin(promise, message) {
-    return oraPromise(promise, {
-      prefixText: pc.green("[Info]"),
-      stream: process.stderr,
-      text: message
-    });
-  },
-  warn(...data) {
-    console.warn(pc.yellow("[Warning]"), ...data);
-  },
-  warnPrefixed(prefix, ...data) {
-    this.warn(pc.blue(`[${prefix}]`), ...data);
-  },
-  error(...data) {
-    console.error(pc.red("[Error]"), ...data);
-  },
-  errorPrefixed(prefix, ...data) {
-    this.error(pc.blue(`[${prefix}]`), ...data);
-  }
-};
-
-async function getVideosInDirectory(directory) {
-  const files = await fs.readdir(directory);
-  const videoFiles = files.filter((file) => {
-    const fileExtension = path.extname(file);
-    const videoExtensions = [".mp4", ".mov", ".avi", ".mkv"];
-    return videoExtensions.includes(fileExtension);
-  }).map((file) => path.join(directory, file));
-  return videoFiles;
-}
-async function videoHasMetadata(filename) {
-  if (ffmpegPath === null) {
-    throw new Error("ffmpeg-static failed to locate ffmpeg binary");
-  }
-  try {
-    const { stderr, stdout } = await execa(ffmpegPath, ["-i", filename, "-f", "ffmetadata", "-"]);
-    return stdout.includes("creation_time") || stderr.includes("creation_time");
-  } catch (error) {
-    throw new Error(`Failed to check metadata for: ${filename}:
-${String(error)}`);
-  }
-}
-async function stripVideoMetadata(filename) {
-  if (ffmpegPath === null) {
-    throw new Error("ffmpeg-static failed to locate ffmpeg binary");
-  }
-  try {
-    const extension = path.extname(filename).slice(1);
-    const temporaryFilename = `${filename.slice(0, Math.max(0, filename.lastIndexOf(".")))}.temp.${extension}`;
-    await execa(ffmpegPath, [
-      "-i",
-      filename,
-      "-map_metadata",
-      "-1",
-      "-c:v",
-      "copy",
-      "-c:a",
-      "copy",
-      temporaryFilename
-    ]);
-    await fs.rename(temporaryFilename, filename);
-  } catch (error) {
-    throw new Error(`Failed to strip metadata from: ${filename}:
-${String(error)}`);
-  }
-}
-
-async function stripVideoMetadataInDirectory(directory, options = {}) {
-  const { dryRun = false, verbose = false } = options;
-  const files = await getVideosInDirectory(directory);
-  return stripVideoMetadataInFiles(files, {
-    dryRun,
-    verbose
-  });
-}
-async function stripVideoMetadataInFiles(files, options = {}) {
-  const { dryRun = false, verbose = false } = options;
-  const initialVerbosity = log.verbose;
-  log.verbose = verbose;
-  const localVideosWithMetadata = [];
-  for (const videoFile of files) {
-    if (await videoHasMetadata(videoFile)) {
-      localVideosWithMetadata.push(videoFile);
-    }
-  }
-  if (!dryRun) {
-    log.info(`Found ${localVideosWithMetadata.length} videos with metadata to strip`);
-    for (const videoFile of localVideosWithMetadata) {
-      console.log(`Stripping metadata from: ${videoFile}`);
-      await stripVideoMetadata(videoFile);
-    }
-  }
-  log.verbose = initialVerbosity;
-  return localVideosWithMetadata;
-}
-
-function getTempFilename(file) {
-  const f = file instanceof URL ? fileURLToPath(file) : file.toString();
-  return join(dirname(f), `.${basename(f)}.tmp`);
-}
-async function retryAsyncOperation(fn, maxRetries, delayMs) {
-  for (let i = 0; i < maxRetries; i++) {
-    try {
-      return await fn();
-    } catch (error) {
-      if (i < maxRetries - 1) {
-        await new Promise((resolve) => setTimeout(resolve, delayMs));
-      } else {
-        throw error;
-      }
-    }
-  }
-}
-class Writer {
-  #filename;
-  #tempFilename;
-  #locked = false;
-  #prev = null;
-  #next = null;
-  #nextPromise = null;
-  #nextData = null;
-  // File is locked, add data for later
-  #add(data) {
-    this.#nextData = data;
-    this.#nextPromise ||= new Promise((resolve, reject) => {
-      this.#next = [resolve, reject];
-    });
-    return new Promise((resolve, reject) => {
-      this.#nextPromise?.then(resolve).catch(reject);
-    });
-  }
-  // File isn't locked, write data
-  async #write(data) {
-    this.#locked = true;
-    try {
-      await writeFile(this.#tempFilename, data, "utf-8");
-      await retryAsyncOperation(async () => {
-        await rename(this.#tempFilename, this.#filename);
-      }, 10, 100);
-      this.#prev?.[0]();
-    } catch (err) {
-      if (err instanceof Error) {
-        this.#prev?.[1](err);
-      }
-      throw err;
-    } finally {
-      this.#locked = false;
-      this.#prev = this.#next;
-      this.#next = this.#nextPromise = null;
-      if (this.#nextData !== null) {
-        const nextData = this.#nextData;
-        this.#nextData = null;
-        await this.write(nextData);
-      }
-    }
-  }
-  constructor(filename) {
-    this.#filename = filename;
-    this.#tempFilename = getTempFilename(filename);
-  }
-  async write(data) {
-    return this.#locked ? this.#add(data) : this.#write(data);
-  }
-}
-
-class TextFile {
-  #filename;
-  #writer;
-  constructor(filename) {
-    this.#filename = filename;
-    this.#writer = new Writer(filename);
-  }
-  async read() {
-    let data;
-    try {
-      data = await readFile(this.#filename, "utf-8");
-    } catch (e) {
-      if (e.code === "ENOENT") {
-        return null;
-      }
-      throw e;
-    }
-    return data;
-  }
-  write(str) {
-    return this.#writer.write(str);
-  }
-}
-
-class DataFile {
-  #adapter;
-  #parse;
-  #stringify;
-  constructor(filename, { parse, stringify }) {
-    this.#adapter = new TextFile(filename);
-    this.#parse = parse;
-    this.#stringify = stringify;
-  }
-  async read() {
-    const data = await this.#adapter.read();
-    if (data === null) {
-      return null;
-    } else {
-      return this.#parse(data);
-    }
-  }
-  write(obj) {
-    return this.#adapter.write(this.#stringify(obj));
-  }
-}
-
-class JSONFile extends DataFile {
-  constructor(filename) {
-    super(filename, {
-      parse: JSON.parse,
-      stringify: (data) => JSON.stringify(data, null, 2)
-    });
-  }
-}
-
-class Memory {
-  #data = null;
-  read() {
-    return Promise.resolve(this.#data);
-  }
-  write(obj) {
-    this.#data = obj;
-    return Promise.resolve();
-  }
-}
-
-function checkArgs(adapter, defaultData) {
-  if (adapter === void 0)
-    throw new Error("lowdb: missing adapter");
-  if (defaultData === void 0)
-    throw new Error("lowdb: missing default data");
-}
-class Low {
-  adapter;
-  data;
-  constructor(adapter, defaultData) {
-    checkArgs(adapter, defaultData);
-    this.adapter = adapter;
-    this.data = defaultData;
-  }
-  async read() {
-    const data = await this.adapter.read();
-    if (data)
-      this.data = data;
-  }
-  async write() {
-    if (this.data)
-      await this.adapter.write(this.data);
-  }
-  async update(fn) {
-    fn(this.data);
-    await this.write();
-  }
-}
-
-async function JSONFilePreset(filename, defaultData) {
-  const adapter = process.env.NODE_ENV === "test" ? new Memory() : new JSONFile(filename);
-  const db = new Low(adapter, defaultData);
-  await db.read();
-  return db;
-}
-
-async function syncVideoInDirectory(directory, options) {
-  const { credentials, dryRun = false, service, verbose = false } = options;
-  const initialVerbosity = log.verbose;
-  log.verbose = verbose;
-  const syncReport = [];
-  const videoFiles = await getVideosInDirectory(directory);
-  log.info(`Found ${videoFiles.length} video files in directory "${directory}"`);
-  const state = await JSONFilePreset(path.join(directory, ".vidup-state.json"), {
-    syncState: []
-  });
-  state.data.syncState = state.data.syncState.filter(
-    (entry) => videoFiles.includes(path.join(directory, entry.filename))
-  );
-  for (const videoFile of videoFiles) {
-    const filename = path.basename(videoFile);
-    const localHash = await hash(videoFile, { algorithm: "sha1" });
-    const existingEntry = state.data.syncState.find((entry) => entry.filename === filename);
-    if (existingEntry) {
-      existingEntry.localHash = localHash;
-    } else {
-      state.data.syncState.push({ filename, localHash, remoteHash: {} });
-    }
-  }
-  if (!dryRun) {
-    await state.write();
-  }
-  if (service !== "bunny") {
-    throw new Error(`Streaming service not yet implemented: ${service}`);
-  }
-  const stream = new BunnyCdnStream({
-    apiKey: credentials.key,
-    videoLibrary: credentials.library
-  });
-  const remoteVideos = await stream.listAllVideos();
-  log.info(`Found ${remoteVideos.length} video files on ${service} remote streaming service`);
-  const remoteVideosInGoodStanding = remoteVideos.filter((video) => {
-    const entry = state.data.syncState.find((entry2) => entry2.filename === video.title);
-    return entry !== void 0 && entry.localHash === entry.remoteHash[service];
-  });
-  for (const video of remoteVideosInGoodStanding) {
-    syncReport.push({
-      action: "None",
-      localFile: video.title,
-      remoteId: video.guid
-    });
-  }
-  const remoteVideosToCreate = state.data.syncState.filter(
-    (entry) => !remoteVideos.some((video) => video.title === entry.filename)
-  );
-  for (const video of remoteVideosToCreate) {
-    syncReport.push({
-      action: "Create",
-      localFile: video.filename,
-      remoteId: "Not yet uploaded (Dry run)"
-    });
-  }
-  const remoteVideosToUpdate = remoteVideos.filter((video) => {
-    const entry = state.data.syncState.find((entry2) => entry2.filename === video.title);
-    return entry !== void 0 && entry.localHash !== entry.remoteHash[service];
-  });
-  for (const video of remoteVideosToUpdate) {
-    syncReport.push({
-      action: "Update",
-      localFile: video.title,
-      remoteId: "Not yet uploaded (Dry run)"
-    });
-  }
-  const remoteVideosToDelete = remoteVideos.filter(
-    (video) => !state.data.syncState.some((entry) => entry.filename === video.title)
-  );
-  for (const video of remoteVideosToDelete) {
-    syncReport.push({
-      action: "Delete",
-      localFile: video.title,
-      remoteId: video.guid
-    });
-  }
-  if (!dryRun) {
-    state.data.lastRun = /* @__PURE__ */ new Date();
-    await state.write();
-    log.info(`Synchronizing...`);
-    for (const [index, remoteVideo] of remoteVideosToDelete.entries()) {
-      if (index === 0) log.info(`Deleting ${remoteVideosToDelete.length} remote videos...`);
-      const deleteResponse = await log.infoSpin(
-        stream.deleteVideo(remoteVideo.guid),
-        `Deleting remote video ${index + 1}/${remoteVideosToDelete.length}: ${remoteVideo.title}`
-      );
-      if (!deleteResponse.success) {
-        throw new Error(`Failed to delete remote video: ${remoteVideo.title}`);
-      }
-      state.data.lastUpdate = /* @__PURE__ */ new Date();
-      await state.write();
-    }
-    for (const [index, localVideo] of remoteVideosToCreate.entries()) {
-      if (index === 0) log.info(`Uploading ${remoteVideosToCreate.length} new local videos...`);
-      const videoFile = createReadStream(path.join(directory, localVideo.filename));
-      const response = await log.infoSpin(
-        stream.createAndUploadVideo(videoFile, { title: localVideo.filename }),
-        `Uploading new video ${index + 1}/${remoteVideosToCreate.length}: ${localVideo.filename}`
-      );
-      log.info(
-        `Remote video ${index + 1}/${remoteVideosToCreate.length} created with GUID: ${response.guid}`
-      );
-      const stateEntry = state.data.syncState.find(
-        (entry) => entry.filename === localVideo.filename
-      );
-      if (stateEntry === void 0) {
-        throw new Error(`Failed to find state entry for: ${localVideo.filename}`);
-      }
-      stateEntry.remoteHash[service] = localVideo.localHash;
-      state.data.lastUpdate = /* @__PURE__ */ new Date();
-      await state.write();
-      const reportEntry = syncReport.find((entry) => entry.localFile === localVideo.filename);
-      if (reportEntry === void 0) {
-        throw new Error(`Failed to find report entry for: ${localVideo.filename}`);
-      }
-      reportEntry.remoteId = response.guid;
-    }
-    for (const [index, remoteVideo] of remoteVideosToUpdate.entries()) {
-      if (index === 0) {
-        log.info(`Updating ${remoteVideosToUpdate.length} remote videos...`);
-        log.warn(
-          "Bunny does not currently support updating videos in-place, so vidup will delete and re-uploading instead... this will change the video's GUID!"
-        );
-      }
-      const stateEntry = state.data.syncState.find((entry) => entry.filename === remoteVideo.title);
-      if (stateEntry === void 0) {
-        throw new Error(`Failed to find state entry for: ${remoteVideo.title}`);
-      }
-      const deleteResponse = await stream.deleteVideo(remoteVideo.guid);
-      if (!deleteResponse.success) {
-        throw new Error(`Failed to delete remote video before updating: ${remoteVideo.title}`);
-      }
-      const videoFile = createReadStream(path.join(directory, stateEntry.filename));
-      const createResponse = await log.infoSpin(
-        stream.createAndUploadVideo(videoFile, { title: stateEntry.filename }),
-        `Updating remote video ${index + 1}/${remoteVideosToUpdate.length}: ${remoteVideo.title}`
-      );
-      log.info(
-        `Updated remote video ${index + 1}/${remoteVideosToUpdate.length} created with GUID: ${createResponse.guid}`
-      );
-      stateEntry.remoteHash[service] = stateEntry.localHash;
-      state.data.lastUpdate = /* @__PURE__ */ new Date();
-      await state.write();
-      const reportEntry = syncReport.find((entry) => entry.localFile === stateEntry.filename);
-      if (reportEntry === void 0) {
-        throw new Error(`Failed to find report entry for: ${stateEntry.filename}`);
-      }
-      reportEntry.remoteId = createResponse.guid;
-    }
-    log.info(`All ${videoFiles.length} videos are now in sync!`);
-  }
-  log.verbose = initialVerbosity;
-  return syncReport;
-}
-
-export { syncVideoInDirectory as a, log as l, stripVideoMetadataInDirectory as s };