vidup 1.0.12 → 1.0.14

package/dist/bin/cli.js

@@ -1,5 +1,274 @@
 #!/usr/bin/env node
-var M=Object.defineProperty;var a=(e,t)=>M(e,"name",{value:t,configurable:!0});import I from"node:path";import O from"node:os";import S from"yargs";import{hideBin as $}from"yargs/helpers";import{l as h,s as x,a as E}from"../sync-DAKTIkq2.js";import"bunnycdn-stream";import"hasha";import"node:fs";import"node:fs/promises";import"node:url";import"ora";import"execa";import"ffmpeg-static";const v=a(e=>Number.isFinite(e)?e:0,"toZeroIfInfinity");function F(e){return{days:Math.trunc(e/864e5),hours:Math.trunc(e/36e5%24),minutes:Math.trunc(e/6e4%60),seconds:Math.trunc(e/1e3%60),milliseconds:Math.trunc(e%1e3),microseconds:Math.trunc(v(e*1e3)%1e3),nanoseconds:Math.trunc(v(e*1e6)%1e3)}}a(F,"parseNumber");function B(e){return{days:e/86400000n,hours:e/3600000n%24n,minutes:e/60000n%60n,seconds:e/1000n%60n,milliseconds:e%1000n,microseconds:0n,nanoseconds:0n}}a(B,"parseBigint");function k(e){switch(typeof e){case"number":{if(Number.isFinite(e))return F(e);break}case"bigint":return B(e)}throw new TypeError("Expected a finite number or bigint")}a(k,"parseMilliseconds");const C=a(e=>e===0||e===0n,"isZero"),T=a((e,t)=>t===1||t===1n?e:`${e}s`,"pluralize"),z=1e-7,A=24n*60n*60n*1000n;function P(e,t){const u=typeof e=="bigint";if(!u&&!Number.isFinite(e))throw new TypeError("Expected a finite number or bigint");t={...t};const f=e<0?"-":"";e=e<0?-e:e,t.colonNotation&&(t.compact=!1,t.formatSubMilliseconds=!1,t.separateMilliseconds=!1,t.verbose=!1),t.compact&&(t.unitCount=1,t.secondsDecimalDigits=0,t.millisecondsDecimalDigits=0);let d=[];const b=a((i,n)=>{const c=Math.floor(i*10**n+z);return(Math.round(c)/10**n).toFixed(n)},"floorDecimals"),r=a((i,n,c,o)=>{if(!((d.length===0||!t.colonNotation)&&C(i)&&!(t.colonNotation&&c==="m"))){if(o??=String(i),t.colonNotation){const m=o.includes(".")?o.split(".")[0].length:o.length,y=d.length>0?2:1;o="0".repeat(Math.max(0,y-m))+o}else o+=t.verbose?" "+T(n,i):c;d.push(o)}},"add"),s=k(e),l=BigInt(s.days);if(t.hideYearAndDays?r(BigInt(l)*24n+BigInt(s.hours),"hour","h"):(t.hideYear?r(l,"day","d"):(r(l/365n,"year","y"),r(l%365n,"day","d")),r(Number(s.hours),"hour","h")),r(Number(s.minutes),"minute","m"),!t.hideSeconds)if(t.separateMilliseconds||t.formatSubMilliseconds||!t.colonNotation&&e<1e3){const i=Number(s.seconds),n=Number(s.milliseconds),c=Number(s.microseconds),o=Number(s.nanoseconds);if(r(i,"second","s"),t.formatSubMilliseconds)r(n,"millisecond","ms"),r(c,"microsecond","\xB5s"),r(o,"nanosecond","ns");else{const m=n+c/1e3+o/1e6,y=typeof t.millisecondsDecimalDigits=="number"?t.millisecondsDecimalDigits:0,w=m>=1?Math.round(m):Math.ceil(m),g=y?m.toFixed(y):w;r(Number.parseFloat(g),"millisecond","ms",g)}}else{const i=(u?Number(e%A):e)/1e3%60,n=typeof t.secondsDecimalDigits=="number"?t.secondsDecimalDigits:1,c=b(i,n),o=t.keepDecimalsOnWholeSeconds?c:c.replace(/\.0+$/,"");r(Number.parseFloat(o),"second","s",o)}if(d.length===0)return f+"0"+(t.verbose?" milliseconds":"ms");const p=t.colonNotation?":":" ";return typeof t.unitCount=="number"&&(d=d.slice(0,Math.max(t.unitCount,1))),f+d.join(p)}a(P,"prettyMilliseconds");const D=O.homedir();function V(e){if(typeof e!="string")throw new TypeError(`Expected a string, got ${typeof e}`);return D?e.replace(/^~(?=$|\/|\\)/,D):e}a(V,"untildify");var _="1.0.12";const L=performance.now(),N=S($(process.argv));await N.scriptName("vidup").usage("$0 [command]","Run a vidup command.").command(["$0 <directory> [options]","sync <directory> [options]"],"Synchronize a remote video streaming service to mirror the contents of a local directory. Warning: This command will irrevocably delete remote videos that are not present in the local directory.",e=>e.positional("directory",{default:void 0,demandOption:!0,describe:"The path to the local directory of video files to sync.",type:"string"}).option("service",{alias:"s",choices:["bunny","mux","cloudflare"],demandOption:!0,describe:"Streaming service / platform to sync local video files to. Only the Bunny.net streaming CDN is supported at this time.",type:"string"}).option("key",{default:void 0,demandOption:!0,describe:"Streaming service API access key.",type:"string"}).option("library",{default:void 0,demandOption:!0,describe:"Streaming service library ID.",type:"string"}).option("strip-metadata",{default:!1,describe:"Remove all metadata from the video files before uploading them to the streaming service. Warning: This will modify local videos in-place.",type:"boolean"}).option("dry-run",{alias:"d",default:!1,describe:"Perform a dry run without making any changes. Useful for testing and debugging. Pairs well with the `--json` command.",type:"boolean"}).option("json",{default:!1,describe:"Output the sync report as JSON.",type:"boolean"}).option("verbose",{default:!1,describe:"Enable verbose logging. All verbose logs and prefixed with their log level and are printed to `stderr` for ease of redirection.",type:"boolean"}).check(t=>{if(t.service==="bunny")return t;throw new Error(`Sorry, vidup doesn't yet implement synchronization support the ${t.service} streaming service. Only Bunny.net is supported at the moment. If you'd like to see support for another service, please open an issue or send a PR on GitHub: https://github.com/kitschpatrol/vidup/issues`)}),async({directory:e,dryRun:t,json:u,key:f,library:d,service:b,stripMetadata:r,verbose:s})=>{h.verbose=s;const l=I.resolve(V(e));h.info("Starting video synchronization..."),t&&h.warn("Dry run enabled, not making any changes");const p=r?await x(l,{dryRun:t,verbose:s}):[],i=await E(l,{credentials:{key:f,library:d},dryRun:t,service:b,verbose:s});if(u){for(const n of i)n.stripMetadata=n.localFile!==void 0&&p.includes(n.localFile);process.stdout.write(JSON.stringify(i,void 0,2)),process.stdout.write(`
-`)}else{for(const n of p)process.stdout.write(`${t?"Found":"Stripped"} metadata: "${n}"
-`);for(const n of i)process.stdout.write(`${n.action}: "${n.localFile}"	 Remote GUID: "${n.remoteId}"
-`)}h.info(`Synchronized video in ${P(performance.now()-L)}`),process.exitCode=0}).demandCommand(1).alias("h","help").version(_).alias("v","version").help().wrap(process.stdout.isTTY?Math.min(120,N.terminalWidth()):0).parse();
+import path from 'node:path';
+import os from 'node:os';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { l as log, s as stripVideoMetadataInDirectory, a as syncVideoInDirectory } from '../sync-CCKOz_Uf.js';
+import 'bunnycdn-stream';
+import 'hasha';
+import 'node:fs';
+import 'node:fs/promises';
+import 'node:url';
+import 'ora';
+import 'execa';
+import 'ffmpeg-static';
+
+const toZeroIfInfinity = (value) => Number.isFinite(value) ? value : 0;
+function parseNumber(milliseconds) {
+  return {
+    days: Math.trunc(milliseconds / 864e5),
+    hours: Math.trunc(milliseconds / 36e5 % 24),
+    minutes: Math.trunc(milliseconds / 6e4 % 60),
+    seconds: Math.trunc(milliseconds / 1e3 % 60),
+    milliseconds: Math.trunc(milliseconds % 1e3),
+    microseconds: Math.trunc(toZeroIfInfinity(milliseconds * 1e3) % 1e3),
+    nanoseconds: Math.trunc(toZeroIfInfinity(milliseconds * 1e6) % 1e3)
+  };
+}
+function parseBigint(milliseconds) {
+  return {
+    days: milliseconds / 86400000n,
+    hours: milliseconds / 3600000n % 24n,
+    minutes: milliseconds / 60000n % 60n,
+    seconds: milliseconds / 1000n % 60n,
+    milliseconds: milliseconds % 1000n,
+    microseconds: 0n,
+    nanoseconds: 0n
+  };
+}
+function parseMilliseconds(milliseconds) {
+  switch (typeof milliseconds) {
+    case "number": {
+      if (Number.isFinite(milliseconds)) {
+        return parseNumber(milliseconds);
+      }
+      break;
+    }
+    case "bigint": {
+      return parseBigint(milliseconds);
+    }
+  }
+  throw new TypeError("Expected a finite number or bigint");
+}
+
+const isZero = (value) => value === 0 || value === 0n;
+const pluralize = (word, count) => count === 1 || count === 1n ? word : `${word}s`;
+const SECOND_ROUNDING_EPSILON = 1e-7;
+const ONE_DAY_IN_MILLISECONDS = 24n * 60n * 60n * 1000n;
+function prettyMilliseconds(milliseconds, options) {
+  const isBigInt = typeof milliseconds === "bigint";
+  if (!isBigInt && !Number.isFinite(milliseconds)) {
+    throw new TypeError("Expected a finite number or bigint");
+  }
+  options = { ...options };
+  const sign = milliseconds < 0 ? "-" : "";
+  milliseconds = milliseconds < 0 ? -milliseconds : milliseconds;
+  if (options.colonNotation) {
+    options.compact = false;
+    options.formatSubMilliseconds = false;
+    options.separateMilliseconds = false;
+    options.verbose = false;
+  }
+  if (options.compact) {
+    options.unitCount = 1;
+    options.secondsDecimalDigits = 0;
+    options.millisecondsDecimalDigits = 0;
+  }
+  let result = [];
+  const floorDecimals = (value, decimalDigits) => {
+    const flooredInterimValue = Math.floor(value * 10 ** decimalDigits + SECOND_ROUNDING_EPSILON);
+    const flooredValue = Math.round(flooredInterimValue) / 10 ** decimalDigits;
+    return flooredValue.toFixed(decimalDigits);
+  };
+  const add = (value, long, short, valueString) => {
+    if ((result.length === 0 || !options.colonNotation) && isZero(value) && !(options.colonNotation && short === "m")) {
+      return;
+    }
+    valueString ??= String(value);
+    if (options.colonNotation) {
+      const wholeDigits = valueString.includes(".") ? valueString.split(".")[0].length : valueString.length;
+      const minLength = result.length > 0 ? 2 : 1;
+      valueString = "0".repeat(Math.max(0, minLength - wholeDigits)) + valueString;
+    } else {
+      valueString += options.verbose ? " " + pluralize(long, value) : short;
+    }
+    result.push(valueString);
+  };
+  const parsed = parseMilliseconds(milliseconds);
+  const days = BigInt(parsed.days);
+  if (options.hideYearAndDays) {
+    add(BigInt(days) * 24n + BigInt(parsed.hours), "hour", "h");
+  } else {
+    if (options.hideYear) {
+      add(days, "day", "d");
+    } else {
+      add(days / 365n, "year", "y");
+      add(days % 365n, "day", "d");
+    }
+    add(Number(parsed.hours), "hour", "h");
+  }
+  add(Number(parsed.minutes), "minute", "m");
+  if (!options.hideSeconds) {
+    if (options.separateMilliseconds || options.formatSubMilliseconds || !options.colonNotation && milliseconds < 1e3 && !options.subSecondsAsDecimals) {
+      const seconds = Number(parsed.seconds);
+      const milliseconds2 = Number(parsed.milliseconds);
+      const microseconds = Number(parsed.microseconds);
+      const nanoseconds = Number(parsed.nanoseconds);
+      add(seconds, "second", "s");
+      if (options.formatSubMilliseconds) {
+        add(milliseconds2, "millisecond", "ms");
+        add(microseconds, "microsecond", "\xB5s");
+        add(nanoseconds, "nanosecond", "ns");
+      } else {
+        const millisecondsAndBelow = milliseconds2 + microseconds / 1e3 + nanoseconds / 1e6;
+        const millisecondsDecimalDigits = typeof options.millisecondsDecimalDigits === "number" ? options.millisecondsDecimalDigits : 0;
+        const roundedMilliseconds = millisecondsAndBelow >= 1 ? Math.round(millisecondsAndBelow) : Math.ceil(millisecondsAndBelow);
+        const millisecondsString = millisecondsDecimalDigits ? millisecondsAndBelow.toFixed(millisecondsDecimalDigits) : roundedMilliseconds;
+        add(
+          Number.parseFloat(millisecondsString),
+          "millisecond",
+          "ms",
+          millisecondsString
+        );
+      }
+    } else {
+      const seconds = (isBigInt ? Number(milliseconds % ONE_DAY_IN_MILLISECONDS) : milliseconds) / 1e3 % 60;
+      const secondsDecimalDigits = typeof options.secondsDecimalDigits === "number" ? options.secondsDecimalDigits : 1;
+      const secondsFixed = floorDecimals(seconds, secondsDecimalDigits);
+      const secondsString = options.keepDecimalsOnWholeSeconds ? secondsFixed : secondsFixed.replace(/\.0+$/, "");
+      add(Number.parseFloat(secondsString), "second", "s", secondsString);
+    }
+  }
+  if (result.length === 0) {
+    return sign + "0" + (options.verbose ? " milliseconds" : "ms");
+  }
+  const separator = options.colonNotation ? ":" : " ";
+  if (typeof options.unitCount === "number") {
+    result = result.slice(0, Math.max(options.unitCount, 1));
+  }
+  return sign + result.join(separator);
+}
+
+let homeDirectory;
+let currentUser;
+function untildify(pathWithTilde) {
+  if (typeof pathWithTilde !== "string") {
+    throw new TypeError(`Expected a string, got ${typeof pathWithTilde}`);
+  }
+  if (homeDirectory === void 0) {
+    homeDirectory = os.homedir();
+  }
+  if (homeDirectory && /^~(?=$|\/|\\)/.test(pathWithTilde)) {
+    return pathWithTilde.replace(/^~/, homeDirectory);
+  }
+  const userMatch = pathWithTilde.match(/^~([^/\\]+)(.*)/);
+  if (userMatch) {
+    if (currentUser === void 0) {
+      currentUser = os.userInfo().username;
+    }
+    if (currentUser) {
+      const username = userMatch[1];
+      const rest = userMatch[2];
+      if (username === currentUser) {
+        return homeDirectory + rest;
+      }
+    }
+  }
+  return pathWithTilde;
+}
+
+var version = "1.0.14";
+
+const startTime = performance.now();
+const yargsInstance = yargs(hideBin(process.argv));
+await yargsInstance.scriptName("vidup").usage("$0 [command]", "Run a vidup command.").command(
+  ["$0 <directory> [options]", "sync <directory> [options]"],
+  "Synchronize a remote video streaming service to mirror the contents of a local directory. Warning: This command will irrevocably delete remote videos that are not present in the local directory.",
+  (yargs2) => yargs2.positional("directory", {
+    default: void 0,
+    demandOption: true,
+    describe: "The path to the local directory of video files to sync.",
+    type: "string"
+  }).option("service", {
+    alias: "s",
+    choices: ["bunny", "mux", "cloudflare"],
+    demandOption: true,
+    describe: "Streaming service / platform to sync local video files to. Only the Bunny.net streaming CDN is supported at this time.",
+    type: "string"
+  }).option("key", {
+    default: void 0,
+    demandOption: true,
+    describe: "Streaming service API access key.",
+    type: "string"
+  }).option("library", {
+    default: void 0,
+    demandOption: true,
+    describe: "Streaming service library ID.",
+    type: "string"
+  }).option("strip-metadata", {
+    default: false,
+    describe: "Remove all metadata from the video files before uploading them to the streaming service. Warning: This will modify local videos in-place.",
+    type: "boolean"
+  }).option("dry-run", {
+    alias: "d",
+    default: false,
+    describe: "Perform a dry run without making any changes. Useful for testing and debugging. Pairs well with the `--json` command.",
+    type: "boolean"
+  }).option("json", {
+    default: false,
+    describe: "Output the sync report as JSON.",
+    type: "boolean"
+  }).option("verbose", {
+    default: false,
+    describe: "Enable verbose logging. All verbose logs and prefixed with their log level and are printed to `stderr` for ease of redirection.",
+    type: "boolean"
+  }).check((argv) => {
+    if (argv.service === "bunny") {
+      return argv;
+    }
+    throw new Error(
+      `Sorry, vidup doesn't yet implement synchronization support the ${argv.service} streaming service. Only Bunny.net is supported at the moment. If you'd like to see support for another service, please open an issue or send a PR on GitHub: https://github.com/kitschpatrol/vidup/issues`
+    );
+  }),
+  async ({ directory, dryRun, json, key, library, service, stripMetadata, verbose }) => {
+    log.verbose = verbose;
+    const resolvedDirectory = path.resolve(untildify(directory));
+    log.info("Starting video synchronization...");
+    if (dryRun) {
+      log.warn(`Dry run enabled, not making any changes`);
+    }
+    const stripReport = stripMetadata ? await stripVideoMetadataInDirectory(resolvedDirectory, {
+      dryRun,
+      verbose
+    }) : [];
+    const syncReport = await syncVideoInDirectory(resolvedDirectory, {
+      credentials: {
+        key,
+        library
+      },
+      dryRun,
+      service,
+      verbose
+    });
+    if (json) {
+      for (const entry of syncReport) {
+        entry.stripMetadata = entry.localFile !== void 0 && stripReport.includes(entry.localFile);
+      }
+      process.stdout.write(JSON.stringify(syncReport, void 0, 2));
+      process.stdout.write("\n");
+    } else {
+      for (const entry of stripReport) {
+        process.stdout.write(`${dryRun ? "Found" : "Stripped"} metadata: "${entry}"
+`);
+      }
+      for (const entry of syncReport) {
+        process.stdout.write(
+          `${entry.action}: "${entry.localFile}"	 Remote GUID: "${entry.remoteId}"
+`
+        );
+      }
+    }
+    log.info(`Synchronized video in ${prettyMilliseconds(performance.now() - startTime)}`);
+    process.exitCode = 0;
+  }
+).demandCommand(1).alias("h", "help").version(version).alias("v", "version").help().wrap(process.stdout.isTTY ? Math.min(120, yargsInstance.terminalWidth()) : 0).parse();

