@jonathanleelx/meddle 0.5.0-beta.24 → 0.5.0-beta.26

package/README.md

@@ -188,7 +188,7 @@ meddle --remote --no-intercept-https
 - 传非空数组：用它替换原有的排除规则。
 - 如果一行写了多个 pattern，修改或删除其中一个时，若剩下的 pattern 以 `//` 或 `#` 开头（拆开后会被当成注释），写入会被拒绝并提示「该行剩余的 pattern 以 // 或 # 开头，拆开后会被当成注释，请用文本编辑器手动修改」，规则文件不变。
 - 新增规则的 pattern 不能以 `#` 或 `//` 开头（例如 `#foo.com`、`//foo.com`），否则写进文件后会被当成注释或禁用行。写入会被拒绝并提示「规则不能以 // 或 # 开头，否则会被当成禁用行或注释。要写注释或禁用规则，请用文本编辑器。」，规则文件不变。
-- CLI 没有单独的排除规则参数：`meddle route add/update` 的 pattern 参数里写了 `!path`（如 `"api.example.com !/health"`）就替换，不写就保留原有的；CLI 无法清空排除规则，需要清空时用 MCP 传 `[]`，或在 Web 界面里编辑。
+- CLI：`meddle route update <file> <pattern> --exclusions=` 清空该规则的排除项（该行不再有 `!path`，其余行逐字节不变）。`--exclusions=/a,/b` 替换。pattern 里写 `!path`（如 `"api.example.com !/health"`）同样是替换。两者都不写则保留原有排除项。单独的 `--exclusions`（没有 `=`）、空的 `!`、未知参数，或 `!path` 与 `--exclusions` 同时出现，都会非 0 退出且不改文件。`#` 只有出现在一行开头（前导空白之后）才是整行注释；行尾的 `#` 不是注释。
 
 **只读规则集**（[详细说明](./docs/RULESET_READONLY.md)）：规则集（规则文件）可以在 Meddle Web 界面中加只读锁，防止 Agent 误改。
 

package/bin/commands/route/add.js

@@ -6,129 +6,141 @@ const output = require('../../lib/output')
 const { isProxyRunning } = require('../../lib/proxy-detect')
 const { apiGet, apiPut } = require('../../lib/api-client')
 const { getRuleFileContent, saveRuleFileContent } = require('../../lib/file-access')
-const { addRouteRule, splitPatternArg } = require('../../lib/rule-file-edit')
+const { addRouteRule } = require('../../lib/rule-file-edit')
 const { isRulesetReadonlyError, exitRulesetReadonly } = require('../../lib/ruleset-readonly')
+const { parseRouteWriteArgs, parsePatternArg, resolveExclusions } = require('../../lib/route-write-args')
+
+const ADD_HELP = `
+meddle route add <file> <pattern> <target> [--exclusions=<list>] [--json]
+
+Add a rule. If the pattern already exists, its target is overwritten in place.
+--exclusions= clears that rule's exclusions; --exclusions=/a,/b replaces them.
+Omit --exclusions and any !path in the pattern to keep existing exclusions.
+See: meddle route update --help
+`
 
-// Parse arguments (skip 'route' and 'add' 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(ADD_HELP.trim())
+  process.exit(0)
+}
+
+const jsonFlag = parsed.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]
+const fileName = parsed.positional[0]
+const pattern = parsed.positional[1]
+const target = parsed.positional[2]
+
+let explicitExclusions = false
+let appliedExclusions = []
+
+function planAdd() {
+  const { patterns, exclusions: patternExclusions } = parsePatternArg(pattern)
+  if (patterns.length === 0) fail('Missing required argument: <pattern>', jsonFlag)
+  const resolved = resolveExclusions(patternExclusions, parsed.exclusions)
+  explicitExclusions = resolved.explicit
+  appliedExclusions = resolved.exclusions || []
+  return { patterns, exclusions: resolved.explicit ? resolved.exclusions : undefined }
+}
 
 /**
  * Issue #145: edit only the line(s) holding this pattern; comments, blank
  * lines and other rules (with their `!exclusions`) keep their exact bytes.
- * Exclusions may be given inside the pattern argument ("app.example.com !/api").
+ * Exclusions may be given inside the pattern argument ("app.example.com !/api")
+ * or with --exclusions. `--exclusions=` clears them (issue #149).
  */
