@jonathanleelx/meddle 0.5.0-beta.9 → 0.5.1

package/bin/commands/route/preview.js

@@ -57,7 +57,7 @@ async function run() {
         const content = await fetch(`${baseUrl}/api/rule-files/${encodeURIComponent(ruleFileArg)}/content`)
           .then(r => r.ok ? r.text() : null)
           .catch(() => null)
-        if (!content) {
+        if (content == null) {
           output.error(`Rule file not found: ${ruleFileArg}`)
           process.exit(1)
         }
@@ -91,7 +91,7 @@ async function run() {
       if (ruleFileArg) {
         // Use specified rule file
         const content = getRuleFileContent(ruleFileArg)
-        if (!content) {
+        if (content == null) {
           output.error(`Rule file not found: ${ruleFileArg}`)
           process.exit(1)
         }

package/bin/commands/route/show.js

@@ -5,7 +5,7 @@
 const output = require('../../lib/output')
 const { isProxyRunning } = require('../../lib/proxy-detect')
 const { apiGet } = require('../../lib/api-client')
-const { getRuleFileContent, parseEprcWithExclusions } = require('../../lib/file-access')
+const { getRuleFileContent, parseEprcWithExclusions, isRuleFileReadonly } = require('../../lib/file-access')
 
 // Parse arguments (skip 'route' and 'show' from argv)
 const args = process.argv.slice(4)
@@ -26,33 +26,40 @@ async function run() {
   let content = null
   let ruleMap = {}
   let excludeMap = {}
+  // Issue #137: report the lock state (read-only for the CLI either way).
+  let readonly = false
 
   if (running) {
     try {
       content = await apiGet(`/api/rule-files/${encodeURIComponent(fileName)}/content`)
+      const files = await apiGet('/api/rule-files')
+      const info = Array.isArray(files) ? files.find((f) => f && f.name === fileName) : null
+      readonly = Boolean(info && info.readonly)
       const parsed = parseEprcWithExclusions(typeof content === 'string' ? content : String(content))
       ruleMap = parsed.ruleMap
       excludeMap = parsed.excludeMap
     } catch (e) {
       // Fallback to file mode
       content = getRuleFileContent(fileName)
-      if (!content) {
+      if (content == null) {
         output.error(`Route file not found: ${fileName}`)
         process.exit(1)
       }
       const parsed = parseEprcWithExclusions(content)
       ruleMap = parsed.ruleMap
       excludeMap = parsed.excludeMap
+      readonly = isRuleFileReadonly(fileName)
     }
   } else {
     content = getRuleFileContent(fileName)
-    if (!content) {
+    if (content == null) {
       output.error(`Route file not found: ${fileName}`)
       process.exit(1)
     }
     const parsed = parseEprcWithExclusions(content)
     ruleMap = parsed.ruleMap
     excludeMap = parsed.excludeMap
+    readonly = isRuleFileReadonly(fileName)
   }
 
   // Build display rules (handle [marker] syntax)
@@ -76,6 +83,7 @@ async function run() {
   if (jsonFlag) {
     output.jsonRaw({
       file: fileName,
+      readonly,
       rules: displayRules,
       ruleCount: Object.keys(displayRules).length,
       exclusionCount: totalExclusions
@@ -84,6 +92,7 @@ async function run() {
   }
 
   output.header(`Route File: ${fileName}`)
+  output.kv('Read-only', readonly ? 'Yes (unlock in the Meddle UI)' : 'No')
   output.kv('Rules', Object.keys(displayRules).length)
   if (totalExclusions > 0) {
     output.kv('Exclusions', totalExclusions)

package/bin/commands/route/update.js

@@ -1,126 +1,169 @@
 /**
  * meddle route update - Update a rule in a route file
+ *
+ * Issue #149: `--exclusions=` clears a rule's exclusions. Omitting the flag
+ * (and any !path in the pattern) still keeps them.
  */
 
 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')
+const { getRuleFileContent, saveRuleFileContent } = require('../../lib/file-access')
+const { updateRouteRule, patternKey, parseRuleLine } = require('../../lib/rule-file-edit')
+const { isRulesetReadonlyError, exitRulesetReadonly } = require('../../lib/ruleset-readonly')
+const {
+  parseRouteWriteArgs,
+  parsePatternArg,
+  resolveExclusions,
+  UPDATE_HELP,
+} = require('../../lib/route-write-args')
 
-// Parse arguments (skip 'route' and 'update' from argv)
 const args = process.argv.slice(4)
-const jsonFlag = args.includes('--json')
+
+function fail(message, jsonFlag) {
+  if (jsonFlag) {
+    console.log(JSON.stringify({ success: false, error: { message } }))
+    console.error(message)
+  } else {
+    output.setJsonMode(false)
+    output.error(message)
+  }
+  process.exit(1)
+}
+
+let parsed
+try {
+  parsed = parseRouteWriteArgs(args)
+} catch (e) {
+  fail(e.message, args.includes('--json'))
+}
+
+if (parsed.help) {
+  console.log(UPDATE_HELP.trim())
+  process.exit(0)
+}
+
+const jsonFlag = parsed.json
 output.setJsonMode(jsonFlag)
 
-// Get positional arguments: file, pattern, newTarget
-const positionalArgs = args.filter(a => !a.startsWith('--'))
-const fileName = positionalArgs[0]
-const pattern = positionalArgs[1]
-const newTarget = positionalArgs[2]
+const fileName = parsed.positional[0]
+const pattern = parsed.positional[1]
+const newTarget = parsed.positional[2]
 
-async function run() {
-  if (!fileName) {
-    output.error('Missing required argument: <file>')
-    process.exit(1)
+/** Set once arguments are valid. `explicit` means the user asked to set exclusions, including clear. */
+let explicitExclusions = false
+let appliedExclusions = []
+
+function planUpdate() {
+  const { patterns, exclusions: patternExclusions } = parsePatternArg(pattern)
+  if (patterns.length === 0) {
+    fail('Missing required argument: <pattern>', jsonFlag)
   }
-  if (!pattern) {
-    output.error('Missing required argument: <pattern>')
-    process.exit(1)
+  const resolved = resolveExclusions(patternExclusions, parsed.exclusions)
+  explicitExclusions = resolved.explicit
+  appliedExclusions = resolved.exclusions || []
+  return { patterns, exclusions: resolved.explicit ? resolved.exclusions : undefined }
+}
+
+/**
+ * Issue #145: rewrite only the line(s) holding this pattern. The rule keeps its
+ * own `!exclusions` unless new ones are given. Issue #149: `--exclusions=` passes
+ * `[]`, which removes `!path` from that line. Every other line keeps its bytes.
+ */
+function applyUpdate(text, plan) {
+  const target = newTarget ? newTarget.trim() : undefined
+  let next = text
+  for (const p of plan.patterns) {
+    const result = updateRouteRule(next, { pattern: p, target, exclusions: plan.exclusions })
+    if (!result.found) {
+      fail(`Pattern not found: ${pattern.trim()}`, jsonFlag)
+    }
+    next = result.content
   }
-  if (!newTarget) {
-    output.error('Missing required argument: <target>')
-    process.exit(1)
+  return next
+}
+
+/** Target token actually written, for feedback when the user did not pass one. */
+function targetOnDisk(content, patternToken) {
+  const key = patternKey(patternToken)
+  const lines = content.split(/\r?\n/)
+  for (const line of lines) {
+    const parsedLine = parseRuleLine(line)
+    if (parsedLine && parsedLine.patterns.some((p) => patternKey(p) === key)) return parsedLine.target
   }
+  return ''
+}
 
-  const running = await isProxyRunning()
+function emitUpdated({ fileOnly, target }) {
+  const payload = { success: true, file: fileName, pattern: pattern.trim(), newTarget: target }
+  if (explicitExclusions) payload.exclusions = appliedExclusions
+  if (fileOnly) {
+    payload.fileOnly = true
+    payload.warning = output.FILE_ONLY_WARNING
+  }
+  if (jsonFlag) {
+    output.jsonRaw(payload)
+    return
+  }
+  output.header('Route Rule Updated')
+  output.success(`${pattern.trim()} -> ${target}`)
+  if (explicitExclusions) {
+    output.kv('Exclusions', appliedExclusions.length ? appliedExclusions.map((e) => `!${e}`).join(' ') : 'cleared')
+  }
+  output.kv('File', fileName)
+}
+
+async function run() {
+  if (!fileName) fail('Missing required argument: <file>', jsonFlag)
+  if (!pattern) fail('Missing required argument: <pattern>', jsonFlag)
+  if (parsed.positional.length > 3) fail(`Unexpected argument: ${parsed.positional[3]}`, jsonFlag)
+
+  let plan
+  try {
+    plan = planUpdate()
+  } catch (e) {
+    fail(e.message, jsonFlag)
+  }
+  if (!newTarget && !explicitExclusions) fail('Missing required argument: <target>', jsonFlag)
 
-  const pat = pattern.trim()
-  const tgt = newTarget.trim()
+  const running = await isProxyRunning()
 
-  // Handle [marker] syntax for lookup
-  const bm = pat.match(/\[([^\]]+)\]/)
-  const internalKey = bm ? pat.replace(bm[0], bm[1]) : pat
+  const finish = (content, fileOnly) => {
+    const target = newTarget ? newTarget.trim() : targetOnDisk(content, plan.patterns[0])
+    emitUpdated({ fileOnly, target })
+  }
 
   if (running) {
     try {
       let content = await apiGet(`/api/rule-files/${encodeURIComponent(fileName)}/content`)
       const text = typeof content === 'string' ? content : String(content)
-      const ruleMap = parseEprc(text)
-
-      if (!Object.prototype.hasOwnProperty.call(ruleMap, internalKey)) {
-        output.error(`Pattern not found: ${pat}`)
-        process.exit(1)
-      }
-
-      ruleMap[internalKey] = bm ? tgt + bm[0] : tgt
-      const newContent = ruleMapToEprcText(ruleMap)
+      const newContent = applyUpdate(text, plan)
       await apiPut(`/api/rule-files/${encodeURIComponent(fileName)}/content`, { content: newContent })
-
-      if (jsonFlag) {
-        output.jsonRaw({ success: true, file: fileName, pattern: pat, newTarget: tgt })
-        return
-      }
-
-      output.header('Route Rule Updated')
-      output.success(`${pat} -> ${tgt}`)
-      output.kv('File', fileName)
+      finish(newContent, false)
+      return
     } catch (e) {
+      // Issue #137: a locked ruleset is a final answer, never a cue to write the file directly.
+      if (isRulesetReadonlyError(e)) exitRulesetReadonly(e, { json: jsonFlag, ruleFile: fileName })
       // Fallback to file mode
       const content = getRuleFileContent(fileName)
-      if (!content) {
-        output.error(`Route file not found: ${fileName}`)
-        process.exit(1)
-      }
-
-      const ruleMap = parseEprc(content)
-      if (!Object.prototype.hasOwnProperty.call(ruleMap, internalKey)) {
-        output.error(`Pattern not found: ${pat}`)
-        process.exit(1)
-      }
-
-      ruleMap[internalKey] = bm ? tgt + bm[0] : tgt
-      const newContent = ruleMapToEprcText(ruleMap)
+      if (content == null) fail(`Route file not found: ${fileName}`, jsonFlag)
+      const newContent = applyUpdate(content, plan)
       saveRuleFileContent(fileName, newContent)
-
-      if (jsonFlag) {
-        output.jsonRaw({ success: true, file: fileName, pattern: pat, newTarget: tgt })
-        return
-      }
-
-      output.header('Route Rule Updated')
-      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)
-    if (!Object.prototype.hasOwnProperty.call(ruleMap, internalKey)) {
-      output.error(`Pattern not found: ${pat}`)
-      process.exit(1)
-    }
-
-    ruleMap[internalKey] = bm ? tgt + bm[0] : tgt
-    const newContent = ruleMapToEprcText(ruleMap)
-    saveRuleFileContent(fileName, newContent)
-
-    if (jsonFlag) {
-      output.jsonRaw({ success: true, file: fileName, pattern: pat, newTarget: tgt })
+      output.warnFileOnlyMode()
+      finish(newContent, true)
       return
     }
-
-    output.header('Route Rule Updated')
-    output.success(`${pat} -> ${tgt}`)
-    output.kv('File', fileName)
   }
+
+  const content = getRuleFileContent(fileName)
+  if (content == null) fail(`Route file not found: ${fileName}`, jsonFlag)
+  const newContent = applyUpdate(content, plan)
+  saveRuleFileContent(fileName, newContent)
+  output.warnFileOnlyMode()
+  finish(newContent, true)
 }
 
 run().catch(e => {
-  output.error(e.message)
-  process.exit(1)
-})
+  if (isRulesetReadonlyError(e)) exitRulesetReadonly(e, { json: jsonFlag, ruleFile: fileName })
+  fail(e.message, jsonFlag)
+})

package/bin/commands/status.js

@@ -22,6 +22,22 @@ async function run() {
   let activeRoutes = 0
   let health = null
 
+  let mocksError = null
+
+  function readMocksFromFile() {
+    try {
+      const mocks = loadMockRules()
+      mockCount = mocks.length
+      activeMocks = mocks.filter(m => m.enabled).length
+    } catch (err) {
+      mocksError = err && err.code === 'MOCKS_FILE_INVALID'
+        ? 'Mock 规则文件格式错误'
+        : (err && err.message ? String(err.message) : String(err))
+      mockCount = 0
+      activeMocks = 0
+    }
+  }
+
   if (running) {
     try {
       // Get mock rules from API
@@ -36,19 +52,13 @@ async function run() {
       health = await apiGet('/api/health')
     } catch (_) {
       // Fallback to file access
-      const mocks = loadMockRules()
-      mockCount = mocks.length
-      activeMocks = mocks.filter(m => m.enabled).length
-
+      readMocksFromFile()
       routeFiles = listRuleFiles()
       activeRoutes = routeFiles.filter(f => f.enabled).length
     }
   } else {
     // File mode
-    const mocks = loadMockRules()
-    mockCount = mocks.length
-    activeMocks = mocks.filter(m => m.enabled).length
-
+    readMocksFromFile()
     routeFiles = listRuleFiles()
     activeRoutes = routeFiles.filter(f => f.enabled).length
   }
@@ -61,7 +71,9 @@ async function run() {
       proxyUrl: url,
       running,
       health,
-      mocks: { total: mockCount, active: activeMocks },
+      mocks: mocksError
+        ? { total: mockCount, active: activeMocks, error: mocksError }
+        : { total: mockCount, active: activeMocks },
       routes: { files: routeFiles.length, activeFiles: activeRoutes, totalRules: totalRouteRules, totalExclusions }
     })
     return
@@ -81,8 +93,12 @@ async function run() {
   }
 
   output.section('Mock Rules')
-  output.kv('Total', mockCount)
-  output.kv('Active', activeMocks)
+  if (mocksError) {
+    output.warning(mocksError)
+  } else {
+    output.kv('Total', mockCount)
+    output.kv('Active', activeMocks)
+  }
 
   output.section('Route Rules')
   output.kv('Files', routeFiles.length)

package/bin/commands/update.js

@@ -77,6 +77,10 @@ meddle update - 检查并升级 meddle
   meddle update --auto on|off     启用/禁用自动更新 (默认关闭)
   meddle update status            查看安装方式、当前版本和自动更新开关
   meddle update --help, -h        显示帮助
+
+私有仓库二进制更新需要设置 GH_TOKEN 或 GITHUB_TOKEN（优先 GH_TOKEN；
+权限：repo，或 fine-grained contents:read）。也可：
+  gh release download -R JonathanLee-LX/meddle -p 'meddle-*'
 `)
 }
 

package/bin/doctor.js

@@ -7,7 +7,7 @@
 const fs = require('fs')
 const path = require('path')
 const chalk = require('chalk')
-const { resolveMeddleHome } = require('./lib/meddle-home')
+const { resolveMeddleHome, resolveConfiguredMocksPath } = require('./lib/meddle-home')
 
 const meddleDir = resolveMeddleHome()
 const settingsPath = path.resolve(meddleDir, 'settings.json')
@@ -183,10 +183,14 @@ function checkMocksFile(settings) {
   
   let mocksPath = defaultMocksPath
   
-  // 检查自定义路径
+  // Same resolution as the proxy: ~ expands, relative paths use MEDDLE_HOME.
   if (settings && settings.mocksFilePath) {
-    mocksPath = settings.mocksFilePath
-    printInfo(`使用自定义路径: ${mocksPath}`)
+    const resolved = resolveConfiguredMocksPath(settings.mocksFilePath, meddleDir)
+    mocksPath = resolved || defaultMocksPath
+    printInfo(`使用自定义路径: ${settings.mocksFilePath}`)
+    if (resolved && resolved !== settings.mocksFilePath) {
+      printInfo(`解析后路径: ${resolved}`)
+    }
   } else {
     printInfo(`使用默认路径: ${mocksPath}`)
   }

package/bin/index.js

@@ -59,13 +59,13 @@ if (command === 'mock' || command === 'route' || command === 'session') {
   // No command or only flags - start proxy (default behavior)
   require('../index.js')
 } else {
-  console.log(`Unknown command: ${command}`)
-  showHelp()
+  console.error(`Unknown command: ${command}`)
+  showHelp(process.stderr)
   process.exit(1)
 }
 
-function showHelp() {
-  console.log(`
+function showHelp(stream = process.stdout) {
+  stream.write(`
 Meddle - 开发代理工具
 
 用法:
@@ -106,8 +106,10 @@ Route 命令:
   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 add <file> <pattern> <target> [--exclusions=]
+                              添加路由规则；--exclusions= 清空排除项
+  meddle route update <file> <pattern> [<target>] [--exclusions=]
+                              更新路由规则；--exclusions= 清空排除项
   meddle route delete <file> <pattern> 删除路由规则
 
 全局选项:
@@ -137,8 +139,10 @@ Route 命令:
   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 add dev-rules "api.test.com" "localhost:3000" --exclusions=
+  meddle route update dev-rules "api.test.com" --exclusions=
   meddle route active set beta-rules
 
 更多信息请访问: https://github.com/JonathanLee-LX/meddle
-  `)
+`)
 }

package/bin/lib/api-client.js

@@ -25,14 +25,26 @@ async function apiRequest(method, pathname, body, timeoutMs = DEFAULT_TIMEOUT) {
 
   if (!response.ok) {
     const text = await response.text()
-    throw new Error(text || response.statusText)
+    const err = new Error(text || response.statusText)
+    err.status = response.status
+    // Structured errors (e.g. issue #137 RULESET_READONLY) keep their code.
+    try {
+      const data = JSON.parse(text)
+      if (data && typeof data === 'object') {
+        if (typeof data.code === 'string') err.code = data.code
+        if (typeof data.ruleFile === 'string') err.ruleFile = data.ruleFile
+      }
+    } catch (_) {}
+    throw err
   }
 
   const contentType = response.headers.get('content-type')
   if (contentType && contentType.includes('application/json')) {
     return response.json()
   }
-  return response.text()
+  // Issue #145: `Response.text()` strips a leading UTF-8 BOM, so a rule file
+  // read and written back through the API would silently lose it.
+  return new TextDecoder('utf-8', { ignoreBOM: true }).decode(await response.arrayBuffer())
 }
 
 /**