@jonathanleelx/meddle 0.0.1

package/bin/commands/mock/add.js

@@ -0,0 +1,92 @@
+/**
+ * meddle mock add - Add a mock rule
+ */
+
+const output = require('../../lib/output')
+const { isProxyRunning } = require('../../lib/proxy-detect')
+const { apiPost } = require('../../lib/api-client')
+const { addMockRule } = require('../../lib/file-access')
+
+// Parse arguments
+const args = process.argv.slice(3)
+const jsonFlag = args.includes('--json')
+output.setJsonMode(jsonFlag)
+
+function parseArgs(args) {
+  const options = {}
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--name') options.name = args[++i]
+    else if (args[i] === '--pattern') options.urlPattern = args[++i]
+    else if (args[i] === '--method') options.method = args[++i]
+    else if (args[i] === '--status') options.statusCode = parseInt(args[++i], 10)
+    else if (args[i] === '--body') options.body = args[++i]
+    else if (args[i] === '--delay') options.delay = parseInt(args[++i], 10)
+    else if (args[i] === '--headers') {
+      try {
+        options.headers = JSON.parse(args[++i])
+      } catch (_) {
+        options.headers = {}
+      }
+    }
+  }
+  return options
+}
+
+async function run() {
+  const options = parseArgs(args)
+
+  // Validate required fields
+  if (!options.name) {
+    output.error('Missing required option: --name')
+    process.exit(1)
+  }
+  if (!options.urlPattern) {
+    output.error('Missing required option: --pattern')
+    process.exit(1)
+  }
+
+  // Set defaults
+  const rule = {
+    name: options.name,
+    urlPattern: options.urlPattern,
+    method: options.method || '*',
+    statusCode: options.statusCode || 200,
+    delay: options.delay || 0,
+    bodyType: 'inline',
+    headers: options.headers || {},
+    body: options.body || '',
+    enabled: true
+  }
+
+  const running = await isProxyRunning()
+
+  let result
+  if (running) {
+    try {
+      result = await apiPost('/api/mocks', rule)
+      result = result.rule || result
+    } catch (e) {
+      // Fallback to file mode
+      result = addMockRule(rule)
+    }
+  } else {
+    result = addMockRule(rule)
+  }
+
+  if (jsonFlag) {
+    output.jsonRaw(result)
+    return
+  }
+
+  output.header('Mock Rule Added')
+  output.success(`#${result.id}: ${result.name}`)
+  output.kv('Pattern', result.urlPattern)
+  output.kv('Method', result.method)
+  output.kv('Status', result.statusCode)
+  output.kv('Delay', `${result.delay}ms`)
+}
+
+run().catch(e => {
+  output.error(e.message)
+  process.exit(1)
+})

package/bin/commands/mock/delete.js

@@ -0,0 +1,58 @@
+/**
+ * meddle mock delete - Delete a mock rule
+ */
+
+const output = require('../../lib/output')
+const { isProxyRunning } = require('../../lib/proxy-detect')
+const { apiDelete } = require('../../lib/api-client')
+const { deleteMockRule } = require('../../lib/file-access')
+
+// Parse arguments (skip 'mock' and 'delete' from argv)
+const args = process.argv.slice(4)
+const jsonFlag = args.includes('--json')
+output.setJsonMode(jsonFlag)
+
+// Get id from positional argument
+const idArg = args.find(a => !a.startsWith('--'))
+const id = idArg ? parseInt(idArg, 10) : null
+
+async function run() {
+  if (id === null) {
+    output.error('Missing required argument: <id>')
+    process.exit(1)
+  }
+
+  const running = await isProxyRunning()
+
+  if (running) {
+    try {
+      await apiDelete(`/api/mocks/${id}`)
+    } catch (e) {
+      // Fallback to file mode
+      const deleted = deleteMockRule(id)
+      if (!deleted) {
+        output.error(`Mock rule not found: id=${id}`)
+        process.exit(1)
+      }
+    }
+  } else {
+    const deleted = deleteMockRule(id)
+    if (!deleted) {
+      output.error(`Mock rule not found: id=${id}`)
+      process.exit(1)
+    }
+  }
+
+  if (jsonFlag) {
+    output.jsonRaw({ success: true, id })
+    return
+  }
+
+  output.header('Mock Rule Deleted')
+  output.success(`id=${id}`)
+}
+
+run().catch(e => {
+  output.error(e.message)
+  process.exit(1)
+})