-function applyAdd(text) {
-  const { patterns, exclusions } = splitPatternArg(pattern)
-  if (patterns.length === 0) {
-    output.error('Missing required argument: <pattern>')
-    process.exit(1)
-  }
+function applyAdd(text, plan) {
   let next = text
-  for (const p of patterns) {
-    next = addRouteRule(next, { pattern: p, target: target.trim(), exclusions: exclusions.length ? exclusions : undefined }).content
+  for (const p of plan.patterns) {
+    next = addRouteRule(next, { pattern: p, target: target.trim(), exclusions: plan.exclusions }).content
   }
   return next
 }
 
-async function run() {
-  if (!fileName) {
-    output.error('Missing required argument: <file>')
-    process.exit(1)
+function emitAdded({ fileOnly }) {
+  const payload = { success: true, file: fileName, pattern: pattern.trim(), target: target.trim() }
+  if (explicitExclusions) payload.exclusions = appliedExclusions
+  if (fileOnly) {
+    payload.fileOnly = true
+    payload.warning = output.FILE_ONLY_WARNING
   }
-  if (!pattern) {
-    output.error('Missing required argument: <pattern>')
-    process.exit(1)
+  if (jsonFlag) {
+    output.jsonRaw(payload)
+    return
   }
-  if (!target) {
-    output.error('Missing required argument: <target>')
-    process.exit(1)
+  output.header('Route Rule Added')
+  output.success(`${pattern.trim()} -> ${target.trim()}`)
+  if (explicitExclusions) {
+    output.kv('Exclusions', appliedExclusions.length ? appliedExclusions.map((e) => `!${e}`).join(' ') : 'cleared')
   }
+  output.kv('File', fileName)
+}
 
-  const running = await isProxyRunning()
+async function run() {
+  if (!fileName) fail('Missing required argument: <file>', jsonFlag)
+  if (!pattern) fail('Missing required argument: <pattern>', jsonFlag)
+  if (!target) fail('Missing required argument: <target>', jsonFlag)
+  if (parsed.positional.length > 3) fail(`Unexpected argument: ${parsed.positional[3]}`, jsonFlag)
+
+  let plan
+  try {
+    plan = planAdd()
+  } catch (e) {
+    fail(e.message, jsonFlag)
+  }
 
-  const pat = pattern.trim()
-  const tgt = target.trim()
+  const running = await isProxyRunning()
 
   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 newContent = applyAdd(text)
+      const newContent = applyAdd(text, plan)
       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)
+      emitAdded({ fileOnly: 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 newContent = applyAdd(content)
+      if (!content) fail(`Route file not found: ${fileName}`, jsonFlag)
+      const newContent = applyAdd(content, plan)
       saveRuleFileContent(fileName, newContent)
       output.warnFileOnlyMode()
-
-      if (jsonFlag) {
-        output.jsonRaw({ success: true, file: fileName, pattern: pat, target: tgt,
-        fileOnly: true,
-        warning: output.FILE_ONLY_WARNING
-      })
-        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 newContent = applyAdd(content)
-    saveRuleFileContent(fileName, newContent)
-    output.warnFileOnlyMode()
-
-    if (jsonFlag) {
-      output.jsonRaw({ success: true, file: fileName, pattern: pat, target: tgt,
-      fileOnly: true,
-      warning: output.FILE_ONLY_WARNING
-    })
+      emitAdded({ fileOnly: true })
       return
     }
-
-
-    output.header('Route Rule Added')
-    output.success(`${pat} -> ${tgt}`)
-    output.kv('File', fileName)
   }
+
+  const content = getRuleFileContent(fileName)
+  if (!content) fail(`Route file not found: ${fileName}`, jsonFlag)
+  const newContent = applyAdd(content, plan)
+  saveRuleFileContent(fileName, newContent)
+  output.warnFileOnlyMode()
+  emitAdded({ fileOnly: true })
 }
 
 run().catch(e => {
   if (isRulesetReadonlyError(e)) exitRulesetReadonly(e, { json: jsonFlag, ruleFile: fileName })
-  output.error(e.message)
-  process.exit(1)
+  fail(e.message, jsonFlag)
 })

package/bin/commands/route/delete.js

@@ -6,35 +6,61 @@ const output = require('../../lib/output')
 const { isProxyRunning } = require('../../lib/proxy-detect')
 const { apiGet, apiPut } = require('../../lib/api-client')
 const { getRuleFileContent, saveRuleFileContent } = require('../../lib/file-access')
-const { deleteRouteRule, splitPatternArg } = require('../../lib/rule-file-edit')
+const { deleteRouteRule } = require('../../lib/rule-file-edit')
 const { isRulesetReadonlyError, exitRulesetReadonly } = require('../../lib/ruleset-readonly')
+const { parseRouteWriteArgs, parsePatternArg } = require('../../lib/route-write-args')
+
+const DELETE_HELP = `
+meddle route delete <file> <pattern> [--json]
+
+Delete a rule. This command does not take --exclusions.
+`
 
-// Parse arguments (skip 'route' and 'delete' 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, { allowExclusions: false })
+} catch (e) {
+  fail(e.message, args.includes('--json'))
+}
+
+if (parsed.help) {
+  console.log(DELETE_HELP.trim())
+  process.exit(0)
+}
+
+const jsonFlag = parsed.json
 output.setJsonMode(jsonFlag)
 
-// Get positional arguments: file, pattern
-const positionalArgs = args.filter(a => !a.startsWith('--'))
-const fileName = positionalArgs[0]
-const pattern = positionalArgs[1]
+const fileName = parsed.positional[0]
+const pattern = parsed.positional[1]
 
 /**
  * Issue #145: remove only this pattern; every other line (comments, blank
  * lines, other rules and their `!exclusions`) keeps its exact bytes.
  */
 function applyDelete(text) {
-  const { patterns } = splitPatternArg(pattern)
+  const { patterns } = parsePatternArg(pattern)
   if (patterns.length === 0) {
-    output.error('Missing required argument: <pattern>')
-    process.exit(1)
+    fail('Missing required argument: <pattern>', jsonFlag)
   }
   let next = text
   for (const p of patterns) {
     const result = deleteRouteRule(next, { pattern: p })
     if (!result.found) {
-      output.error(`Pattern not found: ${pattern.trim()}`)
-      process.exit(1)
+      fail(`Pattern not found: ${pattern.trim()}`, jsonFlag)
     }
     next = result.content
   }
@@ -42,13 +68,13 @@ function applyDelete(text) {
 }
 
 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 (!fileName) fail('Missing required argument: <file>', jsonFlag)
+  if (!pattern) fail('Missing required argument: <pattern>', jsonFlag)
+  if (parsed.positional.length > 2) fail(`Unexpected argument: ${parsed.positional[2]}`, jsonFlag)
+  try {
+    parsePatternArg(pattern)
+  } catch (e) {
+    fail(e.message, jsonFlag)
   }
 
   const running = await isProxyRunning()
@@ -76,8 +102,7 @@ async function run() {
       // Fallback to file mode
       const content = getRuleFileContent(fileName)
       if (!content) {
-        output.error(`Route file not found: ${fileName}`)
-        process.exit(1)
+        fail(`Route file not found: ${fileName}`, jsonFlag)
       }
 
       const newContent = applyDelete(content)
@@ -101,8 +126,7 @@ async function run() {
     // File mode
     const content = getRuleFileContent(fileName)
     if (!content) {
-      output.error(`Route file not found: ${fileName}`)
-      process.exit(1)
+      fail(`Route file not found: ${fileName}`, jsonFlag)
     }
 
     const newContent = applyDelete(content)
@@ -126,6 +150,5 @@ async function run() {
 
 run().catch(e => {
   if (isRulesetReadonlyError(e)) exitRulesetReadonly(e, { json: jsonFlag, ruleFile: fileName })
-  output.error(e.message)
-  process.exit(1)
+  fail(e.message, jsonFlag)
 })

package/bin/commands/route/index.js

@@ -39,8 +39,10 @@ Route Commands:
   meddle route active                           Show active route files
   meddle route active set <file>                Set active route file
   meddle route create <name> [--content <text>] Create a route file
-  meddle route add <file> <pattern> <target>    Add a rule to file
-  meddle route update <file> <pattern> <target> Update a rule in file
+  meddle route add <file> <pattern> <target> [--exclusions=<list>]
+                                            Add a rule to file
+  meddle route update <file> <pattern> [<target>] [--exclusions=<list>]
+                                            Update a rule in file
   meddle route delete <file> <pattern>          Delete a rule from file
 
 Read-only route files:
@@ -57,7 +59,19 @@ Examples:
   meddle route create staging --content "example.com localhost:3000"
   meddle route add dev-rules "api.test.com" "localhost:8080"
   meddle route update dev-rules "api.test.com" "localhost:9000"
+  meddle route update dev-rules "api.test.com" --exclusions=
   meddle route delete dev-rules "api.test.com"
+
+Exclusions:
+  Omit --exclusions and any !path in the pattern to keep the rule's exclusions.
+  --exclusions=            Clear exclusions (that line loses every !path).
+  --exclusions=/a,/b       Replace exclusions. A leading ! is optional.
+  "pattern !/a"            Replace exclusions. A bare "!" is an error.
+  A bare --exclusions, an unknown flag, or both forms at once exits 1
+  and does not change the file. meddle route update --help has the details.
+
+  A "#" comments out a whole line only when it is the first non-space
+  character. A "#" later on a rule line is a pattern, not a trailing comment.
 `)
     process.exit(1)
 }

package/bin/commands/route/update.js

@@ -1,138 +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 } = require('../../lib/file-access')
-const { updateRouteRule, splitPatternArg } = require('../../lib/rule-file-edit')
+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]
+
+/** 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)
+  }
+  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 in the pattern argument; every
- * other line keeps its exact bytes.
+ * 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) {
-  const { patterns, exclusions } = splitPatternArg(pattern)
-  if (patterns.length === 0) {
-    output.error('Missing required argument: <pattern>')
-    process.exit(1)
-  }
+function applyUpdate(text, plan) {
+  const target = newTarget ? newTarget.trim() : undefined
   let next = text
-  for (const p of patterns) {
-    const result = updateRouteRule(next, { pattern: p, target: newTarget.trim(), exclusions: exclusions.length ? exclusions : undefined })
+  for (const p of plan.patterns) {
+    const result = updateRouteRule(next, { pattern: p, target, exclusions: plan.exclusions })
     if (!result.found) {
-      output.error(`Pattern not found: ${pattern.trim()}`)
-      process.exit(1)
+      fail(`Pattern not found: ${pattern.trim()}`, jsonFlag)
     }
     next = result.content
   }
   return next
 }
 
-async function run() {
-  if (!fileName) {
-    output.error('Missing required argument: <file>')
-    process.exit(1)
+/** 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 ''
+}
+
+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 (!pattern) {
-    output.error('Missing required argument: <pattern>')
-    process.exit(1)
+  if (jsonFlag) {
+    output.jsonRaw(payload)
+    return
   }
-  if (!newTarget) {
-    output.error('Missing required argument: <target>')
-    process.exit(1)
+  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 running = await isProxyRunning()
 
-  const pat = pattern.trim()
-  const tgt = newTarget.trim()
+  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 newContent = applyUpdate(text)
+      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 newContent = applyUpdate(content)
+      if (!content) fail(`Route file not found: ${fileName}`, jsonFlag)
+      const newContent = applyUpdate(content, plan)
       saveRuleFileContent(fileName, newContent)
       output.warnFileOnlyMode()
-
-      if (jsonFlag) {
-        output.jsonRaw({ success: true, file: fileName, pattern: pat, newTarget: tgt,
-        fileOnly: true,
-        warning: output.FILE_ONLY_WARNING
-      })
-        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 newContent = applyUpdate(content)
-    saveRuleFileContent(fileName, newContent)
-    output.warnFileOnlyMode()
-
-    if (jsonFlag) {
-      output.jsonRaw({ success: true, file: fileName, pattern: pat, newTarget: tgt,
-      fileOnly: true,
-      warning: output.FILE_ONLY_WARNING
-    })
+      finish(newContent, true)
       return
     }
-
-
-    output.header('Route Rule Updated')
-    output.success(`${pat} -> ${tgt}`)
-    output.kv('File', fileName)
   }
+
+  const content = getRuleFileContent(fileName)
+  if (!content) fail(`Route file not found: ${fileName}`, jsonFlag)
+  const newContent = applyUpdate(content, plan)
+  saveRuleFileContent(fileName, newContent)
+  output.warnFileOnlyMode()
+  finish(newContent, true)
 }
 
 run().catch(e => {
   if (isRulesetReadonlyError(e)) exitRulesetReadonly(e, { json: jsonFlag, ruleFile: fileName })
-  output.error(e.message)
-  process.exit(1)
-})
+  fail(e.message, jsonFlag)
+})