@jonathanleelx/meddle 0.5.0-beta.9 → 0.5.1

package/bin/commands/route/active.js

@@ -5,7 +5,13 @@
 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')
+const { listRuleFiles, getActiveRuleFileNames, setRuleFileEnabled } = require('../../lib/file-access')
+const { isRulesetReadonlyError, exitRulesetReadonly, assertListedFilesWritable } = require('../../lib/ruleset-readonly')
+
+/** Names whose enabled state `active set <file>` would change. */
+function pendingToggles(files, target) {
+  return files.filter((f) => !!f.enabled !== (f.name === target)).map((f) => f.name)
+}
 
 // Parse arguments (skip 'route' and 'active' from argv)
 const args = process.argv.slice(4)
@@ -39,6 +45,9 @@ async function run() {
           process.exit(1)
         }
 
+        // Issue #137: refuse up front so a locked ruleset never leaves a half-applied switch.
+        assertListedFilesWritable(files, pendingToggles(files, targetFile))
+
         for (const f of files) {
           const nextEnabled = f.name === targetFile
           if (!!f.enabled === nextEnabled) continue
@@ -53,6 +62,7 @@ async function run() {
         output.header('Active Route File Set')
         output.success(targetFile)
       } catch (e) {
+        if (isRulesetReadonlyError(e)) exitRulesetReadonly(e, { json: jsonFlag, ruleFile: targetFile })
         // Fallback to file mode
         const files = listRuleFiles()
         const target = files.find(f => f.name === targetFile)
@@ -61,11 +71,14 @@ async function run() {
           process.exit(1)
         }
 
+        assertListedFilesWritable(files, pendingToggles(files, targetFile))
         // Disable all, then enable target
         files.forEach(f => setRuleFileEnabled(f.name, f.name === targetFile))
 
+        output.warnFileOnlyMode()
+
         if (jsonFlag) {
-          output.jsonRaw({ success: true, activeFile: targetFile })
+          output.jsonRaw({ success: true, activeFile: targetFile, fileOnly: true, warning: output.FILE_ONLY_WARNING })
           return
         }
 
@@ -81,10 +94,13 @@ async function run() {
         process.exit(1)
       }
 
+      assertListedFilesWritable(files, pendingToggles(files, targetFile))
       files.forEach(f => setRuleFileEnabled(f.name, f.name === targetFile))
 
+      output.warnFileOnlyMode()
+
       if (jsonFlag) {
-        output.jsonRaw({ success: true, activeFile: targetFile })
+        output.jsonRaw({ success: true, activeFile: targetFile, fileOnly: true, warning: output.FILE_ONLY_WARNING })
         return
       }
 
@@ -136,6 +152,7 @@ async function run() {
 }
 
 run().catch(e => {
+  if (isRulesetReadonlyError(e)) exitRulesetReadonly(e, { json: jsonFlag, ruleFile: targetFile })
   output.error(e.message)
   process.exit(1)
 })

package/bin/commands/route/add.js

@@ -5,123 +5,142 @@
 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 { 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]
 
-async function run() {
-  if (!fileName) {
-    output.error('Missing required argument: <file>')
-    process.exit(1)
+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")
+ * or with --exclusions. `--exclusions=` clears them (issue #149).
+ */
+function applyAdd(text, plan) {
+  let next = text
+  for (const p of plan.patterns) {
+    next = addRouteRule(next, { pattern: p, target: target.trim(), exclusions: plan.exclusions }).content
   }
-  if (!pattern) {
-    output.error('Missing required argument: <pattern>')
-    process.exit(1)
+  return next
+}
+
+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 (!target) {
-    output.error('Missing required argument: <target>')
-    process.exit(1)
+  if (jsonFlag) {
+    output.jsonRaw(payload)
+    return
   }
+  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 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)
+      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) {
-      // Fallback to file mode
+      // 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 })
       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)
+      if (content == null) fail(`Route file not found: ${fileName}`, jsonFlag)
+      const newContent = applyAdd(content, plan)
       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 })
+      output.warnFileOnlyMode()
+      emitAdded({ fileOnly: true })
       return
     }
-
-    output.header('Route Rule Added')
-    output.success(`${pat} -> ${tgt}`)
-    output.kv('File', fileName)
   }
+
+  const content = getRuleFileContent(fileName)
+  if (content == null) fail(`Route file not found: ${fileName}`, jsonFlag)
+  const newContent = applyAdd(content, plan)
+  saveRuleFileContent(fileName, newContent)
+  output.warnFileOnlyMode()
+  emitAdded({ fileOnly: 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/route/create.js

@@ -34,6 +34,7 @@ async function run() {
   const running = await isProxyRunning()
 
   let result
+  let fileOnly = false
   if (running) {
     try {
       result = await apiPost('/api/rule-files', {
@@ -46,6 +47,7 @@ async function run() {
       // Fallback to file mode
       try {
         result = createRuleFile(fileName, content, true)
+        fileOnly = true
       } catch (err) {
         output.error(err.message)
         process.exit(1)
@@ -54,14 +56,19 @@ async function run() {
   } else {
     try {
       result = createRuleFile(fileName, content, true)
+      fileOnly = true
     } catch (err) {
       output.error(err.message)
       process.exit(1)
     }
   }
 
+  if (fileOnly) output.warnFileOnlyMode()
+
   if (jsonFlag) {
-    output.jsonRaw(result)
+    output.jsonRaw(fileOnly
+      ? { ...result, fileOnly: true, warning: output.FILE_ONLY_WARNING }
+      : result)
     return
   }
 

package/bin/commands/route/delete.js

@@ -5,49 +5,87 @@
 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 { 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]
 
-async function run() {
-  if (!fileName) {
-    output.error('Missing required argument: <file>')
-    process.exit(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 } = parsePatternArg(pattern)
+  if (patterns.length === 0) {
+    fail('Missing required argument: <pattern>', jsonFlag)
+  }
+  let next = text
+  for (const p of patterns) {
+    const result = deleteRouteRule(next, { pattern: p })
+    if (!result.found) {
+      fail(`Pattern not found: ${pattern.trim()}`, jsonFlag)
+    }
+    next = result.content
   }
-  if (!pattern) {
-    output.error('Missing required argument: <pattern>')
-    process.exit(1)
+  return next
+}
+
+async function run() {
+  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()
 
   const pat = pattern.trim()
 
-  // Handle [marker] syntax for lookup
-  const bm = pat.match(/\[([^\]]+)\]/)
-  const internalKey = bm ? pat.replace(bm[0], bm[1]) : pat
-
   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)
-      }
-
-      delete ruleMap[internalKey]
-      const newContent = ruleMapToEprcText(ruleMap)
+      const newContent = applyDelete(text)
       await apiPut(`/api/rule-files/${encodeURIComponent(fileName)}/content`, { content: newContent })
 
       if (jsonFlag) {
@@ -59,28 +97,27 @@ async function run() {
       output.success(pat)
       output.kv('File', fileName)
     } 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)
+      if (content == null) {
+        fail(`Route file not found: ${fileName}`, jsonFlag)
       }
 
-      const ruleMap = parseEprc(content)
-      if (!Object.prototype.hasOwnProperty.call(ruleMap, internalKey)) {
-        output.error(`Pattern not found: ${pat}`)
-        process.exit(1)
-      }
-
-      delete ruleMap[internalKey]
-      const newContent = ruleMapToEprcText(ruleMap)
+      const newContent = applyDelete(content)
       saveRuleFileContent(fileName, newContent)
+      output.warnFileOnlyMode()
 
       if (jsonFlag) {
-        output.jsonRaw({ success: true, file: fileName, pattern: pat })
+        output.jsonRaw({ success: true, file: fileName, pattern: pat,
+        fileOnly: true,
+        warning: output.FILE_ONLY_WARNING
+      })
         return
       }
 
+
       output.header('Route Rule Deleted')
       output.success(pat)
       output.kv('File', fileName)
@@ -88,26 +125,23 @@ async function run() {
   } else {
     // File mode
     const content = getRuleFileContent(fileName)
-    if (!content) {
-      output.error(`Route file not found: ${fileName}`)
-      process.exit(1)
+    if (content == null) {
+      fail(`Route file not found: ${fileName}`, jsonFlag)
     }
 
-    const ruleMap = parseEprc(content)
-    if (!Object.prototype.hasOwnProperty.call(ruleMap, internalKey)) {
-      output.error(`Pattern not found: ${pat}`)
-      process.exit(1)
-    }
-
-    delete ruleMap[internalKey]
-    const newContent = ruleMapToEprcText(ruleMap)
+    const newContent = applyDelete(content)
     saveRuleFileContent(fileName, newContent)
+    output.warnFileOnlyMode()
 
     if (jsonFlag) {
-      output.jsonRaw({ success: true, file: fileName, pattern: pat })
+      output.jsonRaw({ success: true, file: fileName, pattern: pat,
+      fileOnly: true,
+      warning: output.FILE_ONLY_WARNING
+    })
       return
     }
 
+
     output.header('Route Rule Deleted')
     output.success(pat)
     output.kv('File', fileName)
@@ -115,6 +149,6 @@ async function run() {
 }
 
 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/route/index.js

@@ -2,8 +2,70 @@
  * meddle route - Route rule subcommand router
  */
 
+const output = require('../../lib/output')
+
 const args = process.argv.slice(3)
 const subcommand = args[0]
+const jsonFlag = args.includes('--json')
+
+const ROUTE_HELP = `
+Route Commands:
+  meddle route list [--json]                    List all route files
+  meddle route show <file> [--json]             Show rules in a file
+  meddle route preview <url> [--file <name>] [--json]  Preview route target for a URL
+  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> [--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:
+  Files locked in the Meddle web UI reject add/update/delete and active set
+  (error RULESET_READONLY, exit code 3). Lock/unlock is only available in the web UI.
+
+Examples:
+  meddle route list
+  meddle route show dev-rules
+  meddle route preview "https://api.example.com/v1/users"
+  meddle route preview "https://cdn.com/assets/js/app.js" --file dev-rules
+  meddle route preview "https://api.test.com/data" --json
+  meddle route active set beta-rules
+  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.
+`
+
+function printHelp(stream = process.stdout) {
+  stream.write(ROUTE_HELP.trimStart())
+}
+
+function failUnknown(name) {
+  const message = `Unknown command: route ${name}`
+  if (jsonFlag) {
+    output.setJsonMode(true)
+    output.error(message)
+  } else {
+    console.error(message)
+    printHelp(process.stderr)
+  }
+  process.exit(1)
+}
 
 switch (subcommand) {
   case 'list':
@@ -30,30 +92,16 @@ switch (subcommand) {
   case 'delete':
     require('./delete.js')
     break
+  case '--help':
+  case '-h':
+  case 'help':
+    printHelp()
+    process.exit(0)
+    break
   default:
-    console.log(`
-Route Commands:
-  meddle route list [--json]                    List all route files
-  meddle route show <file> [--json]             Show rules in a file
-  meddle route preview <url> [--file <name>] [--json]  Preview route target for a URL
-  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 delete <file> <pattern>          Delete a rule from file
-
-Examples:
-  meddle route list
-  meddle route show dev-rules
-  meddle route preview "https://api.example.com/v1/users"
-  meddle route preview "https://cdn.com/assets/js/app.js" --file dev-rules
-  meddle route preview "https://api.test.com/data" --json
-  meddle route active set beta-rules
-  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 delete dev-rules "api.test.com"
-`)
-    process.exit(1)
-}
+    if (!subcommand) {
+      printHelp()
+      process.exit(1)
+    }
+    failUnknown(subcommand)
+}

package/bin/commands/route/list.js

@@ -48,7 +48,7 @@ async function run() {
     output.section('Active Files')
     active.forEach(f => {
       const excludeInfo = f.excludeCount > 0 ? `, ${f.excludeCount} exclusions` : ''
-      output.success(`${f.name} (${f.ruleCount} rules${excludeInfo})`)
+      output.success(`${f.name} (${f.ruleCount} rules${excludeInfo})${f.readonly ? ' [read-only]' : ''}`)
     })
   }
 
@@ -56,7 +56,7 @@ async function run() {
     output.section('Inactive Files')
     inactive.forEach(f => {
       const excludeInfo = f.excludeCount > 0 ? `, ${f.excludeCount} exclusions` : ''
-      output.bullet(`${f.name} (${f.ruleCount} rules${excludeInfo})`, false)
+      output.bullet(`${f.name} (${f.ruleCount} rules${excludeInfo})${f.readonly ? ' [read-only]' : ''}`, false)
     })
   }
 }