package/dist/lib/index.d.ts

@@ -43,4 +43,5 @@ declare const log: {
     errorPrefixed(prefix: string, ...data: unknown[]): void;
 };
 
-export { type Service, type StripOptions, type SyncOptions, type SyncReport, log, stripVideoMetadataInDirectory, syncVideoInDirectory };
+export { log, stripVideoMetadataInDirectory, syncVideoInDirectory };
+export type { Service, StripOptions, SyncOptions, SyncReport };

package/dist/lib/index.js

@@ -1 +1,10 @@
-import{l as n,s as y,a as l}from"../sync-DAKTIkq2.js";import"bunnycdn-stream";import"hasha";import"node:fs";import"node:fs/promises";import"node:path";import"node:url";import"ora";import"execa";import"ffmpeg-static";export{n as log,y as stripVideoMetadataInDirectory,l as syncVideoInDirectory};
+export { l as log, s as stripVideoMetadataInDirectory, a as syncVideoInDirectory } from '../sync-CCKOz_Uf.js';
+import 'bunnycdn-stream';
+import 'hasha';
+import 'node:fs';
+import 'node:fs/promises';
+import 'node:path';
+import 'node:url';
+import 'ora';
+import 'execa';
+import 'ffmpeg-static';

package/dist/sync-CCKOz_Uf.js

