@vargai/sdk 0.1.1 → 0.2.0

package/action/fade/index.ts

@@ -0,0 +1,116 @@
+#!/usr/bin/env bun
+
+/**
+ * fade action
+ * add fade in, fade out, or both to a video
+ */
+
+import { existsSync } from "node:fs";
+import { basename, dirname, extname, join } from "node:path";
+import type { ActionMeta } from "../../cli/types";
+import { fadeVideo } from "../../lib/ffmpeg";
+
+export const meta: ActionMeta = {
+  name: "fade",
+  type: "action",
+  description: "add fade in, fade out, or both to a video",
+  inputType: "video",
+  outputType: "video",
+  schema: {
+    input: {
+      type: "object",
+      required: ["video", "type"],
+      properties: {
+        video: {
+          type: "string",
+          format: "file-path",
+          description: "input video file",
+        },
+        type: {
+          type: "string",
+          enum: ["in", "out", "both"],
+          description: "fade direction: in, out, or both",
+        },
+        duration: {
+          type: "number",
+          default: 1,
+          description: "fade duration in seconds",
+        },
+        output: {
+          type: "string",
+          format: "file-path",
+          description: "output video path (auto-generated if not provided)",
+        },
+      },
+    },
+    output: { type: "string", format: "file-path", description: "video path" },
+  },
+  async run(options) {
+    const { video, type, duration, output } = options as {
+      video: string;
+      type: "in" | "out" | "both";
+      duration?: number;
+      output?: string;
+    };
+    return fade({ video, type, duration, output });
+  },
+};
+
+export interface FadeOptions {
+  video: string;
+  type: "in" | "out" | "both";
+  duration?: number;
+  output?: string;
+}
+
+export interface FadeResult {
+  output: string;
+  fadeType: string;
+  fadeDuration: number;
+}
+
+/**
+ * add fade effects to video
+ */
+export async function fade(options: FadeOptions): Promise<FadeResult> {
+  const { video, type, duration = 1, output } = options;
+
+  if (!video) {
+    throw new Error("video is required");
+  }
+  if (!type) {
+    throw new Error("type is required");
+  }
+  if (!existsSync(video)) {
+    throw new Error(`video file not found: ${video}`);
+  }
+
+  // Generate output path if not provided
+  const outputPath =
+    output ||
+    join(
+      dirname(video),
+      `${basename(video, extname(video))}_faded${extname(video)}`,
+    );
+
+  console.log(`[fade] applying fade ${type} (${duration}s)`);
+
+  await fadeVideo({
+    input: video,
+    output: outputPath,
+    type,
+    duration,
+  });
+
+  return {
+    output: outputPath,
+    fadeType: type,
+    fadeDuration: duration,
+  };
+}
+
+// cli
+if (import.meta.main) {
+  const { runCli } = await import("../../cli/runner");
+  runCli(meta);
+}

package/action/merge/index.ts

