@jonathanleelx/meddle 0.0.1

package/bin/commands/route/create.js

@@ -0,0 +1,77 @@
+/**
+ * meddle route create - Create a route file
+ */
+
+const output = require('../../lib/output')
+const { isProxyRunning } = require('../../lib/proxy-detect')
+const { apiPost } = require('../../lib/api-client')
+const { createRuleFile } = require('../../lib/file-access')
+
+// Parse arguments (skip 'route' and 'create' from argv)
+const args = process.argv.slice(4)
+const jsonFlag = args.includes('--json')
+output.setJsonMode(jsonFlag)
+
+// Get file name from positional argument
+const positionalArgs = args.filter(a => !a.startsWith('--'))
+const fileName = positionalArgs[0]
+
+// Get content from --content option
+let content = ''
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === '--content') {
+    content = args[++i] || ''
+    break
+  }
+}
+
+async function run() {
+  if (!fileName) {
+    output.error('Missing required argument: <name>')
+    process.exit(1)
+  }
+
+  const running = await isProxyRunning()
+
+  let result
+  if (running) {
+    try {
+      result = await apiPost('/api/rule-files', {
+        name: fileName.trim(),
+        content: content.trim(),
+        enabled: true
+      })
+      result = result.ruleFile || result
+    } catch (e) {
+      // Fallback to file mode
+      try {
+        result = createRuleFile(fileName, content, true)
+      } catch (err) {
+        output.error(err.message)
+        process.exit(1)
+      }
+    }
+  } else {
+    try {
+      result = createRuleFile(fileName, content, true)
+    } catch (err) {
+      output.error(err.message)
+      process.exit(1)
+    }
+  }
+
+  if (jsonFlag) {
+    output.jsonRaw(result)
+    return
+  }
+
+  output.header('Route File Created')
+  output.success(result.name)
+  output.kv('Enabled', result.enabled ? 'Yes' : 'No')
+  output.kv('Rules', result.ruleCount)
+}
+
+run().catch(e => {
+  output.error(e.message)
+  process.exit(1)
+})

package/bin/commands/route/delete.js

@@ -0,0 +1,120 @@
+/**
+ * meddle route delete - Delete a rule from 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 'delete' from argv)
+const args = process.argv.slice(4)
+const jsonFlag = args.includes('--json')
+output.setJsonMode(jsonFlag)
+
+// Get positional arguments: file, pattern
+const positionalArgs = args.filter(a => !a.startsWith('--'))
+const fileName = positionalArgs[0]
+const pattern = positionalArgs[1]
+
+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)
+  }
+
+  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)
+      await apiPut(`/api/rule-files/${encodeURIComponent(fileName)}/content`, { content: newContent })
+
+      if (jsonFlag) {
+        output.jsonRaw({ success: true, file: fileName, pattern: pat })
+        return
+      }
+
+      output.header('Route Rule Deleted')
+      output.success(pat)
+      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)
+      if (!Object.prototype.hasOwnProperty.call(ruleMap, internalKey)) {
+        output.error(`Pattern not found: ${pat}`)
+        process.exit(1)
+      }
+
+      delete ruleMap[internalKey]
+      const newContent = ruleMapToEprcText(ruleMap)
+      saveRuleFileContent(fileName, newContent)
+
+      if (jsonFlag) {
+        output.jsonRaw({ success: true, file: fileName, pattern: pat })
+        return
+      }
+
+      output.header('Route Rule Deleted')
+      output.success(pat)
+      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)
+    }
+
+    delete ruleMap[internalKey]
+    const newContent = ruleMapToEprcText(ruleMap)
+    saveRuleFileContent(fileName, newContent)
+
+    if (jsonFlag) {
+      output.jsonRaw({ success: true, file: fileName, pattern: pat })
+      return
+    }
+
+    output.header('Route Rule Deleted')
+    output.success(pat)
+    output.kv('File', fileName)
+  }
+}
+
+run().catch(e => {
+  output.error(e.message)
+  process.exit(1)
+})

package/bin/commands/route/index.js

@@ -0,0 +1,59 @@
+/**
+ * meddle route - Route rule subcommand router
+ */
+
+const args = process.argv.slice(3)
+const subcommand = args[0]
+
+switch (subcommand) {
+  case 'list':
+    require('./list.js')
+    break
+  case 'show':
+    require('./show.js')
+    break
+  case 'preview':
+    require('./preview.js')
+    break
+  case 'active':
+    require('./active.js')
+    break
+  case 'create':
+    require('./create.js')
+    break
+  case 'add':
+    require('./add.js')
+    break
+  case 'update':
+    require('./update.js')
+    break
+  case 'delete':
+    require('./delete.js')
+    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)
+}

package/bin/commands/route/list.js

