@axpo/cli 1.0.0

package/dist/index.js

@@ -0,0 +1,2586 @@
+import * as esbuild from 'esbuild';
+import * as path3 from 'path';
+import path3__default from 'path';
+import * as fs3 from 'fs';
+import fs3__default, { createReadStream } from 'fs';
+import * as readline from 'readline';
+import JSZip from 'jszip';
+import chokidar from 'chokidar';
+import color from 'picocolors';
+import logUpdate from 'log-update';
+import { createSpinner } from 'nanospinner';
+import boxen from 'boxen';
+import { fileURLToPath, pathToFileURL } from 'url';
+import * as http from 'http';
+import * as os from 'os';
+import { WebSocketServer, WebSocket } from 'ws';
+import qr from 'qrcode-terminal';
+import axios from 'axios';
+import FormData from 'form-data';
+import { confirm, input, select, password } from '@inquirer/prompts';
+import { execSync, spawn } from 'child_process';
+
+// src/build.ts
+var CONFIG_NAMES = [
+  "axpo.config.ts",
+  "axpo.config.mjs",
+  "axpo.config.js",
+  "axpo.config.cjs"
+];
+function findConfigFile() {
+  for (const name of CONFIG_NAMES) {
+    const fullPath = path3__default.resolve(process.cwd(), name);
+    if (fs3__default.existsSync(fullPath)) return fullPath;
+  }
+  return null;
+}
+function loadPluginJson() {
+  const pluginJsonPath = path3__default.resolve(process.cwd(), "plugin.json");
+  if (!fs3__default.existsSync(pluginJsonPath)) {
+    throw new Error("plugin.json not found in project root");
+  }
+  try {
+    const pluginJson = JSON.parse(fs3__default.readFileSync(pluginJsonPath, "utf-8"));
+    if (!pluginJson.id) throw new Error('plugin.json: "id" is required');
+    if (!pluginJson.name) throw new Error('plugin.json: "name" is required');
+    if (!pluginJson.version) throw new Error('plugin.json: "version" is required');
+    if (!pluginJson.author?.name) throw new Error('plugin.json: "author.name" is required');
+    if (!pluginJson.author?.email) throw new Error('plugin.json: "author.email" is required');
+    return pluginJson;
+  } catch (error) {
+    if (error.code === "ENOENT") throw new Error("plugin.json not found");
+    throw new Error(`Failed to parse plugin.json: ${error.message}`);
+  }
+}
+async function loadConfig(configPath) {
+  let finalPath = null;
+  if (configPath) {
+    finalPath = path3__default.resolve(process.cwd(), configPath);
+    if (!fs3__default.existsSync(finalPath)) {
+      throw new Error(`Config file not found: ${configPath}`);
+    }
+  } else {
+    finalPath = findConfigFile();
+    if (!finalPath) {
+      throw new Error(
+        "Config file not found. Supported formats:\n" + CONFIG_NAMES.map((n) => `  - ${n}`).join("\n")
+      );
+    }
+  }
+  try {
+    const ext = path3__default.extname(finalPath);
+    if (ext === ".cjs") {
+      const { createRequire } = await import('module');
+      const require2 = createRequire(import.meta.url);
+      const mod2 = require2(finalPath);
+      return mod2.default || mod2;
+    }
+    const url = `${pathToFileURL(finalPath).href}?t=${Date.now()}`;
+    const mod = await import(url);
+    return mod.default || {};
+  } catch (error) {
+    if (error.code === "ERR_MODULE_NOT_FOUND") {
+      throw new Error(`Failed to load config: Module not found
+${error.message}`);
+    }
+    if (error.message?.includes("SyntaxError")) {
+      throw new Error(`Syntax error in config file: ${path3__default.basename(finalPath)}
+${error.message}`);
+    }
+    throw new Error(`Failed to load config: ${error.message}`);
+  }
+}
+function validateConfig(config, pluginJson) {
+  if (!/^[a-z][a-z0-9_]*(\.[a-z0-9_]+)+$/i.test(pluginJson.id)) {
+    throw new Error("Invalid plugin ID format in plugin.json. Use format like: com.example.plugin");
+  }
+  if (!config.buildOptions) {
+    throw new Error("buildOptions is required in axpo.config");
+  }
+  if (!config.buildOptions.entryPoints) {
+    throw new Error("buildOptions.entryPoints is required in axpo.config");
+  }
+  if (!config.buildOptions.outfile && !config.buildOptions.outdir) {
+    throw new Error("buildOptions.outfile or buildOptions.outdir is required in axpo.config");
+  }
+  if (config.dev && typeof config.dev !== "object") {
+    throw new Error("dev must be an object");
+  }
+  if (config.dev?.port && (typeof config.dev.port !== "number" || config.dev.port < 1 || config.dev.port > 65535)) {
+    throw new Error("dev.port must be a valid port number (1-65535)");
+  }
+}
+function getOutDir(config) {
+  if (config.buildOptions?.outdir) return config.buildOptions.outdir;
+  if (config.buildOptions?.outfile) return path3__default.dirname(config.buildOptions.outfile);
+  throw new Error("No output directory found in buildOptions");
+}
+var MINIMUM_API_REQUIREMENTS = {
+  "editorFile": 958,
+  "editorfile": 958
+  // Support both cases
+};
+var CodeAnalyzer = class {
+  constructor(srcDir = "src", pluginMinVersion) {
+    this.srcDir = srcDir;
+    this.pluginMinVersion = pluginMinVersion;
+  }
+  removeComments(code) {
+    return code.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+  }
+  analyzeAPIUsage() {
+    const apis = /* @__PURE__ */ new Set();
+    const warnings = [];
+    this.scanDirectory(this.srcDir, (content, filePath) => {
+      const lines = content.split("\n");
+      const requirePattern = /acode\.require\s*\(\s*['"`]([^'"`]+)['"`]\s*\)/g;
+      lines.forEach((line, index) => {
+        const cleanLine = this.removeComments(line);
+        requirePattern.lastIndex = 0;
+        let match;
+        while ((match = requirePattern.exec(cleanLine)) !== null) {
+          const apiName = match[1];
+          apis.add(apiName);
+          const requiredVersion = MINIMUM_API_REQUIREMENTS[apiName] || MINIMUM_API_REQUIREMENTS[apiName.toLowerCase()];
+          if (requiredVersion) {
+            let severity = "info";
+            if (this.pluginMinVersion !== void 0) {
+              if (requiredVersion > this.pluginMinVersion) {
+                severity = "error";
+              } else {
+                severity = "info";
+              }
+            } else {
+              severity = "warn";
+            }
+            warnings.push({
+              api: apiName,
+              requiredVersion,
+              file: path3.relative(process.cwd(), filePath),
+              line: index + 1,
+              severity
+            });
+          }
+        }
+      });
+    });
+    return {
+      apis,
+      warnings,
+      hasErrors: warnings.some((w) => w.severity === "error"),
+      hasWarnings: warnings.some((w) => w.severity === "warn")
+    };
+  }
+  scanDirectory(dir, callback) {
+    if (!fs3.existsSync(dir)) return;
+    fs3.readdirSync(dir).forEach((file) => {
+      const filePath = path3.join(dir, file);
+      const stat = fs3.statSync(filePath);
+      if (stat.isDirectory()) {
+        if (!["node_modules", "build", "dist", ".git"].includes(file)) {
+          this.scanDirectory(filePath, callback);
+        }
+      } else if (/\.(ts|js|tsx|jsx)$/.test(file)) {
+        callback(fs3.readFileSync(filePath, "utf-8"), filePath);
+      }
+    });
+  }
+};
+
+// src/dev-server.ts
+var MAX_CLIENTS = 5;
+var VIEWPORT_HEIGHT = 15;
+var MAX_LOGS = 200;
+var IP_CHECK_INTERVAL = 5e3;
+var AxpoDevServer = class {
+  constructor(options) {
+    this.server = null;
+    this.wss = null;
+    this.clients = /* @__PURE__ */ new Map();
+    this.logs = /* @__PURE__ */ new Map();
+    this.logOrder = [];
+    this.buildVersion = 0;
+    this.statusSection = {
+      buildStatus: "idle"
+    };
+    this.qrCode = "";
+    this.localIP = "";
+    this.renderScheduled = false;
+    this.terminalWidth = 80;
+    this.availableClientIds = [1, 2, 3, 4, 5];
+    this.clientIdMap = /* @__PURE__ */ new Map();
+    this.scrollOffset = 0;
+    this.lastRenderedLines = 0;
+    this.isFirstRender = true;
+    this.buildSessionWarnings = {
+      apiWarnings: /* @__PURE__ */ new Set(),
+      versionWarnings: /* @__PURE__ */ new Set(),
+      buildErrors: /* @__PURE__ */ new Set(),
+      lastBuildHash: ""
+    };
+    this.sessionWarnings = /* @__PURE__ */ new Map();
+    this.detectedAPIs = /* @__PURE__ */ new Set();
+    // NEW: IP monitoring
+    this.ipCheckInterval = null;
+    this.lastKnownIP = "";
+    this.port = options.port;
+    this.config = options.config;
+    this.pluginJson = options.pluginJson;
+    this.localIP = this.getLocalIP();
+    this.lastKnownIP = this.localIP;
+    this.qrCode = this.generateQRCode(`axpo://${this.localIP}:${this.port}`);
+    this.updateTerminalDimensions();
+    if (process.stdout.isTTY) {
+      process.stdout.on("resize", () => {
+        this.handleTerminalResize();
+      });
+    }
+    this.startIPMonitoring();
+  }
+  // NEW: Start monitoring IP address changes
+  startIPMonitoring() {
+    this.ipCheckInterval = setInterval(() => {
+      this.checkAndUpdateIP();
+    }, IP_CHECK_INTERVAL);
+  }
+  // NEW: Stop IP monitoring
+  stopIPMonitoring() {
+    if (this.ipCheckInterval) {
+      clearInterval(this.ipCheckInterval);
+      this.ipCheckInterval = null;
+    }
+  }
+  // NEW: Check if IP has changed and update accordingly
+  checkAndUpdateIP() {
+    const currentIP = this.getLocalIP();
+    if (currentIP !== this.lastKnownIP) {
+      const oldIP = this.lastKnownIP;
+      this.lastKnownIP = currentIP;
+      this.localIP = currentIP;
+      this.qrCode = this.generateQRCode(`axpo://${this.localIP}:${this.port}`);
+      this.addLog("info", `\u{1F504} Network changed: ${oldIP} \u2192 ${currentIP}`);
+      this.notifyClientsIPChange(currentIP);
+      this.renderUI();
+    }
+  }
+  // NEW: Notify clients about IP change
+  notifyClientsIPChange(newIP) {
+    this.broadcast({
+      type: "ip_changed",
+      newIP,
+      newURL: `axpo://${newIP}:${this.port}`,
+      timestamp: Date.now()
+    });
+  }
+  generateContentHash(content) {
+    let hash = 0;
+    for (let i = 0; i < content.length; i++) {
+      const char = content.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return hash.toString(36);
+  }
+  checkVersionCompatibility(clientId, deviceInfo) {
+    const client = this.clients.get(clientId);
+    if (!client) return;
+    const freshPluginJson = this.getFreshPluginJson();
+    if (!this.sessionWarnings.has(clientId)) {
+      this.sessionWarnings.set(clientId, {
+        minVersionCodeWarning: false,
+        apiWarnings: /* @__PURE__ */ new Set()
+      });
+    }
+    const warnings = this.sessionWarnings.get(clientId);
+    if (freshPluginJson.minVersionCode && !warnings.minVersionCodeWarning) {
+      if (deviceInfo.versionCode < freshPluginJson.minVersionCode) {
+        this.addLog(
+          "warn",
+          `\u26A0\uFE0F Version mismatch: Plugin requires minVersionCode ${freshPluginJson.minVersionCode}, but client has ${deviceInfo.versionCode}. Plugin may not work correctly.`,
+          client.clientNumber
+        );
+        warnings.minVersionCodeWarning = true;
+      }
+    }
+    this.detectedAPIs.forEach((apiName) => {
+      if (!warnings.apiWarnings.has(apiName)) {
+        const requiredVersion = MINIMUM_API_REQUIREMENTS[apiName];
+        if (requiredVersion && deviceInfo.versionCode < requiredVersion) {
+          this.addLog(
+            "warn",
+            `\u26A0\uFE0F API '${apiName}' requires versionCode ${requiredVersion}, but client has ${deviceInfo.versionCode}. This API may not be available.`,
+            client.clientNumber
+          );
+          warnings.apiWarnings.add(apiName);
+        }
+      }
+    });
+  }
+  analyzeAndReportAPIs(analysis) {
+    if (!analysis || !analysis.warnings) return;
+    const { warnings, apis } = analysis;
+    const freshPluginJson = this.getFreshPluginJson();
+    this.detectedAPIs = apis;
+    const warningsHash = this.generateContentHash(
+      JSON.stringify(warnings.map((w) => `${w.api}:${w.severity}`))
+    );
+    if (this.buildSessionWarnings.lastBuildHash === warningsHash) {
+      return;
+    }
+    this.buildSessionWarnings.lastBuildHash = warningsHash;
+    if (apis.size > 0 && this.buildSessionWarnings.apiWarnings.size === 0) {
+      const apiList = Array.from(apis).join(", ");
+      this.addLog("info", `\u{1F4E6} Detected ${apis.size} API(s): ${apiList}`);
+    }
+    const errors = warnings.filter((w) => w.severity === "error");
+    const warns = warnings.filter((w) => w.severity === "warn");
+    errors.forEach((warning) => {
+      const key = `${warning.api}:${warning.severity}`;
+      if (!this.buildSessionWarnings.buildErrors.has(key)) {
+        this.addLog(
+          "error",
+          `\u274C API '${warning.api}' requires versionCode ${warning.requiredVersion}, but plugin minVersionCode is ${freshPluginJson.minVersionCode || "not set"}. Update plugin.json!`
+        );
+        this.buildSessionWarnings.buildErrors.add(key);
+      }
+    });
+    warns.forEach((warning) => {
+      const key = `${warning.api}:${warning.severity}`;
+      if (!this.buildSessionWarnings.versionWarnings.has(key)) {
+        this.addLog(
+          "warn",
+          `\u26A0\uFE0F API '${warning.api}' requires versionCode ${warning.requiredVersion}. Consider adding "minVersionCode": ${warning.requiredVersion} to plugin.json`
+        );
+        this.buildSessionWarnings.versionWarnings.add(key);
+      }
+    });
+    Array.from(apis).forEach((api) => {
+      this.buildSessionWarnings.apiWarnings.add(api);
+    });
+  }
+  // Get fresh plugin.json from disk
+  getFreshPluginJson() {
+    try {
+      const pluginJsonPath = path3.resolve(process.cwd(), "plugin.json");
+      if (fs3.existsSync(pluginJsonPath)) {
+        const content = fs3.readFileSync(pluginJsonPath, "utf-8");
+        return JSON.parse(content);
+      }
+    } catch (error) {
+      console.warn("Failed to read fresh plugin.json:", error);
+    }
+    return this.pluginJson;
+  }
+  handleTerminalResize() {
+    const oldWidth = this.terminalWidth;
+    this.updateTerminalDimensions();
+    if (Math.abs(this.terminalWidth - oldWidth) > 10) {
+      this.qrCode = this.generateQRCode(`axpo://${this.localIP}:${this.port}`);
+    }
+    const totalLines = this.calculateTotalLines();
+    const maxScroll = Math.max(0, totalLines - VIEWPORT_HEIGHT);
+    if (this.scrollOffset > maxScroll) {
+      this.scrollOffset = maxScroll;
+    }
+    logUpdate.clear();
+    logUpdate.done();
+    this.isFirstRender = true;
+    this.renderUI();
+  }
+  updateTerminalDimensions() {
+    if (process.stdout.isTTY) {
+      this.terminalWidth = Math.max(60, (process.stdout.columns || 80) - 2);
+    }
+  }
+  getNextClientId() {
+    return this.availableClientIds.shift() || 0;
+  }
+  releaseClientId(clientId) {
+    const clientNumber = this.clientIdMap.get(clientId);
+    if (!clientNumber) return;
+    this.clientIdMap.delete(clientId);
+    const remainingClients = Array.from(this.clients.values()).filter((c) => c.id !== clientId).sort((a, b) => a.connectedAt.getTime() - b.connectedAt.getTime());
+    this.availableClientIds = [1, 2, 3, 4, 5];
+    this.clientIdMap.clear();
+    remainingClients.forEach((client, index) => {
+      const newNumber = index + 1;
+      const oldNumber = client.clientNumber;
+      client.clientNumber = newNumber;
+      this.clientIdMap.set(client.id, newNumber);
+      if (oldNumber !== newNumber) {
+        this.updateLogsClientNumber(oldNumber, newNumber);
+      }
+    });
+    this.availableClientIds = [1, 2, 3, 4, 5].filter(
+      (id) => !Array.from(this.clientIdMap.values()).includes(id)
+    );
+  }
+  updateLogsClientNumber(oldNumber, newNumber) {
+    this.logs.forEach((entry, key) => {
+      if (entry.clientNumber === oldNumber) {
+        entry.clientNumber = newNumber;
+        const newKey = key.replace(`:${oldNumber}:`, `:${newNumber}:`);
+        if (newKey !== key) {
+          this.logs.delete(key);
+          this.logs.set(newKey, entry);
+          const index = this.logOrder.indexOf(key);
+          if (index !== -1) {
+            this.logOrder[index] = newKey;
+          }
+        }
+      }
+    });
+  }
+  truncateText(text, maxLength = this.terminalWidth) {
+    const plainText = text.replace(/\x1b\[[0-9;]*m/g, "");
+    if (plainText.length <= maxLength) {
+      return text;
+    }
+    let visibleLength = 0;
+    let truncatedIndex = 0;
+    for (let i = 0; i < text.length; i++) {
+      if (text[i] === "\x1B") {
+        const endIndex = text.indexOf("m", i);
+        if (endIndex !== -1) {
+          i = endIndex;
+          continue;
+        }
+      }
+      visibleLength++;
+      truncatedIndex = i + 1;
+      if (visibleLength >= maxLength - 3) {
+        break;
+      }
+    }
+    return text.substring(0, truncatedIndex) + color.dim("...");
+  }
+  scrollUp() {
+    const totalLines = this.calculateTotalLines();
+    const maxScroll = Math.max(0, totalLines - VIEWPORT_HEIGHT);
+    if (this.scrollOffset < maxScroll) {
+      this.scrollOffset++;
+      this.renderUI();
+    }
+  }
+  scrollDown() {
+    if (this.scrollOffset > 0) {
+      this.scrollOffset--;
+      this.renderUI();
+    }
+  }
+  scrollToBottom() {
+    if (this.scrollOffset !== 0) {
+      this.scrollOffset = 0;
+      this.renderUI();
+    }
+  }
+  scrollToTop() {
+    const totalLines = this.calculateTotalLines();
+    const maxScroll = Math.max(0, totalLines - VIEWPORT_HEIGHT);
+    if (this.scrollOffset !== maxScroll) {
+      this.scrollOffset = maxScroll;
+      this.renderUI();
+    }
+  }
+  async start() {
+    return new Promise((resolve5, reject) => {
+      this.server = http.createServer((req, res) => this.handleRequest(req, res));
+      this.wss = new WebSocketServer({ server: this.server });
+      this.wss.on("connection", (ws, req) => this.handleConnection(ws, req));
+      this.server.listen(this.port, () => {
+        this.renderUI();
+        resolve5();
+      });
+      this.server.on("error", (error) => {
+        if (error.code === "EADDRINUSE") {
+          console.error(color.red(`
+\u2717 Port ${this.port} is already in use`));
+        } else {
+          console.error(color.red("Server error:"), error);
+        }
+        reject(error);
+      });
+    });
+  }
+  async stop() {
+    try {
+      this.stopIPMonitoring();
+      this.clients.forEach((client) => {
+        try {
+          if (client.ws.readyState === WebSocket.OPEN) {
+            client.ws.close();
+          }
+        } catch (error) {
+        }
+      });
+      this.clients.clear();
+      if (this.wss) {
+        await new Promise((resolve5) => {
+          this.wss.close(() => resolve5());
+        });
+        this.wss = null;
+      }
+      if (this.server) {
+        await new Promise((resolve5) => {
+          this.server.close(() => {
+            this.server = null;
+            resolve5();
+          });
+        });
+      }
+    } catch (error) {
+    }
+  }
+  scheduleRender() {
+    if (this.renderScheduled) return;
+    this.renderScheduled = true;
+    setImmediate(() => {
+      this.renderScheduled = false;
+      this.renderUI();
+    });
+  }
+  renderUI() {
+    const output = [];
+    const freshPluginJson = this.getFreshPluginJson();
+    output.push("");
+    output.push(color.bold(color.white(`  \u{1F493} Axpo Dev Server`)));
+    output.push("");
+    output.push(this.truncateText(color.cyan(`  ${freshPluginJson.name} \xB7 ${color.gray(`v${freshPluginJson.version}`)}`)));
+    const qrLines = this.qrCode.split("\n");
+    qrLines.forEach((line) => output.push(line));
+    output.push("");
+    output.push(this.truncateText(color.bold(color.white(`\u203A Axpo waiting on ${color.cyan(`axpo://${this.localIP}:${this.port}`)}`))));
+    output.push(this.truncateText(color.bold(color.white(`\u203A Scan the QR code above with Axpo Dev (Acode Plugin)`))));
+    output.push("");
+    const clientText = this.clients.size === MAX_CLIENTS ? color.yellow(`${this.clients.size}/${MAX_CLIENTS} (MAX)`) : `${this.clients.size}/${MAX_CLIENTS}`;
+    output.push(this.truncateText(color.dim(` Clients: ${clientText}`)));
+    output.push("");
+    output.push(color.bold(color.white("\u203A r=Reload \u2502 c=Clear \u2502 q=Quit \u2502 \u2191/\u2193=Scroll \u2502 Home/End")));
+    output.push("");
+    output.push(this.truncateText(color.dim("Logs below. Use arrow keys to scroll.")));
+    output.push("");
+    if (this.statusSection.buildStatus !== "idle") {
+      const timeStr = this.statusSection.buildTimestamp ? new Date(this.statusSection.buildTimestamp).toLocaleTimeString() : (/* @__PURE__ */ new Date()).toLocaleTimeString();
+      if (this.statusSection.buildStatus === "building") {
+        output.push(this.truncateText(`${color.dim(timeStr)} ${color.yellow("\u22EF")} Building...`));
+      } else if (this.statusSection.buildStatus === "success") {
+        const time = this.statusSection.buildTime || 0;
+        try {
+          const outDir = getOutDir(this.config);
+          const mainJsPath = path3.join(outDir, "main.js");
+          const size = fs3.existsSync(mainJsPath) ? fs3.statSync(mainJsPath).size : 0;
+          const sizeKB = (size / 1024).toFixed(2);
+          output.push(this.truncateText(`${color.dim(timeStr)} ${color.green("\u2713")} Build complete in ${time}ms \xB7 ${outDir}/main.js (${sizeKB} KB)`));
+        } catch (error) {
+          output.push(this.truncateText(`${color.dim(timeStr)} ${color.green("\u2713")} Build complete in ${time}ms`));
+        }
+      } else if (this.statusSection.buildStatus === "failed") {
+        const errorCount = this.statusSection.errorCount || 1;
+        const errorText = errorCount === 1 ? "error" : "errors";
+        output.push(this.truncateText(`${color.dim(timeStr)} ${color.red("\u2717")} Build failed with ${errorCount} ${errorText}`));
+      }
+    }
+    if (this.logOrder.length > 0) {
+      const allLines = [];
+      this.logOrder.forEach((key, logIndex) => {
+        const entry = this.logs.get(key);
+        if (!entry) return;
+        const lines = this.getLogLines(entry);
+        lines.forEach((line, lineIndex) => {
+          allLines.push({
+            line,
+            logIndex,
+            lineIndex,
+            totalLinesInLog: lines.length
+          });
+        });
+      });
+      const totalLines = allLines.length;
+      const viewportEnd = totalLines - this.scrollOffset;
+      const viewportStart = Math.max(0, viewportEnd - VIEWPORT_HEIGHT);
+      const visibleLines = allLines.slice(viewportStart, viewportEnd);
+      const fullyHiddenAbove = /* @__PURE__ */ new Set();
+      const fullyHiddenBelow = /* @__PURE__ */ new Set();
+      const partiallyVisibleLogs = /* @__PURE__ */ new Set();
+      visibleLines.forEach((lineInfo) => {
+        partiallyVisibleLogs.add(lineInfo.logIndex);
+      });
+      for (let i = 0; i < viewportStart; i++) {
+        const lineInfo = allLines[i];
+        if (!partiallyVisibleLogs.has(lineInfo.logIndex)) {
+          fullyHiddenAbove.add(lineInfo.logIndex);
+        }
+      }
+      for (let i = viewportEnd; i < totalLines; i++) {
+        const lineInfo = allLines[i];
+        if (!partiallyVisibleLogs.has(lineInfo.logIndex)) {
+          fullyHiddenBelow.add(lineInfo.logIndex);
+        }
+      }
+      if (fullyHiddenAbove.size > 0) {
+        const count = fullyHiddenAbove.size;
+        output.push(color.dim(`  \u2191 ${count} older log${count > 1 ? "s" : ""} hidden (total: ${this.logOrder.length}) \xB7 press \u2191`));
+      } else if (viewportStart > 0) {
+        const firstVisibleLog = visibleLines[0];
+        if (firstVisibleLog && firstVisibleLog.lineIndex > 0) {
+          output.push(color.dim(`  \u2191 scroll up for more \xB7 press \u2191`));
+        }
+      }
+      visibleLines.forEach((lineInfo, idx) => {
+        let line = lineInfo.line;
+        if (idx === 0 && lineInfo.lineIndex > 0) {
+          const plainLine = line.replace(/\x1b\[[0-9;]*m/g, "");
+          if (!plainLine.trim().startsWith("...")) {
+            const contentStart = line.search(/[^\x1b\[0-9;m]/);
+            if (contentStart !== -1) {
+              const prefix = line.substring(0, contentStart);
+              const content = line.substring(contentStart);
+              line = prefix + color.dim("...") + content;
+            } else {
+              line = color.dim("...") + line;
+            }
+          }
+        }
+        if (idx === visibleLines.length - 1) {
+          const remainingLines = lineInfo.totalLinesInLog - lineInfo.lineIndex - 1;
+          if (remainingLines > 0) {
+            line = line + color.dim("...");
+          }
+        }
+        output.push(this.truncateText(line));
+      });
+      if (fullyHiddenBelow.size > 0) {
+        const count = fullyHiddenBelow.size;
+        output.push(color.dim(`  \u2193 ${count} newer log${count > 1 ? "s" : ""} hidden \xB7 press \u2193`));
+      } else if (viewportEnd < totalLines) {
+        const lastVisibleLog = visibleLines[visibleLines.length - 1];
+        if (lastVisibleLog) {
+          const lastLogTotalLines = lastVisibleLog.totalLinesInLog;
+          if (lastVisibleLog.lineIndex < lastLogTotalLines - 1) {
+            output.push(color.dim(`  \u2193 scroll down for more \xB7 press \u2193`));
+          }
+        }
+      }
+      if (totalLines > VIEWPORT_HEIGHT) {
+        const scrollPercent = Math.round((totalLines - viewportEnd) / (totalLines - VIEWPORT_HEIGHT) * 100);
+        output.push(color.dim(`  Viewing ${viewportStart + 1}-${viewportEnd} of ${totalLines} lines (${scrollPercent}% from bottom)`));
+      }
+    }
+    if (this.statusSection.shutdownStatus) {
+      const timeStr = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+      if (this.statusSection.shutdownStatus === "stopping") {
+        output.push(this.truncateText(`${color.dim(timeStr)} ${color.yellow("\u22EF")} Stopping dev server...`));
+      } else if (this.statusSection.shutdownStatus === "stopped") {
+        output.push(this.truncateText(`${color.dim(timeStr)} ${color.green("\u2713")} Server stopped successfully`));
+      } else if (this.statusSection.shutdownStatus === "error") {
+        output.push(this.truncateText(`${color.dim(timeStr)} ${color.red("\u2717")} Error stopping server`));
+      }
+    }
+    output.push("");
+    const newContent = output.join("\n");
+    try {
+      logUpdate(newContent);
+      this.lastRenderedLines = output.length;
+      this.isFirstRender = false;
+    } catch (error) {
+      console.log(newContent);
+    }
+  }
+  wrapText(text, maxWidth) {
+    const plainText = text.replace(/\x1b\[[0-9;]*m/g, "");
+    if (plainText.length <= maxWidth) {
+      return [text];
+    }
+    const lines = [];
+    let remaining = text;
+    while (remaining.length > 0) {
+      if (remaining.length <= maxWidth) {
+        lines.push(remaining);
+        break;
+      }
+      const chunk = remaining.substring(0, maxWidth);
+      const lastSpace = chunk.lastIndexOf(" ");
+      if (lastSpace > maxWidth * 0.7) {
+        lines.push(remaining.substring(0, lastSpace));
+        remaining = "  " + remaining.substring(lastSpace + 1);
+      } else {
+        lines.push(chunk);
+        remaining = "  " + remaining.substring(maxWidth);
+      }
+    }
+    return lines;
+  }
+  calculateTotalLines() {
+    let totalLines = 0;
+    this.logOrder.forEach((key) => {
+      const entry = this.logs.get(key);
+      if (!entry) return;
+      const lines = this.getLogLines(entry);
+      totalLines += lines.length;
+    });
+    return totalLines;
+  }
+  getLogLines(entry) {
+    const entryTimeStr = new Date(entry.timestamp).toLocaleTimeString();
+    const clientSuffix = entry.clientNumber ? ` \u203A ${color.cyan(`[${entry.clientNumber}]`)}` : "";
+    const levelIndicator = entry.level === "error" ? color.red("\u2717 ERROR") : entry.level === "warn" ? color.yellow("\u26A0 WARN") : entry.level === "info" ? color.gray("\u203A INFO") : entry.level === "device" ? color.gray("\u203A DEVICE") : color.blue("\u203A LOG");
+    const countSuffix = entry.count > 1 ? ` ${color.dim(`[${entry.count}\xD7]`)}` : "";
+    const logLine = `${color.dim(entryTimeStr)} ${levelIndicator}${clientSuffix} ${entry.message}${countSuffix}`;
+    return this.wrapText(logLine, this.terminalWidth);
+  }
+  setBuildStatus(status, time, error, errorCount) {
+    this.statusSection.buildStatus = status;
+    this.statusSection.buildTime = time;
+    this.statusSection.errorCount = errorCount;
+    this.statusSection.buildTimestamp = Date.now();
+    if (status === "failed" && error) {
+      const errors = error.split("\n").filter((e) => e.trim());
+      errors.forEach((err) => {
+        this.addLog("error", err);
+      });
+    }
+    this.scrollToBottom();
+    this.renderUI();
+  }
+  setShutdownStatus(status) {
+    this.statusSection.shutdownStatus = status;
+    this.renderUI();
+  }
+  addLog(level, message, clientNumber) {
+    if (!message?.trim()) return;
+    message = message.trim();
+    const filters = [
+      "Starting initial build",
+      "Reloading clients",
+      "Build failed with"
+    ];
+    if (filters.some((filter) => message.includes(filter))) return;
+    const key = clientNumber ? `${level}:${clientNumber}:${message}` : `${level}:${message}`;
+    if (this.logs.has(key)) {
+      const existing = this.logs.get(key);
+      existing.count++;
+      existing.timestamp = Date.now();
+      const currentIndex = this.logOrder.indexOf(key);
+      if (currentIndex !== -1) {
+        this.logOrder.splice(currentIndex, 1);
+      }
+      this.logOrder.push(key);
+    } else {
+      const entry = {
+        level,
+        message,
+        timestamp: Date.now(),
+        count: 1,
+        clientNumber
+      };
+      this.logs.set(key, entry);
+      this.logOrder.push(key);
+      if (this.logOrder.length > MAX_LOGS) {
+        const removedKey = this.logOrder.shift();
+        this.logs.delete(removedKey);
+        if (this.scrollOffset > 0) {
+          this.scrollOffset = Math.max(0, this.scrollOffset - 1);
+        }
+      }
+    }
+    if (this.scrollOffset === 0) {
+      this.scheduleRender();
+    }
+  }
+  addDeviceInfoLog(deviceInfo, clientNumber) {
+    const key = `device:${clientNumber}:${deviceInfo.deviceModel}`;
+    const deviceDetails = [
+      `\u{1F4F1} ${deviceInfo.deviceModel}`,
+      deviceInfo.deviceVendor && deviceInfo.deviceVendor !== "Unknown" ? deviceInfo.deviceVendor : null,
+      deviceInfo.os,
+      `Acode ${deviceInfo.version} (${deviceInfo.versionCode})`,
+      `${deviceInfo.screenWidth}\xD7${deviceInfo.screenHeight}`,
+      deviceInfo.ram ? `${deviceInfo.ram}GB RAM` : null,
+      deviceInfo.cpuCores ? `${deviceInfo.cpuCores} cores` : null
+    ].filter(Boolean).join(" \xB7 ");
+    const entry = {
+      level: "device",
+      message: deviceDetails,
+      // ✅ Use formatted string instead of separate deviceInfo
+      timestamp: Date.now(),
+      count: 1,
+      clientNumber
+      // ✅ REMOVE: deviceInfo field
+    };
+    this.logs.set(key, entry);
+    this.logOrder.push(key);
+    if (this.logOrder.length > MAX_LOGS) {
+      const removedKey = this.logOrder.shift();
+      this.logs.delete(removedKey);
+      if (this.scrollOffset > 0) {
+        this.scrollOffset = Math.max(0, this.scrollOffset - 1);
+      }
+    }
+    if (this.scrollOffset === 0) {
+      this.scheduleRender();
+    }
+  }
+  clearLogs() {
+    this.logs.clear();
+    this.logOrder = [];
+    this.scrollOffset = 0;
+    this.renderUI();
+  }
+  notifyReload() {
+    this.buildVersion++;
+    this.broadcast({ type: "reload", buildVersion: this.buildVersion, timestamp: Date.now() });
+  }
+  handleRequest(req, res) {
+    const url = req.url || "/";
+    if (req.method === "OPTIONS") {
+      res.writeHead(200);
+      res.end();
+      return;
+    }
+    if (url === "/" || url === "/manifest") {
+      this.serveManifest(res);
+    } else if (url === "/plugin.json") {
+      this.serveFile("plugin.json", res);
+    } else if (url === "/status") {
+      this.serveStatus(res);
+    } else {
+      const fileName = url.substring(1);
+      try {
+        const buildDir = getOutDir(this.config);
+        const buildFilePath = path3.join(buildDir, fileName);
+        if (fs3.existsSync(buildFilePath) && fs3.statSync(buildFilePath).isFile()) {
+          try {
+            const content = fs3.readFileSync(buildFilePath);
+            const ext = path3.extname(buildFilePath);
+            const contentType = this.getContentType(ext);
+            res.writeHead(200, {
+              "Content-Type": contentType,
+              "Content-Length": content.length.toString(),
+              "Access-Control-Allow-Origin": "*"
+            });
+            res.end(content);
+            return;
+          } catch (error) {
+            this.serve500(res, error);
+            return;
+          }
+        }
+      } catch (error) {
+      }
+      if (fs3.existsSync(fileName) && fs3.statSync(fileName).isFile()) {
+        this.serveFile(fileName, res);
+      } else {
+        this.serve404(res);
+      }
+    }
+  }
+  serveManifest(res) {
+    try {
+      const freshPluginJson = this.getFreshPluginJson();
+      const manifest = {
+        ...freshPluginJson,
+        protocol: "axpo",
+        buildVersion: this.buildVersion,
+        endpoints: {
+          plugin: "/plugin.json",
+          main: "/main.js",
+          ws: `ws://${this.localIP}:${this.port}`
+        },
+        files: this.getServedFiles()
+      };
+      res.writeHead(200, {
+        "Content-Type": "application/json",
+        "Access-Control-Allow-Origin": "*",
+        "Cache-Control": "no-cache, no-store, must-revalidate",
+        "Pragma": "no-cache",
+        "Expires": "0"
+      });
+      res.end(JSON.stringify(manifest, null, 2));
+    } catch (error) {
+      console.error("Error serving manifest:", error);
+      const manifest = {
+        ...this.pluginJson,
+        protocol: "axpo",
+        buildVersion: this.buildVersion,
+        endpoints: {
+          plugin: "/plugin.json",
+          main: "/main.js",
+          ws: `ws://${this.localIP}:${this.port}`
+        },
+        files: this.getServedFiles()
+      };
+      res.writeHead(200, {
+        "Content-Type": "application/json",
+        "Access-Control-Allow-Origin": "*",
+        "Cache-Control": "no-cache, no-store, must-revalidate"
+      });
+      res.end(JSON.stringify(manifest, null, 2));
+    }
+  }
+  serveStatus(res) {
+    const status = {
+      running: true,
+      buildVersion: this.buildVersion,
+      clients: this.clients.size,
+      maxClients: MAX_CLIENTS,
+      uptime: process.uptime(),
+      logs: this.logs.size,
+      buildStatus: this.statusSection.buildStatus,
+      currentIP: this.localIP,
+      url: `axpo://${this.localIP}:${this.port}`
+    };
+    res.writeHead(200, { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" });
+    res.end(JSON.stringify(status, null, 2));
+  }
+  serveFile(filePath, res) {
+    const fullPath = path3.resolve(process.cwd(), filePath);
+    if (!fullPath.startsWith(process.cwd())) {
+      this.serve403(res);
+      return;
+    }
+    if (!fs3.existsSync(fullPath)) {
+      this.serve404(res);
+      return;
+    }
+    try {
+      const content = fs3.readFileSync(fullPath);
+      const ext = path3.extname(fullPath);
+      const contentType = this.getContentType(ext);
+      res.writeHead(200, {
+        "Content-Type": contentType,
+        "Content-Length": content.length.toString(),
+        "Access-Control-Allow-Origin": "*"
+      });
+      res.end(content);
+    } catch (error) {
+      this.serve500(res, error);
+    }
+  }
+  getContentType(ext) {
+    const types = {
+      ".html": "text/html",
+      ".js": "application/javascript",
+      ".json": "application/json",
+      ".css": "text/css",
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".gif": "image/gif",
+      ".svg": "image/svg+xml",
+      ".ico": "image/x-icon"
+    };
+    return types[ext] || "application/octet-stream";
+  }
+  getServedFiles() {
+    const files = [];
+    if (fs3.existsSync("plugin.json")) files.push("plugin.json");
+    try {
+      const buildDir = getOutDir(this.config);
+      if (fs3.existsSync(buildDir)) {
+        this.addFilesFromBuildDir(buildDir, files);
+      }
+    } catch (error) {
+    }
+    this.config.files?.forEach((file) => {
+      if (fs3.existsSync(file)) {
+        const stat = fs3.statSync(file);
+        if (stat.isFile()) {
+          if (!files.includes(file)) {
+            files.push(file);
+          }
+        } else if (stat.isDirectory()) {
+          this.addFilesFromFolder(file, file, files);
+        }
+      }
+    });
+    this.pluginJson.files?.forEach((file) => {
+      if (fs3.existsSync(file) && !files.includes(file)) {
+        const stat = fs3.statSync(file);
+        if (stat.isFile()) {
+          files.push(file);
+        } else if (stat.isDirectory()) {
+          this.addFilesFromFolder(file, file, files);
+        }
+      }
+    });
+    return [...new Set(files)];
+  }
+  addFilesFromBuildDir(buildDir, files) {
+    if (!fs3.existsSync(buildDir)) return;
+    const entries = fs3.readdirSync(buildDir);
+    entries.forEach((entry) => {
+      const fullPath = path3.join(buildDir, entry);
+      const stat = fs3.statSync(fullPath);
+      if (stat.isDirectory()) {
+        this.addFilesFromBuildDir(fullPath, files);
+      } else {
+        const fileName = path3.basename(fullPath);
+        if (!files.includes(fileName)) {
+          files.push(fileName);
+        }
+      }
+    });
+  }
+  addFilesFromFolder(baseDir, dir, files) {
+    if (!fs3.existsSync(dir)) return;
+    const entries = fs3.readdirSync(dir);
+    entries.forEach((entry) => {
+      const fullPath = path3.join(dir, entry);
+      const stat = fs3.statSync(fullPath);
+      if (stat.isDirectory()) {
+        this.addFilesFromFolder(baseDir, fullPath, files);
+      } else {
+        const relativePath = path3.relative(process.cwd(), fullPath);
+        if (!files.includes(relativePath)) {
+          files.push(relativePath);
+        }
+      }
+    });
+  }
+  handleConnection(ws, req) {
+    if (this.clients.size >= MAX_CLIENTS) {
+      try {
+        ws.close(1008, `Maximum ${MAX_CLIENTS} clients allowed`);
+      } catch (error) {
+      }
+      return;
+    }
+    const clientId = this.generateClientId();
+    const clientNumber = this.getNextClientId();
+    if (clientNumber === 0) {
+      ws.close(1008, "No available client IDs");
+      return;
+    }
+    const freshPluginJson = this.getFreshPluginJson();
+    const client = {
+      ws,
+      id: clientId,
+      clientNumber,
+      connectedAt: /* @__PURE__ */ new Date(),
+      deviceInfo: void 0
+    };
+    this.clients.set(clientId, client);
+    this.clientIdMap.set(clientId, clientNumber);
+    this.scheduleRender();
+    this.sendToClient(ws, {
+      type: "connected",
+      clientId,
+      clientNumber,
+      buildVersion: this.buildVersion,
+      plugin: {
+        name: freshPluginJson.name,
+        id: freshPluginJson.id,
+        version: freshPluginJson.version
+      }
+    });
+    ws.on("message", (data) => {
+      try {
+        const message = JSON.parse(data.toString());
+        this.handleClientMessage(clientId, message);
+      } catch (error) {
+        console.error("Failed to parse message:", error);
+      }
+    });
+    ws.on("close", () => {
+      const disconnectedNumber = this.clientIdMap.get(clientId);
+      const disconnectedClient = this.clients.get(clientId);
+      this.clients.delete(clientId);
+      this.sessionWarnings.delete(clientId);
+      this.releaseClientId(clientId);
+      if (disconnectedNumber) {
+        let disconnectMsg = `Disconnected`;
+        if (disconnectedClient?.deviceInfo) {
+          disconnectMsg += ` (${disconnectedClient.deviceInfo.deviceModel})`;
+        }
+        this.addLog("info", disconnectMsg, disconnectedNumber);
+        this.scrollToBottom();
+      }
+      this.scheduleRender();
+    });
+    ws.on("error", (error) => {
+      const disconnectedNumber = this.clientIdMap.get(clientId);
+      this.clients.delete(clientId);
+      this.sessionWarnings.delete(clientId);
+      this.releaseClientId(clientId);
+      if (disconnectedNumber) {
+        this.addLog("warn", `Error: ${error.message}`, disconnectedNumber);
+        this.scrollToBottom();
+      }
+      this.scheduleRender();
+    });
+  }
+  handleClientMessage(clientId, message) {
+    const client = this.clients.get(clientId);
+    if (message.type === "ping") {
+      if (client) this.sendToClient(client.ws, { type: "pong" });
+    } else if (message.type === "device_info") {
+      if (client && message.deviceInfo) {
+        client.deviceInfo = message.deviceInfo;
+        const deviceModel = message.deviceInfo.deviceModel || "Unknown Device";
+        const acodeVersion = message.deviceInfo.versionCode || "Unknown";
+        this.addLog(
+          "info",
+          `Connected (${deviceModel} \xB7 Acode ${acodeVersion})`,
+          client.clientNumber
+        );
+        this.addDeviceInfoLog(message.deviceInfo, client.clientNumber);
+        this.checkVersionCompatibility(clientId, message.deviceInfo);
+        this.scheduleRender();
+      }
+    } else if (message.type === "log") {
+      const { level, message: logMsg } = message;
+      if (logMsg?.trim() && client) {
+        this.addLog(level || "log", logMsg.trim(), client.clientNumber);
+      }
+    }
+  }
+  sendToClient(ws, message) {
+    if (ws.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify(message));
+    }
+  }
+  broadcast(message) {
+    const data = JSON.stringify(message);
+    this.clients.forEach((client) => {
+      if (client.ws.readyState === WebSocket.OPEN) {
+        client.ws.send(data);
+      }
+    });
+  }
+  generateClientId() {
+    return `client-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  }
+  getLocalIP() {
+    try {
+      const nets = os.networkInterfaces();
+      const results = [];
+      for (const name of Object.keys(nets)) {
+        const netArray = nets[name];
+        if (!netArray) continue;
+        for (const net of netArray) {
+          const familyV4Value = typeof net.family === "string" ? "IPv4" : 4;
+          if (net.family === familyV4Value && !net.internal) {
+            results.push(net.address);
+          }
+        }
+      }
+      const localNetwork = results.find((ip) => ip.startsWith("192.168."));
+      if (localNetwork) return localNetwork;
+      const corporateNetwork = results.find((ip) => ip.startsWith("10."));
+      if (corporateNetwork) return corporateNetwork;
+      const privateNetwork = results.find((ip) => {
+        const parts = ip.split(".");
+        if (parts[0] === "172") {
+          const second = parseInt(parts[1]);
+          return second >= 16 && second <= 31;
+        }
+        return false;
+      });
+      if (privateNetwork) return privateNetwork;
+      if (results.length > 0) return results[0];
+    } catch (error) {
+    }
+    return "127.0.0.1";
+  }
+  generateQRCode(text) {
+    try {
+      const chunks = [];
+      const originalWrite = process.stdout.write.bind(process.stdout);
+      process.stdout.write = (chunk) => {
+        chunks.push(chunk.toString());
+        return true;
+      };
+      try {
+        qr.generate(text, { small: true });
+      } finally {
+        process.stdout.write = originalWrite;
+      }
+      const capturedOutput = chunks.join("");
+      if (capturedOutput.trim()) {
+        return capturedOutput.split("\n").map((line) => `  ${line}`).join("\n");
+      }
+      return this.getFallbackBox();
+    } catch (error) {
+      return this.getFallbackBox();
+    }
+  }
+  getFallbackBox() {
+    return color.gray(`${color.cyan("npm i qrcode-terminal")}`);
+  }
+  serve404(res) {
+    res.writeHead(404, { "Content-Type": "text/plain" });
+    res.end("404 Not Found");
+  }
+  serve403(res) {
+    res.writeHead(403, { "Content-Type": "text/plain" });
+    res.end("403 Forbidden");
+  }
+  serve500(res, error) {
+    res.writeHead(500, { "Content-Type": "text/plain" });
+    res.end(`500 Internal Server Error
+
+${error.message}`);
+  }
+};
+var CACHE_DIR = path3.join(os.homedir(), ".cache", "axpo");
+var CACHE_FILE = path3.join(CACHE_DIR, "version-check.json");
+var CHECK_INTERVAL = 12 * 60 * 60 * 1e3;
+var NPM_PACKAGE = "@axpo/cli";
+function ensureCacheDir() {
+  try {
+    if (!fs3.existsSync(CACHE_DIR)) {
+      fs3.mkdirSync(CACHE_DIR, { recursive: true, mode: 493 });
+    }
+  } catch {
+  }
+}
+function getCurrentVersion() {
+  try {
+    const possiblePaths = [
+      path3.join(import.meta.dirname, "../package.json"),
+      path3.join(process.cwd(), "node_modules/@axpo/cli/package.json")
+    ];
+    for (const p of possiblePaths) {
+      if (fs3.existsSync(p)) {
+        const pkg = JSON.parse(fs3.readFileSync(p, "utf-8"));
+        if (pkg.name === NPM_PACKAGE && pkg.version) {
+          return pkg.version;
+        }
+      }
+    }
+  } catch {
+  }
+  return "1.0.0";
+}
+function readCache() {
+  try {
+    if (!fs3.existsSync(CACHE_FILE)) return null;
+    const cache = JSON.parse(fs3.readFileSync(CACHE_FILE, "utf-8"));
+    if (!cache.lastCheck || !cache.latestVersion || !cache.nextCheck) return null;
+    if (cache.lastCheck < 0 || cache.nextCheck < cache.lastCheck) return null;
+    return cache;
+  } catch {
+    return null;
+  }
+}
+function writeCache(cache) {
+  try {
+    ensureCacheDir();
+    fs3.writeFileSync(CACHE_FILE, JSON.stringify(cache), { encoding: "utf-8", mode: 420 });
+  } catch {
+  }
+}
+function shouldCheckVersion() {
+  const cache = readCache();
+  if (!cache) return { shouldCheck: true };
+  if (Date.now() >= cache.nextCheck) return { shouldCheck: true };
+  return { shouldCheck: false, cachedLatest: cache.latestVersion };
+}
+function compareVersions(v1, v2) {
+  const parts1 = v1.split(".").map(Number);
+  const parts2 = v2.split(".").map(Number);
+  for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+    const diff = (parts1[i] || 0) - (parts2[i] || 0);
+    if (diff !== 0) return diff < 0 ? -1 : 1;
+  }
+  return 0;
+}
+function useStaleCacheFallback(currentVersion) {
+  const cache = readCache();
+  if (cache?.latestVersion && compareVersions(currentVersion, cache.latestVersion) < 0) {
+    return { isOutdated: true, currentVersion, latestVersion: cache.latestVersion };
+  }
+  return null;
+}
+async function checkAxpoVersion() {
+  const currentVersion = getCurrentVersion();
+  const cacheCheck = shouldCheckVersion();
+  if (!cacheCheck.shouldCheck && cacheCheck.cachedLatest) {
+    if (compareVersions(currentVersion, cacheCheck.cachedLatest) < 0) {
+      return { isOutdated: true, currentVersion, latestVersion: cacheCheck.cachedLatest };
+    }
+    return null;
+  }
+  try {
+    const response = await fetch(
+      `https://registry.npmjs.org/${encodeURIComponent(NPM_PACKAGE)}/latest`,
+      { headers: { Accept: "application/json" }, signal: AbortSignal.timeout(3e3) }
+    );
+    if (!response.ok) return useStaleCacheFallback(currentVersion);
+    const data = await response.json();
+    const latestVersion = data.version;
+    if (!latestVersion) return useStaleCacheFallback(currentVersion);
+    const now = Date.now();
+    writeCache({ lastCheck: now, latestVersion, nextCheck: now + CHECK_INTERVAL });
+    if (compareVersions(currentVersion, latestVersion) < 0) {
+      return { isOutdated: true, currentVersion, latestVersion };
+    }
+    return null;
+  } catch {
+    return useStaleCacheFallback(currentVersion);
+  }
+}
+function displayVersionWarning(result) {
+  if (!result.isOutdated || !result.latestVersion) return;
+  const message = [
+    color.dim(`Current: ${result.currentVersion}`),
+    color.green(`Latest:  ${result.latestVersion}`),
+    "",
+    color.cyan(`npm install ${NPM_PACKAGE}@latest`),
+    color.dim("to update in your project")
+  ].join("\n");
+  console.log(boxen(message, {
+    title: "Update Available",
+    titleAlignment: "center",
+    padding: 1,
+    margin: 0,
+    borderStyle: "round",
+    borderColor: "yellow",
+    backgroundColor: "#1a1a1a",
+    textAlignment: "center",
+    width: (process.stdout.columns || 80) - 4
+  }));
+}
+var API_BASE = process.env.AXPO_API_BASE || "https://acode.app/api";
+var CREDENTIALS_DIR = path3.join(os.homedir(), ".axpo");
+var CREDENTIALS_PATH = path3.join(CREDENTIALS_DIR, "credentials.json");
+var REQUEST_TIMEOUT = 3e4;
+var UPLOAD_TIMEOUT = 12e4;
+async function readPluginJsonFromZip(zipPath) {
+  try {
+    const zipData = fs3.readFileSync(zipPath);
+    const zip = await JSZip.loadAsync(zipData);
+    const pluginJsonFile = zip.file("plugin.json");
+    if (!pluginJsonFile) {
+      throw new Error("plugin.json not found in zip file");
+    }
+    const content = await pluginJsonFile.async("text");
+    const pluginJson = JSON.parse(content);
+    if (!pluginJson.id) throw new Error('plugin.json: "id" is required');
+    if (!pluginJson.name) throw new Error('plugin.json: "name" is required');
+    if (!pluginJson.version) throw new Error('plugin.json: "version" is required');
+    if (!pluginJson.author?.name) throw new Error('plugin.json: "author.name" is required');
+    if (!pluginJson.author?.email) throw new Error('plugin.json: "author.email" is required');
+    return pluginJson;
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new Error("plugin.json contains invalid JSON");
+    }
+    if (error.message.includes("plugin.json")) {
+      throw error;
+    }
+    throw new Error(`Failed to read zip file: ${error.message}`);
+  }
+}
+function getZipSize(zipPath) {
+  try {
+    const stats = fs3.statSync(zipPath);
+    return (stats.size / (1024 * 1024)).toFixed(2);
+  } catch (error) {
+    return "0.00";
+  }
+}
+function ensureCredentialsDir() {
+  try {
+    if (!fs3.existsSync(CREDENTIALS_DIR)) {
+      fs3.mkdirSync(CREDENTIALS_DIR, { recursive: true, mode: 448 });
+    }
+  } catch (error) {
+    throw new Error(`Failed to create credentials directory: ${error.message}`);
+  }
+}
+function saveCredentials(credentials) {
+  try {
+    ensureCredentialsDir();
+    const content = JSON.stringify(credentials, null, 2);
+    fs3.writeFileSync(CREDENTIALS_PATH, content, {
+      encoding: "utf-8",
+      mode: 384
+    });
+  } catch (error) {
+    console.warn(color.yellow("\u26A0 Failed to save credentials"));
+  }
+}
+function loadCredentials() {
+  try {
+    if (fs3.existsSync(CREDENTIALS_PATH)) {
+      const content = fs3.readFileSync(CREDENTIALS_PATH, "utf-8");
+      return JSON.parse(content);
+    }
+  } catch (error) {
+  }
+  return null;
+}
+function clearCredentials() {
+  try {
+    if (fs3.existsSync(CREDENTIALS_PATH)) {
+      fs3.unlinkSync(CREDENTIALS_PATH);
+    }
+  } catch (error) {
+  }
+}
+function parseApiError(error) {
+  if (error.code === "ECONNREFUSED" || error.code === "ETIMEDOUT") {
+    return "Cannot connect to Acode registry. Please check your internet connection.";
+  }
+  const apiMessage = error.response?.data?.message;
+  if (apiMessage) return apiMessage;
+  const status = error.response?.status;
+  if (status) return `API error (${status}): ${error.message}`;
+  return error.message || "Unknown error";
+}
+async function checkPluginExists(pluginId) {
+  const spinner = createSpinner("Checking plugin registry...").start();
+  try {
+    const response = await axios.get(`${API_BASE}/plugin/${pluginId}`, {
+      timeout: REQUEST_TIMEOUT,
+      validateStatus: (status) => status === 200 || status === 404
+    });
+    spinner.stop();
+    if (response.status === 404) {
+      return { exists: false };
+    }
+    return {
+      exists: true,
+      plugin: {
+        id: response.data.id,
+        name: response.data.name,
+        version: response.data.version,
+        downloads: response.data.downloads || 0,
+        lastUpdated: response.data.updatedAt || response.data.createdAt
+      }
+    };
+  } catch (error) {
+    spinner.error({ text: "Failed to check plugin registry" });
+    throw new Error(parseApiError(error));
+  }
+}
+async function login(providedToken) {
+  if (providedToken) {
+    const spinner = createSpinner("Validating token...").start();
+    try {
+      await axios.get(`${API_BASE}/user/profile`, {
+        headers: { "Cookie": `token=${providedToken}` },
+        timeout: REQUEST_TIMEOUT
+      });
+      spinner.success({ text: "Token validated" });
+      return providedToken;
+    } catch (error) {
+      spinner.error({ text: "Invalid token" });
+      throw new Error("Provided token is invalid or expired");
+    }
+  }
+  let credentials = loadCredentials();
+  let attemptCount = 0;
+  const maxAttempts = 3;
+  while (attemptCount < maxAttempts) {
+    attemptCount++;
+    if (!credentials) {
+      console.log("");
+      console.log(color.cyan("Acode Account Login"));
+      console.log(color.dim("Credentials will be saved in ~/.axpo/credentials.json"));
+      console.log("");
+      const email = await input({
+        message: "Email:",
+        validate: (val) => val.trim() ? true : "Email is required"
+      });
+      const pwd = await password({
+        message: "Password:",
+        mask: "*",
+        validate: (val) => val ? true : "Password is required"
+      });
+      credentials = { email, password: pwd };
+    }
+    const spinner = createSpinner("Logging in...").start();
+    try {
+      const response = await axios.post(
+        `${API_BASE}/login`,
+        {
+          email: credentials.email,
+          password: credentials.password
+        },
+        {
+          timeout: REQUEST_TIMEOUT,
+          headers: { "Content-Type": "application/json" }
+        }
+      );
+      const setCookieHeader = response.headers["set-cookie"];
+      if (!setCookieHeader || setCookieHeader.length === 0) {
+        throw new Error("No token received");
+      }
+      const token = setCookieHeader[0].split(";")[0].split("=")[1];
+      if (!token) {
+        throw new Error("Failed to extract token");
+      }
+      spinner.success({ text: "Login successful!" });
+      console.log("");
+      saveCredentials(credentials);
+      return token;
+    } catch (error) {
+      const errorMessage = parseApiError(error);
+      spinner.error({ text: errorMessage });
+      credentials = null;
+      clearCredentials();
+      if (attemptCount < maxAttempts) {
+        console.log("");
+        const retry = await confirm({
+          message: `Try again? (${maxAttempts - attemptCount} attempt${maxAttempts - attemptCount > 1 ? "s" : ""} left)`,
+          default: true
+        });
+        if (!retry) {
+          console.log(color.dim("Login cancelled"));
+          console.log("");
+          return null;
+        }
+      }
+    }
+  }
+  console.log("");
+  console.log(color.red("\u2717 Maximum login attempts reached"));
+  console.log("");
+  return null;
+}
+async function uploadPlugin(token, zipPath, isUpdate, pluginJson, zipSizeMB) {
+  const actionText = isUpdate ? "Updating plugin" : "Publishing plugin";
+  const spinner = createSpinner(actionText + "...").start();
+  try {
+    const form = new FormData();
+    form.append("plugin", createReadStream(zipPath));
+    const startTime = Date.now();
+    const method = isUpdate ? "put" : "post";
+    let lastProgress = 0;
+    await axios({
+      method,
+      url: `${API_BASE}/plugin`,
+      data: form,
+      headers: {
+        ...form.getHeaders(),
+        "Cookie": `token=${token}`
+      },
+      timeout: UPLOAD_TIMEOUT,
+      maxContentLength: Infinity,
+      maxBodyLength: Infinity,
+      onUploadProgress: (progressEvent) => {
+        if (progressEvent.total) {
+          const percentage = Math.round(progressEvent.loaded * 100 / progressEvent.total);
+          if (percentage - lastProgress >= 10) {
+            lastProgress = percentage;
+            spinner.update({ text: `${actionText}... ${percentage}%` });
+          }
+        }
+      }
+    });
+    const duration = Date.now() - startTime;
+    spinner.success({ text: `${isUpdate ? "Update" : "Publish"} successful!` });
+    console.log("");
+    console.log(color.dim("  Plugin Details:"));
+    console.log(color.dim(`  \u2022 Name: ${pluginJson.name}`));
+    console.log(color.dim(`  \u2022 Version: ${pluginJson.version}`));
+    console.log(color.dim(`  \u2022 ID: ${pluginJson.id}`));
+    console.log(color.dim(`  \u2022 Size: ${zipSizeMB} MB`));
+    console.log(color.dim(`  \u2022 Upload time: ${(duration / 1e3).toFixed(1)}s`));
+    console.log("");
+    console.log(color.cyan(`  \u{1F517} https://acode.app/plugin/${pluginJson.id}`));
+    console.log("");
+  } catch (error) {
+    const errorMessage = parseApiError(error);
+    spinner.error({ text: "Upload failed" });
+    throw new Error(errorMessage);
+  }
+}
+async function publish(options = {}) {
+  try {
+    console.log("");
+    console.log(color.bold(color.white("\u{1F4E6} Publishing to Acode Plugin Registry")));
+    console.log("");
+    const envToken = process.env.AXPO_TOKEN;
+    const token = options.token || envToken;
+    let config;
+    try {
+      config = await loadConfig();
+    } catch (error) {
+      config = {};
+    }
+    let zipFilename = options.zipFilename || config.zipFilename || "Plugin.zip";
+    if (!zipFilename.endsWith(".zip")) {
+      zipFilename += ".zip";
+    }
+    const zipPath = path3.resolve(process.cwd(), zipFilename);
+    if (!fs3.existsSync(zipPath)) {
+      console.error(color.red(`\u2717 Zip file not found: ${zipFilename}`));
+      console.log("");
+      console.log(color.dim("  Run one of these commands first:"));
+      console.log(color.cyan("  \u2022 axpo build --zip"));
+      console.log(color.cyan("  \u2022 axpo zip"));
+      console.log("");
+      process.exit(1);
+    }
+    const spinner = createSpinner("Reading plugin.json from zip...").start();
+    let pluginJson;
+    try {
+      pluginJson = await readPluginJsonFromZip(zipPath);
+      spinner.success({ text: "Plugin.json loaded from zip" });
+    } catch (error) {
+      spinner.error({ text: "Failed to read plugin.json from zip" });
+      console.log("");
+      console.error(color.red(`\u2717 ${error.message}`));
+      console.log("");
+      console.log(color.dim("  Make sure your zip contains plugin.json in the root"));
+      console.log("");
+      process.exit(1);
+    }
+    const zipSizeMB = getZipSize(zipPath);
+    let pluginCheck;
+    try {
+      pluginCheck = await checkPluginExists(pluginJson.id);
+    } catch (error) {
+      console.error(color.red(`\u2717 ${error.message}`));
+      console.log("");
+      process.exit(1);
+    }
+    const isUpdate = pluginCheck.exists;
+    console.log("");
+    console.log(color.dim("Plugin Information (from zip):"));
+    console.log(color.dim(`\u2022 Name: ${pluginJson.name}`));
+    console.log(color.dim(`\u2022 ID: ${pluginJson.id}`));
+    console.log(color.dim(`\u2022 Version: ${pluginJson.version}`));
+    console.log(color.dim(`\u2022 Author: ${pluginJson.author.name} <${pluginJson.author.email}>`));
+    console.log(color.dim(`\u2022 Zip: ${zipFilename} (${zipSizeMB} MB)`));
+    if (isUpdate && pluginCheck.plugin) {
+      console.log("");
+      console.log(color.yellow("\u26A0 Plugin already exists in registry"));
+      console.log(color.dim(`  Current version: ${pluginCheck.plugin.version}`));
+      console.log(color.dim(`  Downloads: ${pluginCheck.plugin.downloads}`));
+      console.log(color.dim(`  New version: ${pluginJson.version}`));
+      if (pluginCheck.plugin.lastUpdated) {
+        console.log(color.dim(`  Last updated: ${new Date(pluginCheck.plugin.lastUpdated).toLocaleString()}`));
+      }
+    }
+    console.log("");
+    if (!options.force) {
+      const confirmMessage = isUpdate ? `Update plugin to version ${pluginJson.version}?` : `Publish ${pluginJson.name} to Acode registry?`;
+      const proceed = await confirm({
+        message: confirmMessage,
+        default: false
+      });
+      if (!proceed) {
+        console.log(color.dim("Publish cancelled"));
+        console.log("");
+        return;
+      }
+      console.log("");
+    }
+    const authToken = await login(token);
+    if (!authToken) {
+      console.error(color.red("\u2717 Publish failed: Authentication required"));
+      console.log("");
+      process.exit(1);
+    }
+    await uploadPlugin(authToken, zipPath, isUpdate, pluginJson, zipSizeMB);
+  } catch (error) {
+    console.error(color.red(`\u2717 ${error.message}`));
+    console.log("");
+    if (process.env.AXPO_DEBUG) {
+      console.error(error);
+    }
+    process.exit(1);
+  }
+}
+async function logout() {
+  try {
+    const credentialsExist = fs3.existsSync(CREDENTIALS_PATH);
+    if (!credentialsExist) {
+      console.log("");
+      console.log(color.dim("No saved credentials found"));
+      console.log("");
+      return;
+    }
+    clearCredentials();
+    console.log("");
+    console.log(color.green("\u2713 Logged out successfully"));
+    console.log(color.dim("  Credentials cleared from ~/.axpo/credentials.json"));
+    console.log("");
+  } catch (error) {
+    console.error(color.red(`\u2717 Logout failed: ${error.message}`));
+    console.log("");
+    process.exit(1);
+  }
+}
+
+// src/build.ts
+var devServerInstance = null;
+var versionCheckDone = false;
+var logLevelWarningShown = false;
+function createAxpoTransformPlugin(pluginJson) {
+  return {
+    name: "axpo-transform",
+    setup(build3) {
+      build3.onLoad({ filter: /src[\/\\]main\.(ts|js)$/ }, async (args) => {
+        let contents = await fs3.promises.readFile(args.path, "utf8");
+        const hasExportDefault = /export\s+default\s+/.test(contents);
+        if (!hasExportDefault) {
+          return {
+            contents: "",
+            errors: [{
+              text: `Missing 'export default' in main file`,
+              location: { file: args.path, line: 1, column: 0, length: 0, lineText: "" }
+            }]
+          };
+        }
+        if (!contents.includes("__createAxpoPlugin")) {
+          if (contents.includes('from "@axpo/sdk"') || contents.includes("from '@axpo/sdk'")) {
+            contents = contents.replace(
+              /import\s*{([^}]+)}\s*from\s*['"]@axpo\/sdk['"]/,
+              (m, imports) => {
+                if (!imports.includes("__createAxpoPlugin")) {
+                  return `import { ${imports.trim()}, __createAxpoPlugin } from '@axpo/sdk'`;
+                }
+                return m;
+              }
+            );
+          } else {
+            contents = `import { __createAxpoPlugin } from '@axpo/sdk';
+${contents}`;
+          }
+        }
+        let transformed = contents;
+        const pluginVarName = "__axpoPluginExport";
+        transformed = transformed.replace(/export\s+default\s+/, `const ${pluginVarName} = `);
+        transformed += `
+
+__createAxpoPlugin('${pluginJson.id}', ${pluginVarName});
+`;
+        return {
+          contents: transformed,
+          loader: args.path.endsWith(".ts") ? "ts" : "js"
+        };
+      });
+    }
+  };
+}
+function createPluginMetaPlugin(pluginJson) {
+  return {
+    name: "plugin-meta",
+    setup(build3) {
+      build3.onResolve({ filter: /^\.\.?\/axpo\.config(?:\.ts|\.js)?$/ }, (args) => {
+        return { path: args.path, namespace: "plugin-meta" };
+      });
+      build3.onLoad({ filter: /.*/, namespace: "plugin-meta" }, () => {
+        return {
+          contents: `export default ${JSON.stringify({
+            plugin: {
+              id: pluginJson.id,
+              name: pluginJson.name,
+              version: pluginJson.version,
+              author: pluginJson.author,
+              description: pluginJson.description || "",
+              icon: pluginJson.icon || "icon.png",
+              license: pluginJson.license || "MIT"
+            }
+          }, null, 2)};`,
+          loader: "js"
+        };
+      });
+    }
+  };
+}
+function displayLogLevelWarning() {
+  const message = [
+    color.bold(color.yellow("Configuration Warning")),
+    "",
+    color.dim("buildOptions.logLevel cannot be changed."),
+    color.dim('It must remain "silent" for dev server compatibility.'),
+    "",
+    color.cyan('Please remove "logLevel" from your buildOptions.')
+  ].join("\n");
+  console.log(boxen(message, {
+    title: "Warning",
+    titleAlignment: "center",
+    padding: 1,
+    margin: 0,
+    borderStyle: "single",
+    borderColor: "yellow",
+    backgroundColor: "#1a1a1a",
+    textAlignment: "center",
+    width: (process.stdout.columns || 80) - 4
+  }));
+}
+async function showStartupWarnings(config) {
+  if (versionCheckDone) return;
+  const versionCheck = await checkAxpoVersion();
+  if (versionCheck) displayVersionWarning(versionCheck);
+  if ("logLevel" in (config.buildOptions || {}) && !logLevelWarningShown) {
+    displayLogLevelWarning();
+    logLevelWarningShown = true;
+  }
+  versionCheckDone = true;
+}
+function prepareBuildOptions(userOptions, pluginJson) {
+  const cleanOptions = { ...userOptions };
+  delete cleanOptions.logLevel;
+  return {
+    ...cleanOptions,
+    plugins: [
+      createAxpoTransformPlugin(pluginJson),
+      createPluginMetaPlugin(pluginJson),
+      ...cleanOptions.plugins || []
+    ],
+    logLevel: "silent",
+    metafile: true,
+    format: cleanOptions.format || "iife"
+  };
+}
+function getBuildOutputFiles(outDir) {
+  const files = [];
+  if (!fs3.existsSync(outDir)) return files;
+  function scanDir(dir) {
+    fs3.readdirSync(dir).forEach((entry) => {
+      const fullPath = path3.join(dir, entry);
+      const stat = fs3.statSync(fullPath);
+      if (stat.isDirectory()) {
+        scanDir(fullPath);
+      } else {
+        files.push({
+          path: path3.relative(process.cwd(), fullPath),
+          size: stat.size
+        });
+      }
+    });
+  }
+  scanDir(outDir);
+  return files.sort((a, b) => a.path.localeCompare(b.path));
+}
+function analyzeAndShowWarnings(pluginJson) {
+  try {
+    const analyzer = new CodeAnalyzer("src", pluginJson.minVersionCode);
+    const analysis = analyzer.analyzeAPIUsage();
+    if (analysis.apis.size > 0) {
+      console.log(color.cyan("\u{1F4CA} API Usage Analysis:"));
+      console.log(color.dim(`  Found ${analysis.apis.size} API(s): ${Array.from(analysis.apis).join(", ")}`));
+      if (analysis.hasErrors) {
+        console.log(color.red("\n\u274C Critical Issues:"));
+        analysis.warnings.filter((w) => w.severity === "error").forEach((w) => {
+          console.log(color.red(`  \u2022 ${w.api} requires versionCode ${w.requiredVersion}, but plugin minVersionCode is ${pluginJson.minVersionCode || "not set"}`));
+          console.log(color.dim(`    ${w.file}:${w.line}`));
+        });
+      }
+      if (analysis.hasWarnings) {
+        console.log(color.yellow("\n\u26A0\uFE0F  Warnings:"));
+        analysis.warnings.filter((w) => w.severity === "warn").forEach((w) => {
+          console.log(color.yellow(`  \u2022 ${w.api} requires versionCode ${w.requiredVersion}. Consider adding "minVersionCode": ${w.requiredVersion} to plugin.json`));
+          console.log(color.dim(`    ${w.file}:${w.line}`));
+        });
+      }
+      if (analysis.hasErrors || analysis.hasWarnings) {
+        const maxRequired = Math.max(...analysis.warnings.map((w) => w.requiredVersion));
+        console.log(color.yellow("\n\u{1F4A1} Recommendation:"));
+        if (!pluginJson.minVersionCode) {
+          console.log(color.yellow(`  \u2022 Add "minVersionCode": ${maxRequired} to plugin.json`));
+        } else if (pluginJson.minVersionCode < maxRequired) {
+          console.log(color.yellow(`  \u2022 Update "minVersionCode" from ${pluginJson.minVersionCode} to ${maxRequired} in plugin.json`));
+        }
+      }
+      console.log("");
+    }
+  } catch (error) {
+    console.warn(color.yellow("\u26A0 API analysis warning:"), error.message);
+    console.log("");
+  }
+}
+async function build2(options = {}) {
+  const config = await loadConfig();
+  const pluginJson = loadPluginJson();
+  validateConfig(config, pluginJson);
+  const startTime = Date.now();
+  const isStandalone = !devServerInstance;
+  if (isStandalone) {
+    await showStartupWarnings(config);
+    analyzeAndShowWarnings(pluginJson);
+  }
+  const spinner = isStandalone ? createSpinner("Building...").start() : null;
+  const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+  const originalStderrWrite = process.stderr.write.bind(process.stderr);
+  try {
+    const outDir = getOutDir(config);
+    const resolvedOutDir = path3.resolve(process.cwd(), outDir);
+    if (!fs3.existsSync(resolvedOutDir)) {
+      fs3.mkdirSync(resolvedOutDir, { recursive: true });
+    }
+    if (isStandalone) {
+      process.stdout.write = () => true;
+      process.stderr.write = () => true;
+    }
+    const result = await esbuild.build(prepareBuildOptions(config.buildOptions, pluginJson));
+    if (isStandalone) {
+      process.stdout.write = originalStdoutWrite;
+      process.stderr.write = originalStderrWrite;
+    }
+    if (result.errors.length > 0) {
+      const errorMessages = result.errors.map((error) => {
+        let msg = error.text;
+        if (error.location) {
+          msg += ` (${error.location.file}:${error.location.line}:${error.location.column})`;
+        }
+        return msg;
+      }).join("\n");
+      if (devServerInstance) {
+        devServerInstance.setBuildStatus("failed", void 0, errorMessages, result.errors.length);
+        if (result.warnings.length > 0) {
+          result.warnings.forEach((warning) => {
+            const msg = warning.location ? `${warning.text} (${warning.location.file}:${warning.location.line})` : warning.text;
+            devServerInstance.addLog("warn", msg);
+          });
+        }
+      } else {
+        spinner?.error({ text: `Build failed with ${result.errors.length} error(s)` });
+        console.log("");
+        result.errors.forEach((error) => {
+          console.log(color.red(`  \u2022 ${error.text}`));
+          if (error.location) {
+            console.log(color.dim(`    ${error.location.file}:${error.location.line}:${error.location.column}`));
+          }
+        });
+        if (result.warnings.length > 0) {
+          console.log("");
+          result.warnings.forEach((warning) => {
+            const msg = warning.location ? `${warning.text} (${warning.location.file}:${warning.location.line})` : warning.text;
+            console.warn(color.yellow(`  \u26A0 ${msg}`));
+          });
+        }
+        console.log("");
+      }
+      return false;
+    }
+    if (devServerInstance) {
+      try {
+        const analysis = new CodeAnalyzer("src", pluginJson.minVersionCode).analyzeAPIUsage();
+        devServerInstance.analyzeAndReportAPIs({
+          warnings: analysis.warnings,
+          apis: analysis.apis,
+          hasErrors: analysis.hasErrors,
+          hasWarnings: analysis.hasWarnings
+        });
+      } catch (error) {
+        devServerInstance.addLog("warn", `API analyzer error: ${error.message}`);
+      }
+    }
+    const duration = Date.now() - startTime;
+    if (devServerInstance) {
+      devServerInstance.setBuildStatus("success", duration);
+      if (result.warnings.length > 0) {
+        result.warnings.forEach((warning) => {
+          const msg = warning.location ? `${warning.text} (${warning.location.file}:${warning.location.line})` : warning.text;
+          devServerInstance.addLog("warn", msg);
+        });
+      }
+    } else {
+      spinner?.success({ text: `Build complete in ${duration}ms` });
+      getBuildOutputFiles(resolvedOutDir).forEach((file) => {
+        console.log(color.dim(`  ${file.path} (${(file.size / 1024).toFixed(2)} KB)`));
+      });
+      if (result.warnings.length > 0) {
+        console.log("");
+        result.warnings.forEach((warning) => {
+          const msg = warning.location ? `${warning.text} (${warning.location.file}:${warning.location.line})` : warning.text;
+          console.warn(color.yellow(`  \u26A0 ${msg}`));
+        });
+      }
+      console.log("");
+    }
+    if (options.zip) await createZip(options.zipFilename);
+    return true;
+  } catch (error) {
+    if (isStandalone && process.stdout.write !== originalStdoutWrite) {
+      process.stdout.write = originalStdoutWrite;
+      process.stderr.write = originalStderrWrite;
+    }
+    const errorMsg = error.message || String(error);
+    devServerInstance ? devServerInstance.setBuildStatus("failed", void 0, errorMsg, 1) : spinner?.error({ text: `Build failed: ${errorMsg}` });
+    if (!devServerInstance) console.log("");
+    return false;
+  }
+}
+async function dev() {
+  const config = await loadConfig();
+  const pluginJson = loadPluginJson();
+  validateConfig(config, pluginJson);
+  await showStartupWarnings(config);
+  const devConfig = config.dev || {};
+  const port = devConfig.port || 3e3;
+  const devServer = new AxpoDevServer({ port, config, pluginJson });
+  devServerInstance = devServer;
+  let isShuttingDown = false;
+  const gracefulShutdown = async () => {
+    if (isShuttingDown) return;
+    isShuttingDown = true;
+    logUpdate.done();
+    console.log("");
+    const spinner = createSpinner("Stopping dev server...").start();
+    try {
+      if (watcher) await watcher.close();
+      await devServer.stop();
+      spinner.success({ text: "Server stopped successfully" });
+    } catch (error) {
+      spinner.error({ text: "Error stopping server" });
+    }
+    console.log("");
+    process.exit(0);
+  };
+  let watcher = null;
+  process.on("SIGINT", gracefulShutdown);
+  process.on("SIGTERM", gracefulShutdown);
+  await devServer.start();
+  devServer.setBuildStatus("building");
+  await build2();
+  watcher = chokidar.watch([
+    "src/**/*",
+    "axpo.config.{ts,mjs,js,cjs}",
+    // ✅ Support all config formats
+    "plugin.json"
+  ], {
+    ignored: [/(^|[\/\\])\../, "**/node_modules/**", "**/build/**", "**/*.zip"],
+    persistent: true,
+    ignoreInitial: true,
+    awaitWriteFinish: { stabilityThreshold: 100, pollInterval: 50 }
+  });
+  let isBuilding = false;
+  let buildQueued = false;
+  let debounceTimer = null;
+  const doBuild = async () => {
+    if (isBuilding) {
+      buildQueued = true;
+      return;
+    }
+    isBuilding = true;
+    try {
+      devServer.setBuildStatus("building");
+      if (await build2()) devServer.notifyReload();
+    } catch (error) {
+    }
+    isBuilding = false;
+    if (buildQueued) {
+      buildQueued = false;
+      setTimeout(doBuild, 100);
+    }
+  };
+  const handleFileChange = () => {
+    if (debounceTimer) clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(doBuild, 50);
+  };
+  watcher.on("change", handleFileChange);
+  watcher.on("add", handleFileChange);
+  watcher.on("unlink", handleFileChange);
+  setupKeyboardHandler(devServer, gracefulShutdown);
+  process.stdin.resume();
+}
+function setupKeyboardHandler(devServer, gracefulShutdown) {
+  if (process.stdin.isTTY) {
+    readline.emitKeypressEvents(process.stdin);
+    process.stdin.setRawMode(true);
+  }
+  process.stdin.on("keypress", async (str, key) => {
+    if (!key) return;
+    if (key.ctrl && key.name === "c") return await gracefulShutdown();
+    switch (key.name) {
+      case "r":
+        devServer.addLog("info", "Manual reload");
+        devServer.notifyReload();
+        break;
+      case "c":
+        devServer.clearLogs();
+        break;
+      case "q":
+        await gracefulShutdown();
+        break;
+      case "up":
+        devServer.scrollUp();
+        break;
+      case "down":
+        devServer.scrollDown();
+        break;
+      case "home":
+        devServer.scrollToTop();
+        break;
+      case "end":
+        devServer.scrollToBottom();
+        break;
+    }
+  });
+}
+async function createZip(commandZipFilename) {
+  const config = await loadConfig();
+  const pluginJson = loadPluginJson();
+  validateConfig(config, pluginJson);
+  let zipFilename = commandZipFilename || config.zipFilename || "Plugin.zip";
+  if (!zipFilename.endsWith(".zip")) zipFilename += ".zip";
+  const spinner = createSpinner(`Creating ${zipFilename}...`).start();
+  const startTime = Date.now();
+  try {
+    const zip = new JSZip();
+    const buildDir = getOutDir(config);
+    if (!fs3.existsSync(buildDir)) {
+      spinner.error({ text: `Build folder not found: ${buildDir}` });
+      console.log("");
+      throw new Error(`Build folder not found: ${buildDir}
+Run "axpo build" first.`);
+    }
+    let filesAdded = 0;
+    zip.file("plugin.json", JSON.stringify(pluginJson, null, 2));
+    filesAdded++;
+    const addFolder = (folderPath, zipRoot = "") => {
+      if (!fs3.existsSync(folderPath)) return;
+      fs3.readdirSync(folderPath).forEach((file) => {
+        const filePath = path3.join(folderPath, file);
+        try {
+          const stat = fs3.statSync(filePath);
+          if (stat.isDirectory()) {
+            const newZipPath = zipRoot ? path3.join(zipRoot, file) : file;
+            zip.folder(newZipPath);
+            addFolder(filePath, newZipPath);
+          } else if (stat.isFile()) {
+            zip.file(zipRoot ? path3.join(zipRoot, file) : file, fs3.readFileSync(filePath));
+            filesAdded++;
+          }
+        } catch (error) {
+        }
+      });
+    };
+    addFolder(buildDir);
+    const allFiles = /* @__PURE__ */ new Set();
+    config.files?.forEach((f) => allFiles.add(f));
+    pluginJson.files?.forEach((f) => allFiles.add(f));
+    allFiles.forEach((file) => {
+      const filePath = path3.resolve(process.cwd(), file);
+      if (fs3.existsSync(filePath)) {
+        const stat = fs3.statSync(filePath);
+        if (stat.isFile()) {
+          zip.file(file, fs3.readFileSync(filePath));
+          filesAdded++;
+        } else if (stat.isDirectory()) {
+          addFolder(filePath, file);
+        }
+      }
+    });
+    const content = await zip.generateAsync({
+      type: "nodebuffer",
+      compression: "DEFLATE",
+      compressionOptions: { level: 9 }
+    });
+    fs3.writeFileSync(zipFilename, content);
+    const duration = Date.now() - startTime;
+    const sizeKB = (fs3.statSync(zipFilename).size / 1024).toFixed(2);
+    spinner.success({ text: `${zipFilename} created in ${duration}ms (${sizeKB} KB, ${filesAdded} files)` });
+    console.log("");
+    if (devServerInstance) {
+      devServerInstance.addLog("info", `${zipFilename} created in ${duration}ms (${sizeKB} KB, ${filesAdded} files)`);
+    }
+  } catch (error) {
+    if (!error.message?.includes("Build folder not found")) {
+      spinner.error({ text: `Zip creation failed: ${error.message}` });
+      console.log("");
+    }
+    if (devServerInstance) {
+      devServerInstance.addLog("error", `Zip creation failed: ${error.message}`);
+    }
+  }
+}
+async function clean() {
+  const spinner = createSpinner("Cleaning build artifacts...").start();
+  try {
+    const config = await loadConfig();
+    const buildDir = getOutDir(config);
+    const itemsToClean = [];
+    if (fs3.existsSync(buildDir)) {
+      fs3.rmSync(buildDir, { recursive: true, force: true });
+      itemsToClean.push(buildDir);
+    }
+    let zipFilename = config.zipFilename || "Plugin.zip";
+    if (!zipFilename.endsWith(".zip")) zipFilename += ".zip";
+    if (fs3.existsSync(zipFilename)) {
+      fs3.unlinkSync(zipFilename);
+      itemsToClean.push(zipFilename);
+    }
+    if (zipFilename !== "Plugin.zip" && fs3.existsSync("Plugin.zip")) {
+      fs3.unlinkSync("Plugin.zip");
+      itemsToClean.push("Plugin.zip");
+    }
+    spinner.success({
+      text: itemsToClean.length > 0 ? `Clean complete - Removed: ${itemsToClean.join(", ")}` : "Already clean"
+    });
+    console.log("");
+  } catch (error) {
+    spinner.error({ text: `Clean failed: ${error.message}` });
+    console.log("");
+    process.exit(1);
+  }
+}
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = path3.dirname(__filename2);
+var TEMPLATES_DIR = path3.resolve(__dirname2, "../templates");
+var PM_INSTALL_CMD = {
+  npm: ["install"],
+  yarn: [],
+  pnpm: ["install"],
+  bun: ["install"]
+};
+function isTermux() {
+  return process.env.TERMUX_VERSION !== void 0 || fs3.existsSync("/data/data/com.termux") || process.env.PREFIX?.includes("com.termux") === true;
+}
+function getGitUserInfo() {
+  try {
+    const name = execSync("git config user.name", { encoding: "utf-8" }).trim();
+    const email = execSync("git config user.email", { encoding: "utf-8" }).trim();
+    return { name, email };
+  } catch {
+    return { name: "", email: "" };
+  }
+}
+function detectPackageManagers() {
+  const managers = ["npm", "yarn", "pnpm", "bun"];
+  return managers.filter((mgr) => {
+    try {
+      execSync(`${mgr} --version`, { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  });
+}
+function runCommand(cmd, args, cwd) {
+  return new Promise((resolve5, reject) => {
+    const child = spawn(cmd, args, {
+      cwd,
+      stdio: "ignore",
+      shell: false
+    });
+    child.on("close", (code) => {
+      if (code === 0) resolve5();
+      else reject(new Error(`Command failed: ${cmd} ${args.join(" ")}`));
+    });
+  });
+}
+function copyDirectory(src, dest) {
+  if (!fs3.existsSync(dest)) {
+    fs3.mkdirSync(dest, { recursive: true });
+  }
+  const entries = fs3.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path3.join(src, entry.name);
+    const destPath = path3.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirectory(srcPath, destPath);
+    } else {
+      fs3.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+function getCurrentDate() {
+  const now = /* @__PURE__ */ new Date();
+  const day = String(now.getDate()).padStart(2, "0");
+  const month = String(now.getMonth() + 1).padStart(2, "0");
+  const year = now.getFullYear();
+  return `${day}/${month}/${year}`;
+}
+function replacePlaceholders(dir, data) {
+  const walk = (currentDir) => {
+    for (const file of fs3.readdirSync(currentDir)) {
+      const fullPath = path3.join(currentDir, file);
+      if (fs3.statSync(fullPath).isDirectory()) {
+        walk(fullPath);
+      } else {
+        if (/\.(ts|js|json|md|html|xml|css|txt)$/.test(file)) {
+          let content = fs3.readFileSync(fullPath, "utf8");
+          content = content.replace(/\{\{projectName\}\}/g, data.projectName).replace(/\{\{pluginId\}\}/g, data.pluginId).replace(/\{\{pluginName\}\}/g, data.pluginName).replace(/\{\{description\}\}/g, data.description).replace(/\{\{authorName\}\}/g, data.authorName).replace(/\{\{email\}\}/g, data.email).replace(/\{\{github\}\}/g, data.github || "").replace(/\{\{date\}\}/g, data.date);
+          if (data.github) {
+            content = content.replace(/\{\{#if github\}\}(.*?)\{\{\/if\}\}/gs, "$1");
+          } else {
+            content = content.replace(/\{\{#if github\}\}.*?\{\{\/if\}\}/gs, "");
+          }
+          fs3.writeFileSync(fullPath, content, "utf8");
+        }
+      }
+    }
+  };
+  walk(dir);
+}
+async function promptAxpoDevInstallation() {
+  try {
+    console.log("");
+    console.log(color.bold(color.cyan("\u{1F50C} Axpo Dev Plugin")));
+    console.log(color.dim("To test your plugin during development, you need the"));
+    console.log(color.dim('"Axpo Dev" plugin installed in Acode.'));
+    console.log("");
+    const install = await confirm({
+      message: "Would you like to install Axpo Dev plugin in Acode now?",
+      default: true
+    });
+    if (install) {
+      console.log("");
+      console.log(color.cyan("\u{1F4F1} Opening Acode to install Axpo Dev plugin..."));
+      execSync('am start -a android.intent.action.VIEW -d "acode://plugin/install/axpo.dev"', {
+        stdio: "ignore"
+      });
+      console.log(color.green("\u2713 Plugin installation started in Acode"));
+      console.log(color.dim("  Please complete the installation in Acode app"));
+      console.log("");
+    } else {
+      console.log("");
+      console.log(color.dim("  You can install it later from:"));
+      console.log(color.cyan('  \u2022 Acode \u2192 Plugins \u2192 Search "Axpo Dev"'));
+      console.log("");
+    }
+  } catch (error) {
+  }
+}
+async function handleDependencyInstallation(projectDir) {
+  const managers = detectPackageManagers();
+  if (!managers.includes("npm")) {
+    console.error(color.red("\u274C npm is required but not found on your system."));
+    process.exit(1);
+  }
+  let selectedManager = "npm";
+  if (managers.length > 1) {
+    selectedManager = await select({
+      message: "Choose a package manager:",
+      choices: managers.map((manager) => ({
+        name: manager,
+        value: manager
+      }))
+    });
+  } else {
+    console.log(color.gray(`Using ${selectedManager} to install dependencies...`));
+  }
+  const spinner = createSpinner(`Installing dependencies with ${selectedManager}...`).start();
+  try {
+    const isWindows = process.platform === "win32";
+    const command = isWindows ? `${selectedManager}.cmd` : selectedManager;
+    await runCommand(command, PM_INSTALL_CMD[selectedManager], projectDir);
+    spinner.success({ text: `Dependencies installed via ${selectedManager}` });
+    return selectedManager;
+  } catch (err) {
+    spinner.error({ text: "Installation failed. Please try manually." });
+    if (err instanceof Error) {
+      console.error(color.dim(err.message));
+    }
+    return selectedManager;
+  }
+}
+async function init(options = {}) {
+  try {
+    console.log(color.bold(color.cyan("\n\u{1F680} Create Acode Plugin\n")));
+    if (!fs3.existsSync(TEMPLATES_DIR)) {
+      throw new Error(
+        `Templates directory not found. Please ensure axpo is installed correctly.
+Expected: ${TEMPLATES_DIR}`
+      );
+    }
+    const gitInfo = getGitUserInfo();
+    let projectName = options.name || "my-acode-plugin";
+    let targetPath;
+    if (options.current) {
+      projectName = path3.basename(process.cwd());
+      targetPath = process.cwd();
+      const files = fs3.readdirSync(targetPath).filter((file) => !file.startsWith("."));
+      if (files.length > 0 && !options.yes) {
+        const proceed = await confirm({
+          message: "Current directory is not empty. Continue anyway?",
+          default: false
+        });
+        if (!proceed) {
+          console.log(color.dim("Cancelled."));
+          return;
+        }
+      }
+    } else {
+      targetPath = path3.resolve(process.cwd(), projectName);
+    }
+    let pluginName = "My Plugin";
+    let pluginId = "com.example.plugin";
+    let description = "My awesome Acode plugin";
+    let authorName = gitInfo.name || "Your Name";
+    let email = gitInfo.email || "your@email.com";
+    let github = "";
+    let template = "typescript";
+    if (!options.yes) {
+      if (!options.current && !options.name) {
+        projectName = await input({
+          message: "Project name (folder name):",
+          default: "my-acode-plugin",
+          validate: (input3) => {
+            if (!input3.trim()) return "Project name is required";
+            const targetDir = path3.resolve(process.cwd(), input3);
+            const exists = fs3.existsSync(targetDir);
+            if (exists) {
+              return `Directory "${input3}" already exists. Please choose a different name.`;
+            }
+            return true;
+          }
+        });
+        targetPath = path3.resolve(process.cwd(), projectName);
+      }
+      pluginName = await input({
+        message: "Plugin name (display name):",
+        default: "My Plugin",
+        validate: (input3) => {
+          if (!input3.trim()) return "Plugin name is required";
+          return true;
+        }
+      });
+      pluginId = await input({
+        message: "Plugin ID:",
+        default: "com.example.plugin",
+        validate: async (input3) => {
+          if (!input3) return "Plugin ID cannot be empty.";
+          const valid = /^[a-z][a-z0-9_]*(\.[a-z0-9_]+)+$/i.test(input3);
+          if (!valid) return "Invalid format. Use format like com.example.plugin.";
+          try {
+            const res = await fetch(`https://acode.app/api/plugin/${input3}`);
+            const contentType = res.headers.get("content-type");
+            if (contentType && contentType.includes("text/html")) {
+              return true;
+            }
+            const data = await res.json();
+            if (!res.ok && data.error === "Not found") return true;
+            if (data && data.id) {
+              return `Plugin ID already used by ${color.cyan(color.bold(data.author))} in ${color.cyan(color.bold(data.name))} plugin`;
+            }
+            return true;
+          } catch (error) {
+            console.log(color.yellow("\n\u26A0 Could not verify plugin ID availability (network error)"));
+            console.log(color.dim("Continuing without validation...\n"));
+            return true;
+          }
+        }
+      });
+      description = await input({
+        message: "Description:",
+        default: "My awesome Acode plugin"
+      });
+      authorName = await input({
+        message: "Author name:",
+        default: gitInfo.name || "Your Name",
+        validate: (input3) => input3.trim() ? true : "Author name is required"
+      });
+      email = await input({
+        message: "Author email:",
+        default: gitInfo.email || "your@email.com",
+        validate: (input3) => {
+          if (!input3.trim()) return "Email is required";
+          if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(input3)) {
+            return "Please enter a valid email address";
+          }
+          return true;
+        }
+      });
+      github = await input({
+        message: "GitHub username (optional):",
+        default: "",
+        validate: async (input3) => {
+          if (!input3 || !input3.trim()) return true;
+          if (!/^[a-z0-9](?:[a-z0-9]|-(?=[a-z0-9])){0,38}$/i.test(input3)) {
+            return "Invalid GitHub username format";
+          }
+          try {
+            const res = await fetch(`https://api.github.com/users/${input3}`);
+            if (!res.ok) {
+              if (res.status === 404) {
+                return `GitHub user ${color.red(color.bold(input3))} not found`;
+              }
+              return `Error checking GitHub username: ${res.statusText}`;
+            }
+            const data = await res.json();
+            if (data && data.login) {
+              return true;
+            }
+            return "Could not verify GitHub username";
+          } catch (error) {
+            console.log(color.yellow("\n\u26A0 Could not verify GitHub username (network error)"));
+            console.log(color.dim("Continuing without validation...\n"));
+            return true;
+          }
+        }
+      });
+      template = await select({
+        message: "Choose a template:",
+        choices: [
+          { name: "TypeScript (Recommended)", value: "typescript" },
+          { name: "JavaScript", value: "javascript" }
+        ],
+        default: "typescript"
+      });
+    }
+    const templatePath = path3.join(TEMPLATES_DIR, template);
+    if (!fs3.existsSync(templatePath)) {
+      throw new Error(`Template not found: ${template}`);
+    }
+    if (fs3.existsSync(targetPath) && !options.current && (options.name || options.yes)) {
+      throw new Error(`Directory "${projectName}" already exists. Please choose a different name or remove the existing directory.`);
+    }
+    const spinner = createSpinner("Creating project files...").start();
+    try {
+      if (!fs3.existsSync(targetPath)) {
+        fs3.mkdirSync(targetPath, { recursive: true });
+      }
+      copyDirectory(templatePath, targetPath);
+      replacePlaceholders(targetPath, {
+        projectName,
+        pluginName,
+        pluginId,
+        description,
+        authorName,
+        email,
+        github,
+        date: getCurrentDate()
+      });
+      spinner.success({ text: "Project files created" });
+    } catch (err) {
+      spinner.error({ text: "Failed to create project files" });
+      throw err;
+    }
+    let shouldInstall = options.yes;
+    let packageManager = "npm";
+    if (!options.yes) {
+      shouldInstall = await confirm({
+        message: "Install dependencies now?",
+        default: true
+      });
+    }
+    if (shouldInstall) {
+      packageManager = await handleDependencyInstallation(targetPath);
+    }
+    console.log("");
+    console.log(color.green("\u2713 Plugin project created successfully!"));
+    console.log("");
+    console.log(color.bold("Next steps:"));
+    if (!options.current) {
+      console.log(color.cyan(`  cd ${projectName}`));
+    }
+    if (!shouldInstall) {
+      console.log(color.cyan(`  ${packageManager} install`) + color.dim("     # Install dependencies"));
+    }
+    const runCmd = packageManager === "npm" ? "npm run" : packageManager;
+    console.log(color.cyan(`  ${runCmd} dev`) + color.dim("          # Start development server"));
+    console.log(color.cyan(`  ${runCmd} build`) + color.dim("        # Build for production"));
+    console.log("");
+    console.log(color.dim("Then scan the QR code with Axpo Dev plugin in Acode"));
+    console.log("");
+    if (isTermux()) {
+      await promptAxpoDevInstallation();
+    }
+  } catch (error) {
+    if (error.name === "ExitPromptError") {
+      console.log("");
+      console.log(color.bold(color.red("\u2716 Operation cancelled.")));
+      console.log("");
+      process.exit(0);
+    }
+    console.error(color.red(`
+\u2717 ${error.message}
+`));
+    process.exit(1);
+  }
+}
+
+export { build2 as build, checkAxpoVersion, clean, createZip, dev, displayVersionWarning, getOutDir, init, loadConfig, loadPluginJson, logout, publish, validateConfig };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map