Init flow plugins

FlowPluginsTs/CommunityFlowPlugins/ffmpegCommand/ffmpegCommand10BitVideo/1.0.0/index.ts

@@ -0,0 +1,43 @@
+import {
+  IpluginDetails,
+  IpluginInputArgs,
+  IpluginOutputArgs,
+} from '../../../../FlowHelpers/1.0.0/interfaces/interfaces';
+
+/* eslint no-plusplus: ["error", { "allowForLoopAfterthoughts": true }] */
+const details = () :IpluginDetails => ({
+  name: '10 Bit Video',
+  description: 'Set 10 Bit Video',
+  style: {
+    borderColor: '#6efefc',
+    opacity: 0.5,
+  },
+  tags: 'video',
+  isStartPlugin: false,
+  sidebarPosition: -1,
+  icon: '',
+  inputs: [],
+  outputs: [
+    {
+      number: 1,
+      tooltip: 'Continue to next plugin',
+    },
+  ],
+});
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const plugin = (args:IpluginInputArgs):IpluginOutputArgs => {
+  const lib = require('../../../../../methods/lib')();
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars,no-param-reassign
+  args.inputs = lib.loadDefaultValues(args.inputs, details);
+
+  return {
+    outputFileObj: args.inputFileObj,
+    outputNumber: 1,
+    variables: args.variables,
+  };
+};
+export {
+  details,
+  plugin,
+};

FlowPluginsTs/CommunityFlowPlugins/ffmpegCommand/ffmpegCommandCropBlackBars/1.0.0/index.ts

@@ -0,0 +1,43 @@
+import {
+  IpluginDetails,
+  IpluginInputArgs,
+  IpluginOutputArgs,
+} from '../../../../FlowHelpers/1.0.0/interfaces/interfaces';
+
+/* eslint no-plusplus: ["error", { "allowForLoopAfterthoughts": true }] */
+const details = () :IpluginDetails => ({
+  name: 'Crop Black Bars',
+  description: 'Crop Black Bars',
+  style: {
+    borderColor: '#6efefc',
+    opacity: 0.5,
+  },
+  tags: 'video',
+  isStartPlugin: false,
+  sidebarPosition: -1,
+  icon: '',
+  inputs: [],
+  outputs: [
+    {
+      number: 1,
+      tooltip: 'Continue to next plugin',
+    },
+  ],
+});
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const plugin = (args:IpluginInputArgs):IpluginOutputArgs => {
+  const lib = require('../../../../../methods/lib')();
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars,no-param-reassign
+  args.inputs = lib.loadDefaultValues(args.inputs, details);
+
+  return {
+    outputFileObj: args.inputFileObj,
+    outputNumber: 1,
+    variables: args.variables,
+  };
+};
+export {
+  details,
+  plugin,
+};

FlowPluginsTs/CommunityFlowPlugins/ffmpegCommand/ffmpegCommandCustomArguments/1.0.0/index.ts

@@ -0,0 +1,43 @@
+import {
+  IpluginDetails,
+  IpluginInputArgs,
+  IpluginOutputArgs,
+} from '../../../../FlowHelpers/1.0.0/interfaces/interfaces';
+
+/* eslint no-plusplus: ["error", { "allowForLoopAfterthoughts": true }] */
+const details = () :IpluginDetails => ({
+  name: 'Custom Arguments',
+  description: 'Custom Arguments',
+  style: {
+    borderColor: '#6efefc',
+    opacity: 0.5,
+  },
+  tags: 'video',
+  isStartPlugin: false,
+  sidebarPosition: -1,
+  icon: '',
+  inputs: [],
+  outputs: [
+    {
+      number: 1,
+      tooltip: 'Continue to next plugin',
+    },
+  ],
+});
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const plugin = (args:IpluginInputArgs):IpluginOutputArgs => {
+  const lib = require('../../../../../methods/lib')();
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars,no-param-reassign
+  args.inputs = lib.loadDefaultValues(args.inputs, details);
+
+  return {
+    outputFileObj: args.inputFileObj,
+    outputNumber: 1,
+    variables: args.variables,
+  };
+};
+export {
+  details,
+  plugin,
+};

FlowPluginsTs/CommunityFlowPlugins/ffmpegCommand/ffmpegCommandEnsureAudioStream/1.0.0/index.ts

@@ -0,0 +1,43 @@
+import {
+  IpluginDetails,
+  IpluginInputArgs,
+  IpluginOutputArgs,
+} from '../../../../FlowHelpers/1.0.0/interfaces/interfaces';
+
+/* eslint no-plusplus: ["error", { "allowForLoopAfterthoughts": true }] */
+const details = () :IpluginDetails => ({
+  name: 'Ensure Audio Stream',
+  description: 'Ensure that the file has an audio stream with set codec and channel count',
+  style: {
+    borderColor: '#6efefc',
+    opacity: 0.5,
+  },
+  tags: 'video',
+  isStartPlugin: false,
+  sidebarPosition: -1,
+  icon: '',
+  inputs: [],
+  outputs: [
+    {
+      number: 1,
+      tooltip: 'Continue to next plugin',
+    },
+  ],
+});
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const plugin = (args:IpluginInputArgs):IpluginOutputArgs => {
+  const lib = require('../../../../../methods/lib')();
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars,no-param-reassign
+  args.inputs = lib.loadDefaultValues(args.inputs, details);
+
+  return {
+    outputFileObj: args.inputFileObj,
+    outputNumber: 1,
+    variables: args.variables,
+  };
+};
+export {
+  details,
+  plugin,
+};

FlowPluginsTs/CommunityFlowPlugins/ffmpegCommand/ffmpegCommandExecute/1.0.0/index.ts