package/bin/commands/mock/index.js

@@ -0,0 +1,50 @@
+/**
+ * meddle mock - Mock rule subcommand router
+ */
+
+const args = process.argv.slice(3)
+const subcommand = args[0]
+
+switch (subcommand) {
+  case 'list':
+    require('./list.js')
+    break
+  case 'add':
+    require('./add.js')
+    break
+  case 'update':
+    require('./update.js')
+    break
+  case 'delete':
+    require('./delete.js')
+    break
+  case 'enable':
+  case 'disable':
+    require('./toggle.js')
+    break
+  default:
+    console.log(`
+Mock Commands:
+  meddle mock list [--json]           List all mock rules
+  meddle mock add [options]           Add a mock rule
+  meddle mock update <id> [options]   Update a mock rule
+  meddle mock delete <id>             Delete a mock rule
+  meddle mock enable <id>             Enable a mock rule
+  meddle mock disable <id>            Disable a mock rule
+
+Add Options:
+  --name <n>       Rule name
+  --pattern <p>    URL pattern (regex or string)
+  --method <m>     HTTP method (GET, POST, *, default: *)
+  --status <s>     Response status code (default: 200)
+  --body <b>       Response body content
+  --delay <d>      Response delay in ms (default: 0)
+
+Examples:
+  meddle mock list
+  meddle mock add --name "API Mock" --pattern "example.com/api" --status 200
+  meddle mock update 1 --status 404
+  meddle mock delete 1
+`)
+    process.exit(1)
+}

package/bin/commands/mock/list.js

@@ -0,0 +1,68 @@
+/**
+ * meddle mock list - List all mock rules
+ */
+
+const output = require('../../lib/output')
+const { isProxyRunning } = require('../../lib/proxy-detect')
+const { apiGet } = require('../../lib/api-client')
+const { loadMockRules } = require('../../lib/file-access')
+
+// Check for --json flag
+const args = process.argv.slice(3)
+const jsonFlag = args.includes('--json')
+output.setJsonMode(jsonFlag)
+
+async function run() {
+  const running = await isProxyRunning()
+
+  let rules = []
+
+  if (running) {
+    try {
+      rules = await apiGet('/api/mocks')
+    } catch (e) {
+      // Fallback to file mode
+      rules = loadMockRules()
+    }
+  } else {
+    rules = loadMockRules()
+  }
+
+  if (jsonFlag) {
+    output.jsonRaw(rules)
+    return
+  }
+
+  output.header(`Mock Rules (${rules.length} total)`)
+
+  if (rules.length === 0) {
+    output.info('No mock rules found')
+    return
+  }
+
+  // Separate active and inactive
+  const active = rules.filter(r => r.enabled)
+  const inactive = rules.filter(r => !r.enabled)
+
+  if (active.length > 0) {
+    output.section('Active Rules')
+    active.forEach(rule => {
+      output.success(`#${rule.id}: ${rule.name} (${rule.urlPattern})`)
+      output.kv('Status', rule.statusCode, 4)
+      output.kv('Method', rule.method || '*', 4)
+      output.kv('Delay', `${rule.delay || 0}ms`, 4)
+    })
+  }
+
+  if (inactive.length > 0) {
+    output.section('Inactive Rules')
+    inactive.forEach(rule => {
+      output.bullet(`#${rule.id}: ${rule.name} (${rule.urlPattern})`, false)
+    })
+  }
+}
+
+run().catch(e => {
+  output.error(e.message)
+  process.exit(1)
+})

package/bin/commands/mock/toggle.js

