mn-rails-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1737 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/new.ts
+import * as fs from "fs-extra";
+import * as path from "path";
+import chalk from "chalk";
+import inquirer from "inquirer";
+async function newCommand(name, options = {}) {
+  try {
+    let projectName = name;
+    if (!projectName) {
+      const answer = await inquirer.prompt([
+        {
+          type: "input",
+          name: "name",
+          message: "Project name:",
+          validate: (input) => {
+            if (!input.trim()) {
+              return "Project name cannot be empty";
+            }
+            if (!/^[a-z0-9-]+$/.test(input)) {
+              return "Project name can only contain lowercase letters, numbers, and hyphens";
+            }
+            return true;
+          }
+        }
+      ]);
+      projectName = answer.name;
+    }
+    if (!projectName || typeof projectName !== "string") {
+      console.error(chalk.red("Error: Project name is required"));
+      process.exit(1);
+    }
+    const projectPath = path.resolve(process.cwd(), projectName);
+    if (fs.existsSync(projectPath)) {
+      console.error(chalk.red(`Error: Directory "${projectName}" already exists`));
+      process.exit(1);
+    }
+    console.log(chalk.blue(`Creating new plugin project: ${projectName}...`));
+    fs.ensureDirSync(projectPath);
+    const templateName = options.template || "basic";
+    const templatePath = path.resolve(__dirname, "../templates", templateName);
+    if (!fs.existsSync(templatePath)) {
+      console.warn(chalk.yellow(`Template "${templateName}" not found, using basic template`));
+      await createBasicTemplate(projectPath, projectName);
+    } else {
+      await copyTemplate(templatePath, projectPath, projectName);
+    }
+    console.log(chalk.green(`\u2713 Project created successfully!`));
+    console.log(chalk.cyan(`
+Next steps:`));
+    console.log(chalk.cyan(`  cd ${projectName}`));
+    console.log(chalk.cyan(`  npm install`));
+    console.log(chalk.cyan(`  mn-rails build`));
+  } catch (error) {
+    console.error(chalk.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+}
+async function createBasicTemplate(projectPath, projectName) {
+  const dirs = ["src", "src/controllers", "src/views"];
+  dirs.forEach((dir) => fs.ensureDirSync(path.join(projectPath, dir)));
+  const packageJson = {
+    name: projectName,
+    version: "0.1.0",
+    description: "A MarginNote plugin",
+    type: "module",
+    main: "dist/index.js",
+    scripts: {
+      build: "mn-rails build",
+      dev: "mn-rails dev"
+    },
+    dependencies: {
+      "mn-rails-core": "workspace:*"
+    },
+    devDependencies: {
+      typescript: "^5.3.3"
+    }
+  };
+  fs.writeJSONSync(path.join(projectPath, "package.json"), packageJson, { spaces: 2 });
+  const tsconfig = {
+    extends: "mn-rails-core/tsconfig.json",
+    compilerOptions: {
+      outDir: "./dist",
+      rootDir: "./src"
+    },
+    include: ["src/**/*"]
+  };
+  fs.writeJSONSync(path.join(projectPath, "tsconfig.json"), tsconfig, { spaces: 2 });
+  const config = `export default {
+  // Plugin configuration
+  name: '${projectName}',
+  version: '0.1.0',
+};
+`;
+  fs.writeFileSync(path.join(projectPath, "mn-rails.config.js"), config);
+  const indexContent = `import { App, MN } from 'mn-rails-core';
+import MainController from './controllers/MainController.js';
+
+class Plugin extends App {
+  private controller?: MainController;
+
+  onLaunch() {
+    MN.log('Plugin launched!');
+    this.controller = new MainController();
+  }
+
+  onExit() {
+    MN.log('Plugin exiting...');
+    this.controller?.onDestroy?.();
+  }
+}
+
+export default new Plugin();
+`;
+  fs.writeFileSync(path.join(projectPath, "src/index.ts"), indexContent);
+  const controllerContent = `import { Controller, MN } from 'mn-rails-core';
+
+export default class MainController extends Controller {
+  onInit() {
+    MN.log('MainController initialized - Hello World!');
+    
+    // \u793A\u4F8B\uFF1A\u521B\u5EFA\u539F\u751F\u6309\u94AE
+    const button = MN.nativeUI.createButton({
+      title: 'Hello World',
+      style: 'primary',
+      frame: { x: 10, y: 10, width: 150, height: 44 },
+      action: async () => {
+        // \u663E\u793A\u63D0\u793A\u6846
+        MN.alert('Hello World!\\n\u6B22\u8FCE\u4F7F\u7528 MN Rails');
+        
+        // \u6253\u5F00 WebView \u9762\u677F
+        const webView = await MN.webUI.render('HelloWorld', {
+          message: 'Hello from Controller!'
+        }, {
+          x: 100,
+          y: 100,
+          width: 400,
+          height: 300
+        });
+        
+        if (webView) {
+          MN.log('WebView opened:', webView.id);
+        }
+      }
+    });
+    
+    if (button) {
+      MN.log('Native button created');
+    }
+  }
+
+  // \u5B9A\u4E49\u4F9B WebView \u8C03\u7528\u7684 actions\uFF08\u7C7B\u578B\u5B89\u5168\uFF09
+  actions = {
+    /**
+     * Hello World \u793A\u4F8B\uFF1A\u5411\u67D0\u4EBA\u95EE\u597D
+     */
+    async hello(name: string): Promise<string> {
+      const message = \`Hello, \${name}! Welcome to MN Rails!\`;
+      MN.log(message);
+      return message;
+    },
+    
+    /**
+     * \u83B7\u53D6\u5F53\u524D\u65F6\u95F4
+     */
+    async getCurrentTime(): Promise<string> {
+      return new Date().toLocaleString();
+    }
+  };
+}
+`;
+  fs.writeFileSync(path.join(projectPath, "src/controllers/MainController.ts"), controllerContent);
+  const helloWorldView = `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Hello World - MN Rails</title>
+  <style>
+    body {
+      margin: 0;
+      padding: 20px;
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+      color: white;
+      min-height: 100vh;
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+    }
+    .container {
+      text-align: center;
+      max-width: 400px;
+    }
+    h1 {
+      font-size: 2.5em;
+      margin: 0 0 20px 0;
+      text-shadow: 2px 2px 4px rgba(0,0,0,0.3);
+    }
+    .message {
+      font-size: 1.2em;
+      margin: 20px 0;
+      padding: 15px;
+      background: rgba(255,255,255,0.2);
+      border-radius: 10px;
+      backdrop-filter: blur(10px);
+    }
+    button {
+      background: white;
+      color: #667eea;
+      border: none;
+      padding: 12px 24px;
+      font-size: 1em;
+      border-radius: 25px;
+      cursor: pointer;
+      margin: 10px;
+      font-weight: bold;
+      box-shadow: 0 4px 6px rgba(0,0,0,0.2);
+      transition: transform 0.2s;
+    }
+    button:hover {
+      transform: translateY(-2px);
+      box-shadow: 0 6px 8px rgba(0,0,0,0.3);
+    }
+    button:active {
+      transform: translateY(0);
+    }
+    .result {
+      margin-top: 20px;
+      padding: 15px;
+      background: rgba(255,255,255,0.1);
+      border-radius: 10px;
+      min-height: 20px;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>\u{1F44B} Hello World!</h1>
+    <div class="message" id="message">
+      <p>\u6B22\u8FCE\u4F7F\u7528 MN Rails \u6846\u67B6\uFF01</p>
+      <p id="props-message"></p>
+    </div>
+    
+    <button onclick="handleHello()">\u8C03\u7528 Controller</button>
+    <button onclick="handleGetTime()">\u83B7\u53D6\u65F6\u95F4</button>
+    
+    <div class="result" id="result"></div>
+  </div>
+
+  <script>
+    // \u663E\u793A\u4ECE Controller \u4F20\u9012\u7684 props
+    if (window.__MN_RAILS_PROPS__) {
+      const propsMsg = document.getElementById('props-message');
+      if (propsMsg && window.__MN_RAILS_PROPS__.message) {
+        propsMsg.textContent = window.__MN_RAILS_PROPS__.message;
+      }
+    }
+
+    // \u8C03\u7528 Controller \u7684 hello action
+    async function handleHello() {
+      const resultEl = document.getElementById('result');
+      try {
+        if (window.bridge) {
+          resultEl.textContent = '\u8C03\u7528\u4E2D...';
+          const result = await window.bridge.main.hello('MN Rails \u5F00\u53D1\u8005');
+          resultEl.textContent = '\u7ED3\u679C: ' + result;
+          resultEl.style.color = '#4ade80';
+        } else {
+          resultEl.textContent = '\u9519\u8BEF: bridge \u5BF9\u8C61\u4E0D\u53EF\u7528';
+          resultEl.style.color = '#f87171';
+        }
+      } catch (error) {
+        resultEl.textContent = '\u9519\u8BEF: ' + error.message;
+        resultEl.style.color = '#f87171';
+      }
+    }
+
+    // \u8C03\u7528 Controller \u7684 getCurrentTime action
+    async function handleGetTime() {
+      const resultEl = document.getElementById('result');
+      try {
+        if (window.bridge) {
+          resultEl.textContent = '\u83B7\u53D6\u4E2D...';
+          const time = await window.bridge.main.getCurrentTime();
+          resultEl.textContent = '\u5F53\u524D\u65F6\u95F4: ' + time;
+          resultEl.style.color = '#4ade80';
+        } else {
+          resultEl.textContent = '\u9519\u8BEF: bridge \u5BF9\u8C61\u4E0D\u53EF\u7528';
+          resultEl.style.color = '#f87171';
+        }
+      } catch (error) {
+        resultEl.textContent = '\u9519\u8BEF: ' + error.message;
+        resultEl.style.color = '#f87171';
+      }
+    }
+
+    // \u9875\u9762\u52A0\u8F7D\u5B8C\u6210\u540E\u7684\u63D0\u793A
+    window.addEventListener('load', () => {
+      console.log('Hello World WebView loaded!');
+      if (window.bridge) {
+        console.log('\u2713 Bridge is available');
+      } else {
+        console.warn('\u26A0 Bridge is not available');
+      }
+    });
+  </script>
+</body>
+</html>
+`;
+  fs.writeFileSync(path.join(projectPath, "src/views/HelloWorld.html"), helloWorldView);
+  const readme = `# ${projectName}
+
+A MarginNote plugin built with MN Rails.
+
+## Development
+
+\`\`\`bash
+npm install
+mn-rails build
+\`\`\`
+
+## License
+
+MIT
+`;
+  fs.writeFileSync(path.join(projectPath, "README.md"), readme);
+}
+async function copyTemplate(templatePath, projectPath, projectName) {
+  const files = fs.readdirSync(templatePath, { withFileTypes: true });
+  for (const file of files) {
+    const srcPath = path.join(templatePath, file.name);
+    let destPath = path.join(projectPath, file.name);
+    if (file.name.endsWith(".template")) {
+      destPath = destPath.replace(".template", "");
+    }
+    if (file.isDirectory()) {
+      fs.copySync(srcPath, destPath);
+    } else {
+      let content = fs.readFileSync(srcPath, "utf-8");
+      const projectTitle = projectName.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+      content = content.replace(/\{\{PROJECT_NAME\}\}/g, projectName).replace(/\{\{PROJECT_TITLE\}\}/g, projectTitle);
+      fs.writeFileSync(destPath, content);
+    }
+  }
+  const dirs = ["src", "src/controllers", "src/views"];
+  dirs.forEach((dir) => {
+    const dirPath = path.join(projectPath, dir);
+    if (!fs.existsSync(dirPath)) {
+      fs.ensureDirSync(dirPath);
+    }
+  });
+}
+
+// src/commands/build.ts
+import * as path5 from "path";
+import * as fs4 from "fs-extra";
+import chalk3 from "chalk";
+
+// src/build/index.ts
+import * as path4 from "path";
+import * as fs3 from "fs-extra";
+import { execSync } from "child_process";
+import chalk2 from "chalk";
+
+// src/utils/config.ts
+import * as path2 from "path";
+import { cosmiconfig } from "cosmiconfig";
+async function loadConfig(projectRoot) {
+  const defaultConfig = {
+    name: path2.basename(projectRoot),
+    version: "0.1.0",
+    title: path2.basename(projectRoot),
+    author: ""
+  };
+  try {
+    const explorer = cosmiconfig("mn-rails", {
+      searchPlaces: ["mn-rails.config.js", "mn-rails.config.ts", "mn-rails.config.mjs", "mn-rails.config.cjs"]
+    });
+    const result = await explorer.search(projectRoot);
+    if (result && result.config) {
+      return { ...defaultConfig, ...result.config };
+    }
+  } catch (error) {
+    console.warn(`Warning: Could not load config file: ${error}`);
+  }
+  return defaultConfig;
+}
+
+// src/dev/companion.ts
+function generateCompanionCode(options) {
+  const {
+    serverUrl,
+    reconnectInterval = 3e3,
+    maxReconnectAttempts = 10
+  } = options;
+  return `
+// MN Rails Debug Companion - Auto-generated, do not edit
+(function() {
+  'use strict';
+  
+  const SERVER_URL = '${serverUrl}';
+  const RECONNECT_INTERVAL = ${reconnectInterval};
+  const MAX_RECONNECT_ATTEMPTS = ${maxReconnectAttempts};
+  
+  let ws = null;
+  let reconnectAttempts = 0;
+  let reconnectTimer = null;
+  let isConnected = false;
+  let messageQueue = [];
+  
+  // \u539F\u59CB console \u65B9\u6CD5
+  const originalConsole = {
+    log: console.log,
+    error: console.error,
+    warn: console.warn,
+    info: console.info
+  };
+  
+  // \u53D1\u9001\u6D88\u606F\u5230\u670D\u52A1\u5668
+  function sendMessage(type, payload) {
+    const message = {
+      type: type,
+      payload: payload,
+      timestamp: Date.now()
+    };
+    
+    if (isConnected && ws && ws.readyState === 1) {
+      try {
+        ws.send(JSON.stringify(message));
+        return true;
+      } catch (error) {
+        console.error('Failed to send message:', error);
+        return false;
+      }
+    } else {
+      // \u5982\u679C\u672A\u8FDE\u63A5\uFF0C\u5C06\u6D88\u606F\u52A0\u5165\u961F\u5217
+      messageQueue.push(message);
+      return false;
+    }
+  }
+  
+  // \u5904\u7406\u6D88\u606F\u961F\u5217
+  function processMessageQueue() {
+    while (messageQueue.length > 0 && isConnected) {
+      const message = messageQueue.shift();
+      if (message && ws && ws.readyState === 1) {
+        try {
+          ws.send(JSON.stringify(message));
+        } catch (error) {
+          // \u53D1\u9001\u5931\u8D25\uFF0C\u91CD\u65B0\u52A0\u5165\u961F\u5217
+          messageQueue.unshift(message);
+          break;
+        }
+      }
+    }
+  }
+  
+  // \u62E6\u622A console.log
+  console.log = function(...args) {
+    originalConsole.log.apply(console, arguments);
+    sendMessage('log', {
+      level: 'log',
+      args: args.map(arg => {
+        if (typeof arg === 'object') {
+          try {
+            return JSON.stringify(arg);
+          } catch (e) {
+            return String(arg);
+          }
+        }
+        return String(arg);
+      })
+    });
+  };
+  
+  // \u62E6\u622A console.error
+  console.error = function(...args) {
+    originalConsole.error.apply(console, arguments);
+    sendMessage('error', {
+      level: 'error',
+      args: args.map(arg => {
+        if (typeof arg === 'object') {
+          try {
+            return JSON.stringify(arg);
+          } catch (e) {
+            return String(arg);
+          }
+        }
+        return String(arg);
+      })
+    });
+  };
+  
+  // \u62E6\u622A console.warn
+  console.warn = function(...args) {
+    originalConsole.warn.apply(console, arguments);
+    sendMessage('warn', {
+      level: 'warn',
+      args: args.map(arg => {
+        if (typeof arg === 'object') {
+          try {
+            return JSON.stringify(arg);
+          } catch (e) {
+            return String(arg);
+          }
+        }
+        return String(arg);
+      })
+    });
+  };
+  
+  // \u8FDE\u63A5 WebSocket \u670D\u52A1\u5668
+  function connect() {
+    try {
+      if (ws) {
+        ws.close();
+      }
+      
+      ws = new WebSocket(SERVER_URL);
+      
+      ws.onopen = function() {
+        isConnected = true;
+        reconnectAttempts = 0;
+        sendMessage('ready', { message: 'Debug companion connected' });
+        processMessageQueue();
+      };
+      
+      ws.onmessage = function(event) {
+        try {
+          const message = JSON.parse(event.data);
+          handleServerMessage(message);
+        } catch (error) {
+          console.error('Failed to parse server message:', error);
+        }
+      };
+      
+      ws.onerror = function(error) {
+        console.error('WebSocket error:', error);
+      };
+      
+      ws.onclose = function() {
+        isConnected = false;
+        ws = null;
+        
+        // \u5C1D\u8BD5\u91CD\u8FDE
+        if (reconnectAttempts < MAX_RECONNECT_ATTEMPTS) {
+          reconnectAttempts++;
+          reconnectTimer = setTimeout(function() {
+            connect();
+          }, RECONNECT_INTERVAL);
+        } else {
+          console.error('Max reconnect attempts reached. Debug companion disconnected.');
+        }
+      };
+    } catch (error) {
+      console.error('Failed to create WebSocket connection:', error);
+      // \u5C1D\u8BD5\u91CD\u8FDE
+      if (reconnectAttempts < MAX_RECONNECT_ATTEMPTS) {
+        reconnectAttempts++;
+        reconnectTimer = setTimeout(function() {
+          connect();
+        }, RECONNECT_INTERVAL);
+      }
+    }
+  }
+  
+  // \u5B58\u50A8\u63D2\u4EF6\u5B9E\u4F8B\u548C\u6E05\u7406\u51FD\u6570
+  let pluginInstance = null;
+  let cleanupFunctions = [];
+  
+  // \u6CE8\u518C\u6E05\u7406\u51FD\u6570
+  function registerCleanup(fn) {
+    cleanupFunctions.push(fn);
+  }
+  
+  // \u6267\u884C\u6E05\u7406
+  function cleanup() {
+    cleanupFunctions.forEach(fn => {
+      try {
+        fn();
+      } catch (error) {
+        console.error('Cleanup error:', error);
+      }
+    });
+    cleanupFunctions = [];
+    pluginInstance = null;
+  }
+  
+  // \u5904\u7406\u670D\u52A1\u5668\u6D88\u606F
+  function handleServerMessage(message) {
+    switch (message.type) {
+      case 'heartbeat':
+        // \u54CD\u5E94\u5FC3\u8DF3
+        sendMessage('heartbeat', { timestamp: Date.now() });
+        break;
+        
+      case 'code-update':
+        // \u4EE3\u7801\u66F4\u65B0\u901A\u77E5
+        if (message.payload && message.payload.code) {
+          try {
+            // \u6267\u884C\u6E05\u7406
+            cleanup();
+            
+            // \u6267\u884C\u65B0\u4EE3\u7801
+            const newCode = message.payload.code;
+            const executeCode = new Function(newCode);
+            executeCode();
+            
+            console.log('Plugin reloaded successfully');
+          } catch (error) {
+            console.error('Failed to reload plugin:', error);
+          }
+        } else {
+          // \u5982\u679C\u6CA1\u6709\u4EE3\u7801\uFF0C\u53EA\u662F\u901A\u77E5\u66F4\u65B0
+          console.log('Code update detected, please restart the plugin');
+        }
+        break;
+        
+      default:
+        // \u5FFD\u7565\u672A\u77E5\u6D88\u606F\u7C7B\u578B
+        break;
+    }
+  }
+  
+  // \u521D\u59CB\u5316\u8FDE\u63A5
+  connect();
+  
+  // \u5BFC\u51FA\u8FDE\u63A5\u72B6\u6001\u548C\u6E05\u7406\u51FD\u6570\uFF08\u7528\u4E8E\u70ED\u91CD\u8F7D\uFF09
+  if (typeof window !== 'undefined') {
+    window.__MN_RAILS_DEBUG__ = {
+      isConnected: function() { return isConnected; },
+      reconnect: connect,
+      sendMessage: sendMessage,
+      registerCleanup: registerCleanup,
+      cleanup: cleanup
+    };
+  }
+  
+  // \u5168\u5C40\u5BFC\u51FA\uFF08\u7528\u4E8E MarginNote \u73AF\u5883\uFF09
+  if (typeof global !== 'undefined') {
+    global.__MN_RAILS_DEBUG__ = {
+      isConnected: function() { return isConnected; },
+      reconnect: connect,
+      sendMessage: sendMessage,
+      registerCleanup: registerCleanup,
+      cleanup: cleanup
+    };
+  }
+})();
+`;
+}
+
+// src/build/type-generator.ts
+import * as fs2 from "fs-extra";
+import * as path3 from "path";
+import { Project } from "ts-morph";
+function extractActionsType(objectLiteral, sourceFile) {
+  const signatures = [];
+  const properties = objectLiteral.getProperties();
+  for (const prop of properties) {
+    if (prop.getKindName() === "MethodDeclaration") {
+      const sig = extractMethodSignature(prop, sourceFile);
+      if (sig) signatures.push(sig);
+    } else if (prop.getKindName() === "PropertyAssignment") {
+      const propertyAssignment = prop;
+      const initializer = propertyAssignment.getInitializer();
+      if (initializer) {
+        const kindName = initializer.getKindName();
+        if (kindName === "ArrowFunction" || kindName === "FunctionExpression") {
+          const name = propertyAssignment.getName();
+          const sig = extractFunctionSignature(
+            name,
+            initializer,
+            sourceFile
+          );
+          if (sig) signatures.push(sig);
+        }
+      }
+    }
+  }
+  return signatures;
+}
+function extractMethodSignature(method, sourceFile) {
+  const name = method.getName();
+  if (!name) return null;
+  const params = method.getParameters().map((p) => {
+    const typeNode = p.getTypeNode();
+    return {
+      name: p.getName(),
+      type: typeNode ? typeNode.getText() : "any",
+      optional: p.hasQuestionToken(),
+      rest: p.isRestParameter()
+    };
+  });
+  let returnType = "any";
+  const returnTypeNode = method.getReturnTypeNode();
+  if (returnTypeNode) {
+    returnType = resolveReturnType(returnTypeNode.getText());
+  } else {
+    const returnTypeFromChecker = method.getReturnType();
+    if (returnTypeFromChecker) {
+      returnType = resolveReturnType(returnTypeFromChecker.getText());
+    }
+  }
+  return { name, params, returnType };
+}
+function extractFunctionSignature(name, fn, sourceFile) {
+  const params = fn.getParameters().map((p) => {
+    const typeNode = p.getTypeNode();
+    return {
+      name: p.getName(),
+      type: typeNode ? typeNode.getText() : "any",
+      optional: p.hasQuestionToken(),
+      rest: p.isRestParameter()
+    };
+  });
+  let returnType = "any";
+  const returnTypeNode = fn.getReturnTypeNode();
+  if (returnTypeNode) {
+    returnType = resolveReturnType(returnTypeNode.getText());
+  } else {
+    const returnTypeFromChecker = fn.getReturnType();
+    if (returnTypeFromChecker) {
+      returnType = resolveReturnType(returnTypeFromChecker.getText());
+    }
+  }
+  return { name, params, returnType };
+}
+function resolveReturnType(raw) {
+  if (raw.startsWith("Promise<")) return raw;
+  return `Promise<${raw}>`;
+}
+function formatActionSignature(sig) {
+  const params = sig.params.map((p) => {
+    const rest = p.rest ? "..." : "";
+    const optional = p.optional ? "?" : "";
+    return `${rest}${p.name}${optional}: ${p.type}`;
+  }).join(", ");
+  return `    ${sig.name}: (${params}) => ${sig.returnType};`;
+}
+async function parseAllControllers(projectRoot, onWarn) {
+  const srcDir = path3.join(projectRoot, "src");
+  const controllersDir = path3.join(srcDir, "controllers");
+  if (!fs2.existsSync(controllersDir)) {
+    return [];
+  }
+  const controllerFiles = fs2.readdirSync(controllersDir).filter((f) => f.endsWith(".ts") || f.endsWith(".tsx"));
+  if (controllerFiles.length === 0) {
+    return [];
+  }
+  const controllerInfos = [];
+  const project = new Project();
+  for (const file of controllerFiles) {
+    const filePath = path3.join(controllersDir, file);
+    try {
+      const sourceFile = project.addSourceFileAtPath(filePath);
+      const classes = sourceFile.getClasses();
+      for (const classDecl of classes) {
+        const className = classDecl.getName();
+        if (!className) continue;
+        const extendsController = classDecl.getExtends()?.getText().includes("Controller") ?? false;
+        if (!extendsController) continue;
+        const actionsProperty = classDecl.getProperty("actions");
+        if (!actionsProperty) continue;
+        const initializer = actionsProperty.getInitializer();
+        if (!initializer || !initializer.getKindName().includes("ObjectLiteral")) {
+          continue;
+        }
+        const actionsObject = initializer;
+        const actions = extractActionsType(actionsObject, sourceFile);
+        if (actions.length === 0) {
+          continue;
+        }
+        controllerInfos.push({
+          name: className,
+          filePath,
+          actions
+        });
+        break;
+      }
+    } catch (err) {
+      const msg = `Failed to parse Controller in ${filePath}: ${err instanceof Error ? err.message : String(err)}`;
+      onWarn?.(msg);
+    }
+  }
+  return controllerInfos;
+}
+async function generateTypesForInjection(projectRoot, onWarn) {
+  const controllerInfos = await parseAllControllers(projectRoot, onWarn);
+  if (controllerInfos.length === 0) {
+    return null;
+  }
+  const lines = [];
+  lines.push("// Auto-generated bridge types - injected by MN Rails");
+  lines.push("// Do not edit this section manually");
+  lines.push("");
+  lines.push("interface BridgeActions {");
+  for (const info of controllerInfos) {
+    lines.push(`  ${info.name}: {`);
+    for (const sig of info.actions) {
+      lines.push(formatActionSignature(sig));
+    }
+    lines.push("  };");
+  }
+  lines.push("}");
+  lines.push("");
+  lines.push("declare const bridge: BridgeActions;");
+  lines.push("");
+  return lines.join("\n");
+}
+async function generateTypes(options) {
+  const { projectRoot, outputPath, onWarn } = options;
+  const controllerInfos = await parseAllControllers(projectRoot, onWarn);
+  if (controllerInfos.length === 0) {
+    return;
+  }
+  const lines = [];
+  lines.push("// Auto-generated bridge types");
+  lines.push("// Do not edit this file manually");
+  lines.push("");
+  lines.push("export interface BridgeActions {");
+  for (const info of controllerInfos) {
+    lines.push(`  ${info.name}: {`);
+    for (const sig of info.actions) {
+      lines.push(formatActionSignature(sig));
+    }
+    lines.push("  };");
+  }
+  lines.push("}");
+  lines.push("");
+  lines.push("declare global {");
+  lines.push("  const bridge: BridgeActions;");
+  lines.push("}");
+  lines.push("");
+  const output = outputPath || path3.join(projectRoot, "src", "bridge-types.ts");
+  await fs2.ensureDir(path3.dirname(output));
+  await fs2.writeFile(output, lines.join("\n"), "utf-8");
+}
+
+// src/build/index.ts
+async function buildPlugin(projectRoot, options = {}) {
+  const srcDir = path4.join(projectRoot, "src");
+  const distDir = path4.join(projectRoot, "dist");
+  if (!fs3.existsSync(srcDir)) {
+    throw new Error("src directory not found");
+  }
+  if (fs3.existsSync(distDir)) {
+    fs3.removeSync(distDir);
+  }
+  let typeDefinitionsForInjection = null;
+  try {
+    await generateTypes({
+      projectRoot,
+      onWarn: (msg) => console.warn(chalk2.yellow(`Type gen: ${msg}`))
+    });
+    typeDefinitionsForInjection = await generateTypesForInjection(
+      projectRoot,
+      (msg) => console.warn(chalk2.yellow(`Type gen: ${msg}`))
+    );
+    console.log(chalk2.blue("\u2713 Bridge types generated"));
+  } catch (error) {
+    console.warn(chalk2.yellow(`Warning: Failed to generate types: ${error}`));
+  }
+  console.log(chalk2.blue("Compiling TypeScript..."));
+  try {
+    execSync("tsc", {
+      cwd: projectRoot,
+      stdio: "inherit"
+    });
+  } catch (error) {
+    throw new Error("TypeScript compilation failed");
+  }
+  const config = await loadConfig(projectRoot);
+  const addonDir = path4.join(projectRoot, "dist", "addon");
+  fs3.ensureDirSync(addonDir);
+  const copyFiles = (src, dest) => {
+    const entries = fs3.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+      const srcPath = path4.join(src, entry.name);
+      const destPath = path4.join(dest, entry.name);
+      if (entry.isDirectory()) {
+        fs3.ensureDirSync(destPath);
+        copyFiles(srcPath, destPath);
+      } else if (entry.name.endsWith(".js") || entry.name.endsWith(".d.ts")) {
+        fs3.copySync(srcPath, destPath);
+      }
+    }
+  };
+  const collectFilesByExt = (dir, ext, base = "") => {
+    const results = [];
+    const entries = fs3.readdirSync(dir, { withFileTypes: true });
+    for (const e of entries) {
+      const rel = base ? `${base}/${e.name}` : e.name;
+      if (e.isDirectory()) {
+        results.push(...collectFilesByExt(path4.join(dir, e.name), ext, rel));
+      } else if (e.name.endsWith(ext)) {
+        results.push(rel);
+      }
+    }
+    return results;
+  };
+  const copyViewsExcept = (src, dest, skipExts) => {
+    const entries = fs3.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+      const srcPath = path4.join(src, entry.name);
+      const destPath = path4.join(dest, entry.name);
+      if (entry.isDirectory()) {
+        fs3.ensureDirSync(destPath);
+        copyViewsExcept(srcPath, destPath, skipExts);
+      } else {
+        const skip = skipExts.some((ext) => entry.name.endsWith(ext));
+        if (!skip) {
+          fs3.copySync(srcPath, destPath);
+        }
+      }
+    }
+  };
+  copyFiles(distDir, addonDir);
+  const srcViewsDir = path4.join(projectRoot, "src", "views");
+  if (fs3.existsSync(srcViewsDir)) {
+    const addonViewsDir = path4.join(addonDir, "views");
+    fs3.ensureDirSync(addonViewsDir);
+    let typeDefinitions = null;
+    try {
+      typeDefinitions = await generateTypesForInjection(
+        projectRoot,
+        (msg) => console.warn(chalk2.yellow(`Type gen: ${msg}`))
+      );
+    } catch (error) {
+      console.warn(chalk2.yellow(`Warning: Failed to generate types for injection: ${error}`));
+    }
+    const jsxFiles = collectFilesByExt(srcViewsDir, ".jsx");
+    if (jsxFiles.length > 0) {
+      const esbuild = await import("esbuild");
+      for (const rel of jsxFiles) {
+        const inputPath = path4.join(srcViewsDir, rel);
+        const outRel = rel.replace(/\.jsx$/, ".js");
+        const outputPath = path4.join(addonViewsDir, outRel);
+        fs3.ensureDirSync(path4.dirname(outputPath));
+        await esbuild.build({
+          entryPoints: [inputPath],
+          bundle: false,
+          format: "iife",
+          target: "es2015",
+          outfile: outputPath,
+          jsx: "transform"
+        });
+        if (typeDefinitions) {
+          let content = fs3.readFileSync(outputPath, "utf-8");
+          const typeComment = `/**
+ * @typedef {Object} BridgeActions
+${typeDefinitions.split("\n").filter((l) => l.trim() && !l.startsWith("//")).map((l) => ` * ${l}`).join("\n")}
+ */
+`;
+          content = typeComment + content;
+          fs3.writeFileSync(outputPath, content, "utf-8");
+        }
+      }
+      console.log(chalk2.blue(`\u2713 Compiled ${jsxFiles.length} JSX file(s)`));
+    }
+    const vueFiles = collectFilesByExt(srcViewsDir, ".vue");
+    if (vueFiles.length > 0) {
+      const { compileTemplate, compileScript, parse } = await import("@vue/compiler-sfc");
+      const esbuild = await import("esbuild");
+      for (const rel of vueFiles) {
+        const inputPath = path4.join(srcViewsDir, rel);
+        const outRel = rel.replace(/\.vue$/, ".js");
+        const outputPath = path4.join(addonViewsDir, outRel);
+        fs3.ensureDirSync(path4.dirname(outputPath));
+        try {
+          const source = fs3.readFileSync(inputPath, "utf-8");
+          const { descriptor, errors } = parse(source, { filename: inputPath });
+          if (errors.length > 0) {
+            console.warn(chalk2.yellow(`Vue parse warnings for ${rel}:`));
+            errors.forEach((err) => console.warn(chalk2.yellow(`  - ${err.message}`)));
+          }
+          const componentId = `vue-${rel.replace(/[^a-z0-9]/gi, "-")}`;
+          let scriptCode = "";
+          if (descriptor.script || descriptor.scriptSetup) {
+            try {
+              const compiled = compileScript(descriptor, {
+                id: componentId,
+                inlineTemplate: !!descriptor.template
+              });
+              scriptCode = compiled.content;
+            } catch (error) {
+              console.warn(chalk2.yellow(`Failed to compile script for ${rel}: ${error instanceof Error ? error.message : String(error)}`));
+              scriptCode = "export default {};";
+            }
+          } else {
+            scriptCode = "export default {};";
+          }
+          if (descriptor.template && !descriptor.scriptSetup) {
+            try {
+              const templateCompiled = compileTemplate({
+                source: descriptor.template.content,
+                filename: inputPath,
+                id: componentId,
+                compilerOptions: {
+                  mode: "module"
+                }
+              });
+              if (templateCompiled.code) {
+                scriptCode = scriptCode.replace(
+                  /export\s+default\s+\{/,
+                  `const render = ${templateCompiled.code};
+export default { render,`
+                );
+              }
+            } catch (error) {
+              console.warn(chalk2.yellow(`Failed to compile template for ${rel}: ${error instanceof Error ? error.message : String(error)}`));
+            }
+          }
+          if (descriptor.styles && descriptor.styles.length > 0) {
+            const styleContent = descriptor.styles.map((style) => style.content).join("\n");
+            const stylePath = outputPath.replace(/\.js$/, ".css");
+            fs3.writeFileSync(stylePath, styleContent, "utf-8");
+          }
+          const result = await esbuild.transform(scriptCode, {
+            loader: descriptor.script?.lang === "ts" || descriptor.scriptSetup?.lang === "ts" ? "ts" : "js",
+            target: "es2015",
+            format: "iife"
+          });
+          let compiledCode = result.code;
+          if (typeDefinitions) {
+            const typeComment = `/**
+ * @typedef {Object} BridgeActions
+${typeDefinitions.split("\n").filter((l) => l.trim() && !l.startsWith("//")).map((l) => ` * ${l}`).join("\n")}
+ */
+`;
+            compiledCode = typeComment + compiledCode;
+          }
+          fs3.writeFileSync(outputPath, compiledCode, "utf-8");
+        } catch (error) {
+          console.error(chalk2.red(`Failed to compile Vue file ${rel}: ${error instanceof Error ? error.message : String(error)}`));
+        }
+      }
+      console.log(chalk2.blue(`\u2713 Compiled ${vueFiles.length} Vue file(s)`));
+    }
+    const injectTypesIntoFile = (srcPath, destPath) => {
+      if (srcPath.endsWith(".vue") || srcPath.endsWith(".jsx")) {
+        throw new Error(
+          `Source file detected: ${srcPath}. Source files (.vue, .jsx) should not be copied to output directory. They must be compiled first. Please check your build configuration.`
+        );
+      }
+      if (srcPath.endsWith(".js") || srcPath.endsWith(".ts")) {
+        let content = fs3.readFileSync(srcPath, "utf-8");
+        if (srcPath.endsWith(".ts") && typeDefinitions) {
+          content = typeDefinitions + "\n\n" + content;
+        } else if (srcPath.endsWith(".js") && typeDefinitions) {
+          const typeComment = `/**
+ * @typedef {Object} BridgeActions
+${typeDefinitions.split("\n").filter((l) => l.trim() && !l.startsWith("//")).map((l) => ` * ${l}`).join("\n")}
+ */
+`;
+          content = typeComment + content;
+        }
+        fs3.writeFileSync(destPath, content, "utf-8");
+      } else {
+        fs3.copySync(srcPath, destPath);
+      }
+    };
+    const copyViewsWithTypeInjection = (src, dest, skipExts) => {
+      const entries = fs3.readdirSync(src, { withFileTypes: true });
+      for (const entry of entries) {
+        const srcPath = path4.join(src, entry.name);
+        const destPath = path4.join(dest, entry.name);
+        if (entry.isDirectory()) {
+          fs3.ensureDirSync(destPath);
+          copyViewsWithTypeInjection(srcPath, destPath, skipExts);
+        } else {
+          const skip = skipExts.some((ext) => entry.name.endsWith(ext));
+          if (!skip) {
+            injectTypesIntoFile(srcPath, destPath);
+          }
+        }
+      }
+    };
+    copyViewsWithTypeInjection(srcViewsDir, addonViewsDir, [".jsx", ".vue"]);
+    console.log(chalk2.blue("\u2713 Views copied"));
+  }
+  const indexFile = path4.join(addonDir, "index.js");
+  const mainFile = path4.join(addonDir, "main.js");
+  if (fs3.existsSync(indexFile)) {
+    let mainContent = fs3.readFileSync(indexFile, "utf-8");
+    if (options.devMode && options.devServerUrl) {
+      const companionCode = generateCompanionCode({
+        serverUrl: options.devServerUrl
+      });
+      mainContent = companionCode + "\n" + mainContent;
+      console.log(chalk2.blue("\u2713 Debug companion injected"));
+    }
+    fs3.writeFileSync(mainFile, mainContent);
+    fs3.removeSync(indexFile);
+  }
+  if (typeDefinitionsForInjection) {
+    const typesFile = path4.join(addonDir, "bridge-types.js");
+    const jsdocTypes = typeDefinitionsForInjection.split("\n").filter((line) => line.trim() && !line.startsWith("//")).map((line) => ` * ${line}`).join("\n");
+    const typesCode = `/**
+ * Auto-generated bridge types for runtime injection
+ * @typedef {Object} BridgeActions
+${jsdocTypes}
+ * @typedef {BridgeActions} bridge
+ */
+`;
+    fs3.writeFileSync(typesFile, typesCode, "utf-8");
+  }
+  const addonJson = {
+    key: config.name || path4.basename(projectRoot),
+    title: config.title || config.name || path4.basename(projectRoot),
+    version: config.version || "0.1.0",
+    author: config.author || "",
+    main: "main.js"
+  };
+  fs3.writeJSONSync(path4.join(addonDir, "addon.json"), addonJson, { spaces: 2 });
+  const addonName = `${addonJson.key}-${addonJson.version}.mnaddon`;
+  const addonPath = path4.join(projectRoot, addonName);
+  try {
+    execSync(`cd ${addonDir} && zip -r ${addonPath} .`, {
+      stdio: "inherit"
+    });
+    console.log(chalk2.green(`\u2713 Plugin packaged: ${addonName}`));
+  } catch (error) {
+    console.warn(chalk2.yellow("\u26A0\uFE0F  Could not create .mnaddon file (zip command not found)"));
+    console.log(chalk2.cyan(`   Plugin files are in: ${addonDir}`));
+  }
+}
+
+// src/commands/build.ts
+async function buildCommand(options = {}) {
+  try {
+    const projectRoot = process.cwd();
+    const configPath = path5.join(projectRoot, "mn-rails.config.js");
+    if (!fs4.existsSync(configPath)) {
+      console.error(chalk3.red("Error: mn-rails.config.js not found. Are you in a plugin project?"));
+      process.exit(1);
+    }
+    console.log(chalk3.blue("Building plugin..."));
+    await buildPlugin(projectRoot, {
+      watch: options.watch || false
+    });
+    if (!options.watch) {
+      console.log(chalk3.green("\u2713 Build completed successfully!"));
+    }
+  } catch (error) {
+    console.error(chalk3.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/dev.ts
+import chalk7 from "chalk";
+import * as path8 from "path";
+
+// src/dev/server.ts
+import { WebSocketServer, WebSocket } from "ws";
+import chalk4 from "chalk";
+
+// src/dev/protocol.ts
+function createMessage(type, payload, id) {
+  return {
+    type,
+    payload,
+    timestamp: Date.now(),
+    id
+  };
+}
+function parseMessage(data) {
+  try {
+    const message = JSON.parse(data);
+    if (message.type && message.payload !== void 0) {
+      return message;
+    }
+    return null;
+  } catch (error) {
+    return null;
+  }
+}
+function serializeMessage(message) {
+  return JSON.stringify(message);
+}
+
+// src/dev/server.ts
+var DevServer = class {
+  wss = null;
+  clients = /* @__PURE__ */ new Set();
+  options;
+  heartbeatInterval = null;
+  constructor(options) {
+    this.options = options;
+  }
+  /**
+   * 启动服务器
+   */
+  start() {
+    return new Promise((resolve2, reject) => {
+      try {
+        this.wss = new WebSocketServer({ port: this.options.port });
+        this.wss.on("listening", () => {
+          console.log(
+            chalk4.green(`\u2713 Development server started on ws://localhost:${this.options.port}`)
+          );
+          this.startHeartbeat();
+          resolve2();
+        });
+        this.wss.on("error", (error) => {
+          console.error(chalk4.red(`WebSocket server error: ${error.message}`));
+          reject(error);
+        });
+        this.wss.on("connection", (ws) => {
+          this.handleConnection(ws);
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * 停止服务器
+   */
+  stop() {
+    return new Promise((resolve2) => {
+      if (this.heartbeatInterval) {
+        clearInterval(this.heartbeatInterval);
+        this.heartbeatInterval = null;
+      }
+      if (this.wss) {
+        this.clients.forEach((ws) => {
+          ws.close();
+        });
+        this.clients.clear();
+        this.wss.close(() => {
+          console.log(chalk4.yellow("Development server stopped"));
+          resolve2();
+        });
+        this.wss = null;
+      } else {
+        resolve2();
+      }
+    });
+  }
+  /**
+   * 处理新连接
+   */
+  handleConnection(ws) {
+    this.clients.add(ws);
+    console.log(chalk4.cyan(`Client connected (${this.clients.size} total)`));
+    this.send(ws, createMessage("connected", { message: "Connected to dev server" }));
+    if (this.options.onConnection) {
+      this.options.onConnection(ws);
+    }
+    ws.on("message", (data) => {
+      const message = parseMessage(data.toString());
+      if (message) {
+        this.handleMessage(ws, message);
+      }
+    });
+    ws.on("close", () => {
+      this.clients.delete(ws);
+      console.log(chalk4.yellow(`Client disconnected (${this.clients.size} total)`));
+      if (this.options.onDisconnection) {
+        this.options.onDisconnection(ws);
+      }
+    });
+    ws.on("error", (error) => {
+      console.error(chalk4.red(`WebSocket error: ${error.message}`));
+    });
+  }
+  /**
+   * 处理消息
+   */
+  handleMessage(ws, message) {
+    if (message.type === "heartbeat") {
+      this.send(ws, createMessage("heartbeat", { timestamp: Date.now() }));
+      return;
+    }
+    if (message.type === "ready") {
+      console.log(chalk4.green("Client ready"));
+      return;
+    }
+    if (this.options.onMessage) {
+      this.options.onMessage(ws, message);
+    }
+  }
+  /**
+   * 发送消息到指定客户端
+   */
+  send(ws, message) {
+    if (ws.readyState === WebSocket.OPEN) {
+      try {
+        ws.send(serializeMessage(message));
+        return true;
+      } catch (error) {
+        console.error(chalk4.red(`Failed to send message: ${error}`));
+        return false;
+      }
+    }
+    return false;
+  }
+  /**
+   * 广播消息到所有客户端
+   */
+  broadcast(message) {
+    let count = 0;
+    this.clients.forEach((ws) => {
+      if (this.send(ws, message)) {
+        count++;
+      }
+    });
+    return count;
+  }
+  /**
+   * 获取客户端数量
+   */
+  getClientCount() {
+    return this.clients.size;
+  }
+  /**
+   * 启动心跳检测
+   */
+  startHeartbeat() {
+    this.heartbeatInterval = setInterval(() => {
+      this.clients.forEach((ws) => {
+        if (ws.readyState === WebSocket.OPEN) {
+          this.send(ws, createMessage("heartbeat", { timestamp: Date.now() }));
+        } else {
+          this.clients.delete(ws);
+        }
+      });
+    }, 3e4);
+  }
+};
+
+// src/dev/watcher.ts
+import * as path6 from "path";
+import chokidar from "chokidar";
+import chalk5 from "chalk";
+var FileWatcher = class {
+  watcher = null;
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  /**
+   * 开始监听
+   */
+  start() {
+    return new Promise((resolve2, reject) => {
+      try {
+        const watchPaths = this.options.patterns.map(
+          (pattern) => path6.join(this.options.rootDir, pattern)
+        );
+        const ignored = [
+          "**/node_modules/**",
+          "**/dist/**",
+          "**/.git/**",
+          "**/*.mnaddon",
+          ...this.options.ignored || []
+        ];
+        this.watcher = chokidar.watch(watchPaths, {
+          ignored,
+          persistent: true,
+          ignoreInitial: true,
+          awaitWriteFinish: {
+            stabilityThreshold: 200,
+            pollInterval: 100
+          }
+        });
+        this.watcher.on("ready", () => {
+          console.log(chalk5.blue("\u2713 File watcher started"));
+          console.log(chalk5.gray(`Watching: ${watchPaths.join(", ")}`));
+          resolve2();
+        });
+        this.watcher.on("change", (filePath) => {
+          console.log(chalk5.cyan(`File changed: ${path6.relative(this.options.rootDir, filePath)}`));
+          if (this.options.onFileChange) {
+            this.options.onFileChange(filePath);
+          }
+        });
+        this.watcher.on("error", (err) => {
+          const error = err instanceof Error ? err : new Error(String(err));
+          console.error(chalk5.red(`File watcher error: ${error.message}`));
+          if (this.options.onError) {
+            this.options.onError(error);
+          }
+        });
+        this.watcher.on("add", (filePath) => {
+          console.log(chalk5.gray(`File added: ${path6.relative(this.options.rootDir, filePath)}`));
+        });
+        this.watcher.on("unlink", (filePath) => {
+          console.log(chalk5.gray(`File removed: ${path6.relative(this.options.rootDir, filePath)}`));
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * 停止监听
+   */
+  async stop() {
+    if (this.watcher) {
+      await this.watcher.close();
+      this.watcher = null;
+      console.log(chalk5.yellow("File watcher stopped"));
+    }
+  }
+};
+
+// src/dev/builder.ts
+import chalk6 from "chalk";
+
+// src/dev/code-loader.ts
+import * as path7 from "path";
+import * as fs5 from "fs-extra";
+function loadPluginCode(projectRoot) {
+  try {
+    const mainFile = path7.join(projectRoot, "dist", "addon", "main.js");
+    if (!fs5.existsSync(mainFile)) {
+      return null;
+    }
+    let code = fs5.readFileSync(mainFile, "utf-8");
+    const companionEndMarker = "})();";
+    const companionIndex = code.indexOf(companionEndMarker);
+    if (companionIndex !== -1) {
+      code = code.substring(companionIndex + companionEndMarker.length).trim();
+    }
+    return code;
+  } catch (error) {
+    console.error(`Failed to load plugin code: ${error}`);
+    return null;
+  }
+}
+
+// src/dev/builder.ts
+var DevBuilder = class {
+  options;
+  isBuilding = false;
+  buildQueue = [];
+  processingQueue = false;
+  constructor(options) {
+    this.options = options;
+  }
+  /**
+   * 触发构建
+   */
+  async build() {
+    if (this.isBuilding) {
+      return new Promise((resolve2) => {
+        this.buildQueue.push(async () => {
+          await this.doBuild();
+          resolve2();
+        });
+        this.processQueue();
+      });
+    }
+    return this.doBuild();
+  }
+  /**
+   * 执行构建
+   */
+  async doBuild() {
+    if (this.isBuilding) {
+      return;
+    }
+    this.isBuilding = true;
+    if (this.options.onBuildStart) {
+      this.options.onBuildStart();
+    }
+    try {
+      console.log(chalk6.blue("Building plugin..."));
+      await buildPlugin(this.options.projectRoot, {
+        watch: false,
+        devMode: true,
+        devServerUrl: this.options.devServerUrl
+      });
+      const code = loadPluginCode(this.options.projectRoot);
+      if (this.options.onBuildComplete) {
+        this.options.onBuildComplete(true, void 0, code || void 0);
+      }
+      console.log(chalk6.green("\u2713 Build completed"));
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      console.error(chalk6.red(`\u2717 Build failed: ${err.message}`));
+      if (this.options.onBuildComplete) {
+        this.options.onBuildComplete(false, err);
+      }
+    } finally {
+      this.isBuilding = false;
+      this.processQueue();
+    }
+  }
+  /**
+   * 处理构建队列
+   */
+  async processQueue() {
+    if (this.processingQueue || this.buildQueue.length === 0) {
+      return;
+    }
+    this.processingQueue = true;
+    while (this.buildQueue.length > 0 && !this.isBuilding) {
+      const task = this.buildQueue.shift();
+      if (task) {
+        await task();
+      }
+    }
+    this.processingQueue = false;
+  }
+  /**
+   * 检查是否正在构建
+   */
+  get building() {
+    return this.isBuilding;
+  }
+};
+
+// src/dev/logger.ts
+import { createConsola } from "consola";
+var logger = createConsola({
+  formatOptions: {
+    date: true,
+    colors: true,
+    compact: false
+  }
+});
+function printLogMessage(message) {
+  const { level, args } = message;
+  const parsedArgs = args.map((arg) => {
+    try {
+      return JSON.parse(arg);
+    } catch {
+      return arg;
+    }
+  });
+  switch (level) {
+    case "error":
+      if (parsedArgs.length > 0) {
+        logger.error(...parsedArgs);
+      } else {
+        logger.error("");
+      }
+      break;
+    case "warn":
+      if (parsedArgs.length > 0) {
+        logger.warn(...parsedArgs);
+      } else {
+        logger.warn("");
+      }
+      break;
+    case "info":
+      if (parsedArgs.length > 0) {
+        logger.info(...parsedArgs);
+      } else {
+        logger.info("");
+      }
+      break;
+    case "log":
+    default:
+      if (parsedArgs.length > 0) {
+        logger.log(...parsedArgs);
+      } else {
+        logger.log("");
+      }
+      break;
+  }
+}
+
+// src/commands/dev.ts
+async function devCommand(options = {}) {
+  const port = parseInt(options.port || "3000", 10);
+  const projectRoot = process.cwd();
+  console.log(chalk7.blue("Starting development server..."));
+  const configPath = path8.join(projectRoot, "mn-rails.config.js");
+  try {
+    const fs6 = await import("fs-extra");
+    if (!fs6.existsSync(configPath)) {
+      console.error(chalk7.red("Error: mn-rails.config.js not found. Are you in a plugin project?"));
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(chalk7.red(`Error checking project: ${error}`));
+    process.exit(1);
+  }
+  let isFirstBuild = true;
+  const devServerUrl = `ws://localhost:${port}`;
+  const builder = new DevBuilder({
+    projectRoot,
+    devServerUrl,
+    onBuildStart: () => {
+      if (!isFirstBuild) {
+        console.log(chalk7.blue("Rebuilding..."));
+      }
+    },
+    onBuildComplete: async (success, error, code) => {
+      if (success && code) {
+        const updateMessage = {
+          type: "code-update",
+          payload: {
+            message: "Build completed",
+            code
+          },
+          timestamp: Date.now()
+        };
+        const count = server.broadcast(updateMessage);
+        if (count > 0) {
+          console.log(chalk7.green(`\u2713 Code update sent to ${count} client(s)`));
+        }
+        if (isFirstBuild) {
+          isFirstBuild = false;
+          const fs6 = await import("fs-extra");
+          const addonDir = path8.join(projectRoot, "dist", "addon");
+          const addonJsonPath = path8.join(addonDir, "addon.json");
+          if (fs6.existsSync(addonJsonPath)) {
+            const addonJson = fs6.readJSONSync(addonJsonPath);
+            const addonName = `${addonJson.key}-${addonJson.version}.mnaddon`;
+            const addonPath = path8.join(projectRoot, addonName);
+            console.log(chalk7.green("\n\u2713 Initial build completed!"));
+            console.log(chalk7.cyan("\n\u{1F4E6} Plugin Information:"));
+            console.log(chalk7.white(`   Name: ${addonJson.title || addonJson.key}`));
+            console.log(chalk7.white(`   Version: ${addonJson.version}`));
+            if (fs6.existsSync(addonPath)) {
+              console.log(chalk7.cyan(`
+\u{1F4C1} Plugin file: ${addonPath}`));
+            } else {
+              console.log(chalk7.cyan(`
+\u{1F4C1} Plugin directory: ${addonDir}`));
+            }
+            console.log(chalk7.cyan("\n\u{1F4CB} Installation Instructions:"));
+            console.log(chalk7.white("   1. Open MarginNote app"));
+            console.log(chalk7.white("   2. Go to Settings > Add-ons"));
+            console.log(chalk7.white('   3. Tap "Import Add-on" or drag the .mnaddon file'));
+            if (fs6.existsSync(addonPath)) {
+              console.log(chalk7.white(`   4. Select: ${addonName}`));
+            } else {
+              console.log(chalk7.white(`   4. Select the addon directory: ${addonDir}`));
+            }
+            console.log(chalk7.cyan("\n\u{1F50C} Connection:"));
+            console.log(chalk7.white(`   WebSocket server: ${devServerUrl}`));
+            console.log(chalk7.white("   Waiting for plugin to connect..."));
+            console.log(chalk7.gray("\n   The plugin will automatically connect when MarginNote is opened."));
+            console.log(chalk7.gray("   Hot reload will work once connected.\n"));
+          }
+        }
+      } else if (error) {
+        console.error(chalk7.red(`
+\u2717 Build failed: ${error.message}`));
+        if (isFirstBuild) {
+          console.log(chalk7.yellow("\n\u{1F4A1} Troubleshooting:"));
+          console.log(chalk7.white("   - Check if TypeScript compilation errors exist"));
+          console.log(chalk7.white("   - Ensure all dependencies are installed (npm install)"));
+          console.log(chalk7.white("   - Verify mn-rails.config.js is properly configured\n"));
+        }
+      }
+    }
+  });
+  const watcher = new FileWatcher({
+    rootDir: projectRoot,
+    patterns: ["src/**/*"],
+    onFileChange: async (filePath) => {
+      await builder.build();
+    }
+  });
+  const server = new DevServer({
+    port,
+    onConnection: (ws) => {
+      const count = server.getClientCount();
+      console.log(chalk7.green(`\u2713 Client connected (${count} total)`));
+    },
+    onDisconnection: (ws) => {
+      const count = server.getClientCount();
+      console.log(chalk7.yellow(`Client disconnected (${count} remaining)`));
+    },
+    onMessage: (ws, message) => {
+      if (message.type === "log" || message.type === "error" || message.type === "warn") {
+        const logMessage = {
+          level: message.type,
+          args: message.payload.args || [message.payload],
+          timestamp: message.timestamp
+        };
+        printLogMessage(logMessage);
+      } else if (message.type === "ready") {
+        const count = server.getClientCount();
+        console.log(chalk7.green(`\u2713 Client ready (${count} connected)`));
+      }
+    }
+  });
+  try {
+    await server.start();
+    await watcher.start();
+    console.log(chalk7.blue("Performing initial build..."));
+    let buildSuccess = false;
+    try {
+      await builder.build();
+      buildSuccess = true;
+    } catch (error) {
+      console.error(chalk7.red(`
+\u2717 Initial build failed: ${error instanceof Error ? error.message : String(error)}`));
+      console.log(chalk7.yellow("\n\u{1F4A1} Troubleshooting:"));
+      console.log(chalk7.white("   - Check if TypeScript compilation errors exist"));
+      console.log(chalk7.white("   - Ensure all dependencies are installed (npm install)"));
+      console.log(chalk7.white("   - Verify mn-rails.config.js is properly configured"));
+      console.log(chalk7.white("   - Check that src/ directory exists and contains valid code\n"));
+    }
+    if (buildSuccess) {
+      console.log(chalk7.green("\n\u2713 Development server ready!"));
+      console.log(chalk7.cyan("\n\u{1F4CA} Status:"));
+      console.log(chalk7.white(`   Server: ws://localhost:${port}`));
+      console.log(chalk7.white(`   Clients: ${server.getClientCount()}`));
+      console.log(chalk7.cyan("\n\u23F3 Waiting for file changes...\n"));
+    }
+    const shutdown = async () => {
+      console.log(chalk7.yellow("\nShutting down development server..."));
+      await watcher.stop();
+      await server.stop();
+      process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+  } catch (error) {
+    console.error(chalk7.red(`Failed to start server: ${error}`));
+    process.exit(1);
+  }
+}
+
+// src/index.ts
+var program = new Command();
+program.name("mn-rails").description("A modern plugin development framework for MarginNote").version("0.1.0");
+program.command("new").description("Create a new MarginNote plugin project").argument("[name]", "Project name").option("-t, --template <template>", "Template to use", "basic").action(newCommand);
+program.command("build").description("Build the plugin for production").option("-w, --watch", "Watch mode").action(buildCommand);
+program.command("dev").description("Start development server with hot reload").option("-p, --port <port>", "Server port", "3000").action(devCommand);
+program.parse(process.argv);