@@ -0,0 +1,543 @@
+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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vidup",
-  "version": "1.0.12",
+  "version": "1.0.14",
   "description": "Synchronize a local directory of video files to remote streaming services.",
   "keywords": [
     "bunnycdn-stream",
@@ -26,8 +26,8 @@
   "type": "module",
   "exports": {
     ".": {
-      "import": "./dist/lib/index.js",
-      "types": "./dist/lib/index.d.ts"
+      "types": "./dist/lib/index.d.ts",
+      "import": "./dist/lib/index.js"
     }
   },
   "main": "./dist/lib/index.js",
@@ -40,36 +40,37 @@
     "dist/*"
   ],
   "dependencies": {
-    "@types/yargs": "^17.0.33",
-    "bunnycdn-stream": "^2.4.1",
-    "execa": "^9.5.2",
+    "@types/yargs": "^17.0.34",
+    "bunnycdn-stream": "^2.5.5",
+    "execa": "^9.6.0",
     "ffmpeg-static": "^5.2.0",
-    "hasha": "^6.0.0",
-    "ora": "^8.2.0",
+    "hasha": "^7.0.0",
+    "ora": "^9.0.0",
     "yargs": "^17.7.2"
   },
   "devDependencies": {
-    "@kitschpatrol/shared-config": "^5.2.0",
-    "@types/node": "^20.17.23",
-    "bumpp": "^10.0.3",
-    "chalk": "^5.4.1",
+    "@kitschpatrol/shared-config": "^5.8.1",
+    "@types/node": "^20.19.24",
+    "bumpp": "^10.3.1",
     "lowdb": "^7.0.1",
-    "pkgroll": "^2.11.2",
-    "pretty-ms": "^9.2.0",
-    "typescript": "^5.8.2",
-    "untildify": "^5.0.0"
+    "mdat-plugin-cli-help": "^1.0.1",
+    "picocolors": "^1.1.1",
+    "pkgroll": "^2.20.1",
+    "pretty-ms": "^9.3.0",
+    "typescript": "^5.9.3",
+    "untildify": "^6.0.0"
   },
   "engines": {
-    "node": ">=20.9.0"
+    "node": ">=20.19.0"
   },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "pkgroll --clean-dist --minify --tsconfig tsconfig.build.json",