@@ -0,0 +1,67 @@
+/**
+ * meddle route list - List all route files
+ */
+
+const output = require('../../lib/output')
+const { isProxyRunning } = require('../../lib/proxy-detect')
+const { apiGet } = require('../../lib/api-client')
+const { listRuleFiles } = 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 files = []
+
+  if (running) {
+    try {
+      files = await apiGet('/api/rule-files')
+    } catch (e) {
+      // Fallback to file mode
+      files = listRuleFiles()
+    }
+  } else {
+    files = listRuleFiles()
+  }
+
+  if (jsonFlag) {
+    output.jsonRaw(files)
+    return
+  }
+
+  output.header(`Route Files (${files.length} total)`)
+
+  if (files.length === 0) {
+    output.info('No route files found')
+    return
+  }
+
+  // Separate active and inactive
+  const active = files.filter(f => f.enabled)
+  const inactive = files.filter(f => !f.enabled)
+
+  if (active.length > 0) {
+    output.section('Active Files')
+    active.forEach(f => {
+      const excludeInfo = f.excludeCount > 0 ? `, ${f.excludeCount} exclusions` : ''
+      output.success(`${f.name} (${f.ruleCount} rules${excludeInfo})`)
+    })
+  }
+
+  if (inactive.length > 0) {
+    output.section('Inactive Files')
+    inactive.forEach(f => {
+      const excludeInfo = f.excludeCount > 0 ? `, ${f.excludeCount} exclusions` : ''
+      output.bullet(`${f.name} (${f.ruleCount} rules${excludeInfo})`, false)
+    })
+  }
+}
+
+run().catch(e => {
+  output.error(e.message)
+  process.exit(1)
+})

package/bin/commands/route/preview.js

@@ -0,0 +1,159 @@
+/**
+ * meddle route preview - Preview route target for a given URL
+ */
+
+const output = require('../../lib/output')
+const { isProxyRunning, getProxyUrl } = require('../../lib/proxy-detect')
+const { apiPost } = require('../../lib/api-client')
+const { getActiveRuleFileNames, getRuleFileContent, parseEprcWithExclusions } = require('../../lib/file-access')
+
+// Parse arguments (skip 'route' and 'preview' from argv)
+const args = process.argv.slice(4)
+const jsonFlag = args.includes('--json')
+output.setJsonMode(jsonFlag)
+
+// Parse --file argument
+let ruleFileArg = null
+const fileEqIndex = args.findIndex(a => a.startsWith('--file='))
+if (fileEqIndex !== -1) {
+  ruleFileArg = args[fileEqIndex].split('=')[1]
+} else {
+  const fileIndex = args.indexOf('--file')
+  if (fileIndex !== -1 && fileIndex + 1 < args.length) {
+    ruleFileArg = args[fileIndex + 1]
+  }
+}
+
+// Get URL from positional argument (not --file value, not --json, not --file)
+const urlArg = args.find(a => !a.startsWith('--') && a !== ruleFileArg)
+
+async function run() {
+  if (!urlArg) {
+    output.error('Missing required argument: <url>')
+    output.info('Usage: meddle route preview <url> [--file <rule-file>] [--json]')
+    process.exit(1)
+  }
+
+  // Validate URL format
+  try {
+    new URL(urlArg)
+  } catch {
+    output.error('Invalid URL format')
+    process.exit(1)
+  }
+
+  const running = await isProxyRunning()
+  let result
+
+  if (running) {
+    // Use API when proxy is running
+    try {
+      const baseUrl = getProxyUrl()
+
+      // Get rules text from specified file or all active files
+      let rulesText = ''
+      if (ruleFileArg) {
+        // Use specified rule file
+        const content = await fetch(`${baseUrl}/api/rule-files/${encodeURIComponent(ruleFileArg)}/content`)
+          .then(r => r.ok ? r.text() : null)
+          .catch(() => null)
+        if (!content) {
+          output.error(`Rule file not found: ${ruleFileArg}`)
+          process.exit(1)
+        }
+        rulesText = content
+      } else {
+        // Use all active rule files
+        const filesRes = await fetch(`${baseUrl}/api/rule-files`).then(r => r.json())
+        const activeFiles = filesRes.filter(f => f.enabled)
+
+        for (const file of activeFiles) {
+          const content = await fetch(`${baseUrl}/api/rule-files/${encodeURIComponent(file.name)}/content`)
+            .then(r => r.text())
+            .catch(() => '')
+          if (content) {
+            rulesText += content + '\n'
+          }
+        }
+      }
+
+      // Call preview API
+      result = await apiPost('/api/rules/preview', { url: urlArg, rulesText })
+    } catch (e) {
+      output.error(e.message)
+      process.exit(1)
+    }
+  } else {
+    // Use local file access when proxy is not running
+    try {
+      let rulesText = ''
+
+      if (ruleFileArg) {
+        // Use specified rule file
+        const content = getRuleFileContent(ruleFileArg)
+        if (!content) {
+          output.error(`Rule file not found: ${ruleFileArg}`)
+          process.exit(1)
+        }
+        rulesText = content
+      } else {
+        // Use all active rule files
+        const activeNames = getActiveRuleFileNames()
+
+        for (const name of activeNames) {
+          const content = getRuleFileContent(name)
+          if (content) {
+            rulesText += content + '\n'
+          }
+        }
+      }
+
+      if (!rulesText.trim()) {
+        output.error('No active rule files found')
+        output.info('Use --file <name> to specify a rule file, or activate one with: meddle route active set <file>')
+        process.exit(1)
+      }
+
+      // Use local preview logic (same as core/route-preview.ts)
+      const { previewRouteTargetLocal } = require('../../lib/route-preview')
+      result = previewRouteTargetLocal(urlArg, rulesText)
+    } catch (e) {
+      output.error(e.message)
+      process.exit(1)
+    }
+  }
+
+  // Output result
+  if (jsonFlag) {
+    output.jsonRaw(result)
+    return
+  }
+
+  output.header('Route Preview')
+  output.kv('Input URL', result.inputUrl)
+
+  if (result.matched) {
+    output.success('Matched rule found')
+    output.section('Match Details')
+    output.kv('Pattern', result.matchedRule.pattern)
+    output.kv('Target', result.matchedRule.target)
+    output.kv('Kind', result.matchedRule.kind)
+    output.kv('Resolved URL', result.resolvedUrl)
+
+    if (result.notes.length > 0) {
+      output.section('Notes')
+      for (const note of result.notes) {
+        output.info(note)
+      }
+    }
+  } else {
+    output.warning('No matching rule found')
+    output.kv('Resolved URL', result.resolvedUrl)
+    output.info('Request will pass through unchanged')
+  }
+}
+
+run().catch(e => {
+  output.error(e.message)
+  process.exit(1)
+})

