zammy 1.3.0 → 1.3.2

package/dist/chunk-LLLEINP6.js

@@ -0,0 +1,1229 @@
+#!/usr/bin/env node
+
+// src/ui/colors.ts
+import chalk from "chalk";
+var palette = {
+  rose: "#FF6B6B",
+  coral: "#FF8E72",
+  peach: "#FFEAA7",
+  mint: "#96CEB4",
+  teal: "#4ECDC4",
+  sky: "#45B7D1",
+  lavender: "#DDA0DD",
+  purple: "#9B59B6",
+  gold: "#FFD700",
+  silver: "#C0C0C0"
+};
+var theme = {
+  primary: chalk.hex(palette.teal),
+  secondary: chalk.hex(palette.lavender),
+  success: chalk.hex("#2ECC71"),
+  warning: chalk.hex("#F39C12"),
+  error: chalk.hex("#E74C3C"),
+  dim: chalk.hex("#6C7A89"),
+  highlight: chalk.bold.white,
+  command: chalk.bold.hex(palette.teal),
+  prompt: chalk.bold.hex(palette.lavender),
+  accent: chalk.hex(palette.rose),
+  info: chalk.hex(palette.sky),
+  muted: chalk.dim.hex("#95A5A6"),
+  gold: chalk.hex(palette.gold),
+  rose: chalk.hex(palette.rose),
+  mint: chalk.hex(palette.mint),
+  peach: chalk.hex(palette.peach),
+  // Gradient text effects
+  gradient: (text) => {
+    const colors = [palette.rose, palette.coral, palette.peach, palette.mint, palette.teal];
+    return text.split("").map(
+      (char, i) => chalk.hex(colors[i % colors.length])(char)
+    ).join("");
+  },
+  rainbow: (text) => {
+    const colors = ["#FF6B6B", "#FF8E72", "#FFEAA7", "#96CEB4", "#4ECDC4", "#45B7D1", "#DDA0DD"];
+    return text.split("").map(
+      (char, i) => chalk.hex(colors[i % colors.length])(char)
+    ).join("");
+  },
+  ocean: (text) => {
+    const colors = ["#0077B6", "#00B4D8", "#48CAE4", "#90E0EF", "#CAF0F8"];
+    return text.split("").map(
+      (char, i) => chalk.hex(colors[i % colors.length])(char)
+    ).join("");
+  },
+  sunset: (text) => {
+    const colors = ["#FF6B6B", "#FF8E53", "#FFA07A", "#FFB347", "#FFD700"];
+    return text.split("").map(
+      (char, i) => chalk.hex(colors[i % colors.length])(char)
+    ).join("");
+  },
+  // Bold variants
+  b: {
+    primary: chalk.bold.hex(palette.teal),
+    secondary: chalk.bold.hex(palette.lavender),
+    success: chalk.bold.hex("#2ECC71"),
+    warning: chalk.bold.hex("#F39C12"),
+    error: chalk.bold.hex("#E74C3C")
+  }
+};
+var symbols = {
+  // Basic UI
+  arrow: "\u276F",
+  // ❯
+  check: "\u2714",
+  // ✔
+  cross: "\u2718",
+  // ✘
+  info: "\u2139",
+  // ℹ
+  warning: "\u26A0",
+  // ⚠
+  bullet: "\u2022",
+  // •
+  // Decorative
+  star: "\u2605",
+  // ★
+  heart: "\u2665",
+  // ♥
+  diamond: "\u2666",
+  // ♦
+  sparkle: "\u2728",
+  // ✨
+  lightning: "\u26A1",
+  // ⚡
+  // Emoji icons
+  fire: "\u{1F525}",
+  // 🔥
+  rocket: "\u{1F680}",
+  // 🚀
+  dice: "\u{1F3B2}",
+  // 🎲
+  coin: "\u{1FA99}",
+  // 🪙
+  lock: "\u{1F512}",
+  // 🔒
+  clock: "\u{1F552}",
+  // 🕒
+  chart: "\u{1F4CA}",
+  // 📊
+  note: "\u{1F4DD}",
+  // 📝
+  scroll: "\u{1F4DC}",
+  // 📜
+  clipboard: "\u{1F4CB}",
+  // 📋
+  palette: "\u{1F3A8}",
+  // 🎨
+  tomato: "\u{1F345}",
+  // 🍅
+  coffee: "\u2615",
+  // ☕
+  bell: "\u{1F514}",
+  // 🔔
+  gear: "\u2699",
+  // ⚙
+  folder: "\u{1F4C1}",
+  // 📁
+  terminal: "\u{1F4BB}",
+  // 💻
+  key: "\u{1F511}",
+  // 🔑
+  link: "\u{1F517}",
+  // 🔗
+  hourglass: "\u23F3"
+  // ⏳
+};
+var boxChars = {
+  rounded: { tl: "\u256D", tr: "\u256E", bl: "\u2570", br: "\u256F", h: "\u2500", v: "\u2502" },
+  sharp: { tl: "\u250C", tr: "\u2510", bl: "\u2514", br: "\u2518", h: "\u2500", v: "\u2502" },
+  double: { tl: "\u2554", tr: "\u2557", bl: "\u255A", br: "\u255D", h: "\u2550", v: "\u2551" },
+  heavy: { tl: "\u250F", tr: "\u2513", bl: "\u2517", br: "\u251B", h: "\u2501", v: "\u2503" }
+};
+var box = {
+  topLeft: "\u256D",
+  // ╭
+  topRight: "\u256E",
+  // ╮
+  bottomLeft: "\u2570",
+  // ╰
+  bottomRight: "\u256F",
+  // ╯
+  horizontal: "\u2500",
+  // ─
+  vertical: "\u2502",
+  // │
+  draw: (content, width = 50, style = "rounded") => {
+    const chars = boxChars[style];
+    const lines = [];
+    const innerWidth = width - 2;
+    lines.push(theme.dim(`${chars.tl}${chars.h.repeat(innerWidth)}${chars.tr}`));
+    content.forEach((line) => {
+      const stripped = line.replace(/\x1B\[[0-9;]*m/g, "");
+      const padding = innerWidth - stripped.length;
+      lines.push(theme.dim(chars.v) + line + " ".repeat(Math.max(0, padding)) + theme.dim(chars.v));
+    });
+    lines.push(theme.dim(`${chars.bl}${chars.h.repeat(innerWidth)}${chars.br}`));
+    return lines.join("\n");
+  },
+  // Simple title box
+  title: (title, width = 50) => {
+    const chars = boxChars.rounded;
+    const innerWidth = width - 2;
+    const titleLen = title.replace(/\x1B\[[0-9;]*m/g, "").length;
+    const leftPad = Math.floor((innerWidth - titleLen - 2) / 2);
+    const rightPad = innerWidth - titleLen - 2 - leftPad;
+    return theme.dim(`${chars.tl}${chars.h.repeat(leftPad)} `) + title + theme.dim(` ${chars.h.repeat(rightPad)}${chars.tr}`);
+  }
+};
+var progressBar = (percent, width = 30, showPercent = true) => {
+  const filled = Math.round(percent / 100 * width);
+  const empty = width - filled;
+  let color = theme.success;
+  if (percent > 70) color = theme.warning;
+  if (percent > 90) color = theme.error;
+  const bar = color("\u2588".repeat(filled)) + theme.dim("\u2591".repeat(empty));
+  return showPercent ? `${bar} ${percent.toFixed(0)}%` : bar;
+};
+var bubble = {
+  say: (text, width = 50) => {
+    const lines = [];
+    const innerWidth = width - 4;
+    const words = text.split(" ");
+    let currentLine = "";
+    const wrappedLines = [];
+    for (const word of words) {
+      if ((currentLine + " " + word).trim().length <= innerWidth) {
+        currentLine = (currentLine + " " + word).trim();
+      } else {
+        if (currentLine) wrappedLines.push(currentLine);
+        currentLine = word;
+      }
+    }
+    if (currentLine) wrappedLines.push(currentLine);
+    lines.push(theme.dim("  \u256D" + "\u2500".repeat(innerWidth + 2) + "\u256E"));
+    for (const line of wrappedLines) {
+      const padding = innerWidth - line.length;
+      lines.push(theme.dim("  \u2502 ") + line + " ".repeat(padding) + theme.dim(" \u2502"));
+    }
+    lines.push(theme.dim("  \u2570" + "\u2500".repeat(innerWidth + 2) + "\u256F"));
+    lines.push(theme.dim("    \u2572"));
+    lines.push(theme.dim("     \u2572"));
+    return lines.join("\n");
+  },
+  think: (text, width = 50) => {
+    const lines = [];
+    const innerWidth = width - 4;
+    lines.push(theme.dim("  \u256D" + "\u2500".repeat(innerWidth + 2) + "\u256E"));
+    const padding = innerWidth - text.length;
+    lines.push(theme.dim("  \u2502 ") + text + " ".repeat(Math.max(0, padding)) + theme.dim(" \u2502"));
+    lines.push(theme.dim("  \u2570" + "\u2500".repeat(innerWidth + 2) + "\u256F"));
+    lines.push(theme.dim("    \u25CB"));
+    lines.push(theme.dim("   \u25CB"));
+    return lines.join("\n");
+  }
+};
+var categoryIcons = {
+  "Utilities": "\u{1F527}",
+  "Fun": "\u{1F3AE}",
+  "Creative": "\u{1F3A8}",
+  "Dev": "\u{1F4BB}",
+  "Info": "\u{1F4E1}"
+};
+var spinnerFrames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+
+// src/commands/registry.ts
+var commands = /* @__PURE__ */ new Map();
+function registerCommand(command) {
+  commands.set(command.name, { ...command, source: "core" });
+}
+function registerPluginCommand(command, pluginName) {
+  commands.set(command.name, { ...command, source: "plugin", pluginName });
+}
+function unregisterPluginCommands(pluginName) {
+  for (const [name, cmd] of commands.entries()) {
+    if (cmd.source === "plugin" && cmd.pluginName === pluginName) {
+      commands.delete(name);
+    }
+  }
+}
+function getCommand(name) {
+  return commands.get(name);
+}
+function getAllCommands() {
+  return Array.from(commands.values());
+}
+function getPluginCommands() {
+  return Array.from(commands.values()).filter((cmd) => cmd.source === "plugin");
+}
+function checkCommandConflict(name) {
+  const existing = commands.get(name);
+  if (!existing) {
+    return { exists: false };
+  }
+  return {
+    exists: true,
+    source: existing.source,
+    pluginName: existing.pluginName
+  };
+}
+
+// src/plugins/storage.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+function createPluginStorage(pluginName, dataDir) {
+  const storagePath = join(dataDir, "data.json");
+  if (!existsSync(dataDir)) {
+    mkdirSync(dataDir, { recursive: true });
+  }
+  function loadData() {
+    try {
+      if (existsSync(storagePath)) {
+        const content = readFileSync(storagePath, "utf-8");
+        return JSON.parse(content);
+      }
+    } catch {
+    }
+    return {};
+  }
+  function saveData(data) {
+    try {
+      writeFileSync(storagePath, JSON.stringify(data, null, 2), "utf-8");
+    } catch (error) {
+      console.error(`Failed to save plugin storage for ${pluginName}:`, error);
+    }
+  }
+  return {
+    get(key) {
+      const data = loadData();
+      return data[key];
+    },
+    set(key, value) {
+      const data = loadData();
+      data[key] = value;
+      saveData(data);
+    },
+    delete(key) {
+      const data = loadData();
+      delete data[key];
+      saveData(data);
+    },
+    clear() {
+      saveData({});
+    },
+    getAll() {
+      return loadData();
+    }
+  };
+}
+
+// src/plugins/api.ts
+import { execSync, spawn as nodeSpawn } from "child_process";
+import { join as join2 } from "path";
+import { readFileSync as readFileSync2 } from "fs";
+import { fileURLToPath } from "url";
+import { dirname as dirname2 } from "path";
+function getZammyVersion() {
+  try {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname2(__filename);
+    const pkgPath = join2(__dirname, "..", "..", "package.json");
+    const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+    return pkg.version || "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function createPluginUI() {
+  return {
+    theme: {
+      primary: theme.primary,
+      secondary: theme.secondary,
+      accent: theme.accent,
+      success: theme.success,
+      warning: theme.warning,
+      error: theme.error,
+      info: theme.info,
+      dim: theme.dim,
+      gradient: theme.gradient
+    },
+    symbols: {
+      check: symbols.check,
+      cross: symbols.cross,
+      star: symbols.star,
+      arrow: symbols.arrow,
+      bullet: symbols.bullet,
+      folder: symbols.folder,
+      file: "\u{1F4C4}",
+      // 📄
+      warning: symbols.warning,
+      info: symbols.info,
+      rocket: symbols.rocket,
+      sparkles: symbols.sparkle
+    },
+    box: (content, options) => {
+      const lines = content.split("\n");
+      const width = Math.max(...lines.map((l) => l.replace(/\x1B\[[0-9;]*m/g, "").length)) + 4;
+      return box.draw(lines, width);
+    },
+    progressBar: (current, total, width) => {
+      const percent = Math.round(current / total * 100);
+      return progressBar(percent, width || 30);
+    }
+  };
+}
+function createPluginLogger(pluginName) {
+  const prefix = theme.dim(`[${pluginName}]`);
+  return {
+    info: (message) => console.log(`${prefix} ${theme.info(message)}`),
+    warn: (message) => console.log(`${prefix} ${theme.warning(message)}`),
+    error: (message) => console.log(`${prefix} ${theme.error(message)}`),
+    debug: (message) => {
+      if (process.env.ZAMMY_DEBUG) {
+        console.log(`${prefix} ${theme.dim(message)}`);
+      }
+    }
+  };
+}
+function createPluginShell(manifest) {
+  if (!manifest.permissions?.shell) {
+    return void 0;
+  }
+  return {
+    exec: (command, options) => {
+      try {
+        return execSync(command, {
+          encoding: "utf-8",
+          timeout: options?.timeout || 3e4,
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+      } catch (error) {
+        if (error && typeof error === "object" && "stdout" in error) {
+          return error.stdout || "";
+        }
+        throw error;
+      }
+    },
+    spawn: (command, args) => {
+      return new Promise((resolve2) => {
+        const proc = nodeSpawn(command, args || [], {
+          shell: true,
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        let stdout = "";
+        let stderr = "";
+        proc.stdout?.on("data", (data) => {
+          stdout += data.toString();
+        });
+        proc.stderr?.on("data", (data) => {
+          stderr += data.toString();
+        });
+        proc.on("close", (code) => {
+          resolve2({ stdout, stderr, code: code || 0 });
+        });
+        proc.on("error", () => {
+          resolve2({ stdout, stderr, code: 1 });
+        });
+      });
+    }
+  };
+}
+function createPluginAPI(manifest, pluginPath) {
+  const dataDir = pluginPath;
+  const context = {
+    pluginName: manifest.name,
+    pluginVersion: manifest.version,
+    zammyVersion: getZammyVersion(),
+    dataDir,
+    cwd: process.cwd()
+  };
+  return {
+    registerCommand: (command) => {
+      registerPluginCommand(command, manifest.name);
+    },
+    registerCommands: (commands2) => {
+      for (const command of commands2) {
+        registerPluginCommand(command, manifest.name);
+      }
+    },
+    ui: createPluginUI(),
+    storage: createPluginStorage(manifest.name, dataDir),
+    log: createPluginLogger(manifest.name),
+    context,
+    shell: createPluginShell(manifest)
+  };
+}
+
+// src/plugins/loader.ts
+import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync4, mkdirSync as mkdirSync2 } from "fs";
+import { join as join4, normalize, isAbsolute } from "path";
+import { homedir } from "os";
+import { pathToFileURL } from "url";
+
+// src/utils/version.ts
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
+import { join as join3, dirname as dirname3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var cachedVersion = null;
+function getZammyVersion2() {
+  if (cachedVersion) {
+    return cachedVersion;
+  }
+  try {
+    const __filename = fileURLToPath2(import.meta.url);
+    const __dirname = dirname3(__filename);
+    const possiblePaths = [
+      join3(__dirname, "package.json"),
+      // Same dir
+      join3(__dirname, "..", "package.json"),
+      // One up (dist/)
+      join3(__dirname, "..", "..", "package.json")
+      // Two up (src/utils/)
+    ];
+    for (const pkgPath of possiblePaths) {
+      if (existsSync2(pkgPath)) {
+        const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
+        if (pkg.name === "zammy" && pkg.version) {
+          cachedVersion = pkg.version;
+          return pkg.version;
+        }
+      }
+    }
+    return "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function compareVersions(a, b) {
+  const partsA = a.split(".").map((n) => parseInt(n, 10) || 0);
+  const partsB = b.split(".").map((n) => parseInt(n, 10) || 0);
+  for (let i = 0; i < 3; i++) {
+    const numA = partsA[i] || 0;
+    const numB = partsB[i] || 0;
+    if (numA < numB) return -1;
+    if (numA > numB) return 1;
+  }
+  return 0;
+}
+
+// src/plugins/loader.ts
+var PLUGINS_DIR = join4(homedir(), ".zammy", "plugins");
+function isValidEntryPoint(basePath, entryPoint) {
+  const normalized = normalize(entryPoint);
+  if (isAbsolute(normalized)) {
+    return false;
+  }
+  if (normalized.includes("..")) {
+    return false;
+  }
+  return true;
+}
+function checkVersionCompatibility(manifest, zammyVersion) {
+  const minVersion = manifest.zammy?.minVersion;
+  const maxVersion = manifest.zammy?.maxVersion;
+  if (minVersion && compareVersions(zammyVersion, minVersion) < 0) {
+    return {
+      compatible: false,
+      reason: `Requires Zammy v${minVersion}+, but you have v${zammyVersion}`
+    };
+  }
+  if (maxVersion && compareVersions(zammyVersion, maxVersion) > 0) {
+    return {
+      compatible: false,
+      reason: `Incompatible with Zammy v${zammyVersion} (max: v${maxVersion})`
+    };
+  }
+  return { compatible: true };
+}
+var discoveredPlugins = /* @__PURE__ */ new Map();
+var loadedPlugins = /* @__PURE__ */ new Map();
+function ensurePluginsDir() {
+  if (!existsSync3(PLUGINS_DIR)) {
+    mkdirSync2(PLUGINS_DIR, { recursive: true });
+  }
+}
+function getPluginsDir() {
+  return PLUGINS_DIR;
+}
+async function discoverPlugins() {
+  ensurePluginsDir();
+  discoveredPlugins.clear();
+  if (!existsSync3(PLUGINS_DIR)) {
+    return [];
+  }
+  const zammyVersion = getZammyVersion2();
+  const entries = readdirSync(PLUGINS_DIR, { withFileTypes: true });
+  const manifests = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const pluginPath = join4(PLUGINS_DIR, entry.name);
+    const manifestPath = join4(pluginPath, "zammy-plugin.json");
+    if (!existsSync3(manifestPath)) continue;
+    try {
+      const manifestContent = readFileSync4(manifestPath, "utf-8");
+      const manifest = JSON.parse(manifestContent);
+      if (!manifest.name || !manifest.version || !manifest.main || !manifest.commands) {
+        console.log(theme.warning(`  ${symbols.warning} Invalid manifest for plugin in ${entry.name}`));
+        continue;
+      }
+      const compatibility = checkVersionCompatibility(manifest, zammyVersion);
+      if (!compatibility.compatible) {
+        console.log(theme.warning(`  ${symbols.warning} Plugin '${manifest.name}' skipped: ${compatibility.reason}`));
+        continue;
+      }
+      discoveredPlugins.set(manifest.name, { manifest, path: pluginPath });
+      manifests.push(manifest);
+    } catch (error) {
+      console.log(theme.warning(`  ${symbols.warning} Failed to read manifest for ${entry.name}`));
+    }
+  }
+  return manifests;
+}
+async function loadPlugin(name) {
+  if (loadedPlugins.has(name)) {
+    const existing = loadedPlugins.get(name);
+    if (existing.state === "error") {
+      return null;
+    }
+    return existing;
+  }
+  const discovered = discoveredPlugins.get(name);
+  if (!discovered) {
+    return null;
+  }
+  const { manifest, path: pluginPath } = discovered;
+  try {
+    if (!isValidEntryPoint(pluginPath, manifest.main)) {
+      throw new Error("Invalid plugin entry point: path traversal not allowed");
+    }
+    const mainPath = join4(pluginPath, manifest.main);
+    if (!existsSync3(mainPath)) {
+      throw new Error(`Plugin entry point not found: ${mainPath}`);
+    }
+    const moduleUrl = pathToFileURL(mainPath).href;
+    const module = await import(moduleUrl);
+    const plugin = module.default;
+    if (!plugin || typeof plugin.activate !== "function") {
+      throw new Error("Plugin must export a default object with an activate function");
+    }
+    const api = createPluginAPI(manifest, pluginPath);
+    try {
+      await plugin.activate(api);
+    } catch (activationError) {
+      const msg = activationError instanceof Error ? activationError.message : String(activationError);
+      throw new Error(`Plugin activation failed: ${msg}`);
+    }
+    const loaded = {
+      manifest,
+      instance: plugin,
+      path: pluginPath,
+      state: "active"
+    };
+    loadedPlugins.set(name, loaded);
+    return loaded;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.log(theme.error(`  ${symbols.cross} Failed to load plugin '${name}': ${errorMessage}`));
+    const failedPlugin = {
+      manifest,
+      instance: { activate: async () => {
+      } },
+      path: pluginPath,
+      state: "error"
+    };
+    loadedPlugins.set(name, failedPlugin);
+    return null;
+  }
+}
+async function unloadPlugin(name) {
+  const loaded = loadedPlugins.get(name);
+  if (!loaded) {
+    return false;
+  }
+  try {
+    if (loaded.instance.deactivate) {
+      await loaded.instance.deactivate();
+    }
+    unregisterPluginCommands(name);
+    loadedPlugins.delete(name);
+    return true;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.log(theme.error(`  ${symbols.cross} Failed to unload plugin '${name}': ${errorMessage}`));
+    return false;
+  }
+}
+function getDiscoveredPlugins() {
+  return Array.from(discoveredPlugins.values()).map((p) => p.manifest);
+}
+function getLoadedPlugins() {
+  return Array.from(loadedPlugins.values());
+}
+function isPluginLoaded(name) {
+  return loadedPlugins.has(name);
+}
+function getPluginPath(name) {
+  return discoveredPlugins.get(name)?.path;
+}
+async function initPluginLoader() {
+  const manifests = await discoverPlugins();
+  for (const manifest of manifests) {
+    for (const cmdName of manifest.commands) {
+      const lazyExecute = async (args) => {
+        const loaded = await loadPlugin(manifest.name);
+        if (!loaded) {
+          console.log(theme.error(`  ${symbols.cross} Failed to load plugin '${manifest.name}'`));
+          console.log(theme.dim(`  Try reinstalling: /plugin remove ${manifest.name} && /plugin install ${manifest.name}`));
+          return;
+        }
+        const realCommand = getCommand(cmdName);
+        if (realCommand && realCommand.execute !== lazyExecute) {
+          await realCommand.execute(args);
+        } else {
+          console.log(theme.error(`  ${symbols.cross} Plugin '${manifest.name}' did not register command '${cmdName}'`));
+          console.log(theme.dim(`  The plugin may be misconfigured or corrupted.`));
+        }
+      };
+      registerPluginCommand(
+        {
+          name: cmdName,
+          description: `[${manifest.displayName || manifest.name}] Plugin command`,
+          usage: `/${cmdName}`,
+          execute: lazyExecute
+        },
+        manifest.name
+      );
+    }
+  }
+}
+
+// src/plugins/installer.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, cpSync, rmSync, readFileSync as readFileSync5, readdirSync as readdirSync2, createReadStream, createWriteStream, lstatSync } from "fs";
+import { join as join5, resolve, isAbsolute as isAbsolute2, normalize as normalize2 } from "path";
+import { execFileSync, spawnSync } from "child_process";
+import { tmpdir, platform } from "os";
+import { createGunzip } from "zlib";
+import { pipeline } from "stream/promises";
+
+// src/utils/security.ts
+function isValidPluginName(name) {
+  if (!name || typeof name !== "string") {
+    return false;
+  }
+  if (name.includes("..") || name.includes("/") || name.includes("\\")) {
+    if (name.startsWith("@") && name.split("/").length === 2) {
+      const [scope, pkg] = name.split("/");
+      return isValidScopedName(scope, pkg);
+    }
+    return false;
+  }
+  return /^[a-zA-Z0-9_-]+$/.test(name);
+}
+function isValidScopedName(scope, pkg) {
+  return /^@[a-z0-9-~][a-z0-9-._~]*$/.test(scope) && /^[a-z0-9-~][a-z0-9-._~]*$/.test(pkg);
+}
+function isValidNpmPackageName(name) {
+  if (!name || typeof name !== "string") {
+    return false;
+  }
+  if (name.startsWith("@")) {
+    return /^@[a-z0-9-~][a-z0-9-._~]*\/[a-z0-9-~][a-z0-9-._~]*$/.test(name);
+  }
+  return /^[a-z0-9-~][a-z0-9-._~]*$/.test(name);
+}
+function isValidGitHubRepo(repo) {
+  if (!repo || typeof repo !== "string") {
+    return false;
+  }
+  const path = repo.replace(/^github:/, "");
+  const [repoPath] = path.split("#");
+  return /^[a-zA-Z0-9_-]+\/[a-zA-Z0-9_.-]+$/.test(repoPath);
+}
+function isValidBranchName(branch) {
+  if (!branch || typeof branch !== "string") {
+    return false;
+  }
+  if (/[\s~^:?*\[\]\\]/.test(branch) || branch.includes("..")) {
+    return false;
+  }
+  return /^[a-zA-Z0-9/_.-]+$/.test(branch);
+}
+function isValidGitUrl(url) {
+  if (!url || typeof url !== "string") {
+    return false;
+  }
+  if (url.startsWith("https://") && url.endsWith(".git")) {
+    return true;
+  }
+  if (url.startsWith("git@") && url.includes(":") && url.endsWith(".git")) {
+    return true;
+  }
+  if (url.startsWith("git://") && url.endsWith(".git")) {
+    return true;
+  }
+  return false;
+}
+
+// src/plugins/installer.ts
+var isWindows = platform() === "win32";
+function validatePluginPath(basePath, targetPath) {
+  const normalizedTarget = normalize2(targetPath);
+  if (isAbsolute2(normalizedTarget)) {
+    return false;
+  }
+  if (normalizedTarget.includes("..")) {
+    return false;
+  }
+  if (targetPath.includes("\\") && !isWindows) {
+    return false;
+  }
+  return true;
+}
+function containsSymlinks(dirPath) {
+  try {
+    const entries = readdirSync2(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join5(dirPath, entry.name);
+      const stat = lstatSync(fullPath);
+      if (stat.isSymbolicLink()) {
+        return true;
+      }
+      if (stat.isDirectory()) {
+        if (containsSymlinks(fullPath)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function checkVersionCompatibility2(manifest) {
+  const zammyVersion = getZammyVersion2();
+  const minVersion = manifest.zammy?.minVersion;
+  const maxVersion = manifest.zammy?.maxVersion;
+  if (minVersion && compareVersions(zammyVersion, minVersion) < 0) {
+    return {
+      compatible: false,
+      reason: `Requires Zammy v${minVersion}+, but you have v${zammyVersion}`
+    };
+  }
+  if (maxVersion && compareVersions(zammyVersion, maxVersion) > 0) {
+    return {
+      compatible: false,
+      reason: `Incompatible with Zammy v${zammyVersion} (max supported: v${maxVersion})`
+    };
+  }
+  return { compatible: true };
+}
+async function extractTarGz(tarGzPath, destDir) {
+  const tarGzForTar = isWindows ? tarGzPath.replace(/\\/g, "/") : tarGzPath;
+  const destForTar = isWindows ? destDir.replace(/\\/g, "/") : destDir;
+  try {
+    let result;
+    if (isWindows) {
+      result = spawnSync(`tar --force-local -xzf "${tarGzForTar}" -C "${destForTar}"`, {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+        shell: true
+      });
+    } else {
+      result = spawnSync("tar", ["-xzf", tarGzPath, "-C", destDir], {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    }
+    if (result.status === 0) return;
+  } catch {
+  }
+  const tarPath = tarGzPath.replace(/\.tgz$|\.tar\.gz$/, ".tar");
+  const tarForTar = isWindows ? tarPath.replace(/\\/g, "/") : tarPath;
+  try {
+    await pipeline(
+      createReadStream(tarGzPath),
+      createGunzip(),
+      createWriteStream(tarPath)
+    );
+    let result;
+    if (isWindows) {
+      result = spawnSync(`tar --force-local -xf "${tarForTar}" -C "${destForTar}"`, {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+        shell: true
+      });
+    } else {
+      result = spawnSync("tar", ["-xf", tarPath, "-C", destDir], {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    }
+    if (result.status === 0) {
+      rmSync(tarPath, { force: true });
+      return;
+    }
+    rmSync(tarPath, { force: true });
+  } catch (err) {
+    try {
+      rmSync(tarPath, { force: true });
+    } catch {
+    }
+  }
+  throw new Error(
+    "Unable to extract plugin archive. Please ensure tar is available.\n" + (isWindows ? "On Windows 10+, tar should be built-in. Try running: tar --version" : "Install tar and try again.")
+  );
+}
+function validateManifest(manifest) {
+  const errors = [];
+  if (!manifest || typeof manifest !== "object") {
+    return { valid: false, errors: ["Manifest must be an object"] };
+  }
+  const m = manifest;
+  if (!m.name || typeof m.name !== "string") {
+    errors.push('Missing or invalid "name" field');
+  } else if (!isValidPluginName(m.name)) {
+    errors.push("Invalid plugin name: must contain only alphanumeric, dash, underscore");
+  }
+  if (!m.version || typeof m.version !== "string") {
+    errors.push('Missing or invalid "version" field');
+  }
+  if (!m.main || typeof m.main !== "string") {
+    errors.push('Missing or invalid "main" field');
+  } else {
+    const mainPath = m.main;
+    if (!validatePluginPath(".", mainPath)) {
+      errors.push('Invalid "main" field: path traversal not allowed');
+    }
+  }
+  if (!m.commands || !Array.isArray(m.commands) || m.commands.length === 0) {
+    errors.push('Missing or invalid "commands" field (must be non-empty array)');
+  }
+  if (!m.zammy || typeof m.zammy !== "object") {
+    errors.push('Missing or invalid "zammy" field');
+  } else {
+    const zammy = m.zammy;
+    if (!zammy.minVersion || typeof zammy.minVersion !== "string") {
+      errors.push('Missing or invalid "zammy.minVersion" field');
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+function checkConflicts(manifest) {
+  const conflicts = [];
+  for (const cmd of manifest.commands) {
+    const conflict = checkCommandConflict(cmd);
+    if (conflict.exists) {
+      if (conflict.source === "core") {
+        conflicts.push(`Command '/${cmd}' conflicts with core zammy command`);
+      } else {
+        conflicts.push(`Command '/${cmd}' conflicts with plugin '${conflict.pluginName}'`);
+      }
+    }
+  }
+  return { hasConflicts: conflicts.length > 0, conflicts };
+}
+function formatPermissions(manifest) {
+  const perms = [];
+  const p = manifest.permissions;
+  if (!p) return perms;
+  if (p.shell) {
+    perms.push(`${symbols.warning} shell: Can run system commands`);
+  }
+  if (p.filesystem) {
+    if (p.filesystem === true) {
+      perms.push(`${symbols.warning} filesystem: Full file system access`);
+    } else if (Array.isArray(p.filesystem)) {
+      perms.push(`${symbols.info} filesystem: Access to ${p.filesystem.join(", ")}`);
+    }
+  }
+  if (p.network) {
+    if (p.network === true) {
+      perms.push(`${symbols.warning} network: Full network access`);
+    } else if (Array.isArray(p.network)) {
+      perms.push(`${symbols.info} network: Access to ${p.network.join(", ")}`);
+    }
+  }
+  return perms;
+}
+async function installFromLocal(sourcePath) {
+  try {
+    const absPath = resolve(sourcePath);
+    if (!existsSync4(absPath)) {
+      return { success: false, error: `Path not found: ${absPath}` };
+    }
+    const manifestPath = join5(absPath, "zammy-plugin.json");
+    if (!existsSync4(manifestPath)) {
+      return { success: false, error: "No zammy-plugin.json found in source directory" };
+    }
+    const manifestContent = readFileSync5(manifestPath, "utf-8");
+    let manifest;
+    try {
+      manifest = JSON.parse(manifestContent);
+    } catch {
+      return { success: false, error: "Invalid JSON in zammy-plugin.json" };
+    }
+    const validation = validateManifest(manifest);
+    if (!validation.valid) {
+      return { success: false, error: `Invalid manifest: ${validation.errors.join(", ")}` };
+    }
+    const versionCheck = checkVersionCompatibility2(manifest);
+    if (!versionCheck.compatible) {
+      return { success: false, error: versionCheck.reason };
+    }
+    if (!validatePluginPath(absPath, manifest.main)) {
+      return { success: false, error: "Invalid entry point path: path traversal not allowed" };
+    }
+    const mainPath = join5(absPath, manifest.main);
+    if (!existsSync4(mainPath)) {
+      return { success: false, error: `Entry point not found: ${manifest.main}` };
+    }
+    if (containsSymlinks(absPath)) {
+      return { success: false, error: "Plugin contains symbolic links, which are not allowed for security reasons" };
+    }
+    ensurePluginsDir();
+    const targetDir = join5(getPluginsDir(), manifest.name);
+    if (existsSync4(targetDir)) {
+      rmSync(targetDir, { recursive: true, force: true });
+    }
+    cpSync(absPath, targetDir, { recursive: true });
+    return { success: true, manifest };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { success: false, error: message };
+  }
+}
+async function installFromNpm(packageName) {
+  if (!isValidNpmPackageName(packageName)) {
+    return { success: false, error: "Invalid npm package name" };
+  }
+  const tempDir = join5(tmpdir(), `zammy-plugin-${Date.now()}`);
+  try {
+    mkdirSync3(tempDir, { recursive: true });
+    console.log(theme.dim(`  Downloading ${packageName}...`));
+    const packResult = spawnSync(`npm pack ${packageName} --pack-destination="${tempDir}"`, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 6e4,
+      shell: true
+    });
+    if (packResult.status !== 0) {
+      throw new Error(packResult.stderr || "npm pack failed");
+    }
+    const files = readdirSync2(tempDir);
+    const tarball = files.find((f) => f.endsWith(".tgz"));
+    if (!tarball) {
+      return { success: false, error: "Failed to download package" };
+    }
+    const extractDir = join5(tempDir, "extract");
+    mkdirSync3(extractDir);
+    await extractTarGz(join5(tempDir, tarball), extractDir);
+    const packageDir = join5(extractDir, "package");
+    if (!existsSync4(packageDir)) {
+      return { success: false, error: "Invalid package structure" };
+    }
+    return await installFromLocal(packageDir);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { success: false, error: `npm install failed: ${message}` };
+  } finally {
+    try {
+      rmSync(tempDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+async function installFromGithub(repo) {
+  let repoPath = repo.replace(/^github:/, "");
+  let branch = "main";
+  if (repoPath.includes("#")) {
+    const parts = repoPath.split("#");
+    repoPath = parts[0];
+    branch = parts[1] || "main";
+  }
+  if (!isValidGitHubRepo(repoPath)) {
+    return { success: false, error: "Invalid GitHub repository format. Use: user/repo or user/repo#branch" };
+  }
+  if (!isValidBranchName(branch)) {
+    return { success: false, error: "Invalid branch name" };
+  }
+  const tempDir = join5(tmpdir(), `zammy-plugin-${Date.now()}`);
+  try {
+    mkdirSync3(tempDir, { recursive: true });
+    console.log(theme.dim(`  Cloning ${repoPath}...`));
+    execFileSync("git", ["clone", "--depth", "1", "--branch", branch, `https://github.com/${repoPath}.git`, tempDir], {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 12e4
+    });
+    const pkgJsonPath = join5(tempDir, "package.json");
+    if (existsSync4(pkgJsonPath)) {
+      try {
+        const pkgJson = JSON.parse(readFileSync5(pkgJsonPath, "utf-8"));
+        if (pkgJson.scripts?.build) {
+          console.log(theme.warning(`  ${symbols.warning} This plugin requires building.`));
+          console.log(theme.warning(`  ${symbols.warning} npm install and npm run build will execute scripts from the repository.`));
+          console.log(theme.dim(`  Installing dependencies...`));
+          const installResult = spawnSync("npm install --ignore-scripts", {
+            cwd: tempDir,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+            timeout: 12e4,
+            shell: true
+          });
+          if (installResult.status !== 0) {
+            throw new Error(installResult.stderr || "npm install failed");
+          }
+          console.log(theme.dim(`  Building...`));
+          const buildResult = spawnSync("npm run build", {
+            cwd: tempDir,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+            timeout: 12e4,
+            shell: true
+          });
+          if (buildResult.status !== 0) {
+            throw new Error(buildResult.stderr || "npm run build failed");
+          }
+        }
+      } catch (buildError) {
+        const msg = buildError instanceof Error ? buildError.message : String(buildError);
+        return { success: false, error: `Build failed: ${msg}` };
+      }
+    }
+    return await installFromLocal(tempDir);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { success: false, error: `GitHub install failed: ${message}` };
+  } finally {
+    try {
+      rmSync(tempDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+async function installFromGit(url) {
+  if (!isValidGitUrl(url)) {
+    return { success: false, error: "Invalid git URL. Must be https://*.git, git@*:*.git, or git://*.git" };
+  }
+  const tempDir = join5(tmpdir(), `zammy-plugin-${Date.now()}`);
+  try {
+    mkdirSync3(tempDir, { recursive: true });
+    console.log(theme.dim(`  Cloning from ${url}...`));
+    execFileSync("git", ["clone", "--depth", "1", url, tempDir], {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 12e4
+    });
+    const pkgJsonPath = join5(tempDir, "package.json");
+    if (existsSync4(pkgJsonPath)) {
+      try {
+        const pkgJson = JSON.parse(readFileSync5(pkgJsonPath, "utf-8"));
+        if (pkgJson.scripts?.build) {
+          console.log(theme.warning(`  ${symbols.warning} This plugin requires building.`));
+          console.log(theme.dim(`  Installing dependencies...`));
+          const installResult = spawnSync("npm install --ignore-scripts", {
+            cwd: tempDir,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+            timeout: 12e4,
+            shell: true
+          });
+          if (installResult.status !== 0) {
+            throw new Error(installResult.stderr || "npm install failed");
+          }
+          console.log(theme.dim(`  Building...`));
+          const buildResult = spawnSync("npm run build", {
+            cwd: tempDir,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+            timeout: 12e4,
+            shell: true
+          });
+          if (buildResult.status !== 0) {
+            throw new Error(buildResult.stderr || "npm run build failed");
+          }
+        }
+      } catch (buildError) {
+        const msg = buildError instanceof Error ? buildError.message : String(buildError);
+        return { success: false, error: `Build failed: ${msg}` };
+      }
+    }
+    return await installFromLocal(tempDir);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { success: false, error: `Git install failed: ${message}` };
+  } finally {
+    try {
+      rmSync(tempDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+function removePlugin(name) {
+  if (!isValidPluginName(name)) {
+    return { success: false, error: "Invalid plugin name" };
+  }
+  try {
+    const pluginDir = join5(getPluginsDir(), name);
+    if (!existsSync4(pluginDir)) {
+      return { success: false, error: `Plugin '${name}' not found` };
+    }
+    rmSync(pluginDir, { recursive: true, force: true });
+    return { success: true };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { success: false, error: message };
+  }
+}
+function detectSourceType(source) {
+  if (source.startsWith("./") || source.startsWith("/") || source.startsWith("..") || /^[A-Za-z]:/.test(source)) {
+    return "local";
+  }
+  if (source.startsWith("github:")) {
+    return "github";
+  }
+  if (source.includes("github.com")) {
+    return "github";
+  }
+  if (source.endsWith(".git") || source.startsWith("git@") || source.startsWith("git://")) {
+    return "git";
+  }
+  if (isValidNpmPackageName(source)) {
+    return "npm";
+  }
+  return "unknown";
+}
+
+export {
+  theme,
+  symbols,
+  box,
+  progressBar,
+  bubble,
+  categoryIcons,
+  spinnerFrames,
+  registerCommand,
+  registerPluginCommand,
+  getCommand,
+  getAllCommands,
+  getPluginCommands,
+  createPluginStorage,
+  createPluginAPI,
+  ensurePluginsDir,
+  getPluginsDir,
+  discoverPlugins,
+  loadPlugin,
+  unloadPlugin,
+  getDiscoveredPlugins,
+  getLoadedPlugins,
+  isPluginLoaded,
+  getPluginPath,
+  initPluginLoader,
+  validateManifest,
+  checkConflicts,
+  formatPermissions,
+  installFromLocal,
+  installFromNpm,
+  installFromGithub,
+  installFromGit,
+  removePlugin,
+  detectSourceType
+};