+    "build": "pkgroll --clean-dist --tsconfig tsconfig.build.json",
     "clean": "git rm -f pnpm-lock.yaml ; git clean -fdX",
-    "fix": "kpi fix",
-    "lint": "kpi lint",
-    "release": "bumpp --commit 'Release: %s' && pnpm run build && pnpm publish --otp $(op read 'op://Personal/Npmjs/one-time password?attribute=otp')"
+    "fix": "ksc fix",
+    "lint": "ksc lint",
+    "release": "bumpp --commit 'Release: %s' && pnpm run build && NPM_AUTH_TOKEN=$(op read 'op://Personal/npm/token') && pnpm publish"
   }
 }

package/dist/sync-DAKTIkq2.js

@@ -1,7 +0,0 @@
-var Z=Object.defineProperty;var n=(t,e)=>Z(t,"name",{value:e,configurable:!0});import{BunnyCdnStream as ee}from"bunnycdn-stream";import{hash as te}from"hasha";import{createReadStream as U}from"node:fs";import k,{writeFile as oe,rename as re,readFile as ie}from"node:fs/promises";import w,{join as ne,dirname as se,basename as ae}from"node:path";import{fileURLToPath as le}from"node:url";import{oraPromise as ce}from"ora";import{execa as H}from"execa";import j from"ffmpeg-static";const M=10,G=n((t=0)=>e=>`\x1B[${e+t}m`,"wrapAnsi16"),L=n((t=0)=>e=>`\x1B[${38+t};5;${e}m`,"wrapAnsi256"),W=n((t=0)=>(e,o,r)=>`\x1B[${38+t};2;${e};${o};${r}m`,"wrapAnsi16m"),c={modifier:{reset:[0,0],bold:[1,22],dim:[2,22],italic:[3,23],underline:[4,24],overline:[53,55],inverse:[7,27],hidden:[8,28],strikethrough:[9,29]},color:{black:[30,39],red:[31,39],green:[32,39],yellow:[33,39],blue:[34,39],magenta:[35,39],cyan:[36,39],white:[37,39],blackBright:[90,39],gray:[90,39],grey:[90,39],redBright:[91,39],greenBright:[92,39],yellowBright:[93,39],blueBright:[94,39],magentaBright:[95,39],cyanBright:[96,39],whiteBright:[97,39]},bgColor:{bgBlack:[40,49],bgRed:[41,49],bgGreen:[42,49],bgYellow:[43,49],bgBlue:[44,49],bgMagenta:[45,49],bgCyan:[46,49],bgWhite:[47,49],bgBlackBright:[100,49],bgGray:[100,49],bgGrey:[100,49],bgRedBright:[101,49],bgGreenBright:[102,49],bgYellowBright:[103,49],bgBlueBright:[104,49],bgMagentaBright:[105,49],bgCyanBright:[106,49],bgWhiteBright:[107,49]}};Object.keys(c.modifier);const de=Object.keys(c.color),fe=Object.keys(c.bgColor);[...de,...fe];function ue(){const t=new Map;for(const[e,o]of Object.entries(c)){for(const[r,i]of Object.entries(o))c[r]={open:`\x1B[${i[0]}m`,close:`\x1B[${i[1]}m`},o[r]=c[r],t.set(i[0],i[1]);Object.defineProperty(c,e,{value:o,enumerable:!1})}return Object.defineProperty(c,"codes",{value:t,enumerable:!1}),c.color.close="\x1B[39m",c.bgColor.close="\x1B[49m",c.color.ansi=G(),c.color.ansi256=L(),c.color.ansi16m=W(),c.bgColor.ansi=G(M),c.bgColor.ansi256=L(M),c.bgColor.ansi16m=W(M),Object.defineProperties(c,{rgbToAnsi256:{value(e,o,r){return e===o&&o===r?e<8?16:e>248?231:Math.round((e-8)/247*24)+232:16+36*Math.round(e/255*5)+6*Math.round(o/255*5)+Math.round(r/255*5)},enumerable:!1},hexToRgb:{value(e){const o=/[a-f\d]{6}|[a-f\d]{3}/i.exec(e.toString(16));if(!o)return[0,0,0];let[r]=o;r.length===3&&(r=[...r].map(l=>l+l).join(""));const i=Number.parseInt(r,16);return[i>>16&255,i>>8&255,i&255]},enumerable:!1},hexToAnsi256:{value:n(e=>c.rgbToAnsi256(...c.hexToRgb(e)),"value"),enumerable:!1},ansi256ToAnsi:{value(e){if(e<8)return 30+e;if(e<16)return 90+(e-8);let o,r,i;if(e>=232)o=((e-232)*10+8)/255,r=o,i=o;else{e-=16;const m=e%36;o=Math.floor(e/36)/5,r=Math.floor(m/6)/5,i=m%6/5}const l=Math.max(o,r,i)*2;if(l===0)return 30;let u=30+(Math.round(i)<<2|Math.round(r)<<1|Math.round(o));return l===2&&(u+=60),u},enumerable:!1},rgbToAnsi:{value:n((e,o,r)=>c.ansi256ToAnsi(c.rgbToAnsi256(e,o,r)),"value"),enumerable:!1},hexToAnsi:{value:n(e=>c.ansi256ToAnsi(c.hexToAnsi256(e)),"value"),enumerable:!1}}),c}n(ue,"assembleStyles");const g=ue(),Y=(()=>{if(!("navigator"in globalThis))return 0;if(globalThis.navigator.userAgentData){const t=navigator.userAgentData.brands.find(({brand:e})=>e==="Chromium");if(t&&t.version>93)return 3}return/\b(Chrome|Chromium)\//.test(globalThis.navigator.userAgent)?1:0})(),J=Y!==0&&{level:Y},he={stdout:J,stderr:J};function me(t,e,o){let r=t.indexOf(e);if(r===-1)return t;const i=e.length;let l=0,u="";do u+=t.slice(l,r)+e+o,l=r+i,r=t.indexOf(e,l);while(r!==-1);return u+=t.slice(l),u}n(me,"stringReplaceAll");function ge(t,e,o,r){let i=0,l="";do{const u=t[r-1]==="\r";l+=t.slice(i,u?r-1:r)+e+(u?`\r
-`:`
-`)+o,i=r+1,r=t.indexOf(`
-`,i)}while(r!==-1);return l+=t.slice(i),l}n(ge,"stringEncaseCRLFWithFirstIndex");const{stdout:K,stderr:_}=he,V=Symbol("GENERATOR"),$=Symbol("STYLER"),T=Symbol("IS_EMPTY"),z=["ansi","ansi","ansi256","ansi16m"],x=Object.create(null),pe=n((t,e={})=>{if(e.level&&!(Number.isInteger(e.level)&&e.level>=0&&e.level<=3))throw new Error("The `level` option should be an integer from 0 to 3");const o=K?K.level:0;t.level=e.level===void 0?o:e.level},"applyOptions"),we=n(t=>{const e=n((...o)=>o.join(" "),"chalk2");return pe(e,t),Object.setPrototypeOf(e,B.prototype),e},"chalkFactory");function B(t){return we(t)}n(B,"createChalk"),Object.setPrototypeOf(B.prototype,Function.prototype);for(const[t,e]of Object.entries(g))x[t]={get(){const o=C(this,D(e.open,e.close,this[$]),this[T]);return Object.defineProperty(this,t,{value:o}),o}};x.visible={get(){const t=C(this,this[$],!0);return Object.defineProperty(this,"visible",{value:t}),t}};const N=n((t,e,o,...r)=>t==="rgb"?e==="ansi16m"?g[o].ansi16m(...r):e==="ansi256"?g[o].ansi256(g.rgbToAnsi256(...r)):g[o].ansi(g.rgbToAnsi(...r)):t==="hex"?N("rgb",e,o,...g.hexToRgb(...r)):g[o][t](...r),"getModelAnsi"),be=["rgb","hex","ansi256"];for(const t of be){x[t]={get(){const{level:o}=this;return function(...r){const i=D(N(t,z[o],"color",...r),g.color.close,this[$]);return C(this,i,this[T])}}};const e="bg"+t[0].toUpperCase()+t.slice(1);x[e]={get(){const{level:o}=this;return function(...r){const i=D(N(t,z[o],"bgColor",...r),g.bgColor.close,this[$]);return C(this,i,this[T])}}}}const ye=Object.defineProperties(()=>{},{...x,level:{enumerable:!0,get(){return this[V].level},set(t){this[V].level=t}}}),D=n((t,e,o)=>{let r,i;return o===void 0?(r=t,i=e):(r=o.openAll+t,i=e+o.closeAll),{open:t,close:e,openAll:r,closeAll:i,parent:o}},"createStyler"),C=n((t,e,o)=>{const r=n((...i)=>ve(r,i.length===1?""+i[0]:i.join(" ")),"builder");return Object.setPrototypeOf(r,ye),r[V]=t,r[$]=e,r[T]=o,r},"createBuilder"),ve=n((t,e)=>{if(t.level<=0||!e)return t[T]?"":e;let o=t[$];if(o===void 0)return e;const{openAll:r,closeAll:i}=o;if(e.includes("\x1B"))for(;o!==void 0;)e=me(e,o.close,o.open),o=o.parent;const l=e.indexOf(`
-`);return l!==-1&&(e=ge(e,i,r,l)),r+e+i},"applyStyle");Object.defineProperties(B.prototype,x);const p=B();B({level:_?_.level:0});const q=process.versions.node!==void 0,d={verbose:!1,log(...t){if(!this.verbose)return;const e=p.gray("[Log]");q?console.warn(e,...t):console.log(e,...t)},logPrefixed(t,...e){this.info(p.blue(`[${t}]`),...e)},info(...t){if(!this.verbose)return;const e=p.green("[Info]");q?console.warn(e,...t):console.info(e,...t)},infoPrefixed(t,...e){this.info(p.blue(`[${t}]`),...e)},async infoSpin(t,e){return ce(t,{prefixText:p.green("[Info]"),stream:process.stderr,text:e})},warn(...t){console.warn(p.yellow("[Warning]"),...t)},warnPrefixed(t,...e){this.warn(p.blue(`[${t}]`),...e)},error(...t){console.error(p.red("[Error]"),...t)},errorPrefixed(t,...e){this.error(p.blue(`[${t}]`),...e)}};async function Q(t){return(await k.readdir(t)).filter(r=>{const i=w.extname(r);return[".mp4",".mov",".avi",".mkv"].includes(i)}).map(r=>w.join(t,r))}n(Q,"getVideosInDirectory");async function $e(t){if(j===null)throw new Error("ffmpeg-static failed to locate ffmpeg binary");try{const{stderr:e,stdout:o}=await H(j,["-i",t,"-f","ffmetadata","-"]);return o.includes("creation_time")||e.includes("creation_time")}catch(e){throw new Error(`Failed to check metadata for: ${t}:
-${String(e)}`)}}n($e,"videoHasMetadata");async function xe(t){if(j===null)throw new Error("ffmpeg-static failed to locate ffmpeg binary");try{const e=w.extname(t).slice(1),o=`${t.slice(0,Math.max(0,t.lastIndexOf(".")))}.temp.${e}`;await H(j,["-i",t,"-map_metadata","-1","-c:v","copy","-c:a","copy",o]),await k.rename(o,t)}catch(e){throw new Error(`Failed to strip metadata from: ${t}:
-${String(e)}`)}}n(xe,"stripVideoMetadata");async function Se(t,e={}){const{dryRun:o=!1,verbose:r=!1}=e,i=await Q(t);return Fe(i,{dryRun:o,verbose:r})}n(Se,"stripVideoMetadataInDirectory");async function Fe(t,e={}){const{dryRun:o=!1,verbose:r=!1}=e,i=d.verbose;d.verbose=r;const l=[];for(const u of t)await $e(u)&&l.push(u);if(!o){d.info(`Found ${l.length} videos with metadata to strip`);for(const u of l)console.log(`Stripping metadata from: ${u}`),await xe(u)}return d.verbose=i,l}n(Fe,"stripVideoMetadataInFiles");function Ee(t){const e=t instanceof URL?le(t):t.toString();return ne(se(e),`.${ae(e)}.tmp`)}n(Ee,"getTempFilename");async function Oe(t,e,o){for(let r=0;r<e;r++)try{return await t()}catch(i){if(r<e-1)await new Promise(l=>setTimeout(l,o));else throw i}}n(Oe,"retryAsyncOperation");class Ae{static{n(this,"Writer")}#e;#t;#o=!1;#i=null;#n=null;#s=null;#r=null;#a(e){return this.#r=e,this.#s||=new Promise((o,r)=>{this.#n=[o,r]}),new Promise((o,r)=>{this.#s?.then(o).catch(r)})}async#l(e){this.#o=!0;try{await oe(this.#t,e,"utf-8"),await Oe(async()=>{await re(this.#t,this.#e)},10,100),this.#i?.[0]()}catch(o){throw o instanceof Error&&this.#i?.[1](o),o}finally{if(this.#o=!1,this.#i=this.#n,this.#n=this.#s=null,this.#r!==null){const o=this.#r;this.#r=null,await this.write(o)}}}constructor(e){this.#e=e,this.#t=Ee(e)}async write(e){return this.#o?this.#a(e):this.#l(e)}}class Te{static{n(this,"TextFile")}#e;#t;constructor(e){this.#e=e,this.#t=new Ae(e)}async read(){let e;try{e=await ie(this.#e,"utf-8")}catch(o){if(o.code==="ENOENT")return null;throw o}return e}write(e){return this.#t.write(e)}}class Be{static{n(this,"DataFile")}#e;#t;#o;constructor(e,{parse:o,stringify:r}){this.#e=new Te(e),this.#t=o,this.#o=r}async read(){const e=await this.#e.read();return e===null?null:this.#t(e)}write(e){return this.#e.write(this.#o(e))}}class Pe extends Be{static{n(this,"JSONFile")}constructor(e){super(e,{parse:JSON.parse,stringify:n(o=>JSON.stringify(o,null,2),"stringify")})}}class Re{static{n(this,"Memory")}#e=null;read(){return Promise.resolve(this.#e)}write(e){return this.#e=e,Promise.resolve()}}function je(t,e){if(t===void 0)throw new Error("lowdb: missing adapter");if(e===void 0)throw new Error("lowdb: missing default data")}n(je,"checkArgs");class Ce{static{n(this,"Low")}adapter;data;constructor(e,o){je(e,o),this.adapter=e,this.data=o}async read(){const e=await this.adapter.read();e&&(this.data=e)}async write(){this.data&&await this.adapter.write(this.data)}async update(e){e(this.data),await this.write()}}async function Ie(t,e){const o=process.env.NODE_ENV==="test"?new Re:new Pe(t),r=new Ce(o,e);return await r.read(),r}n(Ie,"JSONFilePreset");async function Me(t,e){const{credentials:o,dryRun:r=!1,service:i,verbose:l=!1}=e,u=d.verbose;d.verbose=l;const m=[],P=await Q(t);d.info(`Found ${P.length} video files in directory "${t}"`);const f=await Ie(w.join(t,".vidup-state.json"),{syncState:[]});f.data.syncState=f.data.syncState.filter(s=>P.includes(w.join(t,s.filename)));for(const s of P){const a=w.basename(s),h=await te(s,{algorithm:"sha1"}),b=f.data.syncState.find(y=>y.filename===a);b?b.localHash=h:f.data.syncState.push({filename:a,localHash:h,remoteHash:{}})}if(r||await f.write(),i!=="bunny")throw new Error(`Streaming service not yet implemented: ${i}`);const S=new ee({apiKey:o.key,videoLibrary:o.library}),F=await S.listAllVideos();d.info(`Found ${F.length} video files on ${i} remote streaming service`);const X=F.filter(s=>{const a=f.data.syncState.find(h=>h.filename===s.title);return a!==void 0&&a.localHash===a.remoteHash[i]});for(const s of X)m.push({action:"None",localFile:s.title,remoteId:s.guid});const E=f.data.syncState.filter(s=>!F.some(a=>a.title===s.filename));for(const s of E)m.push({action:"Create",localFile:s.filename,remoteId:"Not yet uploaded (Dry run)"});const O=F.filter(s=>{const a=f.data.syncState.find(h=>h.filename===s.title);return a!==void 0&&a.localHash!==a.remoteHash[i]});for(const s of O)m.push({action:"Update",localFile:s.title,remoteId:"Not yet uploaded (Dry run)"});const R=F.filter(s=>!f.data.syncState.some(a=>a.filename===s.title));for(const s of R)m.push({action:"Delete",localFile:s.title,remoteId:s.guid});if(!r){f.data.lastRun=new Date,await f.write(),d.info("Synchronizing...");for(const[s,a]of R.entries()){if(s===0&&d.info(`Deleting ${R.length} remote videos...`),!(await d.infoSpin(S.deleteVideo(a.guid),`Deleting remote video ${s+1}/${R.length}: ${a.title}`)).success)throw new Error(`Failed to delete remote video: ${a.title}`);f.data.lastUpdate=new Date,await f.write()}for(const[s,a]of E.entries()){s===0&&d.info(`Uploading ${E.length} new local videos...`);const h=U(w.join(t,a.filename)),b=await d.infoSpin(S.createAndUploadVideo(h,{title:a.filename}),`Uploading new video ${s+1}/${E.length}: ${a.filename}`);d.info(`Remote video ${s+1}/${E.length} created with GUID: ${b.guid}`);const y=f.data.syncState.find(v=>v.filename===a.filename);if(y===void 0)throw new Error(`Failed to find state entry for: ${a.filename}`);y.remoteHash[i]=a.localHash,f.data.lastUpdate=new Date,await f.write();const A=m.find(v=>v.localFile===a.filename);if(A===void 0)throw new Error(`Failed to find report entry for: ${a.filename}`);A.remoteId=b.guid}for(const[s,a]of O.entries()){s===0&&(d.info(`Updating ${O.length} remote videos...`),d.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 h=f.data.syncState.find(I=>I.filename===a.title);if(h===void 0)throw new Error(`Failed to find state entry for: ${a.title}`);if(!(await S.deleteVideo(a.guid)).success)throw new Error(`Failed to delete remote video before updating: ${a.title}`);const y=U(w.join(t,h.filename)),A=await d.infoSpin(S.createAndUploadVideo(y,{title:h.filename}),`Updating remote video ${s+1}/${O.length}: ${a.title}`);d.info(`Updated remote video ${s+1}/${O.length} created with GUID: ${A.guid}`),h.remoteHash[i]=h.localHash,f.data.lastUpdate=new Date,await f.write();const v=m.find(I=>I.localFile===h.filename);if(v===void 0)throw new Error(`Failed to find report entry for: ${h.filename}`);v.remoteId=A.guid}d.info(`All ${P.length} videos are now in sync!`)}return d.verbose=u,m}n(Me,"syncVideoInDirectory");export{Me as a,d as l,Se as s};