@@ -0,0 +1,132 @@
+import {
+  IpluginDetails,
+  IpluginInputArgs,
+  IpluginOutputArgs,
+} from '../../../../FlowHelpers/1.0.0/interfaces/interfaces';
+import { CLI } from '../../../../FlowHelpers/1.0.0/utils';
+
+/* eslint no-plusplus: ["error", { "allowForLoopAfterthoughts": true }] */
+const details = (): IpluginDetails => ({
+  name: 'Execute',
+  description: 'Execute the created FFmpeg command',
+  style: {
+    borderColor: 'green',
+  },
+  tags: 'video',
+
+  isStartPlugin: false,
+  sidebarPosition: 2,
+  icon: 'faPlay',
+  inputs: [],
+  outputs: [
+    {
+      number: 1,
+      tooltip: 'File is 480p',
+    },
+    {
+      number: 2,
+      tooltip: 'File is 576p',
+    },
+  ],
+});
+
+const getEncoder = (codec: string) => {
+  switch (codec) {
+    case 'h264':
+      return 'libx264';
+    case 'hevc':
+      return 'libx265';
+    default:
+      return codec;
+  }
+};
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const plugin = async (args: IpluginInputArgs): Promise<IpluginOutputArgs> => {
+  const lib = require('../../../../../methods/lib')();
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars,no-param-reassign
+  args.inputs = lib.loadDefaultValues(args.inputs, details);
+
+  const cliArgs: string[] = [];
+
+  cliArgs.push('-y');
+  cliArgs.push('-i');
+  cliArgs.push(args.inputFileObj._id);
+
+  let shouldProcess = false;
+
+  // @ts-expect-error type
+  args.variables.ffmpegCommand.streams.forEach((stream) => {
+    if (!stream.removed) {
+      cliArgs.push('-map');
+      cliArgs.push(`0:${stream.index}`);
+      cliArgs.push(`-c:${stream.index}`);
+
+      args.jobLog(JSON.stringify({ stream }));
+      if (args.inputs.forceProcess || stream.codec_name !== stream.targetCodec) {
+        shouldProcess = true;
+        cliArgs.push(getEncoder(stream.targetCodec));
+      } else {
+        cliArgs.push('copy');
+      }
+    }
+  });
+
+  if (!shouldProcess) {
+    args.jobLog('No need to process file, already as required');
+    return {
+      outputFileObj: args.inputFileObj,
+      outputNumber: 1,
+      variables: args.variables,
+    };
+  }
+
+  // @ts-expect-error type
+  const outputFilePath = `${args.workDir}/tempFile.${args.variables.ffmpegCommand.container}`;
+  cliArgs.push(outputFilePath);
+
+  // @ts-expect-error type
+  args.deps.fsextra.ensureDirSync(args.workDir);
+
+  args.jobLog('Processing file');
+  args.jobLog(JSON.stringify({
+    cliArgs,
+    outputFilePath,
+  }));
+
+  const cli = new CLI({
+    cli: args.ffmpegPath,
+    spawnArgs: cliArgs,
+    spawnOpts: {},
+    jobLog: args.jobLog,
+    outputFilePath,
+    inputFileObj: args.inputFileObj,
+    logFullCliOutput: args.logFullCliOutput,
+    updateWorker: args.updateWorker,
+  });
+
+  const res = await cli.runCli();
+
+  if (!args.logFullCliOutput) {
+    args.jobLog(res.errorLogFull.slice(-1000).join(''));
+  }
+
+  if (res.cliExitCode !== 0) {
+    args.jobLog('Running FFmpeg failed');
+    throw new Error('FFmpeg failed');
+  }
+
+  args.logOutcome('tSuc');
+
+  return {
+    outputFileObj: {
+      _id: outputFilePath,
+    },
+    outputNumber: 1,
+    variables: args.variables,
+  };
+};
+export {
+  details,
+  plugin,
+};

FlowPluginsTs/CommunityFlowPlugins/ffmpegCommand/ffmpegCommandHdrToSdr/1.0.0/index.ts

@@ -0,0 +1,43 @@
+import {
+  IpluginDetails,
+  IpluginInputArgs,
+  IpluginOutputArgs,
+} from '../../../../FlowHelpers/1.0.0/interfaces/interfaces';
+
+/* eslint no-plusplus: ["error", { "allowForLoopAfterthoughts": true }] */
+const details = () :IpluginDetails => ({
+  name: 'HDR to SDR',
+  description: 'Convert HDR to SDR',
+  style: {
+    borderColor: '#6efefc',
+    opacity: 0.5,
+  },
+  tags: 'video',
+  isStartPlugin: false,
+  sidebarPosition: -1,
+  icon: '',
+  inputs: [],
+  outputs: [
+    {
+      number: 1,
+      tooltip: 'Continue to next plugin',
+    },
+  ],
+});
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const plugin = (args:IpluginInputArgs):IpluginOutputArgs => {
+  const lib = require('../../../../../methods/lib')();
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars,no-param-reassign
+  args.inputs = lib.loadDefaultValues(args.inputs, details);
+
+  return {
+    outputFileObj: args.inputFileObj,
+    outputNumber: 1,
+    variables: args.variables,
+  };
+};
+export {
+  details,
+  plugin,
+};

FlowPluginsTs/CommunityFlowPlugins/ffmpegCommand/ffmpegCommandNormalizeAudio/1.0.0/index.ts

@@ -0,0 +1,43 @@
+import {
+  IpluginDetails,
+  IpluginInputArgs,
+  IpluginOutputArgs,
+} from '../../../../FlowHelpers/1.0.0/interfaces/interfaces';
+
+/* eslint no-plusplus: ["error", { "allowForLoopAfterthoughts": true }] */
+const details = () :IpluginDetails => ({
+  name: 'Normalize Audio',
+  description: 'Normalize Audio',
+  style: {
+    borderColor: '#6efefc',
+    opacity: 0.5,
+  },
+  tags: 'video',
+  isStartPlugin: false,
+  sidebarPosition: -1,
+  icon: '',
+  inputs: [],
+  outputs: [
+    {
+      number: 1,
+      tooltip: 'Continue to next plugin',
+    },
+  ],
+});
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const plugin = (args:IpluginInputArgs):IpluginOutputArgs => {
+  const lib = require('../../../../../methods/lib')();
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars,no-param-reassign
+  args.inputs = lib.loadDefaultValues(args.inputs, details);
+
+  return {
+    outputFileObj: args.inputFileObj,
+    outputNumber: 1,
+    variables: args.variables,
+  };
+};
+export {
+  details,
+  plugin,
+};

