@jonathanleelx/meddle 0.0.1

package/bin/lib/proxy-detect.js

@@ -0,0 +1,105 @@
+/**
+ * Proxy detection utilities
+ * Detect if proxy is running and get proxy URL
+ *
+ * On module load, applies any --session context from argv. This makes
+ * every CLI command session-aware without individual changes: when
+ * --session <id> is set, MEDDLE_HOME is pinned to the session's data dir
+ * and getProxyUrl() returns that session's port.
+ */
+
+const fs = require('fs')
+const path = require('path')
+const { resolveMeddleHome } = require('./meddle-home')
+const { applySessionContext, GLOBAL_DEFAULT_PORT } = require('./session-args')
+
+// Apply --session / MEDDLE_HOME precedence before computing paths.
+applySessionContext()
+
+const meddleDir = resolveMeddleHome()
+const mcpFile = path.join(meddleDir, 'mcp-proxy-url.json')
+const DEFAULT_PROXY_BASE = `http://127.0.0.1:${GLOBAL_DEFAULT_PORT}`
+
+/**
+ * Get proxy URL.
+ *
+ * Priority:
+ *   1. MEDDLE_SESSION_PORT env (set by --session resolution)
+ *   2. mcp-proxy-url.json (written by proxy on startup)
+ *   3. DEFAULT_PROXY_BASE (http://127.0.0.1:8989)
+ */
+function getProxyUrl() {
+  if (process.env.MEDDLE_SESSION_PORT) {
+    return `http://127.0.0.1:${process.env.MEDDLE_SESSION_PORT}`
+  }
+  try {
+    if (fs.existsSync(mcpFile)) {
+      const data = JSON.parse(fs.readFileSync(mcpFile, 'utf8'))
+      if (data.proxyUrl) return data.proxyUrl
+    }
+  } catch (_) {}
+  return DEFAULT_PROXY_BASE
+}
+
+/**
+ * Check if proxy is running by attempting to connect
+ * @param {number} timeoutMs - Timeout in milliseconds (default 2000)
+ */
+async function isProxyRunning(timeoutMs = 2000) {
+  const url = getProxyUrl()
+  try {
+    const response = await fetch(url + '/api/mocks', {
+      method: 'GET',
+      signal: AbortSignal.timeout(timeoutMs)
+    })
+    return response.ok
+  } catch (_) {
+    return false
+  }
+}
+
+/**
+ * Wait for proxy to start
+ * @param {number} timeoutMs - Timeout in milliseconds (default 5000)
+ */
+function waitForProxyUrl(timeoutMs = 5000) {
+  return new Promise((resolve, reject) => {
+    const start = Date.now()
+    const interval = 50
+    const check = () => {
+      try {
+        if (process.env.MEDDLE_SESSION_PORT) {
+          // For --session mode, poll the HTTP endpoint directly.
+          const port = process.env.MEDDLE_SESSION_PORT
+          fetch(`http://127.0.0.1:${port}/api/mocks`, { method: 'GET', signal: AbortSignal.timeout(500) })
+            .then((r) => { if (r.ok) resolve(`http://127.0.0.1:${port}`); else retry() })
+            .catch(() => retry())
+          return
+        }
+        if (fs.existsSync(mcpFile)) {
+          const data = JSON.parse(fs.readFileSync(mcpFile, 'utf8'))
+          if (data.proxyUrl) {
+            return resolve(data.proxyUrl)
+          }
+        }
+      } catch (_) {}
+      retry()
+    }
+    function retry() {
+      if (Date.now() - start > timeoutMs) {
+        return reject(new Error('等待代理启动超时'))
+      }
+      setTimeout(check, interval)
+    }
+    check()
+  })
+}
+
+module.exports = {
+  meddleDir,
+  mcpFile,
+  DEFAULT_PROXY_BASE,
+  getProxyUrl,
+  isProxyRunning,
+  waitForProxyUrl
+}

package/bin/lib/route-preview.js

