@jonathanleelx/meddle 0.0.1

package/bin/commands/supervise.js

@@ -0,0 +1,106 @@
+/**
+ * meddle supervise - Run meddle under a lightweight restart supervisor.
+ */
+
+const fs = require('fs')
+const path = require('path')
+const { spawn } = require('child_process')
+const { resolveMeddleHome } = require('../lib/meddle-home')
+
+const rawArgs = process.argv.slice(3)
+const daemonFlag = rawArgs.includes('--daemon')
+const restartCleanExit = rawArgs.includes('--restart-clean')
+const maxRestarts = readNumberOption('--max-restarts', 0)
+const restartDelayMs = readNumberOption('--restart-delay', 1000)
+
+if (daemonFlag) {
+  startDaemon()
+} else {
+  supervise()
+}
+
+function supervise() {
+  const indexPath = path.join(__dirname, '..', '..', 'index.js')
+  const proxyArgs = stripSupervisorArgs(rawArgs)
+  const childEnv = { ...process.env, DEBUG: process.env.DEBUG || '', MEDDLE_SUPERVISED: '1' }
+
+  let child = null
+  let stopping = false
+  let restarts = 0
+
+  const stop = (signal) => {
+    stopping = true
+    if (child && child.exitCode === null) child.kill(signal)
+  }
+
+  process.on('SIGINT', () => stop('SIGINT'))
+  process.on('SIGTERM', () => stop('SIGTERM'))
+
+  const start = () => {
+    child = spawn(process.execPath, [indexPath, ...proxyArgs], {
+      cwd: process.cwd(),
+      env: childEnv,
+      stdio: 'inherit',
+    })
+
+    child.on('error', (err) => {
+      console.error('[supervisor] failed to start proxy:', err.message)
+      process.exit(1)
+    })
+
+    child.on('exit', (code, signal) => {
+      if (stopping) process.exit(code || 0)
+      if (code === 0 && !restartCleanExit) process.exit(0)
+
+      restarts += 1
+      if (maxRestarts > 0 && restarts > maxRestarts) {
+        console.error(`[supervisor] restart limit reached (${maxRestarts}); last exit code=${code} signal=${signal || ''}`)
+        process.exit(code || 1)
+      }
+
+      console.error(`[supervisor] proxy exited code=${code} signal=${signal || ''}; restarting in ${restartDelayMs}ms`)
+      setTimeout(start, restartDelayMs)
+    })
+  }
+
+  start()
+}
+
+function startDaemon() {
+  const args = rawArgs.filter(arg => arg !== '--daemon')
+  const meddleDir = resolveMeddleHome()
+  fs.mkdirSync(meddleDir, { recursive: true })
+  const logFd = fs.openSync(path.join(meddleDir, 'supervisor.log'), 'a')
+  const binPath = path.join(__dirname, '..', 'index')
+  const child = spawn(process.execPath, [binPath, 'supervise', ...args], {
+    cwd: process.cwd(),
+    detached: true,
+    stdio: ['ignore', logFd, logFd],
+    env: process.env,
+  })
+  child.unref()
+  console.log(`Supervisor started: pid=${child.pid}, log=${path.join(meddleDir, 'supervisor.log')}`)
+}
+
+function stripSupervisorArgs(args) {
+  const result = []
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]
+    if (arg === '--daemon' || arg === '--restart-clean') continue
+    if (arg === '--max-restarts' || arg === '--restart-delay') {
+      i += 1
+      continue
+    }
+    if (arg.startsWith('--max-restarts=') || arg.startsWith('--restart-delay=')) continue
+    result.push(arg)
+  }
+  return result
+}
+
+function readNumberOption(name, fallback) {
+  const inline = rawArgs.find(arg => arg.startsWith(name + '='))
+  const index = rawArgs.indexOf(name)
+  const value = inline ? inline.slice(name.length + 1) : (index >= 0 ? rawArgs[index + 1] : undefined)
+  const parsed = Number(value)
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback
+}

package/bin/commands/url.js