FlowPluginsTs/CommunityFlowPlugins/ffmpegCommand/ffmpegCommandRemoveDataStreams/1.0.0/index.ts

@@ -0,0 +1,52 @@
+/* eslint no-plusplus: ["error", { "allowForLoopAfterthoughts": true }] */
+
+import {
+  IpluginDetails,
+  IpluginInputArgs,
+  IpluginOutputArgs,
+} from '../../../../FlowHelpers/1.0.0/interfaces/interfaces';
+
+/* eslint-disable no-param-reassign */
+const details = ():IpluginDetails => ({
+  name: 'Remove Data Streams',
+  description: 'Remove Data Streams ',
+  style: {
+    borderColor: '#6efefc',
+  },
+  tags: 'video',
+
+  isStartPlugin: false,
+  sidebarPosition: -1,
+  icon: '',
+  inputs: [],
+  outputs: [
+    {
+      number: 1,
+      tooltip: 'Continue to next plugin',
+    },
+  ],
+});
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const plugin = (args:IpluginInputArgs):IpluginOutputArgs => {
+  const lib = require('../../../../../methods/lib')();
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars,no-param-reassign
+  args.inputs = lib.loadDefaultValues(args.inputs, details);
+
+  // @ts-expect-error type
+  args.variables.ffmpegCommand.streams.forEach((stream) => {
+    if (stream.codec_type === 'data') {
+      stream.removed = true;
+    }
+  });
+
+  return {
+    outputFileObj: args.inputFileObj,
+    outputNumber: 1,
+    variables: args.variables,
+  };
+};
+export {
+  details,
+  plugin,
+};

FlowPluginsTs/CommunityFlowPlugins/ffmpegCommand/ffmpegCommandRemoveSubtitles/1.0.0/index.ts

@@ -0,0 +1,52 @@
+/* eslint no-plusplus: ["error", { "allowForLoopAfterthoughts": true }] */
+
+import {
+  IpluginDetails,
+  IpluginInputArgs,
+  IpluginOutputArgs,
+} from '../../../../FlowHelpers/1.0.0/interfaces/interfaces';
+
+/* eslint-disable no-param-reassign */
+const details = ():IpluginDetails => ({
+  name: 'Remove Subtitles',
+  description: 'Remove subtitles from the file',
+  style: {
+    borderColor: '#6efefc',
+  },
+  tags: 'video',
+  isStartPlugin: false,
+  sidebarPosition: -1,
+  icon: '',
+  inputs: [],
+  outputs: [
+    {
+      number: 1,
+      tooltip: 'Continue to next plugin',
+    },
+  ],
+});
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const plugin = (args:IpluginInputArgs):IpluginOutputArgs => {
+  const lib = require('../../../../../methods/lib')();
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars,no-param-reassign
+  args.inputs = lib.loadDefaultValues(args.inputs, details);
+
+  // @ts-expect-error type
+  args.variables.ffmpegCommand.streams.forEach((stream) => {
+    if (stream.codec_type === 'subtitle') {
+      stream.removed = true;
+    }
+  });
+
+  return {
+    outputFileObj: args.inputFileObj,
+    outputNumber: 1,
+    variables: args.variables,
+  };
+};
+
+export {
+  details,
+  plugin,
+};

FlowPluginsTs/CommunityFlowPlugins/ffmpegCommand/ffmpegCommandRorderStreams/1.0.0/index.ts

@@ -0,0 +1,43 @@
+import {
+  IpluginDetails,
+  IpluginInputArgs,
+  IpluginOutputArgs,
+} from '../../../../FlowHelpers/1.0.0/interfaces/interfaces';
+
+/* eslint no-plusplus: ["error", { "allowForLoopAfterthoughts": true }] */
+const details = () :IpluginDetails => ({
+  name: 'Set Video Bitrate',
+  description: 'Set Video Bitrate',
+  style: {
+    borderColor: '#6efefc',
+    opacity: 0.5,
+  },
+  tags: 'video',
+  isStartPlugin: false,
+  sidebarPosition: -1,
+  icon: '',
+  inputs: [],
+  outputs: [
+    {
+      number: 1,
+      tooltip: 'Continue to next plugin',
+    },
+  ],
+});
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const plugin = (args:IpluginInputArgs):IpluginOutputArgs => {
+  const lib = require('../../../../../methods/lib')();
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars,no-param-reassign
+  args.inputs = lib.loadDefaultValues(args.inputs, details);
+
+  return {
+    outputFileObj: args.inputFileObj,
+    outputNumber: 1,
+    variables: args.variables,
+  };
+};
+export {
+  details,
+  plugin,
+};

FlowPluginsTs/CommunityFlowPlugins/ffmpegCommand/ffmpegCommandSetContainer/1.0.0/index.ts

@@ -0,0 +1,61 @@
+/* eslint no-plusplus: ["error", { "allowForLoopAfterthoughts": true }] */
+
+import {
+  IpluginDetails,
+  IpluginInputArgs,
+  IpluginOutputArgs,
+} from '../../../../FlowHelpers/1.0.0/interfaces/interfaces';
+
+/* eslint-disable no-param-reassign */
+const details = ():IpluginDetails => ({
+  name: 'Set Container',
+  description: 'Set the container of the output file',
+  style: {
+    borderColor: '#6efefc',
+  },
+  tags: 'video',
+  isStartPlugin: false,
+  sidebarPosition: -1,
+  icon: '',
+  inputs: [
+    {
+      name: 'container',
+      type: 'string',
+      defaultValue: 'mkv',
+      inputUI: {
+        type: 'dropdown',
+        options: [
+          'mkv',
+          'mp4',
+        ],
+      },
+      tooltip: 'Specify the container to use',
+    },
+  ],
+  outputs: [
+    {
+      number: 1,
+      tooltip: 'Continue to next plugin',
+    },
+  ],
+});
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const plugin = (args:IpluginInputArgs):IpluginOutputArgs => {
+  const lib = require('../../../../../methods/lib')();
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars,no-param-reassign
+  args.inputs = lib.loadDefaultValues(args.inputs, details);
+
+  // @ts-expect-error type
+  args.variables.ffmpegCommand.container = args.inputs.container;
+
+  return {
+    outputFileObj: args.inputFileObj,
+    outputNumber: 1,
+    variables: args.variables,
+  };
+};
+export {
+  details,
+  plugin,
+};

