@lagandevs/cvt 0.1.0

package/README.md

@@ -0,0 +1,56 @@
+# cvt
+
+`cvt` converts image files and images copied to the clipboard on macOS, Windows, and Linux. It can make a GIF from one image or combine several images into an animation.
+
+## Run without installing
+
+```sh
+npx @lagandevs/cvt
+```
+
+`npx` downloads the package into its cache and opens the interactive interface. It does not add `cvt` globally. To run a one-line conversion through `npx`, put the CLI arguments after the package name:
+
+```sh
+npx @lagandevs/cvt photo.png -o photo.gif
+```
+
+Run `cvt` with no arguments to open the interactive terminal interface. Use the keyboard or mouse to choose a source and format, enter an output path, then convert without leaving the interface. You can drag a file from Finder into the Files field.
+
+After each conversion, `cvt` puts the converted file on the desktop clipboard. Paste it into Finder, Explorer, your Linux file manager, or another app. Pass `--no-copy` when using the one-line command if you only want the file saved to disk.
+
+## Examples
+
+```sh
+# Image to GIF
+cvt photo.png -o photo.gif
+
+# Several images to an animated GIF
+cvt frame-1.png frame-2.png frame-3.png -o animation.gif --delay 12
+
+# Copy an image, then read it straight from the clipboard
+cvt --paste -o copied-image.gif
+
+# PNG, JPEG, WebP, HEIC, TIFF, and BMP conversions
+cvt photo.heic -o photo.jpg --quality 88
+cvt photo.png -o photo.webp --resize '1200x1200>'
+```
+
+Run `cvt --help` for every option. If you omit the input file, `cvt` reads the clipboard automatically. If you omit the output, it creates a GIF beside the source file, or `clipboard.gif` in the current directory.
+
+## Development
+
+```sh
+pnpm install
+pnpm check
+pnpm build
+pnpm install --global .
+```
+
+## Requirements
+
+- Node.js 20 or newer
+- Linux clipboard access: `wl-clipboard` on Wayland or `xclip` on X11
+
+`cvt` includes [ImageMagick](https://imagemagick.org/) through the `@imagemagick/magick-wasm` WebAssembly build. Users do not need to install ImageMagick. If a system ImageMagick binary exists, `cvt` can use it as a fallback for HEIC encoding, which the smaller WebAssembly build omits.
+
+Use Windows Terminal, iTerm2, Terminal.app, or a modern Linux terminal for mouse support in the interactive interface.

package/dist/cli.js

@@ -0,0 +1,331 @@
+#!/usr/bin/env node
+import { Command, Option } from "commander";
+import { execFile, spawn } from "node:child_process";
+import { mkdtemp, rm, stat, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { extname, join, resolve } from "node:path";
+import { promisify } from "node:util";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { runTui } from "./tui.js";
+import { convertWithBuiltInImageMagick } from "./image-engine.js";
+const execFileAsync = promisify(execFile);
+const formats = ["gif", "png", "jpg", "jpeg", "webp", "heic", "tiff", "bmp"];
+function fail(message) {
+    process.stderr.write(`cvt: ${message}\n`);
+    process.exit(1);
+}
+async function commandExists(command) {
+    try {
+        await execFileAsync(process.platform === "win32" ? "where.exe" : "/usr/bin/which", [command]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function capture(command, args, input) {
+    return new Promise((done, reject) => {
+        const child = spawn(command, args, { stdio: ["pipe", "pipe", "pipe"] });
+        const stdout = [];
+        const stderr = [];
+        child.stdout.on("data", (chunk) => stdout.push(chunk));
+        child.stderr.on("data", (chunk) => stderr.push(chunk));
+        child.once("error", reject);
+        child.once("exit", (code) => code === 0
+            ? done(Buffer.concat(stdout))
+            : reject(new Error(Buffer.concat(stderr).toString().trim() || `${command} exited with code ${code}`)));
+        child.stdin.end(input);
+    });
+}
+function lastErrorLine(error, fallback) {
+    if (!(error instanceof Error))
+        return String(error) || fallback;
+    return error.message.split("\n").map((line) => line.trim()).filter(Boolean).at(-1) ?? fallback;
+}
+async function readClipboardImage(destination) {
+    if (process.platform === "win32")
+        return readWindowsClipboard(destination);
+    if (process.platform === "linux")
+        return readLinuxClipboard(destination);
+    try {
+        const { stdout } = await execFileAsync("/usr/bin/osascript", [
+            "-l", "JavaScript", "-e",
+            'ObjC.import("AppKit"); ObjC.unwrap($.NSPasteboard.generalPasteboard.stringForType("public.file-url"))',
+        ]);
+        const clipboardFile = fileURLToPath(stdout.trim());
+        if (clipboardFile && (await stat(clipboardFile)).isFile())
+            return clipboardFile;
+    }
+    catch {
+        // The clipboard may contain image pixels instead of a file reference.
+    }
+    const script = `
+    on run argv
+      try
+        set imageData to the clipboard as «class PNGf»
+      on error
+        try
+          set imageData to the clipboard as TIFF picture
+        on error
+          error "The clipboard does not contain an image or image file. Copy one, then try again."
+        end try
+      end try
+      set outputFile to open for access POSIX file (item 1 of argv) with write permission
+      try
+        set eof outputFile to 0
+        write imageData to outputFile
+      on error errorMessage
+        close access outputFile
+        error errorMessage
+      end try
+      close access outputFile
+    end run
+  `;
+    try {
+        await execFileAsync("/usr/bin/osascript", ["-e", script, destination]);
+        return destination;
+    }
+    catch (error) {
+        fail(lastErrorLine(error, "could not read an image from the clipboard"));
+    }
+}
+async function readWindowsClipboard(destination) {
+    const script = `
+    Add-Type -AssemblyName System.Windows.Forms
+    Add-Type -AssemblyName System.Drawing
+    $files = [System.Windows.Forms.Clipboard]::GetFileDropList()
+    if ($files.Count -gt 0) { Write-Output $files[0]; exit 0 }
+    if ([System.Windows.Forms.Clipboard]::ContainsImage()) {
+      $image = [System.Windows.Forms.Clipboard]::GetImage()
+      $image.Save($env:CVT_CLIPBOARD_DEST, [System.Drawing.Imaging.ImageFormat]::Png)
+      Write-Output $env:CVT_CLIPBOARD_DEST
+      exit 0
+    }
+    Write-Error "The clipboard does not contain an image or image file."
+    exit 2
+  `;
+    try {
+        const { stdout } = await execFileAsync("powershell.exe", ["-NoProfile", "-STA", "-Command", script], {
+            env: { ...process.env, CVT_CLIPBOARD_DEST: destination },
+        });
+        return stdout.trim();
+    }
+    catch (error) {
+        fail(lastErrorLine(error, "could not read an image from the Windows clipboard"));
+    }
+}
+async function readLinuxClipboard(destination) {
+    const wayland = await commandExists("wl-paste");
+    const x11 = await commandExists("xclip");
+    if (!wayland && !x11)
+        fail("clipboard support needs wl-clipboard on Wayland or xclip on X11");
+    try {
+        const listArgs = wayland ? ["--list-types"] : ["-selection", "clipboard", "-t", "TARGETS", "-o"];
+        const types = (await capture(wayland ? "wl-paste" : "xclip", listArgs)).toString();
+        if (types.includes("text/uri-list")) {
+            const uriArgs = wayland
+                ? ["--no-newline", "--type", "text/uri-list"]
+                : ["-selection", "clipboard", "-t", "text/uri-list", "-o"];
+            const uriList = (await capture(wayland ? "wl-paste" : "xclip", uriArgs)).toString();
+            const first = uriList.split(/\r?\n/).find((line) => line.startsWith("file://"));
+            if (first)
+                return fileURLToPath(first.trim());
+        }
+        const mime = ["image/png", "image/jpeg", "image/webp", "image/tiff", "image/bmp"]
+            .find((candidate) => types.includes(candidate));
+        if (!mime)
+            fail("the clipboard does not contain an image or image file");
+        const imageArgs = wayland
+            ? ["--type", mime]
+            : ["-selection", "clipboard", "-t", mime, "-o"];
+        await writeFile(destination, await capture(wayland ? "wl-paste" : "xclip", imageArgs));
+        return destination;
+    }
+    catch (error) {
+        fail(lastErrorLine(error, "could not read an image from the Linux clipboard"));
+    }
+}
+async function copyFileToClipboard(file) {
+    if (process.platform === "win32") {
+        const script = `
+      Add-Type -AssemblyName System.Windows.Forms
+      $files = New-Object System.Collections.Specialized.StringCollection
+      [void]$files.Add($env:CVT_CLIPBOARD_FILE)
+      [System.Windows.Forms.Clipboard]::SetFileDropList($files)
+    `;
+        try {
+            await execFileAsync("powershell.exe", ["-NoProfile", "-STA", "-Command", script], {
+                env: { ...process.env, CVT_CLIPBOARD_FILE: file },
+            });
+            return;
+        }
+        catch (error) {
+            fail(lastErrorLine(error, "could not copy the converted file to the Windows clipboard"));
+        }
+    }
+    if (process.platform === "linux") {
+        const uri = `${pathToFileURL(file).href}\n`;
+        try {
+            if (await commandExists("wl-copy"))
+                await capture("wl-copy", ["--type", "text/uri-list"], uri);
+            else if (await commandExists("xclip"))
+                await capture("xclip", ["-selection", "clipboard", "-t", "text/uri-list", "-i"], uri);
+            else
+                fail("clipboard support needs wl-clipboard on Wayland or xclip on X11");
+            return;
+        }
+        catch (error) {
+            fail(lastErrorLine(error, "could not copy the converted file to the Linux clipboard"));
+        }
+    }
+    const script = `
+    on run argv
+      set the clipboard to POSIX file (item 1 of argv)
+    end run
+  `;
+    try {
+        await execFileAsync("/usr/bin/osascript", ["-e", script, file]);
+    }
+    catch (error) {
+        fail(lastErrorLine(error, "could not copy the converted file to the clipboard"));
+    }
+}
+function inferredOutput(input, format) {
+    if (!input)
+        return resolve(`clipboard.${format === "jpeg" ? "jpg" : format}`);
+    const extension = extname(input);
+    const stem = extension ? input.slice(0, -extension.length) : input;
+    return resolve(`${stem}.${format === "jpeg" ? "jpg" : format}`);
+}
+function parsePositiveInteger(value, label, allowZero = false) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < (allowZero ? 0 : 1))
+        fail(`${label} must be ${allowZero ? "zero or " : ""}a positive integer`);
+    return parsed;
+}
+async function runMagick(args) {
+    await new Promise((resolvePromise, reject) => {
+        const child = spawn("magick", args, { stdio: "inherit" });
+        child.once("error", reject);
+        child.once("exit", (code, signal) => {
+            if (code === 0)
+                resolvePromise();
+            else
+                reject(new Error(signal ? `ImageMagick stopped by ${signal}` : `ImageMagick exited with code ${code}`));
+        });
+    });
+}
+async function convertImages(inputs, options) {
+    if (options.paste && inputs.length)
+        fail("use either file inputs or --paste, not both");
+    const useClipboard = options.paste || inputs.length === 0;
+    let tempDirectory;
+    let sourceInputs = inputs.map((input) => resolve(input));
+    try {
+        if (useClipboard) {
+            tempDirectory = await mkdtemp(join(tmpdir(), "cvt-"));
+            const clipboardPath = join(tempDirectory, "clipboard-image");
+            sourceInputs = [await readClipboardImage(clipboardPath)];
+        }
+        for (const input of sourceInputs) {
+            try {
+                if (!(await stat(input)).isFile())
+                    fail(`not a file: ${input}`);
+            }
+            catch {
+                fail(`file not found: ${input}`);
+            }
+        }
+        const requestedFormat = options.format ?? (options.output ? extname(options.output).slice(1).toLowerCase() : "gif");
+        if (!formats.includes(requestedFormat))
+            fail(`unsupported output format: ${requestedFormat || "none"}`);
+        const format = requestedFormat;
+        const output = resolve(options.output ?? inferredOutput(useClipboard ? undefined : inputs[0], format));
+        if (!options.overwrite) {
+            try {
+                await stat(output);
+                fail(`output already exists: ${output} (pass --overwrite to replace it)`);
+            }
+            catch (error) {
+                if (error instanceof Error && error.message.startsWith("cvt:"))
+                    throw error;
+            }
+        }
+        try {
+            await convertWithBuiltInImageMagick({
+                inputs: sourceInputs,
+                output,
+                format,
+                delay: parsePositiveInteger(options.delay, "delay"),
+                loop: parsePositiveInteger(options.loop, "loop", true),
+                resize: options.resize,
+                quality: options.quality ? parsePositiveInteger(options.quality, "quality") : undefined,
+            });
+        }
+        catch (error) {
+            if (await commandExists("magick")) {
+                const args = [...sourceInputs];
+                if (options.resize)
+                    args.push("-resize", options.resize);
+                if (options.quality)
+                    args.push("-quality", options.quality);
+                if (format === "gif")
+                    args.push("-delay", options.delay, "-loop", options.loop, "-layers", "Optimize");
+                args.push(`${format}:${output}`);
+                try {
+                    await runMagick(args);
+                }
+                catch {
+                    fail(error instanceof Error ? error.message : String(error));
+                }
+            }
+            else {
+                fail(error instanceof Error ? error.message : String(error));
+            }
+        }
+        if (options.copy !== false) {
+            await copyFileToClipboard(output);
+            process.stdout.write(`Created ${output} and copied it to the clipboard\n`);
+        }
+        else {
+            process.stdout.write(`Created ${output}\n`);
+        }
+    }
+    finally {
+        if (tempDirectory)
+            await rm(tempDirectory, { recursive: true, force: true });
+    }
+}
+const program = new Command()
+    .name("cvt")
+    .description("Convert images from files or the desktop clipboard")
+    .version("0.1.0")
+    .showHelpAfterError();
+program
+    .command("image", { isDefault: true })
+    .description("Convert one image, or combine several images into an animated GIF")
+    .argument("[inputs...]", "input image files in frame order")
+    .option("-p, --paste", "read an image directly from the desktop clipboard")
+    .option("-o, --output <file>", "output path")
+    .addOption(new Option("-f, --format <format>", "output format when no extension is given").choices([...formats]))
+    .option("--delay <centiseconds>", "GIF frame delay in hundredths of a second", "10")
+    .option("--loop <count>", "GIF loop count; 0 loops forever", "0")
+    .option("-r, --resize <geometry>", "resize, such as 800x600 or 50%")
+    .option("-q, --quality <number>", "output quality")
+    .option("-y, --overwrite", "replace an existing output file")
+    .option("--no-copy", "do not copy the converted file to the clipboard")
+    .addHelpText("after", `
+Examples:
+  cvt photo.png -o photo.gif
+  cvt frame-1.png frame-2.png -o animation.gif --delay 15
+  cvt --paste -o clipboard.gif
+  cvt photo.heic -o photo.jpg -q 88
+  cvt photo.png -f webp -r 1200x1200\>
+`)
+    .action(convertImages);
+if (process.argv.length === 2) {
+    runTui().catch((error) => fail(error instanceof Error ? error.message : String(error)));
+}
+else {
+    program.parseAsync().catch((error) => fail(error instanceof Error ? error.message : String(error)));
+}

package/dist/image-engine.js

@@ -0,0 +1,50 @@
+import { MagickFormat, MagickGeometry, MagickImageCollection, initializeImageMagick, } from "@imagemagick/magick-wasm";
+import { readFile, writeFile } from "node:fs/promises";
+let initialization;
+function initialize() {
+    if (!initialization) {
+        initialization = readFile(new URL(import.meta.resolve("@imagemagick/magick-wasm/magick.wasm")))
+            .then((wasm) => initializeImageMagick(wasm));
+    }
+    return initialization;
+}
+const outputFormats = {
+    gif: MagickFormat.Gif,
+    png: MagickFormat.Png,
+    jpg: MagickFormat.Jpeg,
+    jpeg: MagickFormat.Jpeg,
+    webp: MagickFormat.WebP,
+    heic: MagickFormat.Heic,
+    tiff: MagickFormat.Tiff,
+    bmp: MagickFormat.Bmp,
+};
+export async function convertWithBuiltInImageMagick(options) {
+    await initialize();
+    const images = MagickImageCollection.create();
+    try {
+        for (const input of options.inputs) {
+            const inputImages = MagickImageCollection.create(await readFile(input));
+            images.push(...inputImages.splice(0));
+            inputImages.dispose();
+        }
+        if (images.length === 0)
+            throw new Error("ImageMagick could not read the input image");
+        const geometry = options.resize ? new MagickGeometry(options.resize) : undefined;
+        for (const image of images) {
+            if (geometry)
+                image.resize(geometry);
+            if (options.quality)
+                image.quality = options.quality;
+            if (options.format === "gif") {
+                image.animationDelay = options.delay;
+                image.animationIterations = options.loop;
+            }
+        }
+        if (options.format === "gif" && images.length > 1)
+            images.optimize();
+        await images.write(outputFormats[options.format], (data) => writeFile(options.output, data));
+    }
+    finally {
+        images.dispose();
+    }
+}

package/dist/tui.js

@@ -0,0 +1,231 @@
+import { spawn } from "node:child_process";
+import { extname, resolve } from "node:path";
+import { emitKeypressEvents } from "node:readline";
+const ESC = "\u001b[";
+const formats = ["gif", "png", "jpg", "webp", "heic", "tiff", "bmp"];
+const fields = ["source", "files", "format", "output", "delay", "resize", "convert"];
+const hitRows = new Map();
+function stripDropEscapes(value) {
+    return value.trim().replace(/^['"]|['"]$/g, "").replace(/\\([ '\\()])/g, "$1");
+}
+function parseFiles(value) {
+    return value.split("|").map(stripDropEscapes).filter(Boolean);
+}
+function defaultOutput(state) {
+    if (state.source === "clipboard" || !state.files.trim())
+        return `clipboard.${state.format}`;
+    const first = parseFiles(state.files)[0] ?? "converted";
+    const extension = extname(first);
+    return `${extension ? first.slice(0, -extension.length) : first}.${state.format}`;
+}
+function pad(value, width) {
+    return value.length > width ? `${value.slice(0, Math.max(1, width - 1))}…` : value.padEnd(width);
+}
+function runConversion(state) {
+    const args = [process.argv[1], "image"];
+    if (state.source === "clipboard")
+        args.push("--paste");
+    else
+        args.push(...parseFiles(state.files));
+    args.push("--output", resolve(state.output || defaultOutput(state)), "--format", state.format, "--overwrite");
+    if (state.format === "gif")
+        args.push("--delay", state.delay || "10");
+    if (state.resize.trim())
+        args.push("--resize", state.resize.trim());
+    return new Promise((done) => {
+        const child = spawn(process.execPath, args, { stdio: ["ignore", "pipe", "pipe"] });
+        let output = "";
+        child.stdout.on("data", (data) => output += data.toString());
+        child.stderr.on("data", (data) => output += data.toString());
+        child.once("error", (error) => done({ ok: false, message: error.message }));
+        child.once("exit", (code) => done({
+            ok: code === 0,
+            message: output.trim().split("\n").at(-1) || `Conversion exited with code ${code}`,
+        }));
+    });
+}
+export async function runTui() {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        process.stderr.write("cvt: interactive mode needs a terminal. Run cvt --help for command options.\n");
+        process.exitCode = 1;
+        return;
+    }
+    const state = {
+        source: "clipboard",
+        files: "",
+        format: "gif",
+        output: "clipboard.gif",
+        delay: "10",
+        resize: "",
+        focus: 0,
+        status: "Ready",
+        error: "",
+        busy: false,
+    };
+    let previousDefault = defaultOutput(state);
+    let stopped = false;
+    const updateDefaultOutput = () => {
+        const next = defaultOutput(state);
+        if (!state.output || state.output === previousDefault)
+            state.output = next;
+        previousDefault = next;
+    };
+    const render = () => {
+        const width = Math.max(54, Math.min(process.stdout.columns || 80, 92));
+        const inner = width - 4;
+        const lines = [];
+        hitRows.clear();
+        const add = (content = "", field) => {
+            lines.push(`${ESC}2K  ${content}`);
+            if (field)
+                hitRows.set(lines.length, field);
+        };
+        const selected = (field) => fields[state.focus] === field;
+        const marker = (field) => selected(field) ? `${ESC}38;5;81m›${ESC}0m` : " ";
+        const input = (field, value, placeholder) => {
+            const shown = value || `${ESC}2m${placeholder}${ESC}22m`;
+            return `${marker(field)} ${field === "files" ? "Files " : field === "output" ? "Output" : field === "delay" ? "Delay " : "Resize"}  ${ESC}48;5;236m ${pad(shown, inner - 13)} ${ESC}0m`;
+        };
+        lines.push(`${ESC}2J${ESC}H`);
+        add(`${ESC}1;38;5;81mCVT${ESC}0m  ${ESC}2mimage converter${ESC}0m`);
+        add("─".repeat(inner));
+        add(`${marker("source")} Source  ${state.source === "clipboard" ? `${ESC}48;5;81;30m Clipboard ${ESC}0m  Files` : `Clipboard  ${ESC}48;5;81;30m Files ${ESC}0m`}`, "source");
+        add();
+        add(input("files", state.files, state.source === "clipboard" ? "not used while Clipboard is selected" : "type or drag a file here; use | between frames"), "files");
+        add();
+        add(`${marker("format")} Format  ${formats.map((format) => format === state.format ? `${ESC}48;5;81;30m ${format.toUpperCase()} ${ESC}0m` : ` ${format.toUpperCase()} `).join(" ")}`, "format");
+        add();
+        add(input("output", state.output, defaultOutput(state)), "output");
+        add();
+        add(input("delay", state.delay, "10, hundredths of a second"), "delay");
+        add(input("resize", state.resize, "optional, for example 800x600 or 50%"), "resize");
+        add();
+        add(`${marker("convert")} ${selected("convert") ? `${ESC}48;5;81;30m  Convert  ${ESC}0m` : `${ESC}48;5;238m  Convert  ${ESC}0m`}   ${state.busy ? `${ESC}38;5;220mConverting…${ESC}0m` : state.status}`, "convert");
+        if (state.error) {
+            add(`${ESC}1;38;5;203mConversion failed${ESC}0m`);
+            add(`${ESC}38;5;203m${pad(state.error, inner)}${ESC}0m`);
+        }
+        add();
+        add(`${ESC}2m↑↓/Tab move   ←→ choose   Enter select   mouse works   q quit${ESC}0m`);
+        add(`${ESC}2mThe converted file is copied automatically. Paste it into any app.${ESC}0m`);
+        process.stdout.write(lines.join("\n"));
+    };
+    const cleanup = () => {
+        if (stopped)
+            return;
+        stopped = true;
+        process.stdin.setRawMode(false);
+        process.stdin.pause();
+        process.stdout.write(`${ESC}?1000l${ESC}?1006l${ESC}?25h${ESC}?1049l`);
+    };
+    const convert = async () => {
+        if (state.busy)
+            return;
+        if (state.source === "files" && parseFiles(state.files).length === 0) {
+            state.status = "Add at least one file";
+            render();
+            return;
+        }
+        state.busy = true;
+        state.status = "Working";
+        state.error = "";
+        render();
+        const result = await runConversion(state);
+        state.busy = false;
+        state.status = result.ok ? `${ESC}38;5;82m${result.message}${ESC}0m` : "Error";
+        state.error = result.ok ? "" : result.message.replace(/^cvt:\s*/, "");
+        render();
+    };
+    const choose = (direction) => {
+        const field = fields[state.focus];
+        if (field === "source") {
+            state.source = state.source === "clipboard" ? "files" : "clipboard";
+            updateDefaultOutput();
+        }
+        else if (field === "format") {
+            const index = formats.indexOf(state.format);
+            state.format = formats[(index + direction + formats.length) % formats.length];
+            updateDefaultOutput();
+        }
+    };
+    const edit = (text) => {
+        const field = fields[state.focus];
+        if (field === "files" || field === "output" || field === "delay" || field === "resize") {
+            state[field] += text;
+            if (field === "files")
+                updateDefaultOutput();
+        }
+    };
+    emitKeypressEvents(process.stdin);
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdout.write(`${ESC}?1049h${ESC}?25l${ESC}?1000h${ESC}?1006h`);
+    render();
+    process.stdout.on("resize", render);
+    process.stdin.on("keypress", async (text, key) => {
+        if (stopped || state.busy)
+            return;
+        if (key.ctrl && key.name === "c" || key.name === "escape" || (text === "q" && !["files", "output", "delay", "resize"].includes(fields[state.focus]))) {
+            cleanup();
+            return;
+        }
+        if (key.name === "tab" || key.name === "down")
+            state.focus = (state.focus + 1) % fields.length;
+        else if (key.name === "up")
+            state.focus = (state.focus - 1 + fields.length) % fields.length;
+        else if (key.name === "left")
+            choose(-1);
+        else if (key.name === "right")
+            choose(1);
+        else if (key.name === "return") {
+            const field = fields[state.focus];
+            if (field === "convert")
+                await convert();
+            else if (field === "source" || field === "format")
+                choose(1);
+            else
+                state.focus = (state.focus + 1) % fields.length;
+        }
+        else if (key.name === "backspace") {
+            const field = fields[state.focus];
+            if (field === "files" || field === "output" || field === "delay" || field === "resize") {
+                state[field] = state[field].slice(0, -1);
+                if (field === "files")
+                    updateDefaultOutput();
+            }
+        }
+        else if (text && !key.ctrl && !key.meta && text >= " ")
+            edit(text);
+        render();
+    });
+    process.stdin.on("data", (data) => {
+        const match = data.toString().match(/\u001b\[<0;(\d+);(\d+)M/);
+        if (!match)
+            return;
+        const x = Number(match[1]);
+        const y = Number(match[2]);
+        const field = hitRows.get(y);
+        if (!field)
+            return;
+        state.focus = fields.indexOf(field);
+        if (field === "source")
+            choose(1);
+        if (field === "format") {
+            const start = 12;
+            const approximate = Math.max(0, Math.min(formats.length - 1, Math.floor((x - start) / 7)));
+            state.format = formats[approximate];
+            updateDefaultOutput();
+        }
+        if (field === "convert")
+            void convert();
+        render();
+    });
+    await new Promise((done) => {
+        const timer = setInterval(() => {
+            if (stopped) {
+                clearInterval(timer);
+                done();
+            }
+        }, 50);
+    });
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@lagandevs/cvt",
+  "version": "0.1.0",
+  "description": "Fast image conversion from files or the desktop clipboard",
+  "type": "module",
+  "bin": {
+    "cvt": "dist/cli.js",
+    "convert-file": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "scripts",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/LaganYT/convertCLI.git"
+  },
+  "bugs": {
+    "url": "https://github.com/LaganYT/convertCLI/issues"
+  },
+  "homepage": "https://github.com/LaganYT/convertCLI#readme",
+  "keywords": [
+    "cli",
+    "image",
+    "converter",
+    "gif",
+    "imagemagick"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@imagemagick/magick-wasm": "0.0.43",
+    "commander": "^14.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^24.13.3",
+    "typescript": "^5.9.2"
+  },
+  "scripts": {
+    "build": "tsc && node scripts/make-executable.mjs",
+    "dev": "pnpm build && node dist/cli.js",
+    "check": "tsc --noEmit",
+    "test": "pnpm build && node --test"
+  }
+}

package/scripts/make-executable.mjs

@@ -0,0 +1,5 @@
+import { chmod } from "node:fs/promises";
+
+if (process.platform !== "win32") {
+  await chmod(new URL("../dist/cli.js", import.meta.url), 0o755);
+}