@@ -0,0 +1,177 @@
+#!/usr/bin/env bun
+
+/**
+ * merge action
+ * join multiple videos into one, optionally with transitions
+ */
+
+import { existsSync } from "node:fs";
+import type { ActionMeta } from "../../cli/types";
+import { concatWithFileList, xfadeVideos } from "../../lib/ffmpeg";
+
+export const meta: ActionMeta = {
+  name: "merge",
+  type: "action",
+  description: "join multiple videos into one with optional transitions",
+  inputType: "video",
+  outputType: "video",
+  schema: {
+    input: {
+      type: "object",
+      required: ["videos", "output"],
+      properties: {
+        videos: {
+          type: "string",
+          description: "comma-separated video paths to merge",
+        },
+        output: {
+          type: "string",
+          format: "file-path",
+          description: "output video path",
+        },
+        transition: {
+          type: "string",
+          enum: ["cut", "crossfade", "dissolve"],
+          default: "cut",
+          description: "transition type between clips",
+        },
+        duration: {
+          type: "number",
+          default: 1,
+          description: "transition duration in seconds",
+        },
+        fit: {
+          type: "string",
+          enum: ["pad", "crop", "blur", "stretch"],
+          default: "pad",
+          description:
+            "how to handle different resolutions: pad (black bars), crop (center), blur (TikTok style), stretch",
+        },
+      },
+    },
+    output: { type: "string", format: "file-path", description: "video path" },
+  },
+  async run(options) {
+    const { videos, output, transition, duration, fit } = options as {
+      videos: string;
+      output: string;
+      transition?: "cut" | "crossfade" | "dissolve";
+      duration?: number;
+      fit?: "pad" | "crop" | "blur" | "stretch";
+    };
+    return merge({ videos, output, transition, duration, fit });
+  },
+};
+
+export interface MergeOptions {
+  videos: string;
+  output: string;
+  transition?: "cut" | "crossfade" | "dissolve";
+  duration?: number;
+  fit?: "pad" | "crop" | "blur" | "stretch";
+}
+
+export interface MergeResult {
+  output: string;
+  inputCount: number;
+}
+
+/**
+ * merge multiple videos with optional transitions
+ */
+export async function merge(options: MergeOptions): Promise<MergeResult> {
+  const {
+    videos,
+    output,
+    transition = "cut",
+    duration = 1,
+    fit = "pad",
+  } = options;
+
+  if (!videos) {
+    throw new Error("videos are required");
+  }
+  if (!output) {
+    throw new Error("output is required");
+  }
+
+  // Parse video paths from comma-separated string
+  const videoPaths = videos.split(",").map((v) => v.trim());
+
+  if (videoPaths.length < 2) {
+    throw new Error("at least 2 videos are required");
+  }
+
+  // Validate all inputs exist
+  for (const video of videoPaths) {
+    if (!existsSync(video)) {
+      throw new Error(`video file not found: ${video}`);
+    }
+  }
+
+  console.log(
+    `[merge] joining ${videoPaths.length} videos with ${transition} transition`,
+  );
+
+  if (transition === "cut") {
+    // Simple concatenation without transitions
+    await concatWithFileList(videoPaths, output);
+  } else {
+    // Apply transitions between each pair of videos
+    const firstVideo = videoPaths[0] as string;
+    const secondVideo = videoPaths[1] as string;
+
+    if (videoPaths.length === 2) {
+      // Simple case: just two videos
+      await xfadeVideos({
+        input1: firstVideo,
+        input2: secondVideo,
+        output,
+        transition: transition as "crossfade" | "dissolve",
+        duration,
+        fit,
+      });
+    } else {
+      // Multiple videos: chain transitions
+      let currentInput: string = firstVideo;
+
+      for (let i = 1; i < videoPaths.length; i++) {
+        const nextVideo = videoPaths[i] as string;
+        const isLast = i === videoPaths.length - 1;
+        const tempOutput = isLast ? output : `/tmp/merge-temp-${i}.mp4`;
+
+        await xfadeVideos({
+          input1: currentInput,
+          input2: nextVideo,
+          output: tempOutput,
+          transition: transition as "crossfade" | "dissolve",
+          duration,
+          fit,
+        });
+
+        // Clean up previous temp file if not the original input
+        if (i > 1 && currentInput.startsWith("/tmp/merge-temp-")) {
+          try {
+            const { unlinkSync } = await import("node:fs");
+            unlinkSync(currentInput);
+          } catch {
+            // ignore cleanup errors
+          }
+        }
+
+        currentInput = tempOutput;
+      }
+    }
+  }
+
+  return {
+    output,
+    inputCount: videoPaths.length,
+  };
+}
+
+// cli
+if (import.meta.main) {
+  const { runCli } = await import("../../cli/runner");
+  runCli(meta);
+}

package/action/remove/index.ts

