@jonathanleelx/meddle 0.0.1

package/bin/lib/file-access.js

@@ -0,0 +1,337 @@
+/**
+ * Direct file operations for when proxy is not running
+ */
+
+const fs = require('fs')
+const path = require('path')
+const { meddleDir } = require('./proxy-detect')
+
+const routeRulesDir = path.join(meddleDir, 'route-rules')
+const settingsPath = path.join(meddleDir, 'settings.json')
+const defaultMocksPath = path.join(meddleDir, 'mocks.json')
+
+// ========== Settings ==========
+
+/**
+ * Load settings.json
+ */
+function loadSettings() {
+  try {
+    if (fs.existsSync(settingsPath)) {
+      return JSON.parse(fs.readFileSync(settingsPath, 'utf8'))
+    }
+  } catch (_) {}
+  return {}
+}
+
+/**
+ * Save settings.json
+ */
+function saveSettings(settings) {
+  const dir = path.dirname(settingsPath)
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true })
+  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf8')
+}
+
+/**
+ * Get active rule file names
+ */
+function getActiveRuleFileNames() {
+  const settings = loadSettings()
+  const arr = settings.activeRuleFiles
+  return Array.isArray(arr) ? arr : []
+}
+
+/**
+ * Set active rule file names
+ */
+function setActiveRuleFileNames(names) {
+  const settings = loadSettings()
+  settings.activeRuleFiles = names
+  saveSettings(settings)
+}
+
+// ========== Mocks ==========
+
+/**
+ * Get mocks file path (supports custom path in settings)
+ */
+function getMocksPath() {
+  const settings = loadSettings()
+  return settings.mocksFilePath || defaultMocksPath
+}
+
+/**
+ * Load mock rules from file
+ */
+function loadMockRules() {
+  const mocksPath = getMocksPath()
+  try {
+    if (fs.existsSync(mocksPath)) {
+      const data = JSON.parse(fs.readFileSync(mocksPath, 'utf8'))
+      return data.rules || []
+    }
+  } catch (_) {}
+  return []
+}
+
+/**
+ * Save mock rules to file
+ */
+function saveMockRules(rules) {
+  const mocksPath = getMocksPath()
+  const dir = path.dirname(mocksPath)
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true })
+
+  // Find max id for sequence
+  let maxId = 0
+  rules.forEach(r => {
+    if (r.id > maxId) maxId = r.id
+  })
+
+  const data = {
+    rules,
+    lastId: maxId
+  }
+  fs.writeFileSync(mocksPath, JSON.stringify(data, null, 2), 'utf8')
+}
+
+/**
+ * Add mock rule
+ */
+function addMockRule(rule) {
+  const rules = loadMockRules()
+  const mocksPath = getMocksPath()
+
+  // Get next id
+  let nextId = 1
+  try {
+    if (fs.existsSync(mocksPath)) {
+      const data = JSON.parse(fs.readFileSync(mocksPath, 'utf8'))
+      nextId = (data.lastId || 0) + 1
+    }
+  } catch (_) {}
+  if (rules.length > 0) {
+    const maxId = Math.max(...rules.map(r => r.id))
+    if (maxId >= nextId) nextId = maxId + 1
+  }
+
+  rule.id = nextId
+  rules.push(rule)
+  saveMockRules(rules)
+  return rule
+}
+
+/**
+ * Update mock rule by id
+ */
+function updateMockRule(id, updates) {
+  const rules = loadMockRules()
+  const idx = rules.findIndex(r => r.id === id)
+  if (idx === -1) return null
+  rules[idx] = { ...rules[idx], ...updates, id }
+  saveMockRules(rules)
+  return rules[idx]
+}
+
+/**
+ * Delete mock rule by id
+ */
+function deleteMockRule(id) {
+  const rules = loadMockRules()
+  const idx = rules.findIndex(r => r.id === id)
+  if (idx === -1) return false
+  rules.splice(idx, 1)
+  saveMockRules(rules)
+  return true
+}
+
+// ========== Route Rules ==========
+
+/**
+ * Ensure route-rules directory exists
+ */
+function ensureRouteRulesDir() {
+  if (!fs.existsSync(routeRulesDir)) {
+    fs.mkdirSync(routeRulesDir, { recursive: true })
+  }
+}
+
+/**
+ * Get rule file path
+ */
+function getRuleFilePath(name) {
+  return path.join(routeRulesDir, `${name}.txt`)
+}
+
+/**
+ * List all rule files
+ */
+function listRuleFiles() {
+  ensureRouteRulesDir()
+  const activeNames = getActiveRuleFileNames()
+
+  const files = fs.readdirSync(routeRulesDir)
+    .filter(f => f.endsWith('.txt'))
+    .map(f => f.replace(/\.txt$/, ''))
+
+  return files.map(name => {
+    const filePath = getRuleFilePath(name)
+    let ruleCount = 0
+    let excludeCount = 0
+    try {
+      const content = fs.readFileSync(filePath, 'utf8')
+      const { ruleMap, excludeMap } = parseEprcWithExclusions(content)
+      ruleCount = Object.keys(ruleMap).length
+      // Count total exclusions across all rules
+      for (const exclusions of Object.values(excludeMap)) {
+        excludeCount += exclusions.length
+      }
+    } catch (_) {}
+    return {
+      name,
+      enabled: activeNames.includes(name),
+      ruleCount,
+      excludeCount
+    }
+  })
+}
+
+/**
+ * Get rule file content
+ */
+function getRuleFileContent(name) {
+  const filePath = getRuleFilePath(name)
+  try {
+    if (fs.existsSync(filePath)) {
+      return fs.readFileSync(filePath, 'utf8')
+    }
+  } catch (_) {}
+  return null
+}
+
+/**
+ * Save rule file content
+ */
+function saveRuleFileContent(name, content) {
+  ensureRouteRulesDir()
+  const filePath = getRuleFilePath(name)
+  fs.writeFileSync(filePath, content, 'utf8')
+}
+
+/**
+ * Create rule file
+ */
+function createRuleFile(name, content = '', enabled = true) {
+  ensureRouteRulesDir()
+  const safeName = name.trim().replace(/[/\\:*?"<>|]/g, '_')
+  const filePath = getRuleFilePath(safeName)
+
+  if (fs.existsSync(filePath)) {
+    throw new Error(`规则文件 "${safeName}" 已存在`)
+  }
+
+  fs.writeFileSync(filePath, content, 'utf8')
+
+  if (enabled) {
+    const activeNames = getActiveRuleFileNames()
+    if (!activeNames.includes(safeName)) {
+      activeNames.push(safeName)
+      setActiveRuleFileNames(activeNames)
+    }
+  }
+
+  const ruleCount = content.trim() ? Object.keys(parseEprc(content)).length : 0
+  return { name: safeName, enabled, ruleCount }
+}
+
+/**
+ * Delete rule file
+ */
+function deleteRuleFile(name) {
+  const filePath = getRuleFilePath(name)
+  if (!fs.existsSync(filePath)) {
+    throw new Error('规则文件不存在')
+  }
+  fs.unlinkSync(filePath)
+
+  const activeNames = getActiveRuleFileNames()
+  const idx = activeNames.indexOf(name)
+  if (idx !== -1) {
+    activeNames.splice(idx, 1)
+    setActiveRuleFileNames(activeNames)
+  }
+}
+
+/**
+ * Enable/disable rule file
+ */
+function setRuleFileEnabled(name, enabled) {
+  const filePath = getRuleFilePath(name)
+  if (!fs.existsSync(filePath)) {
+    throw new Error('规则文件不存在')
+  }
+
+  const activeNames = getActiveRuleFileNames()
+  const idx = activeNames.indexOf(name)
+
+  if (enabled && idx === -1) {
+    activeNames.push(name)
+  } else if (!enabled && idx !== -1) {
+    activeNames.splice(idx, 1)
+  }
+
+  setActiveRuleFileNames(activeNames)
+}
+
+/**
+ * Get content of all active rule files merged
+ */
+function getActiveRuleFilesContent() {
+  const activeNames = getActiveRuleFileNames()
+  const contents = []
+  for (const name of activeNames) {
+    const content = getRuleFileContent(name)
+    if (content) {
+      contents.push(content)
+    }
+  }
+  return contents.join('\n')
+}
+
+// ========== Parser (imported) ==========
+
+const { parseEprc, parseEprcWithExclusions, ruleMapToEprcText } = require('./parsers')
+
+module.exports = {
+  // Settings
+  loadSettings,
+  saveSettings,
+  getActiveRuleFileNames,
+  setActiveRuleFileNames,
+
+  // Mocks
+  getMocksPath,
+  loadMockRules,
+  saveMockRules,
+  addMockRule,
+  updateMockRule,
+  deleteMockRule,
+
+  // Route Rules
+  routeRulesDir,
+  ensureRouteRulesDir,
+  getRuleFilePath,
+  listRuleFiles,
+  getRuleFileContent,
+  getActiveRuleFilesContent,
+  saveRuleFileContent,
+  createRuleFile,
+  deleteRuleFile,
+  setRuleFileEnabled,
+
+  // Parser (re-exported)
+  parseEprc,
+  parseEprcWithExclusions,
+  ruleMapToEprcText
+}

package/bin/lib/meddle-home.js

@@ -0,0 +1,20 @@
+/**
+ * MEDDLE_HOME resolver — single source of truth for meddle data directory.
+ *
+ * Resolution order:
+ *   1. MEDDLE_HOME env var (if set and non-empty)
+ *   2. ~/.meddle (default, backward compatible)
+ *
+ * Pure JS so the CLI can require it without a build step.
+ */
+
+const os = require('os')
+const path = require('path')
+
+function resolveMeddleHome() {
+    const fromEnv = (process.env.MEDDLE_HOME || '').trim()
+    if (fromEnv) return path.resolve(fromEnv)
+    return path.resolve(os.homedir(), '.meddle')
+}
+
+module.exports = { resolveMeddleHome }

package/bin/lib/output.js

@@ -0,0 +1,146 @@
+/**
+ * Output formatter for CLI commands
+ * Supports both human-readable and JSON output
+ */
+
+const chalk = require('chalk')
+
+let jsonMode = false
+
+/**
+ * Set JSON output mode
+ */
+function setJsonMode(mode) {
+  jsonMode = mode
+}
+
+/**
+ * Check if JSON mode is enabled
+ */
+function isJsonMode() {
+  return jsonMode
+}
+
+/**
+ * Print header with title
+ */
+function header(title) {
+  if (jsonMode) return
+  console.log('')
+  console.log(chalk.bold.cyan('════════════════════════════════════════'))
+  console.log(chalk.bold.cyan(`   ${title}`))
+  console.log(chalk.bold.cyan('════════════════════════════════════════'))
+  console.log('')
+}
+
+/**
+ * Print section header
+ */
+function section(title) {
+  if (jsonMode) return
+  console.log(chalk.bold.yellow(`\n▶ ${title}`))
+  console.log(chalk.gray('─'.repeat(40)))
+}
+
+/**
+ * Print success message
+ */
+function success(message) {
+  if (jsonMode) return
+  console.log(chalk.green('  ✓'), message)
+}
+
+/**
+ * Print error message
+ */
+function error(message) {
+  if (jsonMode) return
+  console.log(chalk.red('  ✗'), message)
+}
+
+/**
+ * Print warning message
+ */
+function warning(message) {
+  if (jsonMode) return
+  console.log(chalk.yellow('  ⚠'), message)
+}
+
+/**
+ * Print info message
+ */
+function info(message) {
+  if (jsonMode) return
+  console.log(chalk.gray('    →'), message)
+}
+
+/**
+ * Print JSON output (only in JSON mode)
+ */
+function json(data) {
+  if (!jsonMode) return
+  console.log(JSON.stringify(data, null, 2))
+}
+
+/**
+ * Print raw JSON (without formatting, for --json output)
+ */
+function jsonRaw(data) {
+  console.log(JSON.stringify(data))
+}
+
+/**
+ * Print plain text message
+ */
+function plain(message) {
+  if (jsonMode) return
+  console.log(message)
+}
+
+/**
+ * Print key-value pair
+ */
+function kv(key, value, indent = 2) {
+  if (jsonMode) return
+  const spaces = ' '.repeat(indent)
+  console.log(spaces + chalk.gray(key + ':'), value)
+}
+
+/**
+ * Print bullet item
+ */
+function bullet(message, active = false, indent = 2) {
+  if (jsonMode) return
+  const spaces = ' '.repeat(indent)
+  const marker = active ? chalk.green('●') : chalk.gray('○')
+  console.log(spaces + marker, message)
+}
+
+/**
+ * Print table row
+ */
+function tableRow(columns, widths) {
+  if (jsonMode) return
+  const row = columns.map((col, i) => {
+    const width = widths[i] || 10
+    return String(col).padEnd(width)
+  }).join('  ')
+  console.log('  ' + row)
+}
+
+module.exports = {
+  setJsonMode,
+  isJsonMode,
+  header,
+  section,
+  success,
+  error,
+  warning,
+  info,
+  json,
+  jsonRaw,
+  plain,
+  kv,
+  bullet,
+  tableRow
+}

package/bin/lib/parsers.js

@@ -0,0 +1,127 @@
+/**
+ * EPRC file parsers
+ * Ported from helpers.ts
+ */
+
+const path = require('path')
+
+const FILE_PATTERN = /^file:\/\//
+const LOCAL_FILE_PATTERN = /^[A-Za-z]:\\|^\/|^\\/
+
+function routeRulesToLegacyMaps(rules) {
+  const ruleMap = Object.create(null)
+  const excludeMap = Object.create(null)
+  for (const entry of rules) {
+    ruleMap[entry.pattern] = entry.target
+    excludeMap[entry.pattern] = entry.exclusions.slice()
+  }
+  return { ruleMap, excludeMap }
+}
+
+/**
+ * Parse EPRC content into ordered rules + legacy ruleMap/excludeMap
+ */
+function parseEprcWithExclusions(content) {
+  const rules = []
+
+  content.split(/\r?\n/).forEach(line => {
+    const trimmed = line.trim()
+    if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith('//')) return
+
+    const parts = trimmed.split(/\s+/).filter(Boolean)
+    if (parts.length < 2) return
+
+    const exclusions = []
+    const regularParts = parts.filter(p => {
+      if (p.startsWith('!')) {
+        exclusions.push(p.slice(1))
+        return false
+      }
+      return true
+    })
+
+    if (regularParts.length < 2) return
+
+    let target = regularParts[regularParts.length - 1]
+    const patterns = regularParts.slice(0, -1)
+
+    if (LOCAL_FILE_PATTERN.test(target) && !FILE_PATTERN.test(target)) {
+      target = 'file://' + target.replace(/\\/g, '/')
+    }
+
+    const lineExclusions = exclusions.slice()
+
+    patterns.forEach(rule => {
+      const bm = rule.match(/\[([^\]]+)\]/)
+      let patternKey
+      let storedTarget = target
+      if (bm) {
+        patternKey = rule.replace(bm[0], bm[1])
+        storedTarget = target + bm[0]
+      } else {
+        patternKey = rule
+      }
+
+      rules.push({
+        pattern: patternKey,
+        target: storedTarget,
+        exclusions: lineExclusions,
+      })
+    })
+  })
+
+  const { ruleMap, excludeMap } = routeRulesToLegacyMaps(rules)
+  return { rules, ruleMap, excludeMap }
+}
+
+/**
+ * Parse EPRC content into ruleMap (without exclusions)
+ */
+function parseEprc(content) {
+  return parseEprcWithExclusions(content).ruleMap
+}
+
+/**
+ * Convert ruleMap back to EPRC text format
+ */
+function ruleMapToEprcText(ruleMap, excludeMap) {
+  const entries = Object.entries(ruleMap)
+  if (entries.length === 0) return ''
+
+  const byTargetAndExclusions = {}
+
+  entries.forEach(([rule, target]) => {
+    const bm = target.match(/\[([^\]]+)\]/)
+    const groupKey = bm ? target.replace(bm[0], '') : target
+    const displayRule = bm ? rule.replace(bm[1], bm[0]) : rule
+    const exclusions = excludeMap?.[rule] || []
+    const exclusionsKey = exclusions.join(',')
+
+    const compoundKey = `${groupKey}|||${exclusionsKey}`
+
+    if (!byTargetAndExclusions[compoundKey]) {
+      byTargetAndExclusions[compoundKey] = { target: groupKey, rules: [], exclusions }
+    }
+    byTargetAndExclusions[compoundKey].rules.push(displayRule)
+  })
+
+  return Object.values(byTargetAndExclusions)
+    .map(({ target, rules, exclusions }) => {
+      let displayTarget = target
+      if (FILE_PATTERN.test(target)) {
+        displayTarget = target.replace(/^file:\/\//, '').replace(/\//g, path.sep)
+      }
+
+      const exclusionStr = exclusions.map(e => `!${e}`).join(' ')
+      const rulesStr = rules.join(' ')
+      return exclusionStr ? `${rulesStr} ${exclusionStr} ${displayTarget}` : `${rulesStr} ${displayTarget}`
+    })
+    .join('\n')
+}
+
+module.exports = {
+  parseEprcWithExclusions,
+  parseEprc,
+  ruleMapToEprcText,
+  routeRulesToLegacyMaps,
+}