FlowPluginsTs/CommunityFlowPlugins/ffmpegCommand/ffmpegCommandSetVideoBitrate/1.0.0/index.ts

@@ -0,0 +1,43 @@
+import {
+  IpluginDetails,
+  IpluginInputArgs,
+  IpluginOutputArgs,
+} from '../../../../FlowHelpers/1.0.0/interfaces/interfaces';
+
+/* eslint no-plusplus: ["error", { "allowForLoopAfterthoughts": true }] */
+const details = () :IpluginDetails => ({
+  name: 'Reorder Streams',
+  description: 'Reorder Streams',
+  style: {
+    borderColor: '#6efefc',
+    opacity: 0.5,
+  },
+  tags: 'video',
+  isStartPlugin: false,
+  sidebarPosition: -1,
+  icon: '',
+  inputs: [],
+  outputs: [
+    {
+      number: 1,
+      tooltip: 'Continue to next plugin',
+    },
+  ],
+});
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const plugin = (args:IpluginInputArgs):IpluginOutputArgs => {
+  const lib = require('../../../../../methods/lib')();
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars,no-param-reassign
+  args.inputs = lib.loadDefaultValues(args.inputs, details);
+
+  return {
+    outputFileObj: args.inputFileObj,
+    outputNumber: 1,
+    variables: args.variables,
+  };
+};
+export {
+  details,
+  plugin,
+};

FlowPluginsTs/CommunityFlowPlugins/ffmpegCommand/ffmpegCommandSetVideoEncoder/1.0.0/index.ts

@@ -0,0 +1,82 @@
+/* eslint no-plusplus: ["error", { "allowForLoopAfterthoughts": true }] */
+
+import {
+  IpluginDetails,
+  IpluginInputArgs,
+  IpluginOutputArgs,
+} from '../../../../FlowHelpers/1.0.0/interfaces/interfaces';
+
+/* eslint-disable no-param-reassign */
+const details = () :IpluginDetails => ({
+  name: 'Set Video Encoder',
+  description: 'Set the video encoder for all streams',
+  style: {
+    borderColor: '#6efefc',
+  },
+  tags: 'video',
+  isStartPlugin: false,
+  sidebarPosition: -1,
+  icon: '',
+  inputs: [
+    {
+      name: 'targetCodec',
+      type: 'string',
+      defaultValue: 'hevc',
+      inputUI: {
+        type: 'dropdown',
+        options: [
+          'hevc',
+          // 'vp9',
+          'h264',
+          // 'vp8',
+        ],
+      },
+      tooltip: 'Specify the codec to use',
+    },
+    {
+      name: 'forceEncoding',
+      type: 'boolean',
+      defaultValue: 'false',
+      inputUI: {
+        type: 'dropdown',
+        options: [
+          'false',
+          'true',
+        ],
+      },
+      tooltip: 'Specify whether to force encoding if stream already has the target codec',
+    },
+  ],
+  outputs: [
+    {
+      number: 1,
+      tooltip: 'Continue to next plugin',
+    },
+  ],
+});
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const plugin = (args:IpluginInputArgs):IpluginOutputArgs => {
+  const lib = require('../../../../../methods/lib')();
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars,no-param-reassign
+  args.inputs = lib.loadDefaultValues(args.inputs, details);
+
+  // @ts-expect-error type
+  args.variables.ffmpegCommand.streams.forEach((stream) => {
+    if (stream.codec_type === 'video') {
+      // @ts-expect-error type
+      stream.targetCodec = args.inputs.targetCodec;
+      stream.forceEncoding = args.inputs.forceEncoding;
+    }
+  });
+
+  return {
+    outputFileObj: args.inputFileObj,
+    outputNumber: 1,
+    variables: args.variables,
+  };
+};
+export {
+  details,
+  plugin,
+};

FlowPluginsTs/CommunityFlowPlugins/ffmpegCommand/ffmpegCommandSetVideoScale/1.0.0/index.ts

@@ -0,0 +1,43 @@
+import {
+  IpluginDetails,
+  IpluginInputArgs,
+  IpluginOutputArgs,
+} from '../../../../FlowHelpers/1.0.0/interfaces/interfaces';
+
+/* eslint no-plusplus: ["error", { "allowForLoopAfterthoughts": true }] */
+const details = () :IpluginDetails => ({
+  name: 'Set Video Scale',
+  description: 'Change video scale',
+  style: {
+    borderColor: '#6efefc',
+    opacity: 0.5,
+  },
+  tags: 'video',
+  isStartPlugin: false,
+  sidebarPosition: -1,
+  icon: '',
+  inputs: [],
+  outputs: [
+    {
+      number: 1,
+      tooltip: 'Continue to next plugin',
+    },
+  ],
+});
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const plugin = (args:IpluginInputArgs):IpluginOutputArgs => {
+  const lib = require('../../../../../methods/lib')();
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars,no-param-reassign
+  args.inputs = lib.loadDefaultValues(args.inputs, details);
+
+  return {
+    outputFileObj: args.inputFileObj,
+    outputNumber: 1,
+    variables: args.variables,
+  };
+};
+export {
+  details,
+  plugin,
+};

FlowPluginsTs/CommunityFlowPlugins/ffmpegCommand/ffmpegCommandStart/1.0.0/index.ts