@@ -0,0 +1,184 @@
+#!/usr/bin/env bun
+
+/**
+ * remove action
+ * delete a segment from the middle of a video
+ */
+
+import { existsSync, unlinkSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, dirname, extname, join } from "node:path";
+import type { ActionMeta } from "../../cli/types";
+import {
+  concatWithFileList,
+  getVideoDuration,
+  trimVideo,
+} from "../../lib/ffmpeg";
+
+export const meta: ActionMeta = {
+  name: "remove",
+  type: "action",
+  description: "delete a segment from the middle of a video",
+  inputType: "video",
+  outputType: "video",
+  schema: {
+    input: {
+      type: "object",
+      required: ["video", "from", "to"],
+      properties: {
+        video: {
+          type: "string",
+          format: "file-path",
+          description: "input video file",
+        },
+        from: {
+          type: "number",
+          description: "start of segment to remove (seconds)",
+        },
+        to: {
+          type: "number",
+          description: "end of segment to remove (seconds)",
+        },
+        output: {
+          type: "string",
+          format: "file-path",
+          description: "output video path (auto-generated if not provided)",
+        },
+      },
+    },
+    output: { type: "string", format: "file-path", description: "video path" },
+  },
+  async run(options) {
+    const { video, from, to, output } = options as {
+      video: string;
+      from: number;
+      to: number;
+      output?: string;
+    };
+    return remove({ video, from, to, output });
+  },
+};
+
+export interface RemoveOptions {
+  video: string;
+  from: number;
+  to: number;
+  output?: string;
+}
+
+export interface RemoveResult {
+  output: string;
+  removedDuration: number;
+}
+
+/**
+ * remove a segment from video
+ */
+export async function remove(options: RemoveOptions): Promise<RemoveResult> {
+  const { video, from, to, output } = options;
+
+  if (!video) {
+    throw new Error("video is required");
+  }
+  if (from === undefined || to === undefined) {
+    throw new Error("from and to are required");
+  }
+  if (from >= to) {
+    throw new Error("from must be less than to");
+  }
+  if (!existsSync(video)) {
+    throw new Error(`video file not found: ${video}`);
+  }
+
+  const videoDuration = await getVideoDuration(video);
+
+  if (from < 0 || to > videoDuration) {
+    throw new Error(
+      `segment ${from}s-${to}s is outside video duration (0-${videoDuration}s)`,
+    );
+  }
+
+  const removedDuration = to - from;
+
+  // Generate output path if not provided
+  const outputPath =
+    output ||
+    join(
+      dirname(video),
+      `${basename(video, extname(video))}_edited${extname(video)}`,
+    );
+
+  console.log(
+    `[remove] removing segment ${from}s - ${to}s (${removedDuration}s)`,
+  );
+
+  // Create temp files for the two parts
+  const timestamp = Date.now();
+  const part1Path = join(tmpdir(), `remove-part1-${timestamp}.mp4`);
+  const part2Path = join(tmpdir(), `remove-part2-${timestamp}.mp4`);
+
+  const tempFiles: string[] = [];
+
+  try {
+    // Extract part before the removed segment (0 to from)
+    if (from > 0) {
+      console.log(`[remove] extracting part 1: 0s - ${from}s`);
+      await trimVideo({
+        input: video,
+        output: part1Path,
+        start: 0,
+        duration: from,
+      });
+      tempFiles.push(part1Path);
+    }
+
+    // Extract part after the removed segment (to to end)
+    if (to < videoDuration) {
+      console.log(`[remove] extracting part 2: ${to}s - ${videoDuration}s`);
+      await trimVideo({
+        input: video,
+        output: part2Path,
+        start: to,
+        duration: videoDuration - to,
+      });
+      tempFiles.push(part2Path);
+    }
+
+    // Concatenate the two parts
+    if (tempFiles.length === 0) {
+      throw new Error("cannot remove entire video");
+    }
+
+    if (tempFiles.length === 1) {
+      // Only one part, just copy/rename it
+      const { copyFileSync } = await import("node:fs");
+      copyFileSync(tempFiles[0] as string, outputPath);
+    } else {
+      // Concatenate both parts
+      console.log(`[remove] joining parts...`);
+      await concatWithFileList(tempFiles, outputPath);
+    }
+
+    console.log(`[remove] saved to ${outputPath}`);
+  } finally {
+    // Cleanup temp files
+    for (const tempFile of tempFiles) {
+      try {
+        unlinkSync(tempFile);
+      } catch {
+        // ignore cleanup errors
+      }
+    }
+  }
+
+  return {
+    output: outputPath,
+    removedDuration,
+  };
+}
+
+// cli
+if (import.meta.main) {
+  const { runCli } = await import("../../cli/runner");
+  runCli(meta);
+}

