pwebm 0.0.1 → 0.1.0-alpha.0

package/README.md

@@ -27,7 +27,7 @@ bun i -g git+https://github.com/4ndrs/pwebm.git
 
 ## Historical Background & Purpose
 
-In 2022, I wrote a script for the mpv media player called [PureMPV](https://github.com/4ndrs/PureMPV) that would help extracting the currently watched video's information, like the timestamps at certain points, and the the cropping coordinates, which would then later be used for encoding videos with ffmpeg with specific parameters.
+In 2022, I wrote a script for the mpv media player called [PureMPV](https://github.com/4ndrs/PureMPV) that would help extracting the currently watched video's information, like the timestamps at certain points, and the cropping coordinates, which would then later be used for encoding videos with ffmpeg with specific parameters.
 
 Up to that point, I mostly spent the time encoding short webm files to keep and share on some imageboards, as well as encoding some mkv files with streams and attachments copied, so I wanted to integrate this functionality in some way with PureMPV. I didn't like the idea of having PureMPV to do the encoding itself, I wanted a seperate process to handle this independently, so I could stop or start another mpv window without affecting the encoding process. I wrote down some of the initial requirements at the time, which were the following:
 

package/TODO.md

@@ -1,30 +1,16 @@
-## Stuff
-
-- [x] argument parser
-- [x] expand tilde and $HOME in config video path
-- [x] check for ffmpeg and ffprobe in path
-- [x] convert webm, retry when limit reached
-- [x] convert any other encoder to mkv copied streams just like purewebm
-- [x] socket file for communication
-- [x] handle queue
-- [x] kill implementation
-- [x] ffmpeg progress
-- [x] status implementation
-- [x] handle signals
-- [x] name the process
-- [x] version implementation
-- [x] help implementation
-- [x] args.ts help is missing dynamic default for crf
-- [x] if input is missing after some other arg, the default parse error is shown
-- [x] warn color is messed up for the message shown when the file limit is reached because of default warn color
-- [x] implement better cleaning process before exit
-- [x] release tagged versions in npm
-- [x] it's not part of this repo, but don't forget to improve the helper script for PureMPV (pwebm-helper), it has a missing readme
-- [x] update readme
-- [x] add subs flag warning to the readme (how it works, output seeking needed, etc)
+## 0.1.0
+- [x] (pwebm-helper) add a keybinding to show the status of the encoding on the mpv window
+- [x] no log file flag
+- [ ] add no log file flag to the docs
+- [ ] when erroring out encoding an item, just log the error and move on to the next item (save the exit code)
+- [ ] update the status on the terminal right away when adding a new item to the queue
+- [ ] rename tries prop in status to try
+- [ ] document status in the readme
+- [ ] pass file to select in the -subs option
+- [ ] pass false to -subs to disable subtitles (if enabled in the config)
 
 ### Might be nice to have
 - [ ] add limit for the amount of tries to redo a conversion
 - [ ] percentage bitrate offset when retrying a conversion with new calcs
 - [ ] handle no duration case, maybe adding an additional crf mode instead of bitrate calcs
-- [ ] (helper script) add a keybinding to show the status of the encoding on the mpv window
+- [ ] multiple encodings at the same time

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pwebm",
-  "version": "0.0.1",
+  "version": "0.1.0-alpha.0",
   "author": "4ndrs <andres.degozaru@gmail.com>",
   "repository": {
     "type": "git",

package/src/args.ts

@@ -8,9 +8,8 @@ import {
   COPYRIGHT_YEAR,
 } from "./constants";
 
-import { ipc } from "./ipc";
 import { config } from "./config";
-import { logger } from "./logger";
+import { ipcClient } from "./ipc/client";
 import { ArgsSchema } from "./schema/args";
 
 const RECOGNIZED_ARGS = [
@@ -34,412 +33,411 @@ const RECOGNIZED_ARGS = [
   "-ep",
   "--extra-params",
   "--video-path",
+  "--no-log-file",
 ];
 
-export const parseArgs = async (args: string[]): Promise<ArgsSchema> => {
-  const rawArgs: Partial<ArgsSchema> = {};
+const printUsage = () => {
+  const usage = `Usage: ${CLI_NAME} [options] [[infile options] -i infile]... [outfile options] [outfile] [extra params]
 
-  let skip = false;
-  let isExtraParam = false;
-  let seeking: { startTime?: string; stopTime?: string } | undefined;
+${DESCRIPTION}
 
-  const skipNext = () => (skip = true);
+Positional arguments:
+  [outfile]                 The output file. If not specified, a generated unix timestamp as filename will be used
+                            and saved to the directory set in the --video-path option
 
-  for (let index = 0; index < args.length; index++) {
-    const arg = args[index];
+Options:
+  -h, --help                 Show this help message
+  -v, --version              Show version information
+  -kill                      Terminate the running ${CLI_NAME} instance, if there is any
+  -status                    Show the current status
+  -i <input>                 The input file to encode
+  -ss <start_time>           The start time (same as ffmpeg's -ss)
+  -to <stop_time>            The stop time (same as ffmpeg's -to)
+  -lavfi <filters>           The set of filters to pass to ffmpeg
+  -c:v <encoder>             The video encoder to use (default is ${config.encoder})
+  -deadline {good,best}      The deadline for libvpx-vp9; good is the recommended one, best has the best
+                             compression efficiency but takes the most time (default is ${config.deadline})
+  -crf <value>               The crf to use (default is ${config.crf})
+  -cpu-used {0,1,2,3,4,5}    The cpu-used for libvpx-vp9; a number between 0 and 5 inclusive, the higher
+                             the number the faster the encoding will be with a quality trade-off (default is ${config.cpuUsed})
+  -subs                      Burn the subtitles onto the output file; this flag will automatically use
+                             the subtitles found in the first input file, to use a different file use
+                             the -lavfi flag with the subtitles filter directly
+  -sl, --size-limit <limit>  The size limit of the output file in MiB, use 0 for no limit (default is ${config.sizeLimit})
+  --video-path <path>        The video path where the video files are stored (default is ${config.videoPath})
+                             this is overridden if the output file is specified
+  --no-log-file              Don't log to the log file
+  -ep, --extra-params <params>
+                             The extra parameters to pass to ffmpeg, these will be appended making it
+                             possible to override some defaults. This option has to be the last one, everything
+                             will be passed as is to ffmpeg
 
-    if (skip) {
-      skip = false;
-      continue;
-    }
+Examples:
+  ${CLI_NAME} -i "/tmp/Videos/nijinosaki.mkv" -ss 00:00:02.268 -to 00:00:10.310
+  ${CLI_NAME} -i "/tmp/Videos/nijinosaki.mkv" --size-limit 6 -subs --extra-params -map 0:a -c:a libopus -b:a 128k`;
 
-    if (isExtraParam) {
-      rawArgs.extraParams?.push(arg);
-      continue;
-    }
+  console.info(usage);
+};
 
-    if (arg.startsWith("-") && !RECOGNIZED_ARGS.includes(arg)) {
-      printUsage();
+const logMissingArg = (arg: string) =>
+  console.error(`The ${arg} flag requires an argument`);
 
-      logger.error(`Unrecognized argument: ${arg}`);
+const logInvalidNumber = (arg: string, value: number) =>
+  console.error(
+    `The ${arg} flag requires a number. "${value}" is not a valid number`,
+  );
 
-      process.exit(1);
-    }
+const argv = Bun.argv.slice(2);
 
-    if (["-h", "--help"].includes(arg)) {
-      printUsage();
+const rawArgs: Partial<ArgsSchema> = {};
 
-      process.exit();
-    }
+let skip = false;
+let isExtraParam = false;
+let seeking: { startTime?: string; stopTime?: string } | undefined;
 
-    if (["-v", "--version"].includes(arg)) {
-      logger.info(
-        `${CLI_NAME} version ${VERSION}\nCopyright (c) ${COPYRIGHT_YEAR} ${AUTHOR}\nLicensed under the ${LICENSE} License\n${HOMEPAGE}`,
-        { onlyConsole: true },
-      );
-      process.exit();
-    }
+const skipNext = () => (skip = true);
 
-    if (arg === "-kill") {
-      try {
-        await ipc.sendMessage({ type: "kill" });
-
-        logger.info("Main instance successfully killed", {
-          logToConsole: true,
-        });
-      } catch (error) {
-        if (
-          error instanceof Error &&
-          "code" in error &&
-          error.code !== "ENOENT"
-        ) {
-          logger.error("Couldn't kill the main instance");
-        }
-
-        process.exit(1);
-      }
+for (let index = 0; index < argv.length; index++) {
+  const arg = argv[index];
 
-      process.exit();
-    }
-
-    if (arg === "-status") {
-      try {
-        const status = await ipc.sendMessage({ type: "status" });
+  if (skip) {
+    skip = false;
+    continue;
+  }
 
-        logger.info(JSON.stringify(status, null, 2), { onlyConsole: true });
+  if (isExtraParam) {
+    rawArgs.extraParams?.push(arg);
+    continue;
+  }
 
-        logger.info("Status printed to the screen");
-      } catch (error) {
-        if (
-          error instanceof Error &&
-          "code" in error &&
-          error.code !== "ENOENT"
-        ) {
-          logger.error("Couldn't get the status of the main instance");
-        }
+  if (arg.startsWith("-") && !RECOGNIZED_ARGS.includes(arg)) {
+    printUsage();
 
-        process.exit(1);
-      }
+    console.error(`Unrecognized argument: ${arg}`);
 
-      process.exit();
-    }
+    process.exit(1);
+  }
 
-    if (!arg.startsWith("-") && !arg.startsWith("--")) {
-      if (rawArgs.output?.file) {
-        logger.error("Only one output file is allowed");
+  if (["-h", "--help"].includes(arg)) {
+    printUsage();
 
-        logger.debug(
-          `Current output file: ${rawArgs.output.file}, new file: ${arg}`,
-        );
+    process.exit();
+  }
 
-        process.exit(1);
-      }
+  if (["-v", "--version"].includes(arg)) {
+    console.info(
+      `${CLI_NAME} version ${VERSION}\nCopyright (c) ${COPYRIGHT_YEAR} ${AUTHOR}\nLicensed under the ${LICENSE} License\n${HOMEPAGE}`,
+    );
+    process.exit();
+  }
 
-      if (!rawArgs.output) {
-        rawArgs.output = {};
+  if (arg === "-kill") {
+    try {
+      await ipcClient.sendMessage({ type: "kill" });
+
+      console.info("Main instance successfully killed");
+    } catch (error) {
+      if (
+        error instanceof Error &&
+        "code" in error &&
+        error.code !== "ENOENT"
+      ) {
+        console.error("Couldn't kill the main instance");
       }
 
-      rawArgs.output.file = arg;
-
-      continue;
+      process.exit(1);
     }
 
-    if (arg === "-ss") {
-      if (args[index + 1] === undefined || args[index + 1].startsWith("-")) {
-        logMissingArg(arg);
+    process.exit();
+  }
 
-        process.exit(1);
+  if (arg === "-status") {
+    try {
+      const status = await ipcClient.sendMessage({ type: "status" });
+
+      console.info(JSON.stringify(status, null, 2));
+    } catch (error) {
+      if (
+        error instanceof Error &&
+        "code" in error &&
+        error.code !== "ENOENT"
+      ) {
+        console.error("Couldn't get the status of the main instance");
       }
 
-      if (!seeking) {
-        seeking = {};
-      }
+      process.exit(1);
+    }
 
-      seeking.startTime = args[index + 1];
+    process.exit();
+  }
 
-      skipNext();
+  if (!arg.startsWith("-") && !arg.startsWith("--")) {
+    if (rawArgs.output?.file) {
+      console.error("Only one output file is allowed");
 
-      continue;
-    }
+      console.debug(
+        `Current output file: ${rawArgs.output.file}, new file: ${arg}`,
+      );
 
-    if (arg === "-to") {
-      if (args[index + 1] === undefined || args[index + 1].startsWith("-")) {
-        logMissingArg(arg);
+      process.exit(1);
+    }
 
-        process.exit(1);
-      }
+    if (!rawArgs.output) {
+      rawArgs.output = {};
+    }
 
-      if (!seeking) {
-        seeking = {};
-      }
+    rawArgs.output.file = arg;
 
-      seeking.stopTime = args[index + 1];
+    continue;
+  }
 
-      skipNext();
+  if (arg === "-ss") {
+    if (argv[index + 1] === undefined || argv[index + 1].startsWith("-")) {
+      logMissingArg(arg);
 
-      continue;
+      process.exit(1);
     }
 
-    if (arg === "-i") {
-      if (args[index + 1] === undefined || args[index + 1].startsWith("-")) {
-        logMissingArg(arg);
-
-        process.exit(1);
-      }
+    if (!seeking) {
+      seeking = {};
+    }
 
-      if (!rawArgs.inputs) {
-        rawArgs.inputs = [];
-      }
+    seeking.startTime = argv[index + 1];
 
-      rawArgs.inputs.push({
-        file: args[index + 1],
-        ...seeking,
-      });
+    skipNext();
 
-      seeking = undefined;
+    continue;
+  }
 
-      skipNext();
+  if (arg === "-to") {
+    if (argv[index + 1] === undefined || argv[index + 1].startsWith("-")) {
+      logMissingArg(arg);
 
-      continue;
+      process.exit(1);
     }
 
-    if (arg === "-subs") {
-      rawArgs.subs = true;
-
-      continue;
+    if (!seeking) {
+      seeking = {};
     }
 
-    if (arg === "-sl" || arg === "--size-limit") {
-      if (args[index + 1] === undefined || args[index + 1].startsWith("-")) {
-        logMissingArg(arg);
+    seeking.stopTime = argv[index + 1];
 
-        process.exit(1);
-      }
+    skipNext();
 
-      const sizeLimit = Number(args[index + 1]);
+    continue;
+  }
 
-      if (isNaN(sizeLimit)) {
-        logInvalidNumber(arg, sizeLimit);
+  if (arg === "-i") {
+    if (argv[index + 1] === undefined || argv[index + 1].startsWith("-")) {
+      logMissingArg(arg);
 
-        process.exit(1);
-      }
+      process.exit(1);
+    }
 
-      rawArgs.sizeLimit = sizeLimit;
+    if (!rawArgs.inputs) {
+      rawArgs.inputs = [];
+    }
 
-      skipNext();
+    rawArgs.inputs.push({
+      file: argv[index + 1],
+      ...seeking,
+    });
 
-      continue;
-    }
+    seeking = undefined;
 
-    if (arg === "-ep" || arg === "--extra-params") {
-      if (args[index + 1] === undefined) {
-        logMissingArg(arg);
+    skipNext();
 
-        process.exit(1);
-      }
+    continue;
+  }
 
-      isExtraParam = true;
+  if (arg === "-subs") {
+    rawArgs.subs = true;
 
-      rawArgs.extraParams = [];
+    continue;
+  }
+
+  if (arg === "-sl" || arg === "--size-limit") {
+    if (argv[index + 1] === undefined || argv[index + 1].startsWith("-")) {
+      logMissingArg(arg);
 
-      continue;
+      process.exit(1);
     }
 
-    if (arg === "--video-path") {
-      if (args[index + 1] === undefined || args[index + 1].startsWith("-")) {
-        logMissingArg(arg);
+    const sizeLimit = Number(argv[index + 1]);
 
-        process.exit(1);
-      }
+    if (isNaN(sizeLimit)) {
+      logInvalidNumber(arg, sizeLimit);
 
-      rawArgs.videoPath = args[index + 1];
+      process.exit(1);
+    }
 
-      skipNext();
+    rawArgs.sizeLimit = sizeLimit;
 
-      continue;
-    }
+    skipNext();
 
-    if (arg === "-crf") {
-      if (args[index + 1] === undefined || args[index + 1].startsWith("-")) {
-        logMissingArg(arg);
+    continue;
+  }
 
-        process.exit(1);
-      }
+  if (arg === "-ep" || arg === "--extra-params") {
+    if (argv[index + 1] === undefined) {
+      logMissingArg(arg);
 
-      const crf = Number(args[index + 1]);
+      process.exit(1);
+    }
 
-      if (isNaN(crf)) {
-        logInvalidNumber(arg, crf);
+    isExtraParam = true;
 
-        process.exit(1);
-      }
+    rawArgs.extraParams = [];
 
-      rawArgs.crf = crf;
+    continue;
+  }
 
-      skipNext();
+  if (arg === "--video-path") {
+    if (argv[index + 1] === undefined || argv[index + 1].startsWith("-")) {
+      logMissingArg(arg);
 
-      continue;
+      process.exit(1);
     }
 
-    if (arg === "-cpu-used") {
-      if (args[index + 1] === undefined || args[index + 1].startsWith("-")) {
-        logMissingArg(arg);
+    rawArgs.videoPath = argv[index + 1];
 
-        process.exit(1);
-      }
+    skipNext();
 
-      const cpuUsed = Number(args[index + 1]);
+    continue;
+  }
 
-      if (isNaN(cpuUsed)) {
-        logInvalidNumber(arg, cpuUsed);
+  if (arg === "--no-log-file") {
+    rawArgs.noLogFile = true;
 
-        process.exit(1);
-      }
+    continue;
+  }
 
-      if (ArgsSchema.shape.cpuUsed.safeParse(cpuUsed).success === false) {
-        logger.error(
-          `The ${arg} flag requires a number between 0 and 5 inclusive. "${cpuUsed}" is out of that range`,
-        );
+  if (arg === "-crf") {
+    if (argv[index + 1] === undefined || argv[index + 1].startsWith("-")) {
+      logMissingArg(arg);
 
-        process.exit(1);
-      }
+      process.exit(1);
+    }
 
-      rawArgs.cpuUsed = cpuUsed as 0 | 1 | 2 | 3 | 4 | 5;
+    const crf = Number(argv[index + 1]);
 
-      skipNext();
+    if (isNaN(crf)) {
+      logInvalidNumber(arg, crf);
 
-      continue;
+      process.exit(1);
     }
 
-    if (arg === "-deadline") {
-      if (args[index + 1] === undefined || args[index + 1].startsWith("-")) {
-        logMissingArg(arg);
+    rawArgs.crf = crf;
 
-        process.exit(1);
-      }
+    skipNext();
 
-      if (!["good", "best"].includes(args[index + 1])) {
-        logger.error(
-          `The ${arg} flag requires either "good" or "best". "${args[index + 1]}" is not a valid value`,
-        );
+    continue;
+  }
 
-        process.exit(1);
-      }
+  if (arg === "-cpu-used") {
+    if (argv[index + 1] === undefined || argv[index + 1].startsWith("-")) {
+      logMissingArg(arg);
+
+      process.exit(1);
+    }
+
+    const cpuUsed = Number(argv[index + 1]);
+
+    if (isNaN(cpuUsed)) {
+      logInvalidNumber(arg, cpuUsed);
 
-      rawArgs.deadline = args[index + 1] as "good" | "best";
+      process.exit(1);
+    }
 
-      skipNext();
+    if (ArgsSchema.shape.cpuUsed.safeParse(cpuUsed).success === false) {
+      console.error(
+        `The ${arg} flag requires a number between 0 and 5 inclusive. "${cpuUsed}" is out of that range`,
+      );
 
-      continue;
+      process.exit(1);
     }
 
-    if (arg === "-c:v") {
-      if (args[index + 1] === undefined || args[index + 1].startsWith("-")) {
-        logMissingArg(arg);
+    rawArgs.cpuUsed = cpuUsed as 0 | 1 | 2 | 3 | 4 | 5;
 
-        process.exit(1);
-      }
+    skipNext();
 
-      rawArgs.encoder = args[index + 1];
+    continue;
+  }
 
-      skipNext();
+  if (arg === "-deadline") {
+    if (argv[index + 1] === undefined || argv[index + 1].startsWith("-")) {
+      logMissingArg(arg);
 
-      continue;
+      process.exit(1);
     }
 
-    if (arg === "-lavfi") {
-      if (args[index + 1] === undefined || args[index + 1].startsWith("-")) {
-        logMissingArg(arg);
+    if (!["good", "best"].includes(argv[index + 1])) {
+      console.error(
+        `The ${arg} flag requires either "good" or "best". "${argv[index + 1]}" is not a valid value`,
+      );
 
-        process.exit(1);
-      }
+      process.exit(1);
+    }
 
-      rawArgs.lavfi = args[index + 1];
+    rawArgs.deadline = argv[index + 1] as "good" | "best";
 
-      skipNext();
+    skipNext();
 
-      continue;
-    }
+    continue;
   }
 
-  if (seeking) {
-    rawArgs.output = { ...rawArgs.output, ...seeking };
+  if (arg === "-c:v") {
+    if (argv[index + 1] === undefined || argv[index + 1].startsWith("-")) {
+      logMissingArg(arg);
 
-    seeking = undefined;
-  }
+      process.exit(1);
+    }
 
-  if (!rawArgs.inputs) {
-    printUsage();
+    rawArgs.encoder = argv[index + 1];
 
-    // if the user isn't using any of the quick actions we require the -i flag
-    logger.error("Input file is required");
+    skipNext();
 
-    process.exit(1);
+    continue;
   }
 
-  const parsedArgs = ArgsSchema.safeParse(rawArgs);
+  if (arg === "-lavfi") {
+    if (argv[index + 1] === undefined || argv[index + 1].startsWith("-")) {
+      logMissingArg(arg);
+
+      process.exit(1);
+    }
 
-  if (!parsedArgs.success) {
-    logger.error("Error parsing the arguments");
+    rawArgs.lavfi = argv[index + 1];
 
-    logger.error(
-      JSON.stringify(parsedArgs.error.flatten().fieldErrors, null, 2),
-    );
+    skipNext();
 
-    process.exit(1);
+    continue;
   }
+}
 
-  return parsedArgs.data;
-};
+if (seeking) {
+  rawArgs.output = { ...rawArgs.output, ...seeking };
 
-const logMissingArg = (arg: string) =>
-  logger.error(`The ${arg} flag requires an argument`);
+  seeking = undefined;
+}
 
-const logInvalidNumber = (arg: string, value: number) =>
-  logger.error(
-    `The ${arg} flag requires a number. "${value}" is not a valid number`,
-  );
+if (!rawArgs.inputs) {
+  printUsage();
 
-const printUsage = () => {
-  const usage = `Usage: ${CLI_NAME} [options] [[infile options] -i infile]... [outfile options] [outfile] [extra params]
+  // if the user isn't using any of the quick actions we require the -i flag
+  console.error("Input file is required");
 
-${DESCRIPTION}
+  process.exit(1);
+}
 
-Positional arguments:
-  [outfile]                 The output file. If not specified, a generated unix timestamp as filename will be used
-                            and saved to the directory set in the --video-path option
+const parsed = ArgsSchema.safeParse(rawArgs);
 
-Options:
-  -h, --help                 Show this help message
-  -v, --version              Show version information
-  -kill                      Terminate the running ${CLI_NAME} instance, if there is any
-  -status                    Show the current status
-  -i <input>                 The input file to encode
-  -ss <start_time>           The start time (same as ffmpeg's -ss)
-  -to <stop_time>            The stop time (same as ffmpeg's -to)
-  -lavfi <filters>           The set of filters to pass to ffmpeg
-  -c:v <encoder>             The video encoder to use (default is ${config.encoder})
-  -deadline {good,best}      The deadline for libvpx-vp9; good is the recommended one, best has the best
-                             compression efficiency but takes the most time (default is ${config.deadline})
-  -crf <value>               The crf to use (default is ${config.crf})
-  -cpu-used {0,1,2,3,4,5}    The cpu-used for libvpx-vp9; a number between 0 and 5 inclusive, the higher
-                             the number the faster the encoding will be with a quality trade-off (default is ${config.cpuUsed})
-  -subs                      Burn the subtitles onto the output file; this flag will automatically use
-                             the subtitles found in the first input file, to use a different file use
-                             the -lavfi flag with the subtitles filter directly
-  -sl, --size-limit <limit>  The size limit of the output file in MiB, use 0 for no limit (default is ${config.sizeLimit})
-  --video-path <path>        The video path where the video files are stored (default is ${config.videoPath})
-                             this is overridden if the output file is specified
-  -ep, --extra-params <params>
-                             The extra parameters to pass to ffmpeg, these will be appended making it
-                             possible to override some defaults. This option has to be the last one, everything
-                             will be passed as is to ffmpeg
+if (!parsed.success) {
+  console.error("Error parsing the arguments");
 
-Examples:
-  ${CLI_NAME} -i "/tmp/Videos/nijinosaki.mkv" -ss 00:00:02.268 -to 00:00:10.310 
-  ${CLI_NAME} -i "/tmp/Videos/nijinosaki.mkv" --size-limit 6 -subs --extra-params -map 0:a -c:a libopus -b:a 128k`;
+  console.error(JSON.stringify(parsed.error.flatten().fieldErrors, null, 2));
 
-  logger.info(usage, {
-    onlyConsole: true,
-  });
-};
+  process.exit(1);
+}
+
+export const parsedArgs = parsed.data;

package/src/config.ts

@@ -1,7 +1,6 @@
 import path from "path";
 
 import { parse } from "smol-toml";
-import { logger } from "./logger";
 import { CONFIG_PATH } from "./paths";
 import { ConfigSchema } from "./schema/config";
 import { CONFIG_FILE_NAME } from "./constants";
@@ -12,13 +11,11 @@ const configPath = path.join(CONFIG_PATH, CONFIG_FILE_NAME);
 let rawConfig: unknown = {};
 
 if (existsSync(configPath)) {
-  logger.info("Loading config file " + configPath);
-
   try {
     rawConfig = parse(readFileSync(configPath, "utf-8"));
   } catch (error) {
     if (error instanceof Error) {
-      logger.error(
+      console.error(
         "Error parsing the config file " + configPath + ":\n\n" + error.message,
       );
 
@@ -32,12 +29,12 @@ if (existsSync(configPath)) {
 const parsedConfig = ConfigSchema.safeParse(rawConfig);
 
 if (!parsedConfig.success) {
-  logger.error("Error parsing the config file " + configPath);
+  console.error("Error parsing the config file " + configPath);
 
   const errors = parsedConfig.error.flatten().fieldErrors;
 
   for (const key in errors) {
-    logger.error(
+    console.error(
       `Error in option "${key}": ` +
         errors[key as keyof typeof errors]?.join("; "),
     );

package/src/ipc/client.ts

@@ -0,0 +1,66 @@
+import { SOCKET_FILE } from "./constants";
+import { ResponseSchema } from "../schema/ipc";
+
+import type { IPCSchema } from "../schema/ipc";
+import type { StatusSchema } from "../schema/status";
+
+// overloading
+type SendMessage = {
+  (message: Exclude<IPCSchema, { type: "status" }>): Promise<void>;
+  (message: Extract<IPCSchema, { type: "status" }>): Promise<StatusSchema>;
+};
+
+const sendMessage: SendMessage = async (message) =>
+  new Promise(async (resolve, reject) => {
+    try {
+      const socket = await Bun.connect({
+        unix: SOCKET_FILE,
+        socket: {
+          data: (socket, rawData) => {
+            socket.end();
+
+            const parsedData = ResponseSchema.safeParse(
+              JSON.parse(rawData.toString()),
+            );
+
+            if (!parsedData.success) {
+              // couldn't parse
+              console.error("Invalid response received through the socket");
+
+              return reject();
+            }
+
+            if (!parsedData.data.success) {
+              // request did not succeed
+              return reject();
+            }
+
+            if (parsedData.data.type === "status") {
+              const { data } = parsedData.data;
+
+              return resolve(data);
+            }
+
+            return resolve(undefined as void & StatusSchema);
+          },
+        },
+      });
+
+      socket.write(JSON.stringify(message));
+    } catch (error) {
+      if (
+        error instanceof Error &&
+        "code" in error &&
+        error.code === "ENOENT" &&
+        message.type !== "enqueue"
+      ) {
+        console.error("No current main instance running");
+      }
+
+      reject(error);
+    }
+  });
+
+export const ipcClient = {
+  sendMessage,
+};

package/src/ipc/constants.ts

@@ -0,0 +1,9 @@
+import os from "os";
+import path from "path";
+
+import { TEMP_PATH } from "../paths";
+import { PIPE_NAME, SOCKET_NAME } from "../constants";
+
+// windows doesn't have unix sockets but named pipes
+export const SOCKET_FILE =
+  os.platform() === "win32" ? PIPE_NAME : path.join(TEMP_PATH, SOCKET_NAME);

package/src/{ipc.ts → ipc/server.ts}

@@ -1,21 +1,14 @@
-import os from "os";
-import path from "path";
-
-import { queue } from "./queue";
-import { status } from "./status";
-import { logger } from "./logger";
-import { TEMP_PATH } from "./paths";
+import { queue } from "../queue";
+import { status } from "../status";
+import { logger } from "../logger";
 import { unlinkSync } from "fs";
-import { assertNever } from "./utils";
-import { PIPE_NAME, SOCKET_NAME } from "./constants";
-import { IPCSchema, ResponseSchema } from "./schema/ipc";
+import { assertNever } from "../utils";
+import { SOCKET_FILE } from "./constants";
+import { IPCSchema, ResponseSchema } from "../schema/ipc";
 
-import type { StatusSchema } from "./schema/status";
-import type { UnixSocketListener } from "bun";
+import os from "os";
 
-// windows doesn't have unix sockets but named pipes
-const SOCKET_FILE =
-  os.platform() === "win32" ? PIPE_NAME : path.join(TEMP_PATH, SOCKET_NAME);
+import type { UnixSocketListener } from "bun";
 
 let listener: UnixSocketListener<undefined> | undefined;
 
@@ -72,8 +65,6 @@ const startListener = () => {
             );
             break;
           case "status":
-            logger.info("Received status request, sending the current status");
-
             socket.end(
               JSON.stringify({
                 type: "status",
@@ -116,67 +107,7 @@ const stopListener = () => {
   }
 };
 
-// overloading
-type SendMessage = {
-  (message: Exclude<IPCSchema, { type: "status" }>): Promise<void>;
-  (message: Extract<IPCSchema, { type: "status" }>): Promise<StatusSchema>;
-};
-
-const sendMessage: SendMessage = async (message) =>
-  new Promise(async (resolve, reject) => {
-    try {
-      const socket = await Bun.connect({
-        unix: SOCKET_FILE,
-        socket: {
-          data: (socket, rawData) => {
-            socket.end();
-
-            const parsedData = ResponseSchema.safeParse(
-              JSON.parse(rawData.toString()),
-            );
-
-            if (!parsedData.success) {
-              // couldn't parse
-              logger.error("Invalid response received through the socket");
-
-              return reject();
-            }
-
-            if (!parsedData.data.success) {
-              // request did not succeed
-              return reject();
-            }
-
-            if (parsedData.data.type === "status") {
-              const { data } = parsedData.data;
-
-              return resolve(data);
-            }
-
-            return resolve(undefined as void & StatusSchema);
-          },
-        },
-      });
-
-      socket.write(JSON.stringify(message));
-    } catch (error) {
-      if (
-        error instanceof Error &&
-        "code" in error &&
-        error.code === "ENOENT" &&
-        message.type !== "enqueue"
-      ) {
-        logger.info("No current main instance running", {
-          logToConsole: true,
-        });
-      }
-
-      reject(error);
-    }
-  });
-
-export const ipc = {
-  sendMessage,
-  stopListener,
-  startListener,
+export const ipcServer = {
+  stop: stopListener,
+  start: startListener,
 };

package/src/logger.ts

@@ -1,6 +1,7 @@
 import os from "os";
 import path from "path";
 
+import { parsedArgs } from "./args";
 import { CONFIG_PATH } from "./paths";
 import { CLI_NAME, LOG_FILE_NAME } from "./constants";
 import { existsSync, mkdirSync, appendFileSync } from "fs";
@@ -113,6 +114,10 @@ const log = (message: Message, level: Level, options?: Options) => {
     consoleLog(consoleMessage);
   }
 
+  if (parsedArgs.noLogFile) {
+    return;
+  }
+
   writeToFile(message, level);
 };
 

package/src/main.ts

@@ -1,9 +1,14 @@
-import { ipc } from "./ipc";
 import { queue } from "./queue";
 import { logger } from "./logger";
 import { CLI_NAME } from "./constants";
-import { parseArgs } from "./args";
 import { cleanExit } from "./utils";
+import { ipcServer } from "./ipc/server";
+import { ipcClient } from "./ipc/client";
+import { parsedArgs } from "./args";
+
+const argv = Bun.argv.slice(2);
+
+logger.info("argv: " + argv.join(" "));
 
 process.title = CLI_NAME;
 
@@ -51,12 +56,6 @@ process.on("unhandledRejection", (reason) => {
   cleanExit(1);
 });
 
-const args = Bun.argv.slice(2);
-
-logger.info("argv: " + args.join(" "));
-
-const parsedArgs = await parseArgs(args);
-
 // let's check if ffmpeg and ffprobe are available before encoding anything
 try {
   const ffmpegProcess = Bun.spawnSync(["ffmpeg", "-hide_banner", "-version"]);
@@ -90,7 +89,7 @@ try {
 
 try {
   // try sending the args to the running process if there is one
-  await ipc.sendMessage({
+  await ipcClient.sendMessage({
     type: "enqueue",
     data: parsedArgs,
   });
@@ -103,9 +102,9 @@ try {
 
   queue.push(parsedArgs);
 
-  ipc.startListener();
+  ipcServer.start();
 
   await queue.processQueue();
 
-  ipc.stopListener();
+  ipcServer.stop();
 }

package/src/schema/args.ts

@@ -28,6 +28,7 @@ export const ArgsSchema = ConfigSchema.merge(
     encoder: ConfigSchema.shape.encoder.default(config.encoder),
     cpuUsed: ConfigSchema.shape.cpuUsed.default(config.cpuUsed),
     deadline: ConfigSchema.shape.deadline.default(config.deadline),
+    noLogFile: ConfigSchema.shape.noLogFile.default(config.noLogFile),
     sizeLimit: ConfigSchema.shape.sizeLimit.default(config.sizeLimit),
     videoPath: ConfigSchema.shape.videoPath.default(config.videoPath),
   }),

package/src/schema/config.ts

@@ -3,6 +3,7 @@ import { DEFAULT_VIDEO_PATH, expandHome } from "../paths";
 
 export const ConfigSchema = z.object({
   subs: z.boolean().default(false),
+  noLogFile: z.boolean().default(false),
   encoder: z.string().default("libvpx-vp9"),
   sizeLimit: z.number().default(4),
   crf: z.number().default(24),

package/src/utils.ts

@@ -1,8 +1,10 @@
-import { ipc } from "./ipc";
 import { queue } from "./queue";
 import { logger } from "./logger";
+import { ipcServer } from "./ipc/server";
 
-export const assertNever = (value: never) => {
+type AssertNever = (value: never) => never;
+
+export const assertNever: AssertNever = (value) => {
   throw new Error(`Unexpected value: ${value}`);
 };
 
@@ -15,7 +17,7 @@ export const cleanExit: CleanExit = async (code = 0) => {
 
   await queue.abortProcessing();
 
-  ipc.stopListener();
+  ipcServer.stop();
 
   process.exit(code);
 };