@@ -0,0 +1,64 @@
+/**
+ * meddle mock enable/disable - Toggle mock rule enabled status
+ */
+
+const output = require('../../lib/output')
+const { isProxyRunning } = require('../../lib/proxy-detect')
+const { apiPut } = require('../../lib/api-client')
+const { updateMockRule } = require('../../lib/file-access')
+
+// Parse arguments
+const args = process.argv.slice(2) // Full args: ['mock', 'enable'/'disable', '<id>']
+const subcommand = args[1] // 'enable' or 'disable' (at index 1)
+const jsonFlag = args.includes('--json')
+output.setJsonMode(jsonFlag)
+
+// Get id from positional argument
+const idArg = args.find(a => !a.startsWith('--') && a !== 'mock' && a !== 'enable' && a !== 'disable')
+const id = idArg ? parseInt(idArg, 10) : null
+
+async function run() {
+  if (id === null) {
+    output.error('Missing required argument: <id>')
+    process.exit(1)
+  }
+
+  const enabled = subcommand === 'enable'
+
+  const running = await isProxyRunning()
+
+  let result
+  if (running) {
+    try {
+      result = await apiPut(`/api/mocks/${id}`, { enabled })
+      result = result.rule || result
+    } catch (e) {
+      // Fallback to file mode
+      result = updateMockRule(id, { enabled })
+      if (!result) {
+        output.error(`Mock rule not found: id=${id}`)
+        process.exit(1)
+      }
+    }
+  } else {
+    result = updateMockRule(id, { enabled })
+    if (!result) {
+      output.error(`Mock rule not found: id=${id}`)
+      process.exit(1)
+    }
+  }
+
+  if (jsonFlag) {
+    output.jsonRaw(result)
+    return
+  }
+
+  output.header('Mock Rule Updated')
+  output.success(`#${result.id}: ${result.name}`)
+  output.kv('Enabled', enabled ? 'Yes' : 'No')
+}
+
+run().catch(e => {
+  output.error(e.message)
+  process.exit(1)
+})

package/bin/commands/mock/update.js

@@ -0,0 +1,94 @@
+/**
+ * meddle mock update - Update a mock rule
+ */
+
+const output = require('../../lib/output')
+const { isProxyRunning } = require('../../lib/proxy-detect')
+const { apiPut } = require('../../lib/api-client')
+const { updateMockRule, loadMockRules, saveMockRules } = require('../../lib/file-access')
+
+// Parse arguments (skip 'mock' and 'update' from argv)
+const args = process.argv.slice(4)
+const jsonFlag = args.includes('--json')
+output.setJsonMode(jsonFlag)
+
+function parseArgs(args) {
+  // First positional arg is id
+  let id = null
+  const options = {}
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--name') options.name = args[++i]
+    else if (args[i] === '--pattern') options.urlPattern = args[++i]
+    else if (args[i] === '--method') options.method = args[++i]
+    else if (args[i] === '--status') options.statusCode = parseInt(args[++i], 10)
+    else if (args[i] === '--body') options.body = args[++i]
+    else if (args[i] === '--delay') options.delay = parseInt(args[++i], 10)
+    else if (args[i] === '--headers') {
+      try {
+        options.headers = JSON.parse(args[++i])
+      } catch (_) {
+        options.headers = {}
+      }
+    }
+    else if (!args[i].startsWith('--') && id === null) {
+      id = parseInt(args[i], 10)
+    }
+  }
+
+  return { id, options }
+}
+
+async function run() {
+  const { id, options } = parseArgs(args)
+
+  if (id === null) {
+    output.error('Missing required argument: <id>')
+    process.exit(1)
+  }
+
+  if (Object.keys(options).length === 0) {
+    output.error('No update options provided')
+    process.exit(1)
+  }
+
+  const running = await isProxyRunning()
+
+  let result
+  if (running) {
+    try {
+      result = await apiPut(`/api/mocks/${id}`, options)
+      result = result.rule || result
+    } catch (e) {
+      // Fallback to file mode
+      result = updateMockRule(id, options)
+      if (!result) {
+        output.error(`Mock rule not found: id=${id}`)
+        process.exit(1)
+      }
+    }
+  } else {
+    result = updateMockRule(id, options)
+    if (!result) {
+      output.error(`Mock rule not found: id=${id}`)
+      process.exit(1)
+    }
+  }
+
+  if (jsonFlag) {
+    output.jsonRaw(result)
+    return
+  }
+
+  output.header('Mock Rule Updated')
+  output.success(`#${result.id}: ${result.name}`)
+  if (options.urlPattern) output.kv('Pattern', result.urlPattern)
+  if (options.method) output.kv('Method', result.method)
+  if (options.statusCode) output.kv('Status', result.statusCode)
+  if (options.delay) output.kv('Delay', `${result.delay}ms`)
+}
+
+run().catch(e => {
+  output.error(e.message)
+  process.exit(1)
+})