package/bin/commands/route/show.js

@@ -0,0 +1,111 @@
+/**
+ * meddle route show - Show rules in a file
+ */
+
+const output = require('../../lib/output')
+const { isProxyRunning } = require('../../lib/proxy-detect')
+const { apiGet } = require('../../lib/api-client')
+const { getRuleFileContent, parseEprcWithExclusions } = require('../../lib/file-access')
+
+// Parse arguments (skip 'route' and 'show' from argv)
+const args = process.argv.slice(4)
+const jsonFlag = args.includes('--json')
+output.setJsonMode(jsonFlag)
+
+// Get file name from positional argument
+const fileName = args.find(a => !a.startsWith('--'))
+
+async function run() {
+  if (!fileName) {
+    output.error('Missing required argument: <file>')
+    process.exit(1)
+  }
+
+  const running = await isProxyRunning()
+
+  let content = null
+  let ruleMap = {}
+  let excludeMap = {}
+
+  if (running) {
+    try {
+      content = await apiGet(`/api/rule-files/${encodeURIComponent(fileName)}/content`)
+      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) {
+        output.error(`Route file not found: ${fileName}`)
+        process.exit(1)
+      }
+      const parsed = parseEprcWithExclusions(content)
+      ruleMap = parsed.ruleMap
+      excludeMap = parsed.excludeMap
+    }
+  } else {
+    content = getRuleFileContent(fileName)
+    if (!content) {
+      output.error(`Route file not found: ${fileName}`)
+      process.exit(1)
+    }
+    const parsed = parseEprcWithExclusions(content)
+    ruleMap = parsed.ruleMap
+    excludeMap = parsed.excludeMap
+  }
+
+  // Build display rules (handle [marker] syntax)
+  const displayRules = {}
+  for (const [pat, tgt] of Object.entries(ruleMap)) {
+    const bm = tgt.match(/\[([^\]]+)\]/)
+    const displayPat = bm ? pat.replace(bm[1], bm[0]) : pat
+    const displayTgt = bm ? tgt.replace(bm[0], '') : tgt
+    const exclusions = excludeMap[pat] || []
+    displayRules[displayPat] = exclusions.length > 0
+      ? { target: displayTgt, exclusions }
+      : displayTgt
+  }
+
+  // Calculate total exclusions
+  let totalExclusions = 0
+  for (const exclusions of Object.values(excludeMap)) {
+    totalExclusions += exclusions.length
+  }
+
+  if (jsonFlag) {
+    output.jsonRaw({
+      file: fileName,
+      rules: displayRules,
+      ruleCount: Object.keys(displayRules).length,
+      exclusionCount: totalExclusions
+    })
+    return
+  }
+
+  output.header(`Route File: ${fileName}`)
+  output.kv('Rules', Object.keys(displayRules).length)
+  if (totalExclusions > 0) {
+    output.kv('Exclusions', totalExclusions)
+  }
+
+  if (Object.keys(displayRules).length === 0) {
+    output.info('No rules in this file')
+    return
+  }
+
+  output.section('Rules')
+  for (const [pattern, rule] of Object.entries(displayRules)) {
+    if (typeof rule === 'string') {
+      output.kv(pattern, rule)
+    } else {
+      const exclStr = rule.exclusions.map(e => `!${e}`).join(' ')
+      output.kv(pattern, `${rule.target} ${exclStr}`)
+    }
+  }
+}
+
+run().catch(e => {
+  output.error(e.message)
+  process.exit(1)
+})