@@ -0,0 +1,62 @@
+/* eslint no-plusplus: ["error", { "allowForLoopAfterthoughts": true }] */
+
+import {
+  IpluginDetails,
+  IpluginInputArgs,
+  IpluginOutputArgs,
+} from '../../../../FlowHelpers/1.0.0/interfaces/interfaces';
+import { Istreams } from '../../../../FlowHelpers/1.0.0/interfaces/synced/IFileObject';
+
+/* eslint-disable no-param-reassign */
+const details = () :IpluginDetails => ({
+  name: 'Start',
+  description: 'Start FFmpeg Command',
+  style: {
+    borderColor: 'green',
+  },
+  tags: 'video',
+
+  isStartPlugin: false,
+  sidebarPosition: 1,
+  icon: '',
+  inputs: [],
+  outputs: [
+    {
+      number: 1,
+      tooltip: 'Continue to next plugin',
+    },
+  ],
+});
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const plugin = (args:IpluginInputArgs):IpluginOutputArgs => {
+  const lib = require('../../../../../methods/lib')();
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars,no-param-reassign
+  args.inputs = lib.loadDefaultValues(args.inputs, details);
+
+  const containerParts = args.inputFileObj._id.split('.');
+  const container = containerParts[containerParts.length - 1];
+
+  const ffmpegCommand = {
+    inputFiles: [],
+    streams: JSON.parse(JSON.stringify(args.inputFileObj.ffProbeData.streams)).map((stream:Istreams) => ({
+      ...stream,
+      removed: false,
+      targetCodec: stream.codec_name,
+      args: [],
+    })),
+    container,
+  };
+
+  args.variables.ffmpegCommand = ffmpegCommand;
+
+  return {
+    outputFileObj: args.inputFileObj,
+    outputNumber: 1,
+    variables: args.variables,
+  };
+};
+export {
+  details,
+  plugin,
+};

FlowPluginsTs/CommunityFlowPlugins/file/checkFileMedium/1.0.0/index.ts

@@ -0,0 +1,67 @@
+import {
+  IpluginDetails,
+  IpluginInputArgs,
+  IpluginOutputArgs,
+} from '../../../../FlowHelpers/1.0.0/interfaces/interfaces';
+
+/* eslint no-plusplus: ["error", { "allowForLoopAfterthoughts": true }] */
+const details = (): IpluginDetails => ({
+  name: 'Check File Medium',
+  description: 'Check if file is video, audio or other type of file',
+  style: {
+    borderColor: 'orange',
+  },
+  tags: '',
+
+  isStartPlugin: false,
+  sidebarPosition: -1,
+  icon: 'faQuestion',
+  inputs: [],
+  outputs: [
+    {
+      number: 1,
+      tooltip: 'File medium is a Video',
+
+    },
+    {
+      number: 2,
+      tooltip: 'File medium is an Audio',
+    },
+    {
+      number: 3,
+      tooltip: 'File medium is Other',
+    },
+  ],
+});
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const plugin = (args: IpluginInputArgs): IpluginOutputArgs => {
+  const lib = require('../../../../../methods/lib')();
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars,no-param-reassign
+  args.inputs = lib.loadDefaultValues(args.inputs, details);
+
+  let outputNumber = 1;
+  switch (args.inputFileObj.fileMedium) {
+    case 'video':
+      outputNumber = 1;
+      break;
+    case 'audio':
+      outputNumber = 2;
+      break;
+    case 'other':
+      outputNumber = 3;
+      break;
+    default:
+      throw new Error('File has no fileMedium!');
+  }
+
+  return {
+    outputFileObj: args.inputFileObj,
+    outputNumber,
+    variables: args.variables,
+  };
+};
+export {
+  details,
+  plugin,
+};

FlowPluginsTs/CommunityFlowPlugins/file/copyToDirectory/1.0.0/index.ts

@@ -0,0 +1,60 @@
+import {
+  IpluginDetails,
+  IpluginInputArgs,
+  IpluginOutputArgs,
+} from '../../../../FlowHelpers/1.0.0/interfaces/interfaces';
+
+/* eslint no-plusplus: ["error", { "allowForLoopAfterthoughts": true }] */
+const details = ():IpluginDetails => ({
+  name: 'Copy to Directory',
+  description: 'Copy the working file to a directory',
+  style: {
+    borderColor: 'green',
+    opacity: 0.5,
+  },
+  tags: '',
+
+  isStartPlugin: false,
+  sidebarPosition: -1,
+  icon: 'faArrowRight',
+  inputs: [
+    {
+      name: 'target_codec',
+      type: 'string',
+      defaultValue: 'hevc',
+      inputUI: {
+        type: 'dropdown',
+        options: [
+          'hevc',
+          // 'vp9',
+          'h264',
+          // 'vp8',
+        ],
+      },
+      tooltip: 'Specify the codec to use',
+    },
+  ],
+  outputs: [
+    {
+      number: 1,
+      tooltip: 'Continue to next plugin',
+    },
+  ],
+});
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const plugin = (args:IpluginInputArgs):IpluginOutputArgs => {
+  const lib = require('../../../../../methods/lib')();
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars,no-param-reassign
+  args.inputs = lib.loadDefaultValues(args.inputs, details);
+
+  return {
+    outputFileObj: args.inputFileObj,
+    outputNumber: 1,
+    variables: args.variables,
+  };
+};
+export {
+  details,
+  plugin,
+};

FlowPluginsTs/CommunityFlowPlugins/file/moveToDirectory/1.0.0/index.ts