@@ -0,0 +1,180 @@
+/**
+ * Local route preview logic (for CLI when proxy is not running)
+ * Ported from core/route-preview.ts
+ */
+
+const { parseEprcWithExclusions } = require('./parsers')
+
+function getTargetKind(target) {
+  const trimmed = target.trim()
+  if (!trimmed) return 'empty'
+  if (/^file:\/\//i.test(trimmed) || /^[A-Za-z]:\\|^\//.test(trimmed)) return 'file'
+  if (/^(https?|wss?):\/\//i.test(trimmed)) return 'absolute-url'
+  return 'host'
+}
+
+function buildNotes(kind, target, resolvedUrl, inputUrl) {
+  const notes = []
+
+  if (resolvedUrl === inputUrl) {
+    notes.push('未命中规则，保持原 URL')
+    return notes
+  }
+
+  switch (kind) {
+    case 'file':
+      notes.push('命中本地文件目标')
+      break
+    case 'absolute-url':
+      notes.push('使用完整目标地址')
+      break
+    case 'host':
+      notes.push('继承原请求协议、路径和 query')
+      break
+    case 'empty':
+      notes.push('规则目标为空')
+      break
+  }
+
+  if (/\[[^\]]+\]/.test(target)) {
+    notes.push('保留 marker 尾缀')
+  }
+
+  return notes
+}
+
+function testRulePattern(pattern, input) {
+  function looksLikeWildcardPattern(p) {
+    if (!p.includes('*')) return false
+    return !/[\\^$+?()[\]{}|]/.test(p)
+  }
+
+  function isSimplePattern(p) {
+    return !/[\\^$+?()[\]{}|]/.test(p) && !p.includes('*')
+  }
+
+  function escapeRegexLiteral(value) {
+    return value.replace(/[|\\{}()[\]^$+?.*]/g, '\\$&')
+  }
+
+  function wildcardPatternToRegex(p) {
+    const escaped = escapeRegexLiteral(p)
+    const withOptionalSubdomain = p.startsWith('*.')
+      ? escaped.replace(/^\\\*\\\./, '(?:[^/:?#]+\\.)*')
+      : escaped
+    const regexSource = withOptionalSubdomain.replace(/\\\*/g, '.*')
+    return new RegExp(regexSource)
+  }
+
+  if (looksLikeWildcardPattern(pattern)) {
+    return wildcardPatternToRegex(pattern).test(input)
+  }
+  if (isSimplePattern(pattern)) {
+    const escaped = escapeRegexLiteral(pattern)
+    return new RegExp(escaped).test(input)
+  }
+  return new RegExp(pattern).test(input)
+}
+
+function applyRuleTarget(url, urlSegment) {
+  const originUrlObj = new URL(url)
+
+  const bracketMatch = urlSegment.match(/\[([^\]]+)\]/)
+  if (bracketMatch) {
+    const marker = bracketMatch[1]
+    const markerIdx = url.indexOf(marker)
+    const before = urlSegment.substring(0, bracketMatch.index)
+    const after = urlSegment.substring(bracketMatch.index + bracketMatch[0].length)
+    if (markerIdx !== -1) {
+      const tail = url.substring(markerIdx + marker.length)
+      urlSegment = (before + tail + after).replace(/([^:])\/\//g, '$1/')
+    } else {
+      urlSegment = before + after
+    }
+  }
+
+  if (!urlSegment.startsWith('http') && !urlSegment.startsWith('ws') && !urlSegment.startsWith('file')) {
+    urlSegment = originUrlObj.protocol + urlSegment
+  }
+
+  if (urlSegment.startsWith('file://')) {
+    return urlSegment
+  }
+
+  const targetURLObj = new URL(urlSegment)
+
+  if (!targetURLObj.port && originUrlObj.port) {
+    targetURLObj.port = originUrlObj.port
+  }
+
+  if (targetURLObj.pathname === '/' && originUrlObj.pathname !== '/') {
+    targetURLObj.pathname = originUrlObj.pathname
+  }
+
+  if (targetURLObj.search === '' && originUrlObj.search) {
+    targetURLObj.search = originUrlObj.search
+  }
+
+  const originIsWs = /^wss?:\/\//.test(url)
+  const targetIsHttp = /^https?:\/\//.test(targetURLObj.toString())
+  if (originIsWs && targetIsHttp) {
+    targetURLObj.protocol = originUrlObj.protocol
+  }
+
+  return targetURLObj.toString()
+}
+
+function findMatchedRouteRule(url, rules) {
+  for (const entry of rules) {
+    if (!testRulePattern(entry.pattern, url)) continue
+    if (entry.exclusions.some((exc) => testRulePattern(exc, url))) continue
+    const resolvedUrl = applyRuleTarget(url, entry.target)
+    if (resolvedUrl) {
+      return { entry, resolvedUrl }
+    }
+  }
+  return null
+}
+
+function previewRouteTargetLocal(inputUrl, rulesText) {
+  let parsedUrl
+  try {
+    parsedUrl = new URL(inputUrl)
+  } catch {
+    throw new Error('请输入合法的 URL')
+  }
+
+  const { rules } = parseEprcWithExclusions(rulesText)
+  const matched = findMatchedRouteRule(parsedUrl.toString(), rules)
+
+  if (!matched) {
+    return {
+      inputUrl: parsedUrl.toString(),
+      matched: false,
+      resolvedUrl: parsedUrl.toString(),
+      notes: ['未命中规则，保持原 URL'],
+    }
+  }
+
+  const { entry, resolvedUrl } = matched
+  const kind = getTargetKind(entry.target)
+
+  return {
+    inputUrl: parsedUrl.toString(),
+    matched: true,
+    resolvedUrl,
+    matchedRule: {
+      pattern: entry.pattern,
+      target: entry.target,
+      kind,
+    },
+    notes: buildNotes(kind, entry.target, resolvedUrl, parsedUrl.toString()),
+  }
+}
+
+module.exports = {
+  previewRouteTargetLocal,
+  testRulePattern,
+  findMatchedRouteRule,
+  getTargetKind,
+}

package/bin/lib/session-args.js

@@ -0,0 +1,54 @@
+/**
+ * --session flag resolution & MEDDLE_HOME precedence.
+ *
+ * Rules (per proposal §5.3):
+ *   - --session <id> only     → resolve id via sessions.json, set MEDDLE_HOME
+ *                                to the session's meddleHome so proxy-detect /
+ *                                file-access see its data dir, and pin the
+ *                                proxy port.
+ *   - MEDDLE_HOME env only        → use that path directly (already handled by
+ *                                resolveMeddleHome() in meddle-home.js)
+ *   - both set                → error, exit
+ *   - neither set             → default (~/.meddle), backward compatible
+ *
+ * bin/index strips --session <id> from argv and stashes the id in
+ * MEDDLE_SESSION_ID. This module reads that env var so every CLI command
+ * picks up the session context without individual changes.
+ */
+
+const { resolveMeddleHome } = require('./meddle-home')
+const { getSession } = require('./sessions')
+
+const GLOBAL_DEFAULT_PORT = 8989
+
+function applySessionContext() {
+    const sessionId = (process.env.MEDDLE_SESSION_ID || '').trim()
+    const meddleHomeEnv = (process.env.MEDDLE_HOME || '').trim()
+
+    if (sessionId && meddleHomeEnv) {
+        console.error('error: --session and MEDDLE_HOME are mutually exclusive')
+        process.exit(2)
+    }
+
+    if (sessionId) {
+        const record = getSession(sessionId)
+        if (!record) {
+            console.error(`error: session not found: ${sessionId}`)
+            process.exit(1)
+        }
+        // Pin MEDDLE_HOME so resolveMeddleHome() everywhere returns the session dir
+        process.env.MEDDLE_HOME = record.meddleHome
+        // Stash the port so proxy-detect can return it instead of reading
+        // mcp-proxy-url.json (which may not exist for non-default sessions
+        // that weren't started via MCP).
+        process.env.MEDDLE_SESSION_PORT = String(record.port)
+        return { sessionId, port: record.port, meddleHome: record.meddleHome }
+    }
+
+    return { sessionId: null, port: null, meddleHome: resolveMeddleHome() }
+}
+
+module.exports = {
+    applySessionContext,
+    GLOBAL_DEFAULT_PORT,
+}

package/bin/lib/sessions.js

@@ -0,0 +1,213 @@
+/**
+ * Session registry — tracks all non-default proxy sessions.
+ *
+ * Storage: ~/.meddle/sessions.json
+ *
+ * Concurrency: atomic writes (tmp + rename) + optimistic-lock retry on
+ * port allocation. No file locking (cross-platform complexity not
+ * justified for the low-frequency create path).
+ *
+ * NOTE: the CA directory (~/.meddle/ca) is intentionally NOT registered —
+ * all sessions share it. Only config (route-rules, mocks, plugins, …)
+ * is isolated per session via MEDDLE_HOME.
+ */
+
+const fs = require('fs')
+const path = require('path')
+const { resolveMeddleHome } = require('./meddle-home')
+
+const MAX_SESSIONS = 32
+const PORT_RANGE_START = 9000
+const PORT_RANGE_END = 9999
+
+function registryPath() {
+    return path.join(resolveMeddleHome(), 'sessions.json')
+}
+
+function sessionsDir() {
+    return path.join(resolveMeddleHome(), 'sessions')
+}
+
+function sessionDir(id) {
+    return path.join(sessionsDir(), id)
+}
+
+/**
+ * Read the registry. Returns {} if missing or corrupt.
+ */
+function readRegistry() {
+    try {
+        const raw = fs.readFileSync(registryPath(), 'utf8')
+        const parsed = JSON.parse(raw)
+        return (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) ? parsed : {}
+    } catch (_) {
+        return {}
+    }
+}
+
+/**
+ * Atomically write the registry (tmp file + rename).
+ */
+function writeRegistry(registry) {
+    const file = registryPath()
+    const dir = path.dirname(file)
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true })
+    const tmp = file + '.tmp'
+    fs.writeFileSync(tmp, JSON.stringify(registry, null, 2), 'utf8')
+    fs.renameSync(tmp, file)
+}
+
+/**
+ * Check whether a TCP port is currently free on 127.0.0.1.
+ */
+function isPortFree(port) {
+    try {
+        const net = require('net')
+        const server = net.createServer()
+        server.listen(port, '127.0.0.1')
+        // sync check: if listen throws synchronously we catch below
+        server.close()
+        return true
+    } catch (_) {
+        return false
+    }
+}
+
+/**
+ * Allocate a free port in [PORT_RANGE_START, PORT_RANGE_END], avoiding
+ * ports already recorded in the registry. Returns null if exhausted.
+ *
+ * Uses optimistic locking: caller should re-verify the port is still
+ * free in the registry before committing.
+ */
+function allocatePort(registry) {
+    const usedPorts = new Set()
+    for (const id of Object.keys(registry)) {
+        if (registry[id] && typeof registry[id].port === 'number') {
+            usedPorts.add(registry[id].port)
+        }
+    }
+    for (let port = PORT_RANGE_START; port <= PORT_RANGE_END; port++) {
+        if (usedPorts.has(port)) continue
+        if (!isPortFree(port)) continue
+        return port
+    }
+    return null
+}
+
+/**
+ * Generate a session ID: `{label}-{timestamp}`.
+ */
+function generateId(label) {
+    const safe = String(label || 'session').trim().replace(/[^a-zA-Z0-9_-]/g, '-').slice(0, 32) || 'session'
+    return `${safe}-${Date.now()}`
+}
+
+/**
+ * Check if a process is alive. pid 0 / negative → false.
+ */
+function isPidAlive(pid) {
+    if (!pid || typeof pid !== 'number' || pid <= 0) return false
+    try {
+        process.kill(pid, 0)
+        return true
+    } catch (err) {
+        // ESRCH: no such process — definitely not alive
+        if (err.code === 'ESRCH') return false
+        // EPERM: exists but we don't have permission to signal — alive
+        if (err.code === 'EPERM') return true
+        // Unexpected error — assume alive to be safe (don't prune on fluke)
+        return true
+    }
+}
+
+/**
+ * Create a new session record. Returns the new record (with id, port,
+ * pid, meddleHome, createdAt, label) or throws on conflict / limit.
+ *
+ * `pid` should be the spawned child's pid; caller spawns first, then
+ * calls this to register.
+ */
+function createSession({ id, label, port, pid, meddleHome }) {
+    const registry = readRegistry()
+    const ids = Object.keys(registry)
+    if (ids.length >= MAX_SESSIONS) {
+        throw new Error(`session limit reached (${MAX_SESSIONS}); run 'meddle session prune' to clean orphaned records`)
+    }
+    if (registry[id]) {
+        throw new Error(`session already exists: ${id}`)
+    }
+    const record = {
+        port,
+        pid,
+        meddleHome,
+        createdAt: new Date().toISOString(),
+        label: label || '',
+    }
+    registry[id] = record
+    writeRegistry(registry)
+    return { id, ...record }
+}
+
+function getSession(id) {
+    const registry = readRegistry()
+    return registry[id] ? { id, ...registry[id] } : null
+}
+
+function listSessions() {
+    const registry = readRegistry()
+    return Object.keys(registry).map((id) => ({
+        id,
+        ...registry[id],
+        alive: isPidAlive(registry[id].pid),
+    }))
+}
+
+/**
+ * Remove a session from the registry. Does NOT kill the process or
+ * delete the MEDDLE_HOME directory — caller handles those.
+ */
+function deleteSession(id) {
+    const registry = readRegistry()
+    if (!registry[id]) return null
+    const record = { id, ...registry[id] }
+    delete registry[id]
+    writeRegistry(registry)
+    return record
+}
+
+/**
+ * Remove all sessions whose pid is no longer alive. Returns the
+ * removed records. Does NOT delete their MEDDLE_HOME directories.
+ */
+function pruneOrphaned() {
+    const registry = readRegistry()
+    const removed = []
+    for (const id of Object.keys(registry)) {
+        if (!isPidAlive(registry[id].pid)) {
+            removed.push({ id, ...registry[id] })
+            delete registry[id]
+        }
+    }
+    if (removed.length > 0) writeRegistry(registry)
+    return removed
+}
+
+module.exports = {
+    MAX_SESSIONS,
+    PORT_RANGE_START,
+    PORT_RANGE_END,
+    registryPath,
+    sessionsDir,
+    sessionDir,
+    readRegistry,
+    writeRegistry,
+    allocatePort,
+    generateId,
+    isPidAlive,
+    createSession,
+    getSession,
+    listSessions,
+    deleteSession,
+    pruneOrphaned,
+}

package/dist/cert.d.ts

@@ -0,0 +1,10 @@
+declare const crtMgr: any;
+interface CAStatus {
+    exist: boolean;
+    trusted?: boolean;
+}
+export declare function getCAStatus(): Promise<CAStatus>;
+export declare function ensureRootCA(): Promise<void>;
+export declare function getRootCAPath(): string;
+export { crtMgr };
+//# sourceMappingURL=cert.d.ts.map

package/dist/cert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cert.d.ts","sourceRoot":"","sources":["../cert.ts"],"names":[],"mappings":"AAsBA,QAAA,MAAM,MAAM,KAA8B,CAAC;AA+B3C,UAAU,QAAQ;IACd,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB;AAGD,wBAAsB,WAAW,IAAI,OAAO,CAAC,QAAQ,CAAC,CAcrD;AAkED,wBAAsB,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC,CAgBlD;AAED,wBAAgB,aAAa,IAAI,MAAM,CAEtC;AAED,OAAO,EAAE,MAAM,EAAE,CAAC"}