package/bin/commands/route/active.js

@@ -0,0 +1,141 @@
+/**
+ * meddle route active - Show or set active route files
+ */
+
+const output = require('../../lib/output')
+const { isProxyRunning } = require('../../lib/proxy-detect')
+const { apiGet, apiPut } = require('../../lib/api-client')
+const { listRuleFiles, getActiveRuleFileNames, setActiveRuleFileNames, setRuleFileEnabled } = require('../../lib/file-access')
+
+// Parse arguments (skip 'route' and 'active' from argv)
+const args = process.argv.slice(4)
+const jsonFlag = args.includes('--json')
+output.setJsonMode(jsonFlag)
+
+// Check for 'set' subcommand - now 'set' would be at args[0] if present
+const isSet = args[0] === 'set'
+const targetFile = isSet ? args[1] : null
+
+async function run() {
+  const running = await isProxyRunning()
+
+  if (isSet) {
+    if (!targetFile) {
+      output.error('Missing required argument: <file>')
+      process.exit(1)
+    }
+
+    // Set active route file (disable others, enable this one)
+    if (running) {
+      try {
+        const files = await apiGet('/api/rule-files')
+        if (!Array.isArray(files)) {
+          throw new Error('规则文件列表返回格式错误')
+        }
+
+        const target = files.find(f => f && f.name === targetFile)
+        if (!target) {
+          output.error(`Route file not found: ${targetFile}`)
+          process.exit(1)
+        }
+
+        for (const f of files) {
+          const nextEnabled = f.name === targetFile
+          if (!!f.enabled === nextEnabled) continue
+          await apiPut(`/api/rule-files/${encodeURIComponent(f.name)}`, { enabled: nextEnabled })
+        }
+
+        if (jsonFlag) {
+          output.jsonRaw({ success: true, activeFile: targetFile })
+          return
+        }
+
+        output.header('Active Route File Set')
+        output.success(targetFile)
+      } catch (e) {
+        // Fallback to file mode
+        const files = listRuleFiles()
+        const target = files.find(f => f.name === targetFile)
+        if (!target) {
+          output.error(`Route file not found: ${targetFile}`)
+          process.exit(1)
+        }
+
+        // Disable all, then enable target
+        files.forEach(f => setRuleFileEnabled(f.name, f.name === targetFile))
+
+        if (jsonFlag) {
+          output.jsonRaw({ success: true, activeFile: targetFile })
+          return
+        }
+
+        output.header('Active Route File Set')
+        output.success(targetFile)
+      }
+    } else {
+      // File mode
+      const files = listRuleFiles()
+      const target = files.find(f => f.name === targetFile)
+      if (!target) {
+        output.error(`Route file not found: ${targetFile}`)
+        process.exit(1)
+      }
+
+      files.forEach(f => setRuleFileEnabled(f.name, f.name === targetFile))
+
+      if (jsonFlag) {
+        output.jsonRaw({ success: true, activeFile: targetFile })
+        return
+      }
+
+      output.header('Active Route File Set')
+      output.success(targetFile)
+    }
+    return
+  }
+
+  // Show active route files
+  let files = []
+  let activeFiles = []
+
+  if (running) {
+    try {
+      files = await apiGet('/api/rule-files')
+      activeFiles = Array.isArray(files) ? files.filter(f => f && f.enabled).map(f => f.name) : []
+    } catch (e) {
+      activeFiles = getActiveRuleFileNames()
+    }
+  } else {
+    activeFiles = getActiveRuleFileNames()
+  }
+
+  const currentRuleFile = activeFiles.length === 1 ? activeFiles[0] : null
+
+  if (jsonFlag) {
+    output.jsonRaw({
+      currentRuleFile,
+      activeRuleFiles: activeFiles,
+      count: activeFiles.length
+    })
+    return
+  }
+
+  output.header('Active Route Files')
+
+  if (activeFiles.length === 0) {
+    output.info('No active route files')
+    return
+  }
+
+  if (currentRuleFile) {
+    output.kv('Current', currentRuleFile)
+  } else {
+    output.kv('Active Files', activeFiles.length)
+    activeFiles.forEach(f => output.bullet(f, true))
+  }
+}
+
+run().catch(e => {
+  output.error(e.message)
+  process.exit(1)
+})