package/action/split/index.ts

@@ -0,0 +1,133 @@
+#!/usr/bin/env bun
+
+/**
+ * split action
+ * divide video into N equal-length parts
+ */
+
+import { existsSync } from "node:fs";
+import { basename, dirname, extname, join } from "node:path";
+import type { ActionMeta } from "../../cli/types";
+import { getVideoDuration, trimVideo } from "../../lib/ffmpeg";
+
+export const meta: ActionMeta = {
+  name: "split",
+  type: "action",
+  description: "divide video into N equal-length parts",
+  inputType: "video",
+  outputType: "video",
+  schema: {
+    input: {
+      type: "object",
+      required: ["video", "parts"],
+      properties: {
+        video: {
+          type: "string",
+          format: "file-path",
+          description: "input video file",
+        },
+        parts: {
+          type: "integer",
+          description: "number of equal parts to split into",
+        },
+        "output-prefix": {
+          type: "string",
+          description: "prefix for output files (default: input filename)",
+        },
+      },
+    },
+    output: {
+      type: "string",
+      format: "file-path",
+      description: "comma-separated list of output paths",
+    },
+  },
+  async run(options) {
+    const {
+      video,
+      parts,
+      "output-prefix": outputPrefix,
+    } = options as {
+      video: string;
+      parts: number;
+      "output-prefix"?: string;
+    };
+    return split({ video, parts, outputPrefix });
+  },
+};
+
+export interface SplitOptions {
+  video: string;
+  parts: number;
+  outputPrefix?: string;
+}
+
+export interface SplitResult {
+  outputs: string[];
+  count: number;
+  partDuration: number;
+}
+
+/**
+ * divide video into N equal parts
+ */
+export async function split(options: SplitOptions): Promise<SplitResult> {
+  const { video, parts, outputPrefix } = options;
+
+  if (!video) {
+    throw new Error("video is required");
+  }
+  if (!parts || parts < 2) {
+    throw new Error("parts must be at least 2");
+  }
+  if (!existsSync(video)) {
+    throw new Error(`video file not found: ${video}`);
+  }
+
+  // Get video duration
+  const videoDuration = await getVideoDuration(video);
+  const partDuration = videoDuration / parts;
+
+  // Generate output prefix if not provided
+  const prefix =
+    outputPrefix || join(dirname(video), basename(video, extname(video)));
+
+  console.log(
+    `[split] dividing ${videoDuration}s video into ${parts} parts of ${partDuration.toFixed(2)}s each`,
+  );
+
+  const outputs: string[] = [];
+
+  for (let i = 0; i < parts; i++) {
+    const start = i * partDuration;
+    const partNumber = String(i + 1).padStart(3, "0");
+    const outputPath = `${prefix}_part${partNumber}.mp4`;
+
+    console.log(
+      `[split] creating part ${i + 1}/${parts}: ${start.toFixed(2)}s - ${(start + partDuration).toFixed(2)}s`,
+    );
+
+    await trimVideo({
+      input: video,
+      output: outputPath,
+      start,
+      duration: partDuration,
+    });
+
+    outputs.push(outputPath);
+  }
+
+  console.log(`[split] created ${outputs.length} parts`);
+
+  return {
+    outputs,
+    count: outputs.length,
+    partDuration,
+  };
+}
+
+// cli
+if (import.meta.main) {
+  const { runCli } = await import("../../cli/runner");
+  runCli(meta);
+}