@@ -0,0 +1,42 @@
+import {
+  IpluginDetails,
+  IpluginInputArgs,
+  IpluginOutputArgs,
+} from '../../../../FlowHelpers/1.0.0/interfaces/interfaces';
+
+/* eslint no-plusplus: ["error", { "allowForLoopAfterthoughts": true }] */
+const details = ():IpluginDetails => ({
+  name: 'Move To Directory',
+  description: 'Move working file to directory.',
+  style: {
+    borderColor: 'green',
+  },
+  tags: '',
+  isStartPlugin: false,
+  sidebarPosition: -1,
+  icon: '',
+  inputs: [],
+  outputs: [
+    {
+      number: 1,
+      tooltip: 'Continue to next plugin',
+    },
+  ],
+});
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const plugin = (args:IpluginInputArgs):IpluginOutputArgs => {
+  const lib = require('../../../../../methods/lib')();
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars,no-param-reassign
+  args.inputs = lib.loadDefaultValues(args.inputs, details);
+
+  return {
+    outputFileObj: args.inputFileObj,
+    outputNumber: 1,
+    variables: args.variables,
+  };
+};
+export {
+  details,
+  plugin,
+};

FlowPluginsTs/CommunityFlowPlugins/file/moveToDirectory/2.0.0/index.ts

@@ -0,0 +1,44 @@
+import {
+  IpluginDetails,
+  IpluginInputArgs,
+  IpluginOutputArgs,
+} from '../../../../FlowHelpers/1.0.0/interfaces/interfaces';
+
+/* eslint no-plusplus: ["error", { "allowForLoopAfterthoughts": true }] */
+const details = ():IpluginDetails => ({
+  name: 'Move To Directory',
+  description: 'Move working file to directory.',
+  style: {
+    borderColor: 'green',
+    opacity: 0.5,
+  },
+  tags: '',
+
+  isStartPlugin: false,
+  sidebarPosition: -1,
+  icon: 'faArrowRight',
+  inputs: [],
+  outputs: [
+    {
+      number: 1,
+      tooltip: 'Continue to next plugin',
+    },
+  ],
+});
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const plugin = (args:IpluginInputArgs):IpluginOutputArgs => {
+  const lib = require('../../../../../methods/lib')();
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars,no-param-reassign
+  args.inputs = lib.loadDefaultValues(args.inputs, details);
+
+  return {
+    outputFileObj: args.inputFileObj,
+    outputNumber: 1,
+    variables: args.variables,
+  };
+};
+export {
+  details,
+  plugin,
+};

FlowPluginsTs/CommunityFlowPlugins/file/replaceOriginalFile/1.0.0/index.ts

@@ -0,0 +1,93 @@
+import {
+  IpluginDetails,
+  IpluginInputArgs,
+  IpluginOutputArgs,
+} from '../../../../FlowHelpers/1.0.0/interfaces/interfaces';
+
+/* eslint no-plusplus: ["error", { "allowForLoopAfterthoughts": true }] */
+const details = ():IpluginDetails => ({
+  name: 'Replace Original File',
+  description: 'Replace the origial file',
+  style: {
+    borderColor: 'green',
+  },
+  tags: '',
+  isStartPlugin: false,
+  sidebarPosition: -1,
+  icon: 'faArrowRight',
+  inputs: [
+    {
+      name: 'target_codec',
+      type: 'string',
+      defaultValue: 'hevc',
+      inputUI: {
+        type: 'dropdown',
+        options: [
+          'hevc',
+          // 'vp9',
+          'h264',
+          // 'vp8',
+        ],
+      },
+      tooltip: 'Specify the codec to use',
+    },
+  ],
+  outputs: [
+    {
+      number: 1,
+      tooltip: 'Continue to next plugin',
+    },
+  ],
+});
+
+const getNewPath = (originalPath:string, tempPath:string) => {
+  const tempPathParts = tempPath.split('.');
+  const container = tempPathParts[tempPathParts.length - 1];
+
+  const originalPathParts = originalPath.split('.');
+
+  originalPathParts[originalPathParts.length - 1] = container;
+
+  return originalPathParts.join('.');
+};
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const plugin = async (args:IpluginInputArgs):Promise<IpluginOutputArgs> => {
+  const fs = require('fs');
+  const lib = require('../../../../../methods/lib')();
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars,no-param-reassign
+  args.inputs = lib.loadDefaultValues(args.inputs, details);
+
+  const currentPath = args.inputFileObj._id;
+  const newPath = getNewPath(args.originalLibraryFile._id, currentPath);
+  const newPathTmp = `${newPath}.tmp`;
+
+  args.jobLog(JSON.stringify({
+    currentPath,
+    newPath,
+    newPathTmp,
+  }));
+
+  await new Promise((resolve) => setTimeout(resolve, 2000));
+
+  fs.renameSync(currentPath, newPathTmp);
+
+  if (fs.existsSync(newPath)) {
+    fs.unlinkSync(newPath);
+  }
+
+  await new Promise((resolve) => setTimeout(resolve, 2000));
+  fs.renameSync(newPathTmp, newPath);
+
+  return {
+    outputFileObj: {
+      _id: newPath,
+    },
+    outputNumber: 1,
+    variables: args.variables,
+  };
+};
+export {
+  details,
+  plugin,
+};

FlowPluginsTs/CommunityFlowPlugins/input/inputFile/1.0.0/index.ts

@@ -0,0 +1,43 @@
+import {
+  IpluginDetails,
+  IpluginInputArgs,
+  IpluginOutputArgs,
+} from '../../../../FlowHelpers/1.0.0/interfaces/interfaces';
+
+/* eslint no-plusplus: ["error", { "allowForLoopAfterthoughts": true }] */
+const details = ():IpluginDetails => ({
+  name: 'Input File',
+  description: 'Transcode a video file using ffmpeg. GPU transcoding will be used if possible.',
+  style: {
+    borderColor: 'pink',
+  },
+  tags: '',
+
+  isStartPlugin: true,
+  sidebarPosition: -1,
+  icon: '',
+  inputs: [],
+  outputs: [
+    {
+      number: 1,
+      tooltip: 'Continue to next plugin',
+    },
+  ],
+});
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const plugin = (args:IpluginInputArgs):IpluginOutputArgs => {
+  const lib = require('../../../../../methods/lib')();
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars,no-param-reassign
+  args.inputs = lib.loadDefaultValues(args.inputs, details);
+
+  return {
+    outputFileObj: args.inputFileObj,
+    outputNumber: 1,
+    variables: args.variables,
+  };
+};
+export {
+  details,
+  plugin,
+};

FlowPluginsTs/CommunityFlowPlugins/tools/unpack/1.0.0/index.ts

@@ -0,0 +1,94 @@
+import {
+  IpluginDetails,
+  IpluginInputArgs,
+  IpluginOutputArgs,
+} from '../../../../FlowHelpers/1.0.0/interfaces/interfaces';
+
+/* eslint no-plusplus: ["error", { "allowForLoopAfterthoughts": true }] */
+const details = ():IpluginDetails => ({
+  name: 'Unpack File',
+  description: 'Unpack a file',
+  style: {
+    borderColor: 'green',
+    opacity: 0.5,
+  },
+  tags: '',
+  isStartPlugin: false,
+  sidebarPosition: -1,
+  icon: 'faArrowRight',
+  inputs: [
+    {
+      name: 'target_codec',
+      type: 'string',
+      defaultValue: 'hevc',
+      inputUI: {
+        type: 'dropdown',
+        options: [
+          'hevc',
+          // 'vp9',
+          'h264',
+          // 'vp8',
+        ],
+      },
+      tooltip: 'Specify the codec to use',
+    },
+  ],
+  outputs: [
+    {
+      number: 1,
+      tooltip: 'Continue to next plugin',
+    },
+  ],
+});
+
+const getNewPath = (originalPath:string, tempPath:string) => {
+  const tempPathParts = tempPath.split('.');
+  const container = tempPathParts[tempPathParts.length - 1];
+
+  const originalPathParts = originalPath.split('.');
+
+  originalPathParts[originalPathParts.length - 1] = container;
+
+  return originalPathParts.join('.');
+};
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const plugin = async (args:IpluginInputArgs):Promise<IpluginOutputArgs> => {
+  const fs = require('fs');
+  const lib = require('../../../../../methods/lib')();
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars,no-param-reassign
+  args.inputs = lib.loadDefaultValues(args.inputs, details);
+
+  const currentPath = args.inputFileObj._id;
+  const newPath = getNewPath(args.originalLibraryFile._id, currentPath);
+  const newPathTmp = `${newPath}.tmp`;
+
+  args.jobLog(JSON.stringify({
+    currentPath,
+    newPath,
+    newPathTmp,
+  }));
+
+  await new Promise((resolve) => setTimeout(resolve, 2000));
+
+  fs.renameSync(currentPath, newPathTmp);
+
+  if (fs.existsSync(newPath)) {
+    fs.unlinkSync(newPath);
+  }
+
+  await new Promise((resolve) => setTimeout(resolve, 2000));
+  fs.renameSync(newPathTmp, newPath);
+
+  return {
+    outputFileObj: {
+      _id: newPath,
+    },
+    outputNumber: 1,
+    variables: args.variables,
+  };
+};
+export {
+  details,
+  plugin,
+};

FlowPluginsTs/CommunityFlowPlugins/tools/webRequest/1.0.0/index.ts

@@ -0,0 +1,94 @@
+import {
+  IpluginDetails,
+  IpluginInputArgs,
+  IpluginOutputArgs,
+} from '../../../../FlowHelpers/1.0.0/interfaces/interfaces';
+
+/* eslint no-plusplus: ["error", { "allowForLoopAfterthoughts": true }] */
+const details = ():IpluginDetails => ({
+  name: 'Send Web Request',
+  description: 'Send Web Request',
+  style: {
+    borderColor: 'green',
+    opacity: 0.5,
+  },
+  tags: '',
+  isStartPlugin: false,
+  sidebarPosition: -1,
+  icon: 'faArrowRight',
+  inputs: [
+    {
+      name: 'target_codec',
+      type: 'string',
+      defaultValue: 'hevc',
+      inputUI: {
+        type: 'dropdown',
+        options: [
+          'hevc',
+          // 'vp9',
+          'h264',
+          // 'vp8',
+        ],
+      },
+      tooltip: 'Specify the codec to use',
+    },
+  ],
+  outputs: [
+    {
+      number: 1,
+      tooltip: 'Continue to next plugin',
+    },
+  ],
+});
+
+const getNewPath = (originalPath:string, tempPath:string) => {
+  const tempPathParts = tempPath.split('.');
+  const container = tempPathParts[tempPathParts.length - 1];
+
+  const originalPathParts = originalPath.split('.');
+
+  originalPathParts[originalPathParts.length - 1] = container;
+
+  return originalPathParts.join('.');
+};
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const plugin = async (args:IpluginInputArgs):Promise<IpluginOutputArgs> => {
+  const fs = require('fs');
+  const lib = require('../../../../../methods/lib')();
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars,no-param-reassign
+  args.inputs = lib.loadDefaultValues(args.inputs, details);
+
+  const currentPath = args.inputFileObj._id;
+  const newPath = getNewPath(args.originalLibraryFile._id, currentPath);
+  const newPathTmp = `${newPath}.tmp`;
+
+  args.jobLog(JSON.stringify({
+    currentPath,
+    newPath,
+    newPathTmp,
+  }));
+
+  await new Promise((resolve) => setTimeout(resolve, 2000));
+
+  fs.renameSync(currentPath, newPathTmp);
+
+  if (fs.existsSync(newPath)) {
+    fs.unlinkSync(newPath);
+  }
+
+  await new Promise((resolve) => setTimeout(resolve, 2000));
+  fs.renameSync(newPathTmp, newPath);
+
+  return {
+    outputFileObj: {
+      _id: newPath,
+    },
+    outputNumber: 1,
+    variables: args.variables,
+  };
+};
+export {
+  details,
+  plugin,
+};

FlowPluginsTs/CommunityFlowPlugins/video/checkVideoCodec/1.0.0/index.ts

@@ -0,0 +1,71 @@
+import {
+  IpluginDetails,
+  IpluginInputArgs,
+  IpluginOutputArgs,
+} from '../../../../FlowHelpers/1.0.0/interfaces/interfaces';
+
+/* eslint no-plusplus: ["error", { "allowForLoopAfterthoughts": true }] */
+const details = ():IpluginDetails => ({
+  name: 'Check Video Codec',
+  description: 'Check if a file has a specific video codec',
+  style: {
+    borderColor: 'orange',
+  },
+  tags: 'video',
+  isStartPlugin: false,
+  sidebarPosition: -1,
+  icon: 'faQuestion',
+  inputs: [
+    {
+      name: 'codec',
+      type: 'string',
+      defaultValue: 'hevc',
+      inputUI: {
+        type: 'dropdown',
+        options: [
+          'hevc',
+          'vp9',
+          'h264',
+          'vp8',
+        ],
+      },
+      tooltip: 'Specify the codec check for',
+    },
+  ],
+  outputs: [
+    {
+      number: 1,
+      tooltip: 'File has codec',
+    },
+    {
+      number: 2,
+      tooltip: 'File does not have codec',
+    },
+  ],
+});
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const plugin = (args:IpluginInputArgs):IpluginOutputArgs => {
+  const lib = require('../../../../../methods/lib')();
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars,no-param-reassign
+  args.inputs = lib.loadDefaultValues(args.inputs, details);
+
+  let hasCodec = false;
+
+  // @ts-expect-error type
+  args.inputFileObj.ffProbeData.streams.forEach((stream) => {
+    if (stream.codec_type === 'video' && stream.codec_name === args.inputs.codec) {
+      hasCodec = true;
+    }
+  });
+
+  return {
+    outputFileObj: args.inputFileObj,
+    outputNumber: hasCodec ? 1 : 2,
+    variables: args.variables,
+  };
+};
+export {
+  details,
+  plugin,
+};

FlowPluginsTs/CommunityFlowPlugins/video/checkVideoResolution/1.0.0/index.ts

@@ -0,0 +1,75 @@
+import {
+  IpluginDetails,
+  IpluginInputArgs,
+  IpluginOutputArgs,
+} from '../../../../FlowHelpers/1.0.0/interfaces/interfaces';
+
+/* eslint no-plusplus: ["error", { "allowForLoopAfterthoughts": true }] */
+const details = ():IpluginDetails => ({
+  name: 'Check Video Resolution',
+  description: 'Check is video is 480p,576p,720p,1080p,1440p,4KUHD,DCI4K,8KUHD,Other',
+  style: {
+    borderColor: 'orange',
+  },
+  tags: 'video',
+
+  isStartPlugin: false,
+  sidebarPosition: -1,
+  icon: 'faQuestion',
+  inputs: [],
+  outputs: [
+    {
+      number: 1,
+      tooltip: 'File is 480p',
+    },
+    {
+      number: 2,
+      tooltip: 'File is 576p',
+    },
+    {
+      number: 3,
+      tooltip: 'File is 720p',
+    },
+    {
+      number: 4,
+      tooltip: 'File is 1080p',
+    },
+    {
+      number: 5,
+      tooltip: 'File is 1440p',
+    },
+    {
+      number: 6,
+      tooltip: 'File is 4KUHD',
+    },
+    {
+      number: 7,
+      tooltip: 'File is DCI4K',
+    },
+    {
+      number: 8,
+      tooltip: 'File is 8KUHD',
+    },
+    {
+      number: 9,
+      tooltip: 'File is Other',
+    },
+  ],
+});
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const plugin = (args:IpluginInputArgs):IpluginOutputArgs => {
+  const lib = require('../../../../../methods/lib')();
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars,no-param-reassign
+  args.inputs = lib.loadDefaultValues(args.inputs, details);
+
+  return {
+    outputFileObj: args.inputFileObj,
+    outputNumber: 1,
+    variables: args.variables,
+  };
+};
+export {
+  details,
+  plugin,
+};

FlowPluginsTs/CommunityFlowPlugins/video/transcodeVideo/1.0.0/index.ts

@@ -0,0 +1,72 @@
+import {
+  IpluginDetails,
+  IpluginInputArgs,
+  IpluginOutputArgs,
+} from '../../../../FlowHelpers/1.0.0/interfaces/interfaces';
+
+/* eslint no-plusplus: ["error", { "allowForLoopAfterthoughts": true }] */
+const details = ():IpluginDetails => ({
+  name: 'Transcode Video File',
+  description: 'Transcode a video file using ffmpeg. GPU transcoding will be used if possible.',
+  style: {
+    borderColor: '#6efefc',
+    opacity: 0.5,
+  },
+  tags: '',
+
+  isStartPlugin: false,
+  sidebarPosition: -1,
+  icon: '',
+  inputs: [
+    {
+      name: 'target_codec',
+      type: 'string',
+      defaultValue: 'hevc',
+      inputUI: {
+        type: 'dropdown',
+        options: [
+          'hevc',
+          // 'vp9',
+          'h264',
+          // 'vp8',
+        ],
+      },
+      tooltip: 'Specify the codec to use',
+    },
+  ],
+  outputs: [
+    {
+      number: 1,
+      tooltip: 'Continue to next plugin',
+    },
+  ],
+});
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const plugin = (args:IpluginInputArgs):IpluginOutputArgs => {
+  const lib = require('../../../../../methods/lib')();
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars,no-param-reassign
+  args.inputs = lib.loadDefaultValues(args.inputs, details);
+
+  const fs = require('fs');
+
+  const oldFile = args.inputFileObj._id;
+  const newFile = `${args.inputFileObj._id}.tmp`;
+
+  if (fs.existsSync(newFile)) {
+    fs.unlinkSync(newFile);
+  }
+
+  fs.copyFileSync(oldFile, newFile);
+
+  return {
+    outputFileObj: { _id: newFile },
+    outputNumber: 1,
+    variables: args.variables,
+  };
+};
+
+export {
+  details,
+  plugin,
+};