package/bin/commands/route/add.js

@@ -0,0 +1,127 @@
+/**
+ * meddle route add - Add a rule to a route file
+ */
+
+const output = require('../../lib/output')
+const { isProxyRunning } = require('../../lib/proxy-detect')
+const { apiGet, apiPut } = require('../../lib/api-client')
+const { getRuleFileContent, saveRuleFileContent, parseEprc, ruleMapToEprcText } = require('../../lib/file-access')
+
+// Parse arguments (skip 'route' and 'add' from argv)
+const args = process.argv.slice(4)
+const jsonFlag = args.includes('--json')
+output.setJsonMode(jsonFlag)
+
+// Get positional arguments: file, pattern, target
+const positionalArgs = args.filter(a => !a.startsWith('--'))
+const fileName = positionalArgs[0]
+const pattern = positionalArgs[1]
+const target = positionalArgs[2]
+
+async function run() {
+  if (!fileName) {
+    output.error('Missing required argument: <file>')
+    process.exit(1)
+  }
+  if (!pattern) {
+    output.error('Missing required argument: <pattern>')
+    process.exit(1)
+  }
+  if (!target) {
+    output.error('Missing required argument: <target>')
+    process.exit(1)
+  }
+
+  const running = await isProxyRunning()
+
+  const pat = pattern.trim()
+  const tgt = target.trim()
+
+  if (running) {
+    try {
+      // Get current content
+      let content = await apiGet(`/api/rule-files/${encodeURIComponent(fileName)}/content`)
+      const text = typeof content === 'string' ? content : String(content)
+      const ruleMap = parseEprc(text)
+
+      // Handle [marker] syntax
+      const bm = pat.match(/\[([^\]]+)\]/)
+      if (bm) {
+        ruleMap[pat.replace(bm[0], bm[1])] = tgt + bm[0]
+      } else {
+        ruleMap[pat] = tgt
+      }
+
+      const newContent = ruleMapToEprcText(ruleMap)
+      await apiPut(`/api/rule-files/${encodeURIComponent(fileName)}/content`, { content: newContent })
+
+      if (jsonFlag) {
+        output.jsonRaw({ success: true, file: fileName, pattern: pat, target: tgt })
+        return
+      }
+
+      output.header('Route Rule Added')
+      output.success(`${pat} -> ${tgt}`)
+      output.kv('File', fileName)
+    } catch (e) {
+      // Fallback to file mode
+      const content = getRuleFileContent(fileName)
+      if (!content) {
+        output.error(`Route file not found: ${fileName}`)
+        process.exit(1)
+      }
+
+      const ruleMap = parseEprc(content)
+      const bm = pat.match(/\[([^\]]+)\]/)
+      if (bm) {
+        ruleMap[pat.replace(bm[0], bm[1])] = tgt + bm[0]
+      } else {
+        ruleMap[pat] = tgt
+      }
+
+      const newContent = ruleMapToEprcText(ruleMap)
+      saveRuleFileContent(fileName, newContent)
+
+      if (jsonFlag) {
+        output.jsonRaw({ success: true, file: fileName, pattern: pat, target: tgt })
+        return
+      }
+
+      output.header('Route Rule Added')
+      output.success(`${pat} -> ${tgt}`)
+      output.kv('File', fileName)
+    }
+  } else {
+    // File mode
+    const content = getRuleFileContent(fileName)
+    if (!content) {
+      output.error(`Route file not found: ${fileName}`)
+      process.exit(1)
+    }
+
+    const ruleMap = parseEprc(content)
+    const bm = pat.match(/\[([^\]]+)\]/)
+    if (bm) {
+      ruleMap[pat.replace(bm[0], bm[1])] = tgt + bm[0]
+    } else {
+      ruleMap[pat] = tgt
+    }
+
+    const newContent = ruleMapToEprcText(ruleMap)
+    saveRuleFileContent(fileName, newContent)
+
+    if (jsonFlag) {
+      output.jsonRaw({ success: true, file: fileName, pattern: pat, target: tgt })
+      return
+    }
+
+    output.header('Route Rule Added')
+    output.success(`${pat} -> ${tgt}`)
+    output.kv('File', fileName)
+  }
+}
+
+run().catch(e => {
+  output.error(e.message)
+  process.exit(1)
+})