@@ -0,0 +1,30 @@
+/**
+ * meddle url - Get proxy URL
+ */
+
+const { getProxyUrl, isProxyRunning } = require('../lib/proxy-detect')
+const output = require('../lib/output')
+
+// Check for --json flag
+const args = process.argv.slice(2)
+const jsonFlag = args.includes('--json')
+output.setJsonMode(jsonFlag)
+
+async function run() {
+  const url = getProxyUrl()
+  const running = await isProxyRunning()
+
+  if (output.isJsonMode()) {
+    output.jsonRaw({ url, running })
+    return
+  }
+
+  output.header('Proxy URL')
+  output.kv('URL', url)
+  output.kv('Status', running ? 'Running' : 'Not Running')
+}
+
+run().catch(e => {
+  output.error(e.message)
+  process.exit(1)
+})

package/bin/doctor.js

@@ -0,0 +1,356 @@
+#!/usr/bin/env node
+
+/**
+ * Meddle Doctor - 配置文件健康检查工具
+ */
+
+const fs = require('fs')
+const path = require('path')
+const chalk = require('chalk')
+const { resolveMeddleHome } = require('./lib/meddle-home')
+
+const meddleDir = resolveMeddleHome()
+const settingsPath = path.resolve(meddleDir, 'settings.json')
+const routeRulesDir = path.resolve(meddleDir, 'route-rules')
+const defaultMocksPath = path.resolve(meddleDir, 'mocks.json')
+const certDir = path.resolve(meddleDir, 'ca')
+const rootCACrt = path.resolve(certDir, 'rootCA.crt')
+const rootCAKey = path.resolve(certDir, 'rootCA.key')
+
+let hasErrors = false
+let hasWarnings = false
+
+function printHeader() {
+  console.log('')
+  console.log(chalk.bold.cyan('════════════════════════════════════════'))
+  console.log(chalk.bold.cyan('   Meddle 配置文件健康检查'))
+  console.log(chalk.bold.cyan('════════════════════════════════════════'))
+  console.log('')
+}
+
+function printSection(title) {
+  console.log(chalk.bold.yellow(`\n▶ ${title}`))
+  console.log(chalk.gray('─'.repeat(40)))
+}
+
+function printSuccess(message) {
+  console.log(chalk.green('  ✓'), message)
+}
+
+function printWarning(message) {
+  console.log(chalk.yellow('  ⚠'), message)
+  hasWarnings = true
+}
+
+function printError(message) {
+  console.log(chalk.red('  ✗'), message)
+  hasErrors = true
+}
+
+function printInfo(message) {
+  console.log(chalk.gray('    →'), message)
+}
+
+/**
+ * 检查目录是否存在
+ */
+function checkDirectory() {
+  printSection('1. 配置目录检查')
+  
+  if (fs.existsSync(meddleDir)) {
+    printSuccess(`配置目录存在: ${meddleDir}`)
+    const stats = fs.statSync(meddleDir)
+    printInfo(`创建时间: ${stats.birthtime.toLocaleString()}`)
+  } else {
+    printError(`配置目录不存在: ${meddleDir}`)
+    printInfo('运行 meddle 命令将自动创建')
+  }
+  
+  if (fs.existsSync(certDir)) {
+    printSuccess(`证书目录存在: ${certDir}`)
+  } else {
+    printWarning('证书目录不存在，HTTPS 代理将无法使用')
+    printInfo('首次启动时会自动创建')
+  }
+}
+
+/**
+ * 检查系统设置文件
+ */
+function checkSettings() {
+  printSection('2. 系统设置检查')
+  
+  if (!fs.existsSync(settingsPath)) {
+    printWarning('系统设置文件不存在')
+    printInfo('首次打开设置面板时会自动创建')
+    return null
+  }
+  
+  try {
+    const content = fs.readFileSync(settingsPath, 'utf8')
+    const settings = JSON.parse(content)
+    
+    printSuccess(`系统设置文件: ${settingsPath}`)
+    printInfo(`文件大小: ${content.length} bytes`)
+    
+    // 检查必要字段
+    if (settings.theme) {
+      printSuccess(`主题设置: ${settings.theme}`)
+    } else {
+      printWarning('未设置主题')
+    }
+    
+    if (settings.fontSize) {
+      printSuccess(`字体大小: ${settings.fontSize}`)
+    }
+    
+    if (settings.aiConfig) {
+      const ai = settings.aiConfig
+      if (ai.enabled) {
+        printSuccess(`AI 功能: 已启用 (${ai.provider})`)
+        printInfo(`模型: ${ai.model}`)
+        if (!ai.apiKey) {
+          printWarning('AI 已启用但未配置 API Key')
+        }
+      } else {
+        printInfo('AI 功能: 未启用')
+      }
+      
+      if (ai.models && ai.models.length > 0) {
+        printSuccess(`多模型配置: ${ai.models.length} 个模型`)
+      }
+    }
+    
+    return settings
+    
+  } catch (error) {
+    printError(`系统设置文件格式错误: ${error.message}`)
+    return null
+  }
+}
+
+/**
+ * 检查路由规则目录
+ */
+function checkRulesFile(settings) {
+  printSection('3. 路由规则文件检查')
+
+  printInfo(`规则目录: ${routeRulesDir}`)
+
+  if (!fs.existsSync(routeRulesDir)) {
+    printWarning('路由规则目录不存在')
+    printInfo('首次启动时会自动创建，并生成默认规则文件')
+    return
+  }
+
+  const txtFiles = fs.readdirSync(routeRulesDir).filter(f => f.endsWith('.txt'))
+  printSuccess(`规则目录存在，包含 ${txtFiles.length} 个规则文件`)
+
+  // 检查 settings 中的 activeRuleFiles
+  const activeNames = (settings && Array.isArray(settings.activeRuleFiles)) ? settings.activeRuleFiles : []
+  printInfo(`已启用: ${activeNames.length} 个文件`)
+
+  let totalRules = 0
+  txtFiles.forEach(file => {
+    const filePath = path.join(routeRulesDir, file)
+    const name = file.replace(/\.txt$/, '')
+    const isActive = activeNames.includes(name)
+
+    try {
+      const content = fs.readFileSync(filePath, 'utf8')
+      const lines = content.split('\n').filter(line => {
+        const trimmed = line.trim()
+        return trimmed && !trimmed.startsWith('#') && !trimmed.startsWith('//')
+      })
+      const validRules = lines.filter(line => line.trim().split(/\s+/).length >= 2).length
+      totalRules += validRules
+      printSuccess(`  ${isActive ? '●' : '○'} ${name} (${validRules} 条规则)`)
+    } catch (error) {
+      printError(`  读取 ${file} 失败: ${error.message}`)
+    }
+  })
+
+  if (totalRules > 0) {
+    printSuccess(`有效规则总数: ${totalRules} 条`)
+  }
+}
+
+/**
+ * 检查 Mock 规则文件
+ */
+function checkMocksFile(settings) {
+  printSection('4. Mock 规则文件检查')
+  
+  let mocksPath = defaultMocksPath
+  
+  // 检查自定义路径
+  if (settings && settings.mocksFilePath) {
+    mocksPath = settings.mocksFilePath
+    printInfo(`使用自定义路径: ${mocksPath}`)
+  } else {
+    printInfo(`使用默认路径: ${mocksPath}`)
+  }
+  
+  if (!fs.existsSync(mocksPath)) {
+    printWarning('Mock 规则文件不存在')
+    printInfo('可以通过 Web 界面创建 Mock 规则')
+    return
+  }
+  
+  try {
+    const content = fs.readFileSync(mocksPath, 'utf8')
+    const data = JSON.parse(content)
+    
+    printSuccess(`Mock 规则文件: ${mocksPath}`)
+    printInfo(`文件大小: ${content.length} bytes`)
+    
+    if (!data.rules || !Array.isArray(data.rules)) {
+      printError('Mock 文件格式错误：缺少 rules 数组')
+      return
+    }
+    
+    printSuccess(`Mock 规则数量: ${data.rules.length} 条`)
+    
+    // 检查每条规则
+    let enabledCount = 0
+    data.rules.forEach((rule, index) => {
+      if (rule.enabled) {
+        enabledCount++
+      }
+      
+      // 检查必要字段
+      if (!rule.urlPattern) {
+        printWarning(`规则 #${rule.id || index}: 缺少 urlPattern`)
+      }
+      if (rule.bodyType === 'file' && rule.body && !fs.existsSync(rule.body)) {
+        printWarning(`规则 #${rule.id || index}: 文件不存在 ${rule.body}`)
+      }
+    })
+    
+    printSuccess(`已启用规则: ${enabledCount} 条`)
+    
+  } catch (error) {
+    printError(`Mock 规则文件格式错误: ${error.message}`)
+  }
+}
+
+/**
+ * 检查证书文件
+ */
+function checkCertificates() {
+  printSection('5. SSL 证书检查')
+  
+  if (!fs.existsSync(certDir)) {
+    printWarning('证书目录不存在')
+    printInfo('首次启动时会自动创建')
+    return
+  }
+  
+  printSuccess(`证书目录: ${certDir}`)
+  
+  if (fs.existsSync(rootCACrt)) {
+    printSuccess('根证书文件存在: rootCA.crt')
+    const stats = fs.statSync(rootCACrt)
+    printInfo(`文件大小: ${stats.size} bytes`)
+  } else {
+    printWarning('根证书文件不存在')
+    printInfo('首次启动时会自动生成')
+  }
+  
+  if (fs.existsSync(rootCAKey)) {
+    printSuccess('根证书私钥存在: rootCA.key')
+  } else {
+    printWarning('根证书私钥不存在')
+  }
+  
+  // 检查其他证书文件
+  try {
+    const files = fs.readdirSync(certDir)
+    const certFiles = files.filter(f => f.endsWith('.crt') && f !== 'rootCA.crt')
+    if (certFiles.length > 0) {
+      printSuccess(`域名证书: ${certFiles.length} 个`)
+      certFiles.slice(0, 5).forEach(file => {
+        printInfo(`  - ${file}`)
+      })
+      if (certFiles.length > 5) {
+        printInfo(`  ... 还有 ${certFiles.length - 5} 个`)
+      }
+    }
+  } catch (error) {
+    // ignore
+  }
+}
+
+/**
+ * 检查文件权限
+ */
+function checkPermissions() {
+  printSection('6. 文件权限检查')
+  
+  const checkPaths = [
+    { path: meddleDir, name: '配置目录' },
+    { path: settingsPath, name: '系统设置文件' },
+    { path: routeRulesDir, name: '路由规则目录' },
+    { path: defaultMocksPath, name: 'Mock 规则文件' },
+  ]
+  
+  checkPaths.forEach(({ path: filePath, name }) => {
+    if (fs.existsSync(filePath)) {
+      try {
+        fs.accessSync(filePath, fs.constants.R_OK | fs.constants.W_OK)
+        printSuccess(`${name}: 可读写`)
+      } catch (error) {
+        printError(`${name}: 权限不足`)
+      }
+    }
+  })
+}
+
+/**
+ * 生成诊断报告
+ */
+function generateReport() {
+  printSection('诊断报告')
+  
+  console.log('')
+  
+  if (!hasErrors && !hasWarnings) {
+    console.log(chalk.green.bold('  ✓ 所有检查通过！配置正常。'))
+  } else {
+    if (hasErrors) {
+      console.log(chalk.red.bold(`  ✗ 发现 ${hasErrors ? '错误' : '问题'}`))
+      console.log(chalk.gray('    请根据上述提示修复错误'))
+    }
+    if (hasWarnings) {
+      console.log(chalk.yellow.bold('  ⚠ 发现警告'))
+      console.log(chalk.gray('    建议检查上述警告项'))
+    }
+  }
+  
+  console.log('')
+  console.log(chalk.gray('提示:'))
+  console.log(chalk.gray('  - 运行 meddle 启动代理服务器'))
+  console.log(chalk.gray('  - 访问 http://localhost:8899 打开管理界面'))
+  console.log(chalk.gray('  - 查看 CONFIG_STRUCTURE.md 了解配置文件详情'))
+  console.log('')
+}
+
+/**
+ * 主函数
+ */
+function main() {
+  printHeader()
+  
+  checkDirectory()
+  const settings = checkSettings()
+  checkRulesFile(settings)
+  checkMocksFile(settings)
+  checkCertificates()
+  checkPermissions()
+  
+  generateReport()
+  
+  process.exit(hasErrors ? 1 : 0)
+}
+
+main()

