@spark-apps/piclet 1.0.0

package/dist/cli.js

@@ -0,0 +1,2989 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { extname as extname3 } from "path";
+import { dirname as dirname10, join as join9 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import chalk from "chalk";
+import { Command } from "commander";
+
+// src/lib/banner.ts
+import figlet from "figlet";
+import gradient from "gradient-string";
+var GRADIENT_COLORS = ["#22c55e", "#84cc16", "#eab308", "#fcd34d"];
+function renderLogo() {
+  const ascii = figlet.textSync("PicLet", {
+    font: "Slant",
+    horizontalLayout: "default"
+  });
+  return gradient(GRADIENT_COLORS)(ascii);
+}
+function showBanner(subtitle = "Image manipulation utility toolkit with Windows shell integration") {
+  try {
+    console.log(`
+${renderLogo()}`);
+    if (subtitle) {
+      const subtleGradient = gradient(["#a8a8a8", "#d4d4d4"]);
+      console.log(subtleGradient(`  ${subtitle}
+`));
+    }
+  } catch {
+    console.log("\n\x1B[1mPicLet\x1B[0m");
+    if (subtitle) {
+      console.log(`\x1B[2m  ${subtitle}\x1B[0m
+`);
+    }
+  }
+}
+
+// src/lib/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import { homedir } from "os";
+var DEFAULT_CONFIG = {
+  removeBg: {
+    fuzz: 10,
+    trim: true,
+    preserveInner: false,
+    makeSquare: false
+  },
+  rescale: {
+    defaultScale: 50,
+    makeSquare: false
+  },
+  iconpack: {
+    platforms: ["web", "android", "ios"]
+  }
+};
+function getConfigDir() {
+  return join(homedir(), ".config", "piclet");
+}
+function getConfigPath() {
+  return join(getConfigDir(), "config.json");
+}
+function loadConfig() {
+  const configPath = getConfigPath();
+  if (!existsSync(configPath)) {
+    return { ...DEFAULT_CONFIG };
+  }
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    const loaded = JSON.parse(content);
+    return {
+      removeBg: { ...DEFAULT_CONFIG.removeBg, ...loaded.removeBg },
+      rescale: { ...DEFAULT_CONFIG.rescale, ...loaded.rescale },
+      iconpack: { ...DEFAULT_CONFIG.iconpack, ...loaded.iconpack }
+    };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+function resetConfig() {
+  const configPath = getConfigPath();
+  const configDir = dirname(configPath);
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+  }
+  writeFileSync(configPath, JSON.stringify(DEFAULT_CONFIG, null, 2));
+}
+
+// src/lib/paths.ts
+import { basename, dirname as dirname2, extname, resolve } from "path";
+function windowsToWsl(winPath) {
+  if (winPath.startsWith("/mnt/")) {
+    return winPath;
+  }
+  const match = winPath.match(/^([A-Za-z]):[/\\](.*)$/);
+  if (match) {
+    const drive = match[1].toLowerCase();
+    const rest = match[2].replace(/\\/g, "/");
+    return `/mnt/${drive}/${rest}`;
+  }
+  return winPath;
+}
+function wslToWindows(wslPath) {
+  const match = wslPath.match(/^\/mnt\/([a-z])\/(.*)$/i);
+  if (match) {
+    const drive = match[1].toUpperCase();
+    const rest = match[2].replace(/\//g, "\\");
+    return `${drive}:\\${rest}`;
+  }
+  return wslPath;
+}
+function normalizePath(inputPath) {
+  if (/^[A-Za-z]:[/\\]/.test(inputPath)) {
+    return windowsToWsl(inputPath);
+  }
+  return resolve(inputPath);
+}
+function getFileInfo(filePath) {
+  const dir = dirname2(filePath);
+  const base = basename(filePath);
+  const ext = extname(filePath);
+  const name = base.slice(0, -ext.length);
+  return {
+    dirname: dir,
+    basename: base,
+    filename: name,
+    extension: ext
+  };
+}
+
+// src/lib/prompts.ts
+import prompts from "prompts";
+var useDefaults = false;
+var overrides = {};
+function setUseDefaults(value) {
+  useDefaults = value;
+}
+function setOverrides(values) {
+  Object.assign(overrides, values);
+}
+function clearOverrides() {
+  for (const key of Object.keys(overrides)) {
+    delete overrides[key];
+  }
+}
+function getOverride(message) {
+  const msgLower = message.toLowerCase();
+  for (const [key, value] of Object.entries(overrides)) {
+    if (msgLower.includes(key.toLowerCase())) {
+      return value;
+    }
+  }
+  return void 0;
+}
+async function number(message, defaultValue, min, max) {
+  const override = getOverride(message);
+  if (override !== void 0) return Number(override);
+  if (useDefaults) return defaultValue ?? 0;
+  const response = await prompts({
+    type: "number",
+    name: "value",
+    message,
+    initial: defaultValue,
+    min,
+    max
+  });
+  return response.value ?? defaultValue ?? 0;
+}
+async function confirm(message, defaultValue = true) {
+  const override = getOverride(message);
+  if (override !== void 0) return Boolean(override);
+  if (useDefaults) return defaultValue;
+  const response = await prompts({
+    type: "confirm",
+    name: "value",
+    message,
+    initial: defaultValue
+  });
+  return response.value ?? defaultValue;
+}
+async function select(message, options, defaultValue) {
+  if (useDefaults) return defaultValue ?? options[0]?.value ?? null;
+  const response = await prompts({
+    type: "select",
+    name: "value",
+    message,
+    choices: options.map((opt) => ({
+      title: opt.title,
+      value: opt.value,
+      description: opt.description
+    }))
+  });
+  return response.value ?? null;
+}
+async function multiSelect(message, options, defaultValues) {
+  if (useDefaults) return defaultValues ?? [];
+  const response = await prompts({
+    type: "multiselect",
+    name: "value",
+    message,
+    choices: options.map((opt) => ({
+      title: opt.title,
+      value: opt.value,
+      description: opt.description
+    })),
+    instructions: false,
+    hint: "- Space to select, Enter to confirm"
+  });
+  return response.value ?? [];
+}
+prompts.override({});
+async function pauseOnError(message = "Press Enter to close...") {
+  if (!useDefaults) return;
+  console.log();
+  await prompts({
+    type: "text",
+    name: "value",
+    message
+  });
+}
+
+// src/lib/registry.ts
+import { exec } from "child_process";
+import { dirname as dirname3 } from "path";
+import { fileURLToPath } from "url";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+function isWSL() {
+  return process.platform === "linux" && (process.env.WSL_DISTRO_NAME !== void 0 || process.env.WSLENV !== void 0);
+}
+async function addRegistryKey(keyPath, valueName, value, type = "REG_SZ") {
+  const valueArg = valueName ? `/v "${valueName}"` : "/ve";
+  const escapedValue = value.replace(/"/g, '\\"');
+  const cmd = `reg.exe add "${keyPath}" ${valueArg} /t ${type} /d "${escapedValue}" /f`;
+  try {
+    await execAsync(cmd);
+    return true;
+  } catch (error2) {
+    const message = error2.message;
+    const ignoredErrors = ["Exec format error", "not found"];
+    const shouldIgnore = ignoredErrors.some(
+      (e) => message.toLowerCase().includes(e.toLowerCase())
+    );
+    if (!shouldIgnore) {
+      console.error(`Failed to add registry key: ${keyPath}`);
+      console.error(message);
+    }
+    return false;
+  }
+}
+async function deleteRegistryKey(keyPath) {
+  const cmd = `reg.exe delete "${keyPath}" /f`;
+  try {
+    await execAsync(cmd);
+    return true;
+  } catch (error2) {
+    const message = error2.message;
+    const ignoredErrors = ["unable to find", "Exec format error", "not found"];
+    const shouldIgnore = ignoredErrors.some(
+      (e) => message.toLowerCase().includes(e.toLowerCase())
+    );
+    if (!shouldIgnore) {
+      console.error(`Failed to delete registry key: ${keyPath}`);
+    }
+    return false;
+  }
+}
+
+// src/tools/iconpack.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync4 } from "fs";
+import { basename as basename2, dirname as dirname7 } from "path";
+
+// src/lib/gui-server.ts
+import { spawn } from "child_process";
+import { createServer } from "http";
+import { dirname as dirname5, join as join3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import express from "express";
+
+// src/lib/presets.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname4, join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+var BUILT_IN_PRESETS = [
+  // ── Game Asset Stores ──
+  {
+    id: "unity-asset",
+    name: "Unity Asset Store",
+    description: "Unity Asset Store package images",
+    icons: [
+      { filename: "icon-160.png", width: 160, height: 160 },
+      { filename: "card-420x280.png", width: 420, height: 280 },
+      { filename: "cover-1200x630.png", width: 1200, height: 630 },
+      { filename: "screenshot-1920x1080.png", width: 1920, height: 1080 }
+    ]
+  },
+  {
+    id: "unreal-fab",
+    name: "Unreal / Fab",
+    description: "Unreal Marketplace & Fab assets",
+    icons: [
+      { filename: "icon-256.png", width: 256, height: 256 },
+      { filename: "thumbnail-284.png", width: 284, height: 284 },
+      { filename: "featured-894x488.png", width: 894, height: 488 },
+      { filename: "gallery-1920x1080.png", width: 1920, height: 1080 }
+    ]
+  },
+  {
+    id: "godot-asset",
+    name: "Godot Asset Library",
+    description: "Godot Asset Library images",
+    icons: [
+      { filename: "icon-64.png", width: 64, height: 64 },
+      { filename: "icon-128.png", width: 128, height: 128 },
+      { filename: "screenshot-1280x720.png", width: 1280, height: 720 },
+      { filename: "screenshot-1920x1080.png", width: 1920, height: 1080 }
+    ]
+  },
+  {
+    id: "blender-market",
+    name: "Blender Market",
+    description: "Blender Market product images",
+    icons: [
+      { filename: "icon-128.png", width: 128, height: 128 },
+      { filename: "thumbnail-256.png", width: 256, height: 256 },
+      { filename: "preview-1920x1080.png", width: 1920, height: 1080 }
+    ]
+  },
+  {
+    id: "steam",
+    name: "Steam",
+    description: "Steam store assets",
+    icons: [
+      { filename: "capsule-small-231x87.png", width: 231, height: 87 },
+      { filename: "capsule-main-616x353.png", width: 616, height: 353 },
+      { filename: "header-460x215.png", width: 460, height: 215 },
+      { filename: "hero-1920x620.png", width: 1920, height: 620 },
+      { filename: "library-capsule-600x900.png", width: 600, height: 900 },
+      { filename: "library-hero-3840x1240.png", width: 3840, height: 1240 }
+    ]
+  },
+  {
+    id: "itch-io",
+    name: "itch.io",
+    description: "itch.io game page assets",
+    icons: [
+      { filename: "cover-630x500.png", width: 630, height: 500 },
+      { filename: "thumbnail-315x250.png", width: 315, height: 250 },
+      { filename: "banner-960x540.png", width: 960, height: 540 }
+    ]
+  },
+  // ── Extensions & Packages ──
+  {
+    id: "chrome-extension",
+    name: "Chrome Extension",
+    description: "Chrome Web Store extension icons",
+    icons: [
+      { filename: "icon-16.png", width: 16, height: 16 },
+      { filename: "icon-32.png", width: 32, height: 32 },
+      { filename: "icon-48.png", width: 48, height: 48 },
+      { filename: "icon-128.png", width: 128, height: 128 },
+      { filename: "promo-440x280.png", width: 440, height: 280 },
+      { filename: "promo-1400x560.png", width: 1400, height: 560 }
+    ]
+  },
+  {
+    id: "firefox-addon",
+    name: "Firefox Add-on",
+    description: "Firefox Add-ons icons",
+    icons: [
+      { filename: "icon-48.png", width: 48, height: 48 },
+      { filename: "icon-96.png", width: 96, height: 96 },
+      { filename: "icon-128.png", width: 128, height: 128 }
+    ]
+  },
+  {
+    id: "vscode-extension",
+    name: "VS Code Extension",
+    description: "VS Code Marketplace icons",
+    icons: [
+      { filename: "icon-128.png", width: 128, height: 128 },
+      { filename: "icon-256.png", width: 256, height: 256 }
+    ]
+  },
+  {
+    id: "npm-package",
+    name: "npm Package",
+    description: "npm package icons",
+    icons: [
+      { filename: "logo-64.png", width: 64, height: 64 },
+      { filename: "logo-128.png", width: 128, height: 128 },
+      { filename: "logo-256.png", width: 256, height: 256 },
+      { filename: "banner-1200x600.png", width: 1200, height: 600 }
+    ]
+  },
+  {
+    id: "windows-store",
+    name: "Windows Store",
+    description: "Microsoft Store app icons",
+    icons: [
+      { filename: "Square44x44Logo.png", width: 44, height: 44 },
+      { filename: "Square150x150Logo.png", width: 150, height: 150 },
+      { filename: "Square310x310Logo.png", width: 310, height: 310 },
+      { filename: "Wide310x150Logo.png", width: 310, height: 150 },
+      { filename: "StoreLogo-50.png", width: 50, height: 50 },
+      { filename: "SplashScreen-620x300.png", width: 620, height: 300 }
+    ]
+  }
+];
+function getPresetsPath() {
+  const picletDir = join2(homedir2(), ".piclet");
+  return join2(picletDir, "presets.json");
+}
+function ensurePresetsDir() {
+  const presetsPath = getPresetsPath();
+  const dir = dirname4(presetsPath);
+  if (!existsSync2(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+}
+function loadPresets() {
+  const presetsPath = getPresetsPath();
+  let userPresets = [];
+  if (existsSync2(presetsPath)) {
+    try {
+      const data = readFileSync2(presetsPath, "utf-8");
+      const config7 = JSON.parse(data);
+      userPresets = config7.presets || [];
+    } catch {
+    }
+  }
+  const presetMap = /* @__PURE__ */ new Map();
+  for (const preset of BUILT_IN_PRESETS) {
+    presetMap.set(preset.id, preset);
+  }
+  for (const preset of userPresets) {
+    presetMap.set(preset.id, preset);
+  }
+  return Array.from(presetMap.values());
+}
+function savePresets(presets) {
+  ensurePresetsDir();
+  const config7 = {
+    version: 1,
+    presets
+  };
+  writeFileSync2(getPresetsPath(), JSON.stringify(config7, null, 2));
+}
+function savePreset(preset) {
+  const presetsPath = getPresetsPath();
+  let userPresets = [];
+  if (existsSync2(presetsPath)) {
+    try {
+      const data = readFileSync2(presetsPath, "utf-8");
+      const config7 = JSON.parse(data);
+      userPresets = config7.presets || [];
+    } catch {
+    }
+  }
+  const idx = userPresets.findIndex((p) => p.id === preset.id);
+  if (idx >= 0) {
+    userPresets[idx] = preset;
+  } else {
+    userPresets.push(preset);
+  }
+  savePresets(userPresets);
+}
+function deletePreset(id) {
+  if (BUILT_IN_PRESETS.some((p) => p.id === id)) {
+    return { success: false, error: "Cannot delete built-in presets" };
+  }
+  const presetsPath = getPresetsPath();
+  if (!existsSync2(presetsPath)) {
+    return { success: false, error: "Preset not found" };
+  }
+  try {
+    const data = readFileSync2(presetsPath, "utf-8");
+    const config7 = JSON.parse(data);
+    const userPresets = config7.presets || [];
+    const idx = userPresets.findIndex((p) => p.id === id);
+    if (idx < 0) {
+      return { success: false, error: "Preset not found" };
+    }
+    userPresets.splice(idx, 1);
+    savePresets(userPresets);
+    return { success: true };
+  } catch {
+    return { success: false, error: "Failed to delete preset" };
+  }
+}
+
+// src/lib/gui-server.ts
+var __dirname2 = dirname5(fileURLToPath2(import.meta.url));
+function signalReady() {
+  spawn("cmd.exe", ["/c", "echo.>", "%TEMP%\\piclet-ready.tmp"], {
+    stdio: "ignore",
+    windowsHide: true
+  });
+}
+function openAppWindow(url) {
+  spawn("cmd.exe", ["/c", "start", '""', "msedge", `--app=${url}`], {
+    detached: true,
+    stdio: "ignore",
+    windowsHide: true
+  }).unref();
+  setTimeout(signalReady, 500);
+}
+function startGuiServer(options) {
+  return new Promise((resolve2) => {
+    const app = express();
+    app.use(express.json({ limit: "50mb" }));
+    app.use((err, _req, res, next) => {
+      if (err instanceof SyntaxError && "body" in err) {
+        res.status(400).json({ success: false, error: "Invalid JSON: " + err.message });
+        return;
+      }
+      next(err);
+    });
+    let processResult = null;
+    let server = null;
+    const guiDir = join3(__dirname2, "gui");
+    const iconsDir = join3(__dirname2, "icons");
+    app.use(express.static(guiDir));
+    app.use("/icons", express.static(iconsDir));
+    app.get("/favicon.ico", (_req, res) => {
+      res.sendFile(join3(iconsDir, "banana.ico"));
+    });
+    app.get("/api/info", (_req, res) => {
+      res.json({
+        fileName: options.imageInfo.fileName,
+        width: options.imageInfo.width,
+        height: options.imageInfo.height,
+        borderColor: options.imageInfo.borderColor,
+        defaults: options.defaults
+      });
+    });
+    app.post("/api/preview", async (req, res) => {
+      if (!options.onPreview) {
+        res.json({ success: false, error: "Preview not supported" });
+        return;
+      }
+      try {
+        const result = await options.onPreview(req.body);
+        res.json(result);
+      } catch (err) {
+        res.json({
+          success: false,
+          error: err.message
+        });
+      }
+    });
+    app.post("/api/process", async (req, res) => {
+      try {
+        const result = await options.onProcess(req.body);
+        processResult = result.success;
+        res.json(result);
+      } catch (err) {
+        processResult = false;
+        res.json({
+          success: false,
+          error: err.message,
+          logs: [{ type: "error", message: err.message }]
+        });
+      }
+    });
+    app.post("/api/load", async (req, res) => {
+      if (!options.onLoadImage) {
+        res.json({ success: false, error: "Load not supported" });
+        return;
+      }
+      try {
+        const result = await options.onLoadImage(req.body);
+        if (result.success) {
+          options.imageInfo.filePath = result.filePath;
+          options.imageInfo.fileName = result.fileName;
+          options.imageInfo.width = result.width;
+          options.imageInfo.height = result.height;
+          options.imageInfo.borderColor = result.borderColor ?? null;
+        }
+        res.json(result);
+      } catch (err) {
+        res.json({ success: false, error: err.message });
+      }
+    });
+    app.post("/api/cancel", (_req, res) => {
+      processResult = false;
+      res.json({ ok: true });
+      shutdown();
+    });
+    app.post("/api/close", (_req, res) => {
+      res.json({ ok: true });
+      shutdown();
+    });
+    app.post("/api/save-preset", (req, res) => {
+      try {
+        const preset = req.body;
+        if (!preset.id || !preset.name || !preset.icons?.length) {
+          res.json({ success: false, error: "Invalid preset data" });
+          return;
+        }
+        savePreset(preset);
+        res.json({ success: true });
+      } catch (err) {
+        res.json({ success: false, error: err.message });
+      }
+    });
+    app.post("/api/delete-preset", (req, res) => {
+      try {
+        const { id } = req.body;
+        if (!id) {
+          res.json({ success: false, error: "Missing preset ID" });
+          return;
+        }
+        const result = deletePreset(id);
+        res.json(result);
+      } catch (err) {
+        res.json({ success: false, error: err.message });
+      }
+    });
+    function shutdown() {
+      setTimeout(() => {
+        server?.close();
+        resolve2(processResult ?? false);
+      }, 100);
+    }
+    server = createServer(app);
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      if (typeof addr === "object" && addr) {
+        const port = addr.port;
+        const url = `http://127.0.0.1:${port}/${options.htmlFile}`;
+        openAppWindow(url);
+        setTimeout(() => {
+          if (processResult === null) {
+            shutdown();
+          }
+        }, 5 * 60 * 1e3);
+      }
+    });
+    server.on("error", (err) => {
+      console.error("GUI server error:", err.message);
+      resolve2(false);
+    });
+  });
+}
+
+// src/lib/logger.ts
+var RED = "\x1B[31m";
+var GREEN = "\x1B[32m";
+var YELLOW = "\x1B[33m";
+var BLUE = "\x1B[34m";
+var CYAN = "\x1B[36m";
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+var RESET = "\x1B[0m";
+var CHECK = "\u2713";
+var CROSS = "\u2717";
+var ARROW = "\u2192";
+var BULLET = "\u2022";
+var SPINNER = "\u280B";
+function success(message) {
+  console.log(`${GREEN}${CHECK}${RESET} ${message}`);
+}
+function error(message) {
+  console.log(`${RED}${CROSS}${RESET} ${message}`);
+}
+function warn(message) {
+  console.log(`${YELLOW}${BULLET}${RESET} ${message}`);
+}
+function info(message) {
+  console.log(`${BLUE}${ARROW}${RESET} ${message}`);
+}
+function step(message) {
+  console.log(`${CYAN}${BULLET}${RESET} ${message}`);
+}
+function header(title) {
+  console.log("");
+  console.log(`${BOLD}${title}${RESET}`);
+  console.log(`${DIM}${"\u2500".repeat(40)}${RESET}`);
+}
+function separator() {
+  console.log(`${DIM}${"\u2500".repeat(40)}${RESET}`);
+}
+function wip(message) {
+  process.stdout.write(`${YELLOW}${SPINNER}${RESET} ${message}`);
+}
+function wipDone(isSuccess, message) {
+  process.stdout.write("\r\x1B[K");
+  if (isSuccess) {
+    success(message);
+  } else {
+    error(message);
+  }
+}
+function clearLine() {
+  process.stdout.write("\r\x1B[K");
+}
+
+// src/lib/magick.ts
+import { exec as exec2 } from "child_process";
+import { copyFileSync, existsSync as existsSync3, mkdirSync as mkdirSync3, unlinkSync } from "fs";
+import { dirname as dirname6 } from "path";
+import { promisify as promisify2 } from "util";
+var execAsync2 = promisify2(exec2);
+function getInputSelector(imagePath) {
+  const lowerPath = imagePath.toLowerCase();
+  if (lowerPath.endsWith(".ico")) {
+    return `"${imagePath}[0]"`;
+  }
+  return `"${imagePath}"`;
+}
+async function checkImageMagick() {
+  try {
+    await execAsync2("command -v convert");
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getDimensions(imagePath) {
+  try {
+    const input = getInputSelector(imagePath);
+    const { stdout } = await execAsync2(
+      `convert ${input} -ping -format "%w %h" info:`
+    );
+    const [w, h] = stdout.trim().split(" ").map(Number);
+    if (Number.isNaN(w) || Number.isNaN(h)) return null;
+    return [w, h];
+  } catch {
+    return null;
+  }
+}
+async function getBorderColor(imagePath) {
+  try {
+    const input = getInputSelector(imagePath);
+    const { stdout } = await execAsync2(
+      `convert ${input} -format "%[pixel:u.p{0,0}]" info:`
+    );
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}
+async function trim(inputPath, outputPath) {
+  try {
+    const input = getInputSelector(inputPath);
+    await execAsync2(`convert ${input} -trim +repage "${outputPath}"`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function squarify2(inputPath, outputPath) {
+  const dims = await getDimensions(inputPath);
+  if (!dims) return false;
+  const [width, height] = dims;
+  if (width === height) {
+    if (inputPath !== outputPath) {
+      copyFileSync(inputPath, outputPath);
+    }
+    return true;
+  }
+  const size = Math.max(width, height);
+  const input = getInputSelector(inputPath);
+  try {
+    await execAsync2(
+      `convert ${input} -background none -gravity center -extent ${size}x${size} "${outputPath}"`
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function scaleToSize(inputPath, outputPath, size) {
+  try {
+    await execAsync2(
+      `convert "${inputPath}" -resize ${size}x${size} -background none -gravity center -extent ${size}x${size} "${outputPath}"`
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function scaleWithPadding(inputPath, outputPath, width, height) {
+  try {
+    await execAsync2(
+      `convert "${inputPath}" -resize ${width}x${height} -background none -gravity center -extent ${width}x${height} "${outputPath}"`
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resize(inputPath, outputPath, width, height) {
+  try {
+    await execAsync2(
+      `convert "${inputPath}" -resize ${width}x${height}! "${outputPath}"`
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function scaleFillCrop(inputPath, outputPath, width, height) {
+  try {
+    await execAsync2(
+      `convert "${inputPath}" -resize ${width}x${height}^ -background none -gravity center -extent ${width}x${height} "${outputPath}"`
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function removeBackground(inputPath, outputPath, color, fuzz) {
+  try {
+    const input = getInputSelector(inputPath);
+    await execAsync2(
+      `convert ${input} -fuzz ${fuzz}% -transparent "${color}" "${outputPath}"`
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function removeBackgroundBorderOnly(inputPath, outputPath, color, fuzz) {
+  try {
+    const input = getInputSelector(inputPath);
+    await execAsync2(
+      `convert ${input} -bordercolor "${color}" -border 1x1 -fill none -fuzz ${fuzz}% -draw "matte 0,0 floodfill" -shave 1x1 "${outputPath}"`
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function createIco(inputPath, outputPath, sizes = [256, 128, 64, 48, 32, 16]) {
+  try {
+    const sizeStr = sizes.join(",");
+    await execAsync2(
+      `convert "${inputPath}" -define icon:auto-resize=${sizeStr} "${outputPath}"`
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function createIcoFromMultiple(pngPaths, outputPath) {
+  try {
+    const inputs = pngPaths.map((p) => `"${p}"`).join(" ");
+    await execAsync2(`convert ${inputs} "${outputPath}"`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function cleanup(...files) {
+  for (const file of files) {
+    try {
+      if (existsSync3(file)) {
+        unlinkSync(file);
+      }
+    } catch {
+    }
+  }
+}
+
+// src/tools/iconpack.ts
+var WEB_ICONS = [
+  { filename: "favicon-16x16.png", size: 16 },
+  { filename: "favicon-32x32.png", size: 32 },
+  { filename: "favicon-48x48.png", size: 48 },
+  { filename: "apple-touch-icon.png", size: 180 },
+  { filename: "android-chrome-192x192.png", size: 192 },
+  { filename: "android-chrome-512x512.png", size: 512 },
+  { filename: "mstile-150x150.png", size: 150 }
+];
+var ANDROID_ICONS = [
+  { filename: "mipmap-mdpi/ic_launcher.png", size: 48 },
+  { filename: "mipmap-hdpi/ic_launcher.png", size: 72 },
+  { filename: "mipmap-xhdpi/ic_launcher.png", size: 96 },
+  { filename: "mipmap-xxhdpi/ic_launcher.png", size: 144 },
+  { filename: "mipmap-xxxhdpi/ic_launcher.png", size: 192 },
+  { filename: "playstore-icon.png", size: 512 }
+];
+var IOS_ICONS = [
+  // 20pt - Notifications
+  { filename: "AppIcon-20.png", size: 20 },
+  { filename: "AppIcon-20@2x.png", size: 40 },
+  { filename: "AppIcon-20@3x.png", size: 60 },
+  // 29pt - Settings
+  { filename: "AppIcon-29.png", size: 29 },
+  { filename: "AppIcon-29@2x.png", size: 58 },
+  { filename: "AppIcon-29@3x.png", size: 87 },
+  // 40pt - Spotlight
+  { filename: "AppIcon-40.png", size: 40 },
+  { filename: "AppIcon-40@2x.png", size: 80 },
+  { filename: "AppIcon-40@3x.png", size: 120 },
+  // 60pt - iPhone App
+  { filename: "AppIcon-60@2x.png", size: 120 },
+  { filename: "AppIcon-60@3x.png", size: 180 },
+  // 76pt - iPad App
+  { filename: "AppIcon-76.png", size: 76 },
+  { filename: "AppIcon-76@2x.png", size: 152 },
+  // 83.5pt - iPad Pro
+  { filename: "AppIcon-83.5@2x.png", size: 167 },
+  // App Store
+  { filename: "AppIcon-1024.png", size: 1024 }
+];
+async function generateIcons(outputDir, sourceImg, icons) {
+  const total = icons.length;
+  let current = 0;
+  let failed = 0;
+  for (const icon of icons) {
+    current++;
+    const outputPath = `${outputDir}/${icon.filename}`;
+    const subdir = dirname7(outputPath);
+    if (!existsSync4(subdir)) {
+      mkdirSync4(subdir, { recursive: true });
+    }
+    clearLine();
+    wip(`[${current}/${total}] Generating ${icon.filename}...`);
+    if (await scaleToSize(sourceImg, outputPath, icon.size)) {
+      clearLine();
+      success(
+        `[${current}/${total}] ${icon.filename} (${icon.size}x${icon.size})`
+      );
+    } else {
+      clearLine();
+      error(`[${current}/${total}] Failed: ${icon.filename}`);
+      failed++;
+    }
+  }
+  return failed;
+}
+async function generateFavicon(outputDir, sourceImg) {
+  wip("Generating favicon.ico...");
+  const temp16 = `${outputDir}/.temp_16.png`;
+  const temp32 = `${outputDir}/.temp_32.png`;
+  const temp48 = `${outputDir}/.temp_48.png`;
+  await scaleToSize(sourceImg, temp16, 16);
+  await scaleToSize(sourceImg, temp32, 32);
+  await scaleToSize(sourceImg, temp48, 48);
+  const result = await createIcoFromMultiple(
+    [temp16, temp32, temp48],
+    `${outputDir}/favicon.ico`
+  );
+  cleanup(temp16, temp32, temp48);
+  if (result) {
+    wipDone(true, "favicon.ico (16, 32, 48)");
+    return true;
+  }
+  wipDone(false, "favicon.ico failed");
+  return false;
+}
+async function run(inputRaw) {
+  if (!await checkImageMagick()) {
+    error("ImageMagick not found. Please install it:");
+    console.log("  sudo apt update && sudo apt install imagemagick");
+    await pauseOnError();
+    return false;
+  }
+  const input = normalizePath(inputRaw);
+  if (!existsSync4(input)) {
+    error(`File not found: ${input}`);
+    await pauseOnError();
+    return false;
+  }
+  const fileInfo = getFileInfo(input);
+  header("PicLet Icon Pack Generator");
+  wip("Analyzing source image...");
+  const dims = await getDimensions(input);
+  if (!dims) {
+    wipDone(false, "Failed to read image");
+    return false;
+  }
+  const [origW, origH] = dims;
+  wipDone(true, `Source: ${origW}x${origH}`);
+  if (origW < 1024 || origH < 1024) {
+    warn(
+      "Source image is smaller than 1024px. Larger images produce better quality."
+    );
+  }
+  if (origW !== origH) {
+    warn("Image is not square. Will add transparent padding.");
+  }
+  console.log("");
+  const platforms = await multiSelect(
+    "Select target platforms:",
+    [
+      { title: "Web (PWA, favicon, apple-touch-icon)", value: "web" },
+      { title: "Android (mipmap icons, Play Store)", value: "android" },
+      { title: "iOS (App icons, App Store)", value: "ios" }
+    ],
+    ["web", "android", "ios"]
+    // Default: all platforms
+  );
+  if (platforms.length === 0) {
+    error("No platforms selected");
+    return false;
+  }
+  const doWeb = platforms.includes("web");
+  const doAndroid = platforms.includes("android");
+  const doIos = platforms.includes("ios");
+  const outputDir = `${fileInfo.dirname}/${fileInfo.filename}_icons`;
+  mkdirSync4(outputDir, { recursive: true });
+  info(`Output directory: ${outputDir}`);
+  console.log("");
+  wip("Preparing source image...");
+  const tempSource = `${outputDir}/.source_1024.png`;
+  const tempSquare = `${outputDir}/.temp_square.png`;
+  if (!await squarify2(input, tempSquare)) {
+    wipDone(false, "Failed to prepare source");
+    return false;
+  }
+  if (!await scaleToSize(tempSquare, tempSource, 1024)) {
+    wipDone(false, "Failed to prepare source");
+    cleanup(tempSquare);
+    return false;
+  }
+  cleanup(tempSquare);
+  wipDone(true, "Prepared 1024x1024 source");
+  let totalFailed = 0;
+  if (doWeb) {
+    console.log("");
+    header("Web Icons");
+    const webDir = `${outputDir}/web`;
+    mkdirSync4(webDir, { recursive: true });
+    if (!await generateFavicon(webDir, tempSource)) {
+      totalFailed++;
+    }
+    totalFailed += await generateIcons(webDir, tempSource, WEB_ICONS);
+  }
+  if (doAndroid) {
+    console.log("");
+    header("Android Icons");
+    const androidDir = `${outputDir}/android`;
+    mkdirSync4(androidDir, { recursive: true });
+    totalFailed += await generateIcons(androidDir, tempSource, ANDROID_ICONS);
+  }
+  if (doIos) {
+    console.log("");
+    header("iOS Icons");
+    const iosDir = `${outputDir}/ios`;
+    mkdirSync4(iosDir, { recursive: true });
+    totalFailed += await generateIcons(iosDir, tempSource, IOS_ICONS);
+  }
+  cleanup(tempSource);
+  console.log("");
+  separator();
+  if (totalFailed === 0) {
+    success("All icons generated successfully!");
+  } else {
+    warn(`${totalFailed} icon(s) failed to generate`);
+  }
+  console.log("");
+  info(`Icons saved to: ${outputDir}`);
+  if (doWeb) {
+    step("web/ - Favicon, PWA icons, Apple touch icon");
+  }
+  if (doAndroid) {
+    step("android/ - mipmap folders, Play Store icon");
+  }
+  if (doIos) {
+    step("ios/ - All iOS app icon sizes");
+  }
+  return totalFailed === 0;
+}
+async function runGUI(inputRaw) {
+  const input = normalizePath(inputRaw);
+  if (!existsSync4(input)) {
+    error(`File not found: ${input}`);
+    return false;
+  }
+  const dims = await getDimensions(input);
+  if (!dims) {
+    error("Failed to read image dimensions");
+    return false;
+  }
+  const fileInfo = getFileInfo(input);
+  return startGuiServer({
+    htmlFile: "iconpack.html",
+    title: "PicLet - Icon Pack",
+    imageInfo: {
+      filePath: input,
+      fileName: basename2(input),
+      width: dims[0],
+      height: dims[1],
+      borderColor: null
+    },
+    defaults: {
+      web: true,
+      android: true,
+      ios: true
+    },
+    onProcess: async (opts) => {
+      const logs = [];
+      if (!await checkImageMagick()) {
+        return {
+          success: false,
+          error: "ImageMagick not found",
+          logs: [{ type: "error", message: "ImageMagick not found" }]
+        };
+      }
+      const doWeb = opts.web ?? true;
+      const doAndroid = opts.android ?? true;
+      const doIos = opts.ios ?? true;
+      if (!doWeb && !doAndroid && !doIos) {
+        return {
+          success: false,
+          error: "No platforms selected",
+          logs: [{ type: "error", message: "No platforms selected" }]
+        };
+      }
+      const outputDir = `${fileInfo.dirname}/${fileInfo.filename}_icons`;
+      mkdirSync4(outputDir, { recursive: true });
+      logs.push({ type: "info", message: `Output: ${outputDir}` });
+      logs.push({ type: "info", message: "Preparing source image..." });
+      const tempSource = `${outputDir}/.source_1024.png`;
+      const tempSquare = `${outputDir}/.temp_square.png`;
+      if (!await squarify2(input, tempSquare)) {
+        return { success: false, error: "Failed to prepare source", logs };
+      }
+      if (!await scaleToSize(tempSquare, tempSource, 1024)) {
+        cleanup(tempSquare);
+        return { success: false, error: "Failed to prepare source", logs };
+      }
+      cleanup(tempSquare);
+      logs.push({ type: "success", message: "Prepared 1024x1024 source" });
+      let totalFailed = 0;
+      if (doWeb) {
+        logs.push({ type: "info", message: "Generating Web icons..." });
+        const webDir = `${outputDir}/web`;
+        mkdirSync4(webDir, { recursive: true });
+        if (!await generateFaviconSilent(webDir, tempSource)) {
+          totalFailed++;
+        }
+        totalFailed += await generateIconsSilent(webDir, tempSource, WEB_ICONS, logs);
+        logs.push({ type: "success", message: `Web: ${WEB_ICONS.length + 1} icons` });
+      }
+      if (doAndroid) {
+        logs.push({ type: "info", message: "Generating Android icons..." });
+        const androidDir = `${outputDir}/android`;
+        mkdirSync4(androidDir, { recursive: true });
+        totalFailed += await generateIconsSilent(androidDir, tempSource, ANDROID_ICONS, logs);
+        logs.push({ type: "success", message: `Android: ${ANDROID_ICONS.length} icons` });
+      }
+      if (doIos) {
+        logs.push({ type: "info", message: "Generating iOS icons..." });
+        const iosDir = `${outputDir}/ios`;
+        mkdirSync4(iosDir, { recursive: true });
+        totalFailed += await generateIconsSilent(iosDir, tempSource, IOS_ICONS, logs);
+        logs.push({ type: "success", message: `iOS: ${IOS_ICONS.length} icons` });
+      }
+      cleanup(tempSource);
+      if (totalFailed === 0) {
+        return {
+          success: true,
+          output: `Icons saved to ${fileInfo.filename}_icons/`,
+          logs
+        };
+      }
+      return {
+        success: false,
+        error: `${totalFailed} icon(s) failed`,
+        logs
+      };
+    }
+  });
+}
+async function generateIconsSilent(outputDir, sourceImg, icons, _logs) {
+  let failed = 0;
+  for (const icon of icons) {
+    const outputPath = `${outputDir}/${icon.filename}`;
+    const subdir = dirname7(outputPath);
+    if (!existsSync4(subdir)) {
+      mkdirSync4(subdir, { recursive: true });
+    }
+    if (!await scaleToSize(sourceImg, outputPath, icon.size)) {
+      failed++;
+    }
+  }
+  return failed;
+}
+async function generateFaviconSilent(outputDir, sourceImg) {
+  const temp16 = `${outputDir}/.temp_16.png`;
+  const temp32 = `${outputDir}/.temp_32.png`;
+  const temp48 = `${outputDir}/.temp_48.png`;
+  await scaleToSize(sourceImg, temp16, 16);
+  await scaleToSize(sourceImg, temp32, 32);
+  await scaleToSize(sourceImg, temp48, 48);
+  const result = await createIcoFromMultiple(
+    [temp16, temp32, temp48],
+    `${outputDir}/favicon.ico`
+  );
+  cleanup(temp16, temp32, temp48);
+  return result;
+}
+var config = {
+  id: "iconpack",
+  name: "Icon Pack",
+  icon: "iconpack.ico",
+  extensions: [".png", ".jpg", ".jpeg"]
+};
+
+// src/tools/makeicon.ts
+import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
+import { tmpdir } from "os";
+import { basename as basename3, join as join4 } from "path";
+async function run2(inputRaw) {
+  if (!await checkImageMagick()) {
+    error("ImageMagick not found. Please install it:");
+    console.log("  sudo apt update && sudo apt install imagemagick");
+    await pauseOnError();
+    return false;
+  }
+  const input = normalizePath(inputRaw);
+  if (!existsSync5(input)) {
+    error(`File not found: ${input}`);
+    await pauseOnError();
+    return false;
+  }
+  const fileInfo = getFileInfo(input);
+  const output = `${fileInfo.dirname}/${fileInfo.filename}.ico`;
+  const tempTrimmed = `${fileInfo.dirname}/${fileInfo.filename}_trimmed.png`;
+  const tempSquare = `${fileInfo.dirname}/${fileInfo.filename}_square.png`;
+  const tempScaled = `${fileInfo.dirname}/${fileInfo.filename}_scaled.png`;
+  header("PicLet Make Icon");
+  wip("Analyzing image...");
+  const dims = await getDimensions(input);
+  if (!dims) {
+    wipDone(false, "Failed to read image");
+    return false;
+  }
+  wipDone(true, `Original size: ${dims[0]}x${dims[1]}`);
+  wip("Trimming transparent areas...");
+  if (!await trim(input, tempTrimmed)) {
+    wipDone(false, "Trim failed");
+    cleanup(tempTrimmed);
+    return false;
+  }
+  wipDone(true, "Trimmed");
+  wip("Making square...");
+  if (!await squarify2(tempTrimmed, tempSquare)) {
+    wipDone(false, "Square padding failed");
+    cleanup(tempTrimmed, tempSquare);
+    return false;
+  }
+  cleanup(tempTrimmed);
+  wipDone(true, "Made square");
+  wip("Scaling to 512px...");
+  if (!await scaleToSize(tempSquare, tempScaled, 512)) {
+    wipDone(false, "Scaling failed");
+    cleanup(tempSquare, tempScaled);
+    return false;
+  }
+  cleanup(tempSquare);
+  wipDone(true, "Scaled to 512x512");
+  wip("Creating icon (256, 128, 64, 48, 32, 16)...");
+  if (!await createIco(tempScaled, output)) {
+    wipDone(false, "Icon creation failed");
+    cleanup(tempScaled);
+    return false;
+  }
+  cleanup(tempScaled);
+  wipDone(true, "Icon created");
+  console.log("");
+  success(`Output: ${output}`);
+  return true;
+}
+async function processForIcon(input, output, options, logs) {
+  const fileInfo = getFileInfo(input);
+  const tempTrimmed = `${fileInfo.dirname}/${fileInfo.filename}_trimmed.png`;
+  const tempSquare = `${fileInfo.dirname}/${fileInfo.filename}_square.png`;
+  const tempScaled = `${fileInfo.dirname}/${fileInfo.filename}_scaled.png`;
+  let currentInput = input;
+  if (options.trim) {
+    logs?.push({ type: "info", message: "Trimming transparent areas..." });
+    if (!await trim(currentInput, tempTrimmed)) {
+      cleanup(tempTrimmed);
+      return false;
+    }
+    currentInput = tempTrimmed;
+    logs?.push({ type: "success", message: "Trimmed" });
+  }
+  if (options.makeSquare) {
+    logs?.push({ type: "info", message: "Making square..." });
+    if (!await squarify2(currentInput, tempSquare)) {
+      cleanup(tempTrimmed, tempSquare);
+      return false;
+    }
+    if (currentInput === tempTrimmed) cleanup(tempTrimmed);
+    currentInput = tempSquare;
+    logs?.push({ type: "success", message: "Made square" });
+  }
+  logs?.push({ type: "info", message: "Scaling to 512px..." });
+  if (!await scaleToSize(currentInput, tempScaled, 512)) {
+    cleanup(tempTrimmed, tempSquare, tempScaled);
+    return false;
+  }
+  if (currentInput === tempSquare) cleanup(tempSquare);
+  else if (currentInput === tempTrimmed) cleanup(tempTrimmed);
+  logs?.push({ type: "success", message: "Scaled to 512x512" });
+  logs?.push({ type: "info", message: "Creating icon (256, 128, 64, 48, 32, 16)..." });
+  if (!await createIco(tempScaled, output)) {
+    cleanup(tempScaled);
+    return false;
+  }
+  cleanup(tempScaled);
+  logs?.push({ type: "success", message: "Icon created" });
+  return true;
+}
+async function generatePreview(input, options) {
+  const tempDir = tmpdir();
+  const timestamp = Date.now();
+  const tempTrimmed = join4(tempDir, `piclet-preview-trimmed-${timestamp}.png`);
+  const tempSquare = join4(tempDir, `piclet-preview-square-${timestamp}.png`);
+  const tempOutput = join4(tempDir, `piclet-preview-${timestamp}.png`);
+  try {
+    let currentInput = input;
+    if (options.trim) {
+      if (!await trim(currentInput, tempTrimmed)) {
+        cleanup(tempTrimmed);
+        return { success: false, error: "Trim failed" };
+      }
+      currentInput = tempTrimmed;
+    }
+    if (options.makeSquare) {
+      if (!await squarify2(currentInput, tempSquare)) {
+        cleanup(tempTrimmed, tempSquare);
+        return { success: false, error: "Square failed" };
+      }
+      if (currentInput === tempTrimmed) cleanup(tempTrimmed);
+      currentInput = tempSquare;
+    }
+    if (!await scaleToSize(currentInput, tempOutput, 256)) {
+      cleanup(tempTrimmed, tempSquare, tempOutput);
+      return { success: false, error: "Scale failed" };
+    }
+    if (currentInput === tempSquare) cleanup(tempSquare);
+    else if (currentInput === tempTrimmed) cleanup(tempTrimmed);
+    const buffer = readFileSync3(tempOutput);
+    const base64 = buffer.toString("base64");
+    const imageData = `data:image/png;base64,${base64}`;
+    const dims = await getDimensions(tempOutput);
+    cleanup(tempOutput);
+    return {
+      success: true,
+      imageData,
+      width: dims?.[0],
+      height: dims?.[1]
+    };
+  } catch (err) {
+    cleanup(tempTrimmed, tempSquare, tempOutput);
+    return { success: false, error: err.message };
+  }
+}
+async function runGUI2(inputRaw) {
+  const input = normalizePath(inputRaw);
+  if (!existsSync5(input)) {
+    error(`File not found: ${input}`);
+    return false;
+  }
+  const dims = await getDimensions(input);
+  if (!dims) {
+    error("Failed to read image dimensions");
+    return false;
+  }
+  const fileInfo = getFileInfo(input);
+  return startGuiServer({
+    htmlFile: "makeicon.html",
+    title: "PicLet - Make Icon",
+    imageInfo: {
+      filePath: input,
+      fileName: basename3(input),
+      width: dims[0],
+      height: dims[1],
+      borderColor: null
+    },
+    defaults: {
+      trim: true,
+      makeSquare: true
+    },
+    onPreview: async (opts) => {
+      const options = {
+        trim: opts.trim ?? true,
+        makeSquare: opts.makeSquare ?? true
+      };
+      return generatePreview(input, options);
+    },
+    onProcess: async (opts) => {
+      const logs = [];
+      if (!await checkImageMagick()) {
+        return {
+          success: false,
+          error: "ImageMagick not found",
+          logs: [{ type: "error", message: "ImageMagick not found" }]
+        };
+      }
+      const options = {
+        trim: opts.trim ?? true,
+        makeSquare: opts.makeSquare ?? true
+      };
+      const output = `${fileInfo.dirname}/${fileInfo.filename}.ico`;
+      const success2 = await processForIcon(input, output, options, logs);
+      if (success2) {
+        return {
+          success: true,
+          output: `${fileInfo.filename}.ico`,
+          logs
+        };
+      }
+      return { success: false, error: "Icon creation failed", logs };
+    }
+  });
+}
+var config2 = {
+  id: "makeicon",
+  name: "Make Icon",
+  icon: "makeicon.ico",
+  extensions: [".png"]
+};
+
+// src/tools/piclet-main.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync4, renameSync, writeFileSync as writeFileSync3 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { basename as basename4, dirname as dirname8, extname as extname2, join as join5 } from "path";
+var TOOL_ORDER = ["removebg", "scale", "icons", "storepack"];
+async function generateCombinedPreview(input, borderColor, opts) {
+  const tempDir = tmpdir2();
+  const ts = Date.now();
+  const temps = [];
+  const makeTempPath = (suffix) => {
+    const p = join5(tempDir, `piclet-${ts}-${suffix}.png`);
+    temps.push(p);
+    return p;
+  };
+  try {
+    let current = input;
+    if (opts.original || opts.tools.length === 0) {
+      const dims2 = await getDimensions(input);
+      let previewPath2 = input;
+      if (dims2 && (dims2[0] > 512 || dims2[1] > 512)) {
+        const scaled = makeTempPath("orig-preview");
+        const targetSize = Math.min(512, Math.max(dims2[0], dims2[1]));
+        if (await scaleToSize(input, scaled, targetSize)) {
+          previewPath2 = scaled;
+        }
+      }
+      const buffer2 = readFileSync4(previewPath2);
+      const finalDims2 = await getDimensions(previewPath2);
+      cleanup(...temps);
+      return {
+        success: true,
+        imageData: `data:image/png;base64,${buffer2.toString("base64")}`,
+        width: finalDims2?.[0] ?? dims2?.[0],
+        height: finalDims2?.[1] ?? dims2?.[1]
+      };
+    }
+    const activeTools = TOOL_ORDER.filter((t) => opts.tools.includes(t));
+    for (const tool of activeTools) {
+      switch (tool) {
+        case "removebg": {
+          const rbOpts = opts.removebg;
+          const out = makeTempPath("removebg");
+          let success2 = false;
+          if (rbOpts.preserveInner && borderColor) {
+            success2 = await removeBackgroundBorderOnly(current, out, borderColor, rbOpts.fuzz);
+          }
+          if (!success2 && borderColor) {
+            success2 = await removeBackground(current, out, borderColor, rbOpts.fuzz);
+          }
+          if (!success2) {
+            cleanup(...temps);
+            return { success: false, error: "Background removal failed" };
+          }
+          if (rbOpts.trim) {
+            const trimOut = makeTempPath("trim");
+            if (await trim(out, trimOut)) {
+              current = trimOut;
+            } else {
+              current = out;
+            }
+          } else {
+            current = out;
+          }
+          break;
+        }
+        case "scale": {
+          const scOpts = opts.scale;
+          const out = makeTempPath("scale");
+          let success2 = false;
+          if (scOpts.makeSquare) {
+            const max = Math.max(scOpts.width, scOpts.height);
+            success2 = await scaleWithPadding(current, out, max, max);
+          } else {
+            success2 = await resize(current, out, scOpts.width, scOpts.height);
+          }
+          if (!success2) {
+            cleanup(...temps);
+            return { success: false, error: "Scale failed" };
+          }
+          current = out;
+          break;
+        }
+        case "icons": {
+          const icOpts = opts.icons;
+          if (icOpts.trim && current === input) {
+            const trimOut = makeTempPath("ic-trim");
+            if (await trim(current, trimOut)) {
+              current = trimOut;
+            }
+          }
+          if (icOpts.makeSquare) {
+            const sqOut = makeTempPath("ic-sq");
+            if (await squarify2(current, sqOut)) {
+              current = sqOut;
+            }
+          }
+          break;
+        }
+      }
+    }
+    const dims = await getDimensions(current);
+    let previewPath = current;
+    if (dims && (dims[0] > 512 || dims[1] > 512)) {
+      const scaled = makeTempPath("preview");
+      const targetSize = Math.min(512, Math.max(dims[0], dims[1]));
+      if (await scaleToSize(current, scaled, targetSize)) {
+        previewPath = scaled;
+      }
+    }
+    const buffer = readFileSync4(previewPath);
+    const finalDims = await getDimensions(previewPath);
+    cleanup(...temps);
+    return {
+      success: true,
+      imageData: `data:image/png;base64,${buffer.toString("base64")}`,
+      width: finalDims?.[0],
+      height: finalDims?.[1]
+    };
+  } catch (err) {
+    cleanup(...temps);
+    return { success: false, error: err.message };
+  }
+}
+async function processCombined(input, borderColor, opts, logs) {
+  const fileInfo = getFileInfo(input);
+  const outputs = [];
+  const temps = [];
+  const makeTempPath = (suffix) => {
+    const p = `${fileInfo.dirname}/${fileInfo.filename}_${suffix}.png`;
+    temps.push(p);
+    return p;
+  };
+  let current = input;
+  const activeTools = TOOL_ORDER.filter((t) => opts.tools.includes(t));
+  for (const tool of activeTools) {
+    switch (tool) {
+      case "removebg": {
+        logs.push({ type: "info", message: "Removing background..." });
+        const rbOpts = opts.removebg;
+        const out = makeTempPath("nobg");
+        let success2 = false;
+        if (rbOpts.preserveInner && borderColor) {
+          success2 = await removeBackgroundBorderOnly(current, out, borderColor, rbOpts.fuzz);
+          if (!success2) {
+            logs.push({ type: "warn", message: "Border-only failed, trying full removal" });
+          }
+        }
+        if (!success2 && borderColor) {
+          success2 = await removeBackground(current, out, borderColor, rbOpts.fuzz);
+        }
+        if (!success2) {
+          logs.push({ type: "error", message: "Background removal failed" });
+          cleanup(...temps);
+          return [];
+        }
+        logs.push({ type: "success", message: "Background removed" });
+        if (rbOpts.trim) {
+          logs.push({ type: "info", message: "Trimming edges..." });
+          const trimOut = makeTempPath("trimmed");
+          if (await trim(out, trimOut)) {
+            cleanup(out);
+            temps.splice(temps.indexOf(out), 1);
+            current = trimOut;
+            logs.push({ type: "success", message: "Trimmed" });
+          } else {
+            current = out;
+          }
+        } else {
+          current = out;
+        }
+        if (activeTools.indexOf(tool) === activeTools.length - 1) {
+          const finalOut = `${fileInfo.dirname}/${fileInfo.filename}_nobg.png`;
+          renameSync(current, finalOut);
+          temps.splice(temps.indexOf(current), 1);
+          outputs.push(basename4(finalOut));
+        }
+        break;
+      }
+      case "scale": {
+        logs.push({ type: "info", message: "Scaling image..." });
+        const scOpts = opts.scale;
+        const out = makeTempPath("scaled");
+        let success2 = false;
+        if (scOpts.makeSquare) {
+          const max = Math.max(scOpts.width, scOpts.height);
+          success2 = await scaleWithPadding(current, out, max, max);
+        } else {
+          success2 = await resize(current, out, scOpts.width, scOpts.height);
+        }
+        if (!success2) {
+          logs.push({ type: "error", message: "Scale failed" });
+          cleanup(...temps);
+          return [];
+        }
+        const dims = await getDimensions(out);
+        logs.push({ type: "success", message: `Scaled to ${dims?.[0]}\xD7${dims?.[1]}` });
+        if (current !== input && temps.includes(current)) {
+          cleanup(current);
+          temps.splice(temps.indexOf(current), 1);
+        }
+        current = out;
+        if (activeTools.indexOf(tool) === activeTools.length - 1) {
+          const finalOut = `${fileInfo.dirname}/${fileInfo.filename}_scaled${fileInfo.extension}`;
+          renameSync(current, finalOut);
+          temps.splice(temps.indexOf(current), 1);
+          outputs.push(basename4(finalOut));
+        }
+        break;
+      }
+      case "icons": {
+        logs.push({ type: "info", message: "Generating icons..." });
+        const icOpts = opts.icons;
+        if (!icOpts.ico && !icOpts.web && !icOpts.android && !icOpts.ios) {
+          logs.push({ type: "error", message: "No output format selected" });
+          return [];
+        }
+        let iconSource = current;
+        if (icOpts.trim && current === input) {
+          logs.push({ type: "info", message: "Trimming edges..." });
+          const trimOut = makeTempPath("ic-trim");
+          if (await trim(current, trimOut)) {
+            iconSource = trimOut;
+            logs.push({ type: "success", message: "Trimmed" });
+          }
+        }
+        if (icOpts.makeSquare) {
+          logs.push({ type: "info", message: "Making square..." });
+          const sqOut = makeTempPath("ic-sq");
+          if (await squarify2(iconSource, sqOut)) {
+            if (iconSource !== current && iconSource !== input) cleanup(iconSource);
+            iconSource = sqOut;
+            logs.push({ type: "success", message: "Made square" });
+          }
+        }
+        const maxSize = icOpts.web || icOpts.android || icOpts.ios ? 1024 : 512;
+        const srcTemp = makeTempPath("ic-src");
+        if (!await scaleToSize(iconSource, srcTemp, maxSize)) {
+          logs.push({ type: "error", message: "Failed to prepare icon source" });
+          cleanup(...temps);
+          return [];
+        }
+        if (iconSource !== current && iconSource !== input) cleanup(iconSource);
+        let totalCount = 0;
+        if (icOpts.ico) {
+          logs.push({ type: "info", message: "Creating ICO file..." });
+          const icoOut = `${fileInfo.dirname}/${fileInfo.filename}.ico`;
+          if (await createIco(srcTemp, icoOut)) {
+            logs.push({ type: "success", message: "ICO: 6 sizes (256, 128, 64, 48, 32, 16)" });
+            outputs.push(basename4(icoOut));
+            totalCount += 6;
+          } else {
+            logs.push({ type: "warn", message: "ICO creation failed" });
+          }
+        }
+        const needsPacks = icOpts.web || icOpts.android || icOpts.ios;
+        if (needsPacks) {
+          const outputDir = `${fileInfo.dirname}/${fileInfo.filename}_icons`;
+          mkdirSync5(outputDir, { recursive: true });
+          if (icOpts.web) {
+            logs.push({ type: "info", message: "Generating Web icons..." });
+            const webDir = `${outputDir}/web`;
+            mkdirSync5(webDir, { recursive: true });
+            const t16 = `${webDir}/.t16.png`, t32 = `${webDir}/.t32.png`, t48 = `${webDir}/.t48.png`;
+            await scaleToSize(srcTemp, t16, 16);
+            await scaleToSize(srcTemp, t32, 32);
+            await scaleToSize(srcTemp, t48, 48);
+            await createIcoFromMultiple([t16, t32, t48], `${webDir}/favicon.ico`);
+            cleanup(t16, t32, t48);
+            totalCount++;
+            const webIcons = [
+              { name: "favicon-16x16.png", size: 16 },
+              { name: "favicon-32x32.png", size: 32 },
+              { name: "apple-touch-icon.png", size: 180 },
+              { name: "android-chrome-192x192.png", size: 192 },
+              { name: "android-chrome-512x512.png", size: 512 },
+              { name: "mstile-150x150.png", size: 150 }
+            ];
+            for (const i of webIcons) {
+              await scaleToSize(srcTemp, `${webDir}/${i.name}`, i.size);
+              totalCount++;
+            }
+            logs.push({ type: "success", message: "Web: 7 icons" });
+          }
+          if (icOpts.android) {
+            logs.push({ type: "info", message: "Generating Android icons..." });
+            const androidDir = `${outputDir}/android`;
+            const androidIcons = [
+              { name: "mipmap-mdpi/ic_launcher.png", size: 48 },
+              { name: "mipmap-hdpi/ic_launcher.png", size: 72 },
+              { name: "mipmap-xhdpi/ic_launcher.png", size: 96 },
+              { name: "mipmap-xxhdpi/ic_launcher.png", size: 144 },
+              { name: "mipmap-xxxhdpi/ic_launcher.png", size: 192 },
+              { name: "playstore-icon.png", size: 512 }
+            ];
+            for (const i of androidIcons) {
+              const p = `${androidDir}/${i.name}`;
+              mkdirSync5(dirname8(p), { recursive: true });
+              await scaleToSize(srcTemp, p, i.size);
+              totalCount++;
+            }
+            logs.push({ type: "success", message: "Android: 6 icons" });
+          }
+          if (icOpts.ios) {
+            logs.push({ type: "info", message: "Generating iOS icons..." });
+            const iosDir = `${outputDir}/ios`;
+            mkdirSync5(iosDir, { recursive: true });
+            const iosSizes = [20, 29, 40, 58, 60, 76, 80, 87, 120, 152, 167, 180, 1024];
+            for (const s of iosSizes) {
+              await scaleToSize(srcTemp, `${iosDir}/AppIcon-${s}.png`, s);
+              totalCount++;
+            }
+            logs.push({ type: "success", message: `iOS: ${iosSizes.length} icons` });
+          }
+          outputs.push(`${totalCount} icons \u2192 ${fileInfo.filename}_icons/`);
+        }
+        cleanup(srcTemp);
+        logs.push({ type: "success", message: `Generated ${totalCount} total icons` });
+        break;
+      }
+      case "storepack": {
+        logs.push({ type: "info", message: "Generating store assets..." });
+        const spOpts = opts.storepack;
+        if (!spOpts.dimensions || spOpts.dimensions.length === 0) {
+          logs.push({ type: "error", message: "No dimensions specified" });
+          return [];
+        }
+        const folderName = spOpts.presetName || "assets";
+        const outputDir = `${fileInfo.dirname}/${fileInfo.filename}_${folderName}`;
+        mkdirSync5(outputDir, { recursive: true });
+        let count = 0;
+        for (const dim of spOpts.dimensions) {
+          const filename = dim.filename || `${dim.width}x${dim.height}.png`;
+          const out = join5(outputDir, filename);
+          let success2 = false;
+          switch (spOpts.scaleMode) {
+            case "fill":
+              success2 = await scaleFillCrop(current, out, dim.width, dim.height);
+              break;
+            case "stretch":
+              success2 = await resize(current, out, dim.width, dim.height);
+              break;
+            default:
+              success2 = await scaleWithPadding(current, out, dim.width, dim.height);
+          }
+          if (success2) count++;
+        }
+        logs.push({ type: "success", message: `Generated ${count}/${spOpts.dimensions.length} images` });
+        outputs.push(`${count} images \u2192 ${fileInfo.filename}_${folderName}/`);
+        break;
+      }
+    }
+  }
+  cleanup(...temps);
+  return outputs;
+}
+async function runGUI3(inputRaw) {
+  let currentInput = normalizePath(inputRaw);
+  if (!existsSync6(currentInput)) {
+    error(`File not found: ${currentInput}`);
+    return false;
+  }
+  const dims = await getDimensions(currentInput);
+  if (!dims) {
+    error("Failed to read image dimensions");
+    return false;
+  }
+  let currentBorderColor = await getBorderColor(currentInput);
+  const presets = loadPresets();
+  return startGuiServer({
+    htmlFile: "piclet.html",
+    title: "PicLet",
+    imageInfo: {
+      filePath: currentInput,
+      fileName: basename4(currentInput),
+      width: dims[0],
+      height: dims[1],
+      borderColor: currentBorderColor
+    },
+    defaults: {
+      // Return full preset data for the UI
+      presets: presets.map((p) => ({
+        id: p.id,
+        name: p.name,
+        description: p.description,
+        icons: p.icons
+      }))
+    },
+    onPreview: async (opts) => {
+      const toolOpts = opts;
+      if (!toolOpts.tools) {
+        toolOpts.tools = [];
+      }
+      return generateCombinedPreview(currentInput, currentBorderColor, toolOpts);
+    },
+    onProcess: async (opts) => {
+      const logs = [];
+      const toolOpts = opts;
+      if (!toolOpts.tools || toolOpts.tools.length === 0) {
+        return { success: false, error: "No tools selected", logs };
+      }
+      if (!await checkImageMagick()) {
+        return {
+          success: false,
+          error: "ImageMagick not found",
+          logs: [{ type: "error", message: "ImageMagick not found. Install: sudo apt install imagemagick" }]
+        };
+      }
+      const outputs = await processCombined(currentInput, currentBorderColor, toolOpts, logs);
+      if (outputs.length > 0) {
+        return {
+          success: true,
+          output: outputs.join("\n"),
+          logs
+        };
+      }
+      return { success: false, error: "Processing failed", logs };
+    },
+    onLoadImage: async (data) => {
+      try {
+        const ext = extname2(data.fileName) || ".png";
+        const tempPath = join5(tmpdir2(), `piclet-load-${Date.now()}${ext}`);
+        const buffer = Buffer.from(data.data, "base64");
+        writeFileSync3(tempPath, buffer);
+        const newDims = await getDimensions(tempPath);
+        if (!newDims) {
+          cleanup(tempPath);
+          return { success: false, error: "Failed to read image dimensions" };
+        }
+        const newBorderColor = await getBorderColor(tempPath);
+        currentInput = tempPath;
+        currentBorderColor = newBorderColor;
+        return {
+          success: true,
+          filePath: tempPath,
+          fileName: data.fileName,
+          width: newDims[0],
+          height: newDims[1],
+          borderColor: newBorderColor
+        };
+      } catch (err) {
+        return { success: false, error: err.message };
+      }
+    }
+  });
+}
+var config3 = {
+  id: "piclet",
+  name: "PicLet",
+  icon: "banana.ico",
+  extensions: [".png", ".jpg", ".jpeg", ".gif", ".bmp", ".ico"]
+};
+
+// src/tools/remove-bg.ts
+import { existsSync as existsSync7, readFileSync as readFileSync5, renameSync as renameSync2 } from "fs";
+import { tmpdir as tmpdir3 } from "os";
+import { basename as basename5, join as join6 } from "path";
+async function processImage(input, borderColor, options) {
+  const fileInfo = getFileInfo(input);
+  const output = `${fileInfo.dirname}/${fileInfo.filename}_nobg.png`;
+  const tempFile = `${fileInfo.dirname}/${fileInfo.filename}_temp.png`;
+  wip("Removing background...");
+  let bgRemoved = false;
+  if (options.preserveInner && borderColor) {
+    bgRemoved = await removeBackgroundBorderOnly(
+      input,
+      tempFile,
+      borderColor,
+      options.fuzz
+    );
+    if (!bgRemoved) {
+      warn("Border-only removal failed, using standard method");
+    }
+  }
+  if (!bgRemoved && borderColor) {
+    bgRemoved = await removeBackground(input, tempFile, borderColor, options.fuzz);
+  }
+  if (!bgRemoved) {
+    wipDone(false, "Background removal failed");
+    cleanup(tempFile);
+    return false;
+  }
+  wipDone(true, "Background removed");
+  if (options.doTrim) {
+    wip("Trimming transparent edges...");
+    if (await trim(tempFile, output)) {
+      wipDone(true, "Trimmed");
+      cleanup(tempFile);
+    } else {
+      wipDone(false, "Trim failed, keeping untrimmed");
+      renameSync2(tempFile, output);
+    }
+  } else {
+    renameSync2(tempFile, output);
+  }
+  if (options.makeSquare) {
+    wip("Making square...");
+    const tempSquare = `${fileInfo.dirname}/${fileInfo.filename}_square_temp.png`;
+    if (await squarify2(output, tempSquare)) {
+      renameSync2(tempSquare, output);
+      wipDone(true, "Made square");
+    } else {
+      wipDone(false, "Square padding failed");
+      cleanup(tempSquare);
+    }
+  }
+  const finalDims = await getDimensions(output);
+  console.log("");
+  if (finalDims) {
+    success(`Output: ${output} (${finalDims[0]}x${finalDims[1]})`);
+  } else {
+    success(`Output: ${output}`);
+  }
+  return true;
+}
+async function collectOptionsCLI() {
+  console.log("");
+  console.log(`${BOLD}Fuzz Value:${RESET} Controls color matching strictness`);
+  console.log(`  ${DIM}0-10%   = Only exact or very similar colors${RESET}`);
+  console.log(`  ${DIM}10-30%  = Somewhat similar colors${RESET}`);
+  console.log(`  ${DIM}30-70%  = Aggressive removal${RESET}`);
+  console.log(`  ${DIM}70-100% = May affect non-background areas${RESET}`);
+  console.log("");
+  let fuzz = await number("Fuzz value (0-100)", 10, 0, 100);
+  if (fuzz < 0 || fuzz > 100) {
+    warn("Invalid fuzz value, using 10");
+    fuzz = 10;
+  }
+  console.log("");
+  const doTrim = await confirm(
+    "Trim transparent edges after removal?",
+    true
+  );
+  console.log("");
+  const preserveInner = await confirm(
+    "Preserve inner areas of same color? (border-only removal)",
+    false
+  );
+  console.log("");
+  const makeSquare = await confirm(
+    "Make output square with transparent padding?",
+    false
+  );
+  return { fuzz, doTrim, preserveInner, makeSquare };
+}
+async function run3(inputRaw) {
+  if (!await checkImageMagick()) {
+    error("ImageMagick not found. Please install it:");
+    console.log("  sudo apt update && sudo apt install imagemagick");
+    await pauseOnError();
+    return false;
+  }
+  const input = normalizePath(inputRaw);
+  if (!existsSync7(input)) {
+    error(`File not found: ${input}`);
+    await pauseOnError();
+    return false;
+  }
+  header("PicLet Remove Background");
+  wip("Analyzing image...");
+  const dims = await getDimensions(input);
+  if (!dims) {
+    wipDone(false, "Failed to read image");
+    return false;
+  }
+  const borderColor = await getBorderColor(input);
+  wipDone(true, `Size: ${dims[0]}x${dims[1]}`);
+  if (borderColor) {
+    info(`Detected border color: ${borderColor}`);
+  }
+  const options = await collectOptionsCLI();
+  console.log("");
+  return processImage(input, borderColor, options);
+}
+async function runGUI4(inputRaw) {
+  const input = normalizePath(inputRaw);
+  if (!existsSync7(input)) {
+    error(`File not found: ${input}`);
+    return false;
+  }
+  const dims = await getDimensions(input);
+  if (!dims) {
+    error("Failed to read image dimensions");
+    return false;
+  }
+  const borderColor = await getBorderColor(input);
+  const config7 = loadConfig();
+  const defaults = config7.removeBg;
+  return startGuiServer({
+    htmlFile: "remove-bg.html",
+    title: "PicLet - Remove Background",
+    imageInfo: {
+      filePath: input,
+      fileName: basename5(input),
+      width: dims[0],
+      height: dims[1],
+      borderColor
+    },
+    defaults: {
+      fuzz: defaults.fuzz,
+      trim: defaults.trim,
+      preserveInner: defaults.preserveInner,
+      makeSquare: defaults.makeSquare
+    },
+    onPreview: async (opts) => {
+      const options = {
+        fuzz: opts.fuzz ?? defaults.fuzz,
+        doTrim: opts.trim ?? defaults.trim,
+        preserveInner: opts.preserveInner ?? defaults.preserveInner,
+        makeSquare: opts.makeSquare ?? defaults.makeSquare
+      };
+      return generatePreview2(input, borderColor, options);
+    },
+    onProcess: async (opts) => {
+      const logs = [];
+      if (!await checkImageMagick()) {
+        return {
+          success: false,
+          error: "ImageMagick not found",
+          logs: [{ type: "error", message: "ImageMagick not found. Install with: sudo apt install imagemagick" }]
+        };
+      }
+      logs.push({ type: "info", message: `Processing ${basename5(input)}...` });
+      const options = {
+        fuzz: opts.fuzz ?? defaults.fuzz,
+        doTrim: opts.trim ?? defaults.trim,
+        preserveInner: opts.preserveInner ?? defaults.preserveInner,
+        makeSquare: opts.makeSquare ?? defaults.makeSquare
+      };
+      const fileInfo = getFileInfo(input);
+      const output = `${fileInfo.dirname}/${fileInfo.filename}_nobg.png`;
+      logs.push({ type: "info", message: "Removing background..." });
+      const success2 = await processImageSilent(input, borderColor, options, logs);
+      if (success2) {
+        const finalDims = await getDimensions(output);
+        const sizeStr = finalDims ? ` (${finalDims[0]}x${finalDims[1]})` : "";
+        return {
+          success: true,
+          output: `${basename5(output)}${sizeStr}`,
+          logs
+        };
+      }
+      return {
+        success: false,
+        error: "Processing failed",
+        logs
+      };
+    }
+  });
+}
+async function processImageSilent(input, borderColor, options, logs) {
+  const fileInfo = getFileInfo(input);
+  const output = `${fileInfo.dirname}/${fileInfo.filename}_nobg.png`;
+  const tempFile = `${fileInfo.dirname}/${fileInfo.filename}_temp.png`;
+  let bgRemoved = false;
+  if (options.preserveInner && borderColor) {
+    bgRemoved = await removeBackgroundBorderOnly(
+      input,
+      tempFile,
+      borderColor,
+      options.fuzz
+    );
+    if (!bgRemoved) {
+      logs.push({ type: "warn", message: "Border-only removal failed, using standard method" });
+    }
+  }
+  if (!bgRemoved && borderColor) {
+    bgRemoved = await removeBackground(input, tempFile, borderColor, options.fuzz);
+  }
+  if (!bgRemoved) {
+    logs.push({ type: "error", message: "Background removal failed" });
+    cleanup(tempFile);
+    return false;
+  }
+  logs.push({ type: "success", message: "Background removed" });
+  if (options.doTrim) {
+    logs.push({ type: "info", message: "Trimming transparent edges..." });
+    if (await trim(tempFile, output)) {
+      logs.push({ type: "success", message: "Trimmed" });
+      cleanup(tempFile);
+    } else {
+      logs.push({ type: "warn", message: "Trim failed, keeping untrimmed" });
+      renameSync2(tempFile, output);
+    }
+  } else {
+    renameSync2(tempFile, output);
+  }
+  if (options.makeSquare) {
+    logs.push({ type: "info", message: "Making square..." });
+    const tempSquare = `${fileInfo.dirname}/${fileInfo.filename}_square_temp.png`;
+    if (await squarify2(output, tempSquare)) {
+      renameSync2(tempSquare, output);
+      logs.push({ type: "success", message: "Made square" });
+    } else {
+      logs.push({ type: "warn", message: "Square padding failed" });
+      cleanup(tempSquare);
+    }
+  }
+  return true;
+}
+async function generatePreview2(input, borderColor, options) {
+  const tempDir = tmpdir3();
+  const timestamp = Date.now();
+  const tempFile = join6(tempDir, `piclet-preview-${timestamp}.png`);
+  const tempOutput = join6(tempDir, `piclet-preview-${timestamp}-out.png`);
+  try {
+    let bgRemoved = false;
+    if (options.preserveInner && borderColor) {
+      bgRemoved = await removeBackgroundBorderOnly(input, tempFile, borderColor, options.fuzz);
+    }
+    if (!bgRemoved && borderColor) {
+      bgRemoved = await removeBackground(input, tempFile, borderColor, options.fuzz);
+    }
+    if (!bgRemoved) {
+      return { success: false, error: "Background removal failed" };
+    }
+    let currentFile = tempFile;
+    if (options.doTrim) {
+      if (await trim(tempFile, tempOutput)) {
+        cleanup(tempFile);
+        currentFile = tempOutput;
+      }
+    }
+    if (options.makeSquare) {
+      const squareFile = join6(tempDir, `piclet-preview-${timestamp}-sq.png`);
+      if (await squarify2(currentFile, squareFile)) {
+        cleanup(currentFile);
+        currentFile = squareFile;
+      }
+    }
+    const buffer = readFileSync5(currentFile);
+    const base64 = buffer.toString("base64");
+    const imageData = `data:image/png;base64,${base64}`;
+    const dims = await getDimensions(currentFile);
+    cleanup(currentFile, tempFile, tempOutput);
+    return {
+      success: true,
+      imageData,
+      width: dims?.[0],
+      height: dims?.[1]
+    };
+  } catch (err) {
+    cleanup(tempFile, tempOutput);
+    return { success: false, error: err.message };
+  }
+}
+var config4 = {
+  id: "remove-bg",
+  name: "Remove Background",
+  icon: "removebg.ico",
+  extensions: [".png", ".jpg", ".jpeg", ".ico"]
+};
+
+// src/tools/rescale.ts
+import { existsSync as existsSync8, readFileSync as readFileSync6 } from "fs";
+import { tmpdir as tmpdir4 } from "os";
+import { basename as basename6, join as join7 } from "path";
+async function run4(inputRaw) {
+  if (!await checkImageMagick()) {
+    error("ImageMagick not found. Please install it:");
+    console.log("  sudo apt update && sudo apt install imagemagick");
+    await pauseOnError();
+    return false;
+  }
+  const input = normalizePath(inputRaw);
+  if (!existsSync8(input)) {
+    error(`File not found: ${input}`);
+    await pauseOnError();
+    return false;
+  }
+  const fileInfo = getFileInfo(input);
+  const output = `${fileInfo.dirname}/${fileInfo.filename}_scaled${fileInfo.extension}`;
+  header("PicLet Scale Image");
+  wip("Reading image dimensions...");
+  const dims = await getDimensions(input);
+  if (!dims) {
+    wipDone(false, "Failed to read image");
+    return false;
+  }
+  const [origW, origH] = dims;
+  wipDone(true, `Original size: ${origW}x${origH}`);
+  if (origW !== origH) {
+    warn(`Image is not square (${origW}x${origH})`);
+  }
+  console.log("");
+  console.log(`${BOLD}Scaling Options:${RESET}`);
+  console.log(
+    `  ${DIM}Enter 0 for auto-calculate based on other dimension${RESET}`
+  );
+  console.log(
+    `  ${DIM}Enter single number for both to make square output${RESET}`
+  );
+  console.log("");
+  let targetW = await number("Width (0 for auto)", 0, 0);
+  let targetH = await number("Height (0 for auto)", 0, 0);
+  let makeSquare = false;
+  if (targetW === 0 && targetH === 0) {
+    targetW = Math.floor(origW / 2);
+    targetH = Math.floor(origH / 2);
+    info(`Using default: 50% scale (${targetW}x${targetH})`);
+  } else if (targetW > 0 && targetH === 0) {
+    targetH = Math.floor(targetW * origH / origW);
+    info(`Calculated height: ${targetH}`);
+  } else if (targetW === 0 && targetH > 0) {
+    targetW = Math.floor(targetH * origW / origH);
+    info(`Calculated width: ${targetW}`);
+  }
+  console.log("");
+  makeSquare = await confirm(
+    "Make output square with transparent padding?",
+    false
+  );
+  if (makeSquare) {
+    const maxDim = Math.max(targetW, targetH);
+    targetW = maxDim;
+    targetH = maxDim;
+    info(`Output will be ${targetW}x${targetH} (square with padding)`);
+  }
+  console.log("");
+  wip("Scaling image...");
+  let scaled = false;
+  if (makeSquare) {
+    scaled = await scaleWithPadding(input, output, targetW, targetH);
+  } else {
+    scaled = await resize(input, output, targetW, targetH);
+  }
+  if (!scaled || !existsSync8(output)) {
+    wipDone(false, "Scaling failed");
+    return false;
+  }
+  const finalDims = await getDimensions(output);
+  if (finalDims) {
+    wipDone(true, `Scaled to ${finalDims[0]}x${finalDims[1]}`);
+  } else {
+    wipDone(true, "Scaled");
+  }
+  console.log("");
+  success(`Output: ${output}`);
+  return true;
+}
+async function runGUI5(inputRaw) {
+  const input = normalizePath(inputRaw);
+  if (!existsSync8(input)) {
+    error(`File not found: ${input}`);
+    return false;
+  }
+  const dims = await getDimensions(input);
+  if (!dims) {
+    error("Failed to read image dimensions");
+    return false;
+  }
+  const fileInfo = getFileInfo(input);
+  return startGuiServer({
+    htmlFile: "rescale.html",
+    title: "PicLet - Scale Image",
+    imageInfo: {
+      filePath: input,
+      fileName: basename6(input),
+      width: dims[0],
+      height: dims[1],
+      borderColor: null
+    },
+    defaults: {
+      makeSquare: false
+    },
+    onPreview: async (opts) => {
+      const options = {
+        width: opts.width ?? Math.round(dims[0] / 2),
+        height: opts.height ?? Math.round(dims[1] / 2),
+        makeSquare: opts.makeSquare ?? false
+      };
+      return generatePreview3(input, options);
+    },
+    onProcess: async (opts) => {
+      const logs = [];
+      if (!await checkImageMagick()) {
+        return {
+          success: false,
+          error: "ImageMagick not found",
+          logs: [{ type: "error", message: "ImageMagick not found" }]
+        };
+      }
+      const options = {
+        width: opts.width ?? Math.round(dims[0] / 2),
+        height: opts.height ?? Math.round(dims[1] / 2),
+        makeSquare: opts.makeSquare ?? false
+      };
+      logs.push({ type: "info", message: `Scaling to ${options.width}x${options.height}...` });
+      const output = `${fileInfo.dirname}/${fileInfo.filename}_scaled${fileInfo.extension}`;
+      let scaled = false;
+      if (options.makeSquare) {
+        const maxDim = Math.max(options.width, options.height);
+        scaled = await scaleWithPadding(input, output, maxDim, maxDim);
+      } else {
+        scaled = await resize(input, output, options.width, options.height);
+      }
+      if (scaled && existsSync8(output)) {
+        const finalDims = await getDimensions(output);
+        const sizeStr = finalDims ? ` (${finalDims[0]}x${finalDims[1]})` : "";
+        logs.push({ type: "success", message: "Scaled successfully" });
+        return {
+          success: true,
+          output: `${basename6(output)}${sizeStr}`,
+          logs
+        };
+      }
+      logs.push({ type: "error", message: "Scaling failed" });
+      return { success: false, error: "Scaling failed", logs };
+    }
+  });
+}
+async function generatePreview3(input, options) {
+  const tempDir = tmpdir4();
+  const timestamp = Date.now();
+  const tempOutput = join7(tempDir, `piclet-preview-${timestamp}.png`);
+  try {
+    let scaled = false;
+    let targetW = options.width;
+    let targetH = options.height;
+    if (options.makeSquare) {
+      const maxDim = Math.max(targetW, targetH);
+      targetW = maxDim;
+      targetH = maxDim;
+      scaled = await scaleWithPadding(input, tempOutput, targetW, targetH);
+    } else {
+      scaled = await resize(input, tempOutput, targetW, targetH);
+    }
+    if (!scaled || !existsSync8(tempOutput)) {
+      return { success: false, error: "Scaling failed" };
+    }
+    const buffer = readFileSync6(tempOutput);
+    const base64 = buffer.toString("base64");
+    const imageData = `data:image/png;base64,${base64}`;
+    const dims = await getDimensions(tempOutput);
+    cleanup(tempOutput);
+    return {
+      success: true,
+      imageData,
+      width: dims?.[0],
+      height: dims?.[1]
+    };
+  } catch (err) {
+    cleanup(tempOutput);
+    return { success: false, error: err.message };
+  }
+}
+var config5 = {
+  id: "rescale",
+  name: "Scale Image",
+  icon: "rescale.ico",
+  extensions: [".png", ".jpg", ".jpeg", ".gif", ".bmp"]
+};
+
+// src/tools/storepack.ts
+import { existsSync as existsSync9, mkdirSync as mkdirSync6 } from "fs";
+import { basename as basename7, join as join8 } from "path";
+async function scaleImage(input, output, width, height, mode) {
+  switch (mode) {
+    case "fill":
+      return scaleFillCrop(input, output, width, height);
+    case "stretch":
+      return resize(input, output, width, height);
+    case "fit":
+    default:
+      return scaleWithPadding(input, output, width, height);
+  }
+}
+async function generatePresetImages(sourceImg, outputDir, preset, scaleMode = "fit", logs) {
+  let failed = 0;
+  const total = preset.icons.length;
+  for (let i = 0; i < total; i++) {
+    const icon = preset.icons[i];
+    const outputPath = join8(outputDir, icon.filename);
+    if (logs) {
+      logs.push({ type: "info", message: `[${i + 1}/${total}] ${icon.filename}` });
+    } else {
+      wip(`[${i + 1}/${total}] Generating ${icon.filename}...`);
+    }
+    const scaled = await scaleImage(
+      sourceImg,
+      outputPath,
+      icon.width,
+      icon.height,
+      scaleMode
+    );
+    if (scaled) {
+      if (!logs) {
+        wipDone(true, `[${i + 1}/${total}] ${icon.filename} (${icon.width}x${icon.height})`);
+      }
+    } else {
+      if (logs) {
+        logs.push({ type: "error", message: `Failed: ${icon.filename}` });
+      } else {
+        wipDone(false, `[${i + 1}/${total}] Failed: ${icon.filename}`);
+      }
+      failed++;
+    }
+  }
+  return failed;
+}
+async function run5(inputRaw) {
+  if (!await checkImageMagick()) {
+    error("ImageMagick not found. Please install it:");
+    console.log("  sudo apt update && sudo apt install imagemagick");
+    await pauseOnError();
+    return false;
+  }
+  const input = normalizePath(inputRaw);
+  if (!existsSync9(input)) {
+    error(`File not found: ${input}`);
+    await pauseOnError();
+    return false;
+  }
+  const fileInfo = getFileInfo(input);
+  header("PicLet Store Pack");
+  wip("Analyzing source image...");
+  const dims = await getDimensions(input);
+  if (!dims) {
+    wipDone(false, "Failed to read image");
+    return false;
+  }
+  wipDone(true, `Source: ${dims[0]}x${dims[1]}`);
+  const presets = loadPresets();
+  const choices = presets.map((p) => ({
+    title: p.name,
+    value: p.id,
+    description: p.description
+  }));
+  console.log("");
+  const selectedId = await select("Select target store:", choices, presets[0].id);
+  const preset = presets.find((p) => p.id === selectedId);
+  if (!preset) {
+    error("Preset not found");
+    return false;
+  }
+  const outputDir = `${fileInfo.dirname}/${fileInfo.filename}_${preset.id}`;
+  mkdirSync6(outputDir, { recursive: true });
+  info(`Output: ${outputDir}`);
+  console.log("");
+  wip("Preparing source...");
+  const tempSource = join8(outputDir, ".source.png");
+  if (!await squarify(input, tempSource)) {
+    wipDone(false, "Failed to prepare source");
+    return false;
+  }
+  wipDone(true, "Source prepared");
+  console.log("");
+  header(`Generating ${preset.name} Images`);
+  const failed = await generatePresetImages(tempSource, outputDir, preset);
+  cleanup(tempSource);
+  console.log("");
+  if (failed === 0) {
+    success(`All ${preset.icons.length} images generated!`);
+  } else {
+    error(`${failed}/${preset.icons.length} images failed`);
+  }
+  info(`Output: ${outputDir}`);
+  return failed === 0;
+}
+async function runGUI6(inputRaw) {
+  const input = normalizePath(inputRaw);
+  if (!existsSync9(input)) {
+    error(`File not found: ${input}`);
+    return false;
+  }
+  const dims = await getDimensions(input);
+  if (!dims) {
+    error("Failed to read image dimensions");
+    return false;
+  }
+  const fileInfo = getFileInfo(input);
+  const presets = loadPresets();
+  return startGuiServer({
+    htmlFile: "storepack.html",
+    title: "PicLet - Store Pack",
+    imageInfo: {
+      filePath: input,
+      fileName: basename7(input),
+      width: dims[0],
+      height: dims[1],
+      borderColor: null
+    },
+    defaults: {
+      presets: presets.map((p) => ({
+        id: p.id,
+        name: p.name,
+        description: p.description,
+        icons: p.icons
+      }))
+    },
+    onProcess: async (opts) => {
+      const logs = [];
+      if (!await checkImageMagick()) {
+        return {
+          success: false,
+          error: "ImageMagick not found",
+          logs: [{ type: "error", message: "ImageMagick not found" }]
+        };
+      }
+      const presetId = opts.preset;
+      const scaleMode = opts.scaleMode || "fit";
+      const preset = presets.find((p) => p.id === presetId);
+      if (!preset) {
+        return {
+          success: false,
+          error: "Preset not found",
+          logs: [{ type: "error", message: "No preset selected" }]
+        };
+      }
+      const outputDir = `${fileInfo.dirname}/${fileInfo.filename}_${preset.id}`;
+      mkdirSync6(outputDir, { recursive: true });
+      logs.push({ type: "info", message: `Output: ${outputDir}` });
+      logs.push({ type: "info", message: `Scale mode: ${scaleMode}` });
+      logs.push({ type: "info", message: `Generating ${preset.icons.length} images...` });
+      const failed = await generatePresetImages(input, outputDir, preset, scaleMode, logs);
+      if (failed === 0) {
+        logs.push({ type: "success", message: `All ${preset.icons.length} images generated` });
+        return {
+          success: true,
+          output: `${preset.icons.length} images saved to ${fileInfo.filename}_${preset.id}/`,
+          logs
+        };
+      }
+      return {
+        success: false,
+        error: `${failed} image(s) failed`,
+        logs
+      };
+    }
+  });
+}
+var config6 = {
+  id: "storepack",
+  name: "Store Pack",
+  icon: "storepack.ico",
+  extensions: [".png", ".jpg", ".jpeg"]
+};
+
+// src/cli.ts
+var tools = [
+  { config: config2, run: run2 },
+  { config: config4, run: run3 },
+  { config: config5, run: run4 },
+  { config, run },
+  { config: config6, run: run5 }
+];
+var picletTool = { config: config3, runGUI: runGUI3 };
+var program = new Command();
+function getDistDir() {
+  const currentFile = fileURLToPath3(import.meta.url);
+  return dirname10(currentFile);
+}
+function getMenuBasePath(extension) {
+  return `HKCU\\Software\\Classes\\SystemFileAssociations\\${extension}\\shell\\PicLet`;
+}
+function getAllExtensions() {
+  const extensions = /* @__PURE__ */ new Set();
+  for (const { config: config7 } of tools) {
+    for (const ext of config7.extensions) {
+      extensions.add(ext);
+    }
+  }
+  return Array.from(extensions);
+}
+function getToolsForExtension(extension) {
+  return tools.filter((t) => t.config.extensions.includes(extension));
+}
+async function registerUnifiedMenu(extension, iconsDir, launcherPath) {
+  const basePath = `HKCU\\Software\\Classes\\SystemFileAssociations\\${extension}\\shell\\PicLet`;
+  const iconsDirWin = wslToWindows(iconsDir);
+  const launcherWin = wslToWindows(launcherPath);
+  const menuSuccess = await addRegistryKey(basePath, "MUIVerb", "PicLet");
+  const iconSuccess = await addRegistryKey(basePath, "Icon", `${iconsDirWin}\\banana.ico`);
+  await addRegistryKey(basePath, "MultiSelectModel", "Player");
+  const commandValue = `wscript.exe //B "${launcherWin}" piclet "%1" -g`;
+  const cmdSuccess = await addRegistryKey(`${basePath}\\command`, "", commandValue);
+  return {
+    extension,
+    toolName: "PicLet",
+    success: menuSuccess && iconSuccess && cmdSuccess
+  };
+}
+async function unregisterMenuForExtension(extension) {
+  const results = [];
+  const basePath = getMenuBasePath(extension);
+  const extensionTools = getToolsForExtension(extension);
+  for (const { config: config7 } of extensionTools) {
+    const toolPath = `${basePath}\\shell\\${config7.id}`;
+    await deleteRegistryKey(`${toolPath}\\command`);
+    const success2 = await deleteRegistryKey(toolPath);
+    results.push({
+      extension,
+      toolName: config7.name,
+      success: success2
+    });
+  }
+  await deleteRegistryKey(`${basePath}\\shell`);
+  await deleteRegistryKey(basePath);
+  return results;
+}
+async function registerAllTools(distDir) {
+  const iconsDir = join9(distDir, "icons");
+  const launcherPath = join9(distDir, "launcher.vbs");
+  const results = [];
+  for (const extension of picletTool.config.extensions) {
+    const result = await registerUnifiedMenu(extension, iconsDir, launcherPath);
+    results.push(result);
+  }
+  return results;
+}
+async function unregisterAllTools() {
+  const results = [];
+  const allExts = /* @__PURE__ */ new Set([...getAllExtensions(), ...picletTool.config.extensions]);
+  for (const extension of allExts) {
+    const basePath = getMenuBasePath(extension);
+    const extResults = await unregisterMenuForExtension(extension);
+    results.push(...extResults);
+    await deleteRegistryKey(`${basePath}\\command`);
+    await deleteRegistryKey(basePath);
+  }
+  return results;
+}
+function getTool(id) {
+  return tools.find((t) => t.config.id === id);
+}
+function validateExtensions(files, allowedExtensions) {
+  const valid = [];
+  const invalid = [];
+  for (const file of files) {
+    const ext = extname3(file).toLowerCase();
+    if (allowedExtensions.includes(ext)) {
+      valid.push(file);
+    } else {
+      invalid.push(file);
+    }
+  }
+  return { valid, invalid };
+}
+async function runToolOnFiles(toolId, files, useYes) {
+  const tool = getTool(toolId);
+  if (!tool) {
+    console.error(chalk.red(`Tool not found: ${toolId}`));
+    return false;
+  }
+  const { valid, invalid } = validateExtensions(files, tool.config.extensions);
+  if (invalid.length > 0) {
+    console.error(chalk.red("Invalid file types:"));
+    for (const file of invalid) {
+      console.error(chalk.red(`  \u2717 ${file}`));
+    }
+    console.error(
+      chalk.yellow(
+        `
+Supported extensions: ${tool.config.extensions.join(", ")}`
+      )
+    );
+    if (valid.length === 0) return false;
+    console.log();
+  }
+  if (useYes || valid.length > 1) {
+    setUseDefaults(true);
+  }
+  let allSuccess = true;
+  for (let i = 0; i < valid.length; i++) {
+    const file = valid[i];
+    if (valid.length > 1) {
+      console.log(chalk.cyan(`
+[${i + 1}/${valid.length}] ${file}`));
+    }
+    const success2 = await tool.run(file);
+    if (!success2) allSuccess = false;
+  }
+  return allSuccess;
+}
+function showHelp() {
+  showBanner();
+  const dim = chalk.gray;
+  const cmd = chalk.cyan;
+  const arg = chalk.yellow;
+  const opt = chalk.green;
+  const head = chalk.white.bold;
+  console.log(
+    `  ${head("Usage:")} piclet ${cmd("<command>")} ${arg("<file>")} ${opt("[options]")}`
+  );
+  console.log();
+  console.log(head("  Unified"));
+  console.log(
+    `    ${cmd("piclet")} ${arg("<file>")}     Open all tools in one window`
+  );
+  console.log();
+  console.log(head("  Individual Tools"));
+  console.log(
+    `    ${cmd("makeicon")} ${arg("<file>")}   Convert PNG to multi-resolution ICO`
+  );
+  console.log(
+    `    ${cmd("remove-bg")} ${arg("<file>")}  Remove solid background from image`
+  );
+  console.log(
+    `    ${cmd("scale")} ${arg("<file>")}      Resize image with optional padding`
+  );
+  console.log(
+    `    ${cmd("iconpack")} ${arg("<file>")}   Generate icon sets for Web/Android/iOS`
+  );
+  console.log(
+    `    ${cmd("storepack")} ${arg("<file>")}  Generate assets for app stores`
+  );
+  console.log();
+  console.log(head("  Setup"));
+  console.log(
+    `    ${cmd("install")}              Add Windows right-click menu`
+  );
+  console.log(`    ${cmd("uninstall")}            Remove right-click menu`);
+  console.log();
+  console.log(head("  Config"));
+  console.log(`    ${cmd("config")}               Display current settings`);
+  console.log(`    ${cmd("config reset")}         Restore defaults`);
+  console.log();
+  console.log(head("  Examples"));
+  console.log(`    ${dim("$")} piclet ${cmd("piclet")} ${arg("image.png")}         ${dim("# All tools in one window")}`);
+  console.log(`    ${dim("$")} piclet ${cmd("makeicon")} ${arg("logo.png")}        ${dim("# Interactive")}`);
+  console.log(`    ${dim("$")} piclet ${cmd("makeicon")} ${arg("*.png")} ${opt("-y")}        ${dim("# Batch with defaults")}`);
+  console.log(`    ${dim("$")} piclet ${cmd("remove-bg")} ${arg("photo.png")}      ${dim("# Interactive prompts")}`);
+  console.log(`    ${dim("$")} piclet ${cmd("scale")} ${arg("image.jpg")}          ${dim("# Interactive resize")}`);
+  console.log(`    ${dim("$")} piclet ${cmd("iconpack")} ${arg("icon.png")} ${opt("-y")}     ${dim("# All platforms")}`);
+  console.log();
+  console.log(head("  Requirements"));
+  console.log("    - WSL (Windows Subsystem for Linux)");
+  console.log("    - ImageMagick: sudo apt install imagemagick");
+  console.log();
+}
+program.helpInformation = () => "";
+program.on("--help", () => {
+});
+program.name("piclet").description("Image manipulation utility toolkit with Windows shell integration").version("1.0.0").action(() => {
+  showHelp();
+});
+program.command("help").description("Show help").action(() => {
+  showHelp();
+});
+program.command("install").description("Install Windows shell context menu integration").action(async () => {
+  showBanner();
+  console.log(chalk.bold("Installing...\n"));
+  if (!isWSL()) {
+    console.log(
+      chalk.yellow("! Not running in WSL. Registry integration skipped.")
+    );
+    console.log(
+      chalk.yellow('! Run "piclet install" from WSL to add context menu.')
+    );
+    return;
+  }
+  console.log(chalk.dim("Removing old entries..."));
+  await unregisterAllTools();
+  console.log();
+  const results = await registerAllTools(getDistDir());
+  const successCount = results.filter((r) => r.success).length;
+  for (const result of results) {
+    if (result.success) {
+      console.log(
+        `${chalk.green("\u2713")} ${result.extension} \u2192 ${result.toolName}`
+      );
+    } else {
+      console.log(
+        `${chalk.red("\u2717")} ${result.extension} \u2192 ${result.toolName} (failed)`
+      );
+    }
+  }
+  console.log();
+  if (successCount === results.length) {
+    console.log(
+      chalk.green(`\u2713 Registered ${successCount} context menu entries.`)
+    );
+  } else {
+    console.log(
+      chalk.yellow(`! Registered ${successCount}/${results.length} entries.`)
+    );
+  }
+  console.log(chalk.bold("\nUsage:"));
+  console.log("  Right-click any supported image in Windows Explorer.");
+  console.log("  Multi-select supported for batch processing.");
+  console.log();
+});
+program.command("uninstall").description("Remove Windows shell context menu integration").action(async () => {
+  showBanner();
+  console.log(chalk.bold("Uninstalling...\n"));
+  if (!isWSL()) {
+    console.log(
+      chalk.yellow("! Not running in WSL. Registry cleanup skipped.")
+    );
+    console.log(
+      chalk.yellow(
+        '! Run "piclet uninstall" from WSL to remove context menu.'
+      )
+    );
+    return;
+  }
+  const results = await unregisterAllTools();
+  const removedCount = results.filter((r) => r.success).length;
+  for (const result of results) {
+    if (result.success) {
+      console.log(
+        `${chalk.green("\u2713")} Removed: ${result.extension} \u2192 ${result.toolName}`
+      );
+    } else {
+      console.log(
+        `${chalk.gray("-")} Skipped: ${result.extension} \u2192 ${result.toolName}`
+      );
+    }
+  }
+  console.log();
+  console.log(
+    chalk.green(
+      `\u2713 Cleanup complete. Removed ${removedCount}/${results.length} entries.`
+    )
+  );
+  console.log(chalk.dim("\nThanks for using PicLet!\n"));
+});
+program.command("makeicon <files...>").description("Convert PNG to multi-resolution ICO file").option("-y, --yes", "Use defaults, skip prompts").option("-g, --gui", "Use GUI for confirmation").action(async (files, options) => {
+  if (options.gui) {
+    const { valid, invalid } = validateExtensions(files, config2.extensions);
+    if (invalid.length > 0) {
+      console.error(chalk.red("Invalid file types:"));
+      for (const file of invalid) {
+        console.error(chalk.red(`  - ${file}`));
+      }
+    }
+    if (valid.length === 0) {
+      process.exit(1);
+    }
+    const result = await runGUI2(valid[0]);
+    process.exit(result ? 0 : 1);
+  }
+  const success2 = await runToolOnFiles(
+    "makeicon",
+    files,
+    options.yes ?? false
+  );
+  process.exit(success2 ? 0 : 1);
+});
+program.command("remove-bg <files...>").alias("removebg").description("Remove solid background from image").option("-y, --yes", "Use defaults, skip prompts").option("-g, --gui", "Use TUI (terminal GUI) for options").option("-f, --fuzz <percent>", "Fuzz tolerance 0-100 (default: 10)").option("-t, --trim", "Trim transparent edges (default: true)").option("--no-trim", "Do not trim transparent edges").option("-p, --preserve-inner", "Preserve inner areas of same color").option("-s, --square", "Make output square with padding").action(async (files, options) => {
+  if (options.gui) {
+    const { valid, invalid } = validateExtensions(files, config4.extensions);
+    if (invalid.length > 0) {
+      console.error(chalk.red("Invalid file types:"));
+      for (const file of invalid) {
+        console.error(chalk.red(`  - ${file}`));
+      }
+    }
+    if (valid.length === 0) {
+      process.exit(1);
+    }
+    const result = await runGUI4(valid[0]);
+    process.exit(result ? 0 : 1);
+  }
+  if (options.fuzz !== void 0) {
+    setOverrides({ "fuzz": Number(options.fuzz) });
+  }
+  if (options.trim !== void 0) {
+    setOverrides({ "trim": options.trim });
+  }
+  if (options.preserveInner) {
+    setOverrides({ "preserve inner": true });
+  }
+  if (options.square) {
+    setOverrides({ "square": true });
+  }
+  const success2 = await runToolOnFiles(
+    "remove-bg",
+    files,
+    options.yes ?? false
+  );
+  clearOverrides();
+  process.exit(success2 ? 0 : 1);
+});
+program.command("scale <files...>").alias("rescale").description("Resize image with optional padding").option("-y, --yes", "Use defaults, skip prompts").option("-g, --gui", "Use GUI for options").action(async (files, options) => {
+  if (options.gui) {
+    const { valid, invalid } = validateExtensions(files, config5.extensions);
+    if (invalid.length > 0) {
+      console.error(chalk.red("Invalid file types:"));
+      for (const file of invalid) {
+        console.error(chalk.red(`  - ${file}`));
+      }
+    }
+    if (valid.length === 0) {
+      process.exit(1);
+    }
+    const result = await runGUI5(valid[0]);
+    process.exit(result ? 0 : 1);
+  }
+  const success2 = await runToolOnFiles(
+    "rescale",
+    files,
+    options.yes ?? false
+  );
+  process.exit(success2 ? 0 : 1);
+});
+program.command("iconpack <files...>").description("Generate icon sets for Web, Android, iOS").option("-y, --yes", "Use defaults, skip prompts").option("-g, --gui", "Use GUI for options").action(async (files, options) => {
+  if (options.gui) {
+    const { valid, invalid } = validateExtensions(files, config.extensions);
+    if (invalid.length > 0) {
+      console.error(chalk.red("Invalid file types:"));
+      for (const file of invalid) {
+        console.error(chalk.red(`  - ${file}`));
+      }
+    }
+    if (valid.length === 0) {
+      process.exit(1);
+    }
+    const result = await runGUI(valid[0]);
+    process.exit(result ? 0 : 1);
+  }
+  const success2 = await runToolOnFiles(
+    "iconpack",
+    files,
+    options.yes ?? false
+  );
+  process.exit(success2 ? 0 : 1);
+});
+program.command("storepack <files...>").description("Generate assets for app stores (Windows, Unity, Steam, etc.)").option("-y, --yes", "Use defaults, skip prompts").option("-g, --gui", "Use GUI for options").action(async (files, options) => {
+  if (options.gui) {
+    const { valid, invalid } = validateExtensions(files, config6.extensions);
+    if (invalid.length > 0) {
+      console.error(chalk.red("Invalid file types:"));
+      for (const file of invalid) {
+        console.error(chalk.red(`  - ${file}`));
+      }
+    }
+    if (valid.length === 0) {
+      process.exit(1);
+    }
+    const result = await runGUI6(valid[0]);
+    process.exit(result ? 0 : 1);
+  }
+  const success2 = await runToolOnFiles(
+    "storepack",
+    files,
+    options.yes ?? false
+  );
+  process.exit(success2 ? 0 : 1);
+});
+program.command("piclet <file>").description("Open unified PicLet window with all tools").option("-g, --gui", "Use GUI (default)").action(async (file) => {
+  const { valid, invalid } = validateExtensions([file], picletTool.config.extensions);
+  if (invalid.length > 0) {
+    console.error(chalk.red(`Invalid file type: ${file}`));
+    console.error(chalk.yellow(`Supported: ${picletTool.config.extensions.join(", ")}`));
+    process.exit(1);
+  }
+  const result = await picletTool.runGUI(valid[0]);
+  process.exit(result ? 0 : 1);
+});
+var configCmd = program.command("config").description("Display current settings").action(() => {
+  const config7 = loadConfig();
+  console.log(chalk.white.bold("\n  PicLet Configuration"));
+  console.log(chalk.gray(`  ${getConfigPath()}
+`));
+  console.log(JSON.stringify(config7, null, 2));
+  console.log();
+});
+configCmd.command("reset").description("Restore defaults").action(() => {
+  resetConfig();
+  console.log(chalk.green("Configuration reset to defaults."));
+});
+program.parseAsync(process.argv).catch((error2) => {
+  console.error(chalk.red(`Error: ${error2.message}`));
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map