package/bin/index

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+
+// Strip --session <id> / --session=<id> from argv so command routing
+// and all downstream `process.argv.slice(N)` calls see a clean argv.
+// The session id is stashed in MEDDLE_SESSION_ID for session-args.js to
+// pick up when applying the session context.
+(function stripSessionFlag() {
+  const argv = process.argv
+  for (let i = 2; i < argv.length; i++) {
+    if (argv[i] === '--session' && i + 1 < argv.length) {
+      process.env.MEDDLE_SESSION_ID = argv[i + 1]
+      argv.splice(i, 2)
+      return
+    }
+    if (argv[i].startsWith('--session=')) {
+      process.env.MEDDLE_SESSION_ID = argv[i].slice('--session='.length)
+      argv.splice(i, 1)
+      return
+    }
+  }
+})()
+
+const args = process.argv.slice(2)
+const command = args[0]
+const subcommand = args[1]
+
+// Command routing map
+const commands = {
+  'doctor': './doctor.js',
+  'start': './commands/start.js',
+  'supervise': './commands/supervise.js',
+  'url': './commands/url.js',
+  'status': './commands/status.js',
+  'session': './commands/session/index.js',
+  'mock': './commands/mock/index.js',
+  'route': './commands/route/index.js'
+}
+
+// Check for --help flag
+if (command === '--help' || command === '-h' || command === 'help') {
+  showHelp()
+  process.exit(0)
+}
+
+// Handle nested commands (mock/route/session)
+if (command === 'mock' || command === 'route' || command === 'session') {
+  require(commands[command])
+} else if (commands[command]) {
+  require(commands[command])
+} else if (!command || command.startsWith('--')) {
+  // No command or only flags - start proxy (default behavior)
+  require('../index.js')
+} else {
+  console.log(`Unknown command: ${command}`)
+  showHelp()
+  process.exit(1)
+}
+
+function showHelp() {
+  console.log(`
+Meddle - 开发代理工具
+
+用法:
+  meddle                          启动代理服务器 (默认)
+  meddle start [options]          启动代理服务器
+  meddle supervise [options]      以前台守护模式启动并自动重启
+  meddle --remote                 启动局域网手机代理并解密 HTTPS
+  meddle doctor                   检查配置文件健康状况
+  meddle url                      获取代理 URL
+  meddle status                   查看代理状态
+
+Session 命令 (多实例隔离，预览功能):
+  meddle session create [--name <label>] [--port <port>]
+                              创建一个新的代理 session（独立 MEDDLE_HOME + 端口）
+  meddle session list             列出所有 session（含存活检测）
+  meddle session delete <id> [--clean]
+                              终止 session 并从注册表移除（--clean 同时删除数据目录）
+  meddle session prune            清理所有孤儿 session 记录
+  meddle --session <id> <command> 对指定 session 执行命令（如 route list）
+
+Mock 命令:
+  meddle mock list [--json]       列出所有 mock 规则
+  meddle mock add [options]       添加 mock 规则
+  meddle mock update <id> [opts]  更新 mock 规则
+  meddle mock delete <id>         删除 mock 规则
+  meddle mock enable <id>         启用 mock 规则
+  meddle mock disable <id>        禁用 mock 规则
+
+Route 命令:
+  meddle route list [--json]      列出所有路由文件
+  meddle route show <file> [--json] 查看路由文件规则
+  meddle route preview <url> [--file <name>] [--json] 预览 URL 的转发目标
+  meddle route active             查看当前激活的路由文件
+  meddle route active set <file>  设置激活的路由文件
+  meddle route create <name>      创建路由文件
+  meddle route add <file> <pattern> <target>   添加路由规则
+  meddle route update <file> <pattern> <target> 更新路由规则
+  meddle route delete <file> <pattern> 删除路由规则
+
+全局选项:
+  --help, -h                  显示帮助信息
+  --session <id>              指定目标 session（与 MEDDLE_HOME 互斥）
+  --json                      JSON 格式输出 (用于 list/show/preview 命令)
+  --open                      启动后自动打开浏览器
+  --remote                    允许局域网设备连接代理
+  --remote-token <token>      为远程代理启用 Basic 认证
+  --intercept-https           解密所有 HTTPS 流量
+  --no-intercept-https        远程模式下不解密 HTTPS
+  --daemon                    supervise 后台运行，日志写入 ~/.meddle/supervisor.log
+  --max-restarts <n>          supervise 最大重启次数，0 表示不限
+  --restart-delay <ms>        supervise 重启延迟，默认 1000ms
+
+示例:
+  meddle                          # 启动代理服务器
+  meddle --open                   # 启动并打开浏览器
+  meddle --remote                 # 启动手机抓包代理
+  meddle --remote --remote-token "change-me"
+  meddle supervise --remote       # 守护模式启动远程代理
+  meddle doctor                   # 检查配置文件
+  meddle mock list --json         # JSON 格式列出 mock 规则
+  meddle mock add --name "API" --pattern "api.test.com" --status 200
+  meddle route list               # 列出路由文件
+  meddle route preview "https://api.example.com/v1/users"  # 预览转发目标
+  meddle route preview "https://cdn.com/assets/js/app.js" --file dev-rules --json
+  meddle route add dev-rules "api.test.com" "localhost:3000"
+  meddle route active set beta-rules
+
+更多信息请访问: https://github.com/JonathanLee-LX/meddle
+  `)
+}

package/bin/lib/api-client.js

@@ -0,0 +1,72 @@
+/**
+ * HTTP API client for proxy operations
+ */
+
+const { getProxyUrl } = require('./proxy-detect')
+
+const DEFAULT_TIMEOUT = 2000
+
+/**
+ * Make API request to proxy server
+ */
+async function apiRequest(method, pathname, body, timeoutMs = DEFAULT_TIMEOUT) {
+  const base = getProxyUrl()
+  const url = base.replace(/\/$/, '') + pathname
+  const opts = {
+    method,
+    headers: { 'Content-Type': 'application/json' },
+    signal: AbortSignal.timeout(timeoutMs)
+  }
+  if (body !== undefined) {
+    opts.body = typeof body === 'string' ? body : JSON.stringify(body)
+  }
+
+  const response = await fetch(url, opts)
+
+  if (!response.ok) {
+    const text = await response.text()
+    throw new Error(text || response.statusText)
+  }
+
+  const contentType = response.headers.get('content-type')
+  if (contentType && contentType.includes('application/json')) {
+    return response.json()
+  }
+  return response.text()
+}
+
+/**
+ * GET request
+ */
+async function apiGet(pathname, timeoutMs = DEFAULT_TIMEOUT) {
+  return apiRequest('GET', pathname, undefined, timeoutMs)
+}
+
+/**
+ * POST request
+ */
+async function apiPost(pathname, body, timeoutMs = DEFAULT_TIMEOUT) {
+  return apiRequest('POST', pathname, body, timeoutMs)
+}
+
+/**
+ * PUT request
+ */
+async function apiPut(pathname, body, timeoutMs = DEFAULT_TIMEOUT) {
+  return apiRequest('PUT', pathname, body, timeoutMs)
+}
+
+/**
+ * DELETE request
+ */
+async function apiDelete(pathname, timeoutMs = DEFAULT_TIMEOUT) {
+  return apiRequest('DELETE', pathname, undefined, timeoutMs)
+}
+
+module.exports = {
+  apiRequest,
+  apiGet,
+  apiPost,
+  apiPut,
+  apiDelete
+}