@jonathanleelx/meddle 0.5.0-beta.9 → 0.5.1

package/index.js

@@ -120,8 +120,39 @@ const { createPluginBootstrapRunner } = require('./dist/core/plugin-bootstrap-ru
 const { openBrowserWithProxy } = require('./dist/core/browser')
 const { handleLocalRequest } = require('./dist/core/static-server')
 const { createConfigDiagnostics } = require('./dist/core/config-diagnostics')
-const { appendProxyRecord } = require('./dist/core/proxy-record')
+const { appendProxyRecord, appendUpstreamErrorRecord } = require('./dist/core/proxy-record')
 const { createRuntimeHealthMonitor, parseWatchdogConfig } = require('./dist/core/runtime-health')
+
+function previewRequestBody(reqBody) {
+    if (!reqBody) return ''
+    try {
+        if (Buffer.isBuffer(reqBody)) {
+            const slice = reqBody.length > 65536 ? reqBody.subarray(0, 65536) : reqBody
+            return slice.toString('utf8')
+        }
+        return String(reqBody)
+    } catch (_) {
+        return ''
+    }
+}
+
+/** Send 502 and put the failed request in the traffic list (issue #160). */
+function failProxyWithUpstreamError(res, info) {
+    finishResponseWithProxyError(res, info.statusCode || 502)
+    try {
+        appendUpstreamErrorRecord(ctx, {
+            method: info.method,
+            source: info.source,
+            target: info.target,
+            startTime: info.startTime || Date.now(),
+            clientIdentity: info.clientIdentity,
+            requestHeaders: info.requestHeaders,
+            requestBody: previewRequestBody(info.reqBody),
+            err: info.err,
+            statusCode: info.statusCode || 502,
+        })
+    } catch (_) {}
+}
 const { createRateLimitedLogger } = require('./dist/core/log-rate-limit')
 
 const remoteAccess = buildRemoteAccessConfig()
@@ -200,7 +231,10 @@ const { createApp } = require('./dist/server/index')
 let configDiag = null
 
 const serverContext = {
-    currentMocksPath: ctx.currentMocksPath,
+    // Issue #118: the mocks path must also live only on ctx. refresh-config
+    // reset a stale serverContext copy, so the proxy kept the old file.
+    get currentMocksPath() { return ctx.currentMocksPath },
+    set currentMocksPath(p) { ctx.currentMocksPath = p },
     routeRules: ctx.routeRules,
     ruleMap: ctx.ruleMap,
     excludeMap: ctx.excludeMap,
@@ -208,8 +242,14 @@ const serverContext = {
     proxyRecordArr: ctx.proxyRecordArr,
     proxyRecordDetailMap: ctx.proxyRecordDetailMap,
     recordIdSeq: ctx.recordIdSeq,
-    mockRules: ctx.mockRules,
-    mockIdSeq: ctx.mockIdSeq,
+    // Issue #115: mock state must live in exactly one place. Plain copies went
+    // stale because /api handlers run asynchronously (after body parsing),
+    // after handleLocalRequest had already synced serverContext -> ctx, so
+    // every quick create reused the same id and overwrote the previous rule.
+    get mockRules() { return ctx.mockRules },
+    set mockRules(rules) { ctx.mockRules = rules },
+    get mockIdSeq() { return ctx.mockIdSeq },
+    set mockIdSeq(seq) { ctx.mockIdSeq = seq },
     requestPipeline: ctx.requestPipeline,
     builtinLoggerPlugin: ctx.builtinLoggerPlugin,
     shadowCompareTracker: ctx.shadowCompareTracker,
@@ -218,6 +258,7 @@ const serverContext = {
     hookDispatcher: ctx.hookDispatcher,
     settingsPath: ctx.settingsPath,
     meddleDir: ctx.meddleDir,
+    appInfo: { name: require('./package.json').name, version: require('./package.json').version },
     settings: null,
     loadMockRules: () => {
         mockHandler.loadMockRules()
@@ -225,7 +266,10 @@ const serverContext = {
         serverContext.mockIdSeq = ctx.mockIdSeq
     },
     saveMockRules: () => mockHandler.saveMockRules(),
+    assertMocksWritable: () => mockHandler.assertMocksWritable(),
+    getMocksParseError: () => mockHandler.getMocksParseError(),
     reloadCustomPlugins: () => pluginBoot.reloadCustomPlugins(),
+    unloadCustomPlugin: (pluginId) => pluginBoot.unloadCustomPlugin(pluginId),
     logRuleMap: () => routeLoader.logRuleMap(),
     reloadAllRuleFiles: () => routeLoader.reloadAllRuleFiles(),
     broadcastToAllClients: (data) => {
@@ -264,7 +308,20 @@ const expressApp = createApp(serverContext)
 
 // ===== 加载 Mock 和路由规则 =====
 serverContext.loadMockRules()
+{
+    // Issue #121: relative mocksFilePath now resolves against MEDDLE_HOME; warn once
+    // if the file only exists under the old rule (start directory). No auto-migration.
+    const { detectLegacyMocksPath, readConfiguredMocksPath, formatLegacyMocksNotice } = require('./dist/core/mock-handler')
+    const legacy = detectLegacyMocksPath(readConfiguredMocksPath(ctx.settingsPath), ctx.meddleDir)
+    if (legacy) console.warn(formatLegacyMocksNotice(legacy))
+}
 routeLoader.initRouteRules()
+// Hot-reload mocks when the file is edited externally (CLI file-mode / hand edit). Issue #85.
+mockHandler.initMockFileWatcher(() => {
+    serverContext.mockRules = ctx.mockRules
+    serverContext.mockIdSeq = ctx.mockIdSeq
+    serverContext.broadcastToAllClients({ type: 'mocksUpdated', rules: ctx.mockRules })
+})
 
 // ===== Cross-Origin 插件 =====
 const plugins = [{
@@ -400,6 +457,24 @@ const proxyServer = http.createServer(async (req, res) => {
         const url = new URL(target.startsWith('http') ? target : req.url, 'http://' + req.headers.host)
         const routeChanged = source !== url.href
         const startTime = Date.now()
+        let upstreamFailureRecorded = false
+        const failUpstream = (err) => {
+            if (upstreamFailureRecorded) {
+                finishResponseWithProxyError(res)
+                return
+            }
+            upstreamFailureRecorded = true
+            failProxyWithUpstreamError(res, {
+                method: req.method,
+                source,
+                target: url.href,
+                startTime,
+                clientIdentity,
+                requestHeaders: req.headers,
+                reqBody,
+                err,
+            })
+        }
         const proxyReq = http.request(url, { method: req.method, headers: stripProxyHeaders(req.headers) }, (proxyRes) => {
             const resChunks = []
             const pluginResponseInterception = pluginIntercept.shouldInterceptResponse()
@@ -411,7 +486,7 @@ const proxyServer = http.createServer(async (req, res) => {
                 proxyResponseSettled = true
                 pluginIntercept.emitLegacyErrorToPlugins('onBeforeResponse', err)
                 logRuntimeError(`http:proxy-response:${getErrorKey(err)}`, 'HTTP proxy response error:', getErrorMessage(err))
-                finishResponseWithProxyError(res)
+                failUpstream(err)
             }
             if (routeChanged) proxyRes.headers['x-real-url'] = url.href
             if (!intercepting) res.writeHead(proxyRes.statusCode, proxyRes.headers)
@@ -474,7 +549,7 @@ const proxyServer = http.createServer(async (req, res) => {
                 } catch (err) {
                     pluginIntercept.emitLegacyErrorToPlugins('onBeforeResponse', err)
                     logRuntimeError(`http:response-handler:${getErrorKey(err)}`, 'HTTP proxy response handling error:', getErrorMessage(err))
-                    finishResponseWithProxyError(res)
+                    failUpstream(err)
                 }
             })
         })
@@ -490,14 +565,22 @@ const proxyServer = http.createServer(async (req, res) => {
             } else {
                 logRuntimeError(`http:proxy-request:${getErrorKey(err)}`, 'HTTP proxy error:', getErrorMessage(err))
             }
-            finishResponseWithProxyError(res)
+            failUpstream(err)
         })
         proxyReq.write(reqBody)
         proxyReq.end()
         } catch (err) {
             pluginIntercept.emitLegacyErrorToPlugins('onBeforeResponse', err)
             logRuntimeError(`http:request-handler:${getErrorKey(err)}`, 'HTTP proxy request failed:', getErrorMessage(err))
-            finishResponseWithProxyError(res)
+            failProxyWithUpstreamError(res, {
+                method: req.method,
+                source,
+                target: source,
+                startTime: Date.now(),
+                clientIdentity,
+                requestHeaders: req.headers,
+                err,
+            })
         }
     })
 })
@@ -523,7 +606,7 @@ localWSServer.on('connection', (client, req) => {})
     await ensureRootCA({ trustCheckAsync: true })
     await pluginBoot.bootstrapBuiltinPlugins()
     const port = await getFreePort()
-    proxyServer.listen(port, remoteAccess.bindHost, () => {
+    proxyServer.listen(port, remoteAccess.bindHost, async () => {
         const proxyUrl = `http://127.0.0.1:${port}`
         console.log(chalk.green('代理服务器已启动:'), chalk.cyan(proxyUrl))
         proxyDebug('proxy-server start on ' + chalk.green(proxyUrl))
@@ -531,16 +614,19 @@ localWSServer.on('connection', (client, req) => {})
         if (ctx.requestPipeline.mode === 'on') {
             proxyDebug('plugin on host allowlist: ' + (ctx.PLUGIN_ON_HOSTS.size > 0 ? Array.from(ctx.PLUGIN_ON_HOSTS).join(',') : '(all)'))
         }
-        if (process.env.MEDDLE_MCP) {
+        // Always write probe file so CLI can find this instance (issue #85).
+        // Previously only wrote under MEDDLE_MCP, leaving stale ports after normal starts.
+        {
             const mcpFile = path.join(ctx.meddleDir, 'mcp-proxy-url.json')
-            const mcpData = { proxyUrl }
+            const mcpData = { proxyUrl, pid: process.pid, startedAt: new Date().toISOString() }
             if (process.env.MEDDLE_OPEN_CHROMEDEVTOOLS) mcpData.remoteDebuggingPort = 9222
             fs.writeFileSync(mcpFile, JSON.stringify(mcpData), 'utf8')
         }
         if (ctx.AUTO_OPEN) {
             const proxyAddr = `127.0.0.1:${port}`
             const remotePort = process.env.MEDDLE_OPEN_CHROMEDEVTOOLS ? 9222 : undefined
-            if (openBrowserWithProxy(proxyUrl, proxyAddr, ctx.meddleDir, remotePort)) {
+            const opened = await openBrowserWithProxy(proxyUrl, proxyAddr, ctx.meddleDir, remotePort).catch(() => false)
+            if (opened) {
                 console.log(chalk.green('已启动浏览器（代理:'), proxyAddr + chalk.green(')'))
             } else {
                 console.log(chalk.yellow('浏览器并未启动，请手动打开'), chalk.cyan(proxyUrl), chalk.yellow('并设置代理'), proxyAddr)
@@ -661,6 +747,24 @@ proxyServer.on('connect', async (req, socket, head) => {
 
                         const routeChanged = source !== target
                         const startTime = Date.now()
+                        let upstreamFailureRecorded = false
+                        const failUpstream = (err) => {
+                            if (upstreamFailureRecorded) {
+                                finishResponseWithProxyError(res)
+                                return
+                            }
+                            upstreamFailureRecorded = true
+                            failProxyWithUpstreamError(res, {
+                                method: req.method,
+                                source,
+                                target,
+                                startTime,
+                                clientIdentity: requestClientIdentity,
+                                requestHeaders: req.headers,
+                                reqBody,
+                                err,
+                            })
+                        }
                         try {
                             const proxyRes = await makeProxyRequest(target, req.method, stripProxyHeaders(req.headers), reqBody)
                             const resChunks = []
@@ -673,7 +777,7 @@ proxyServer.on('connect', async (req, socket, head) => {
                                 proxyResponseSettled = true
                                 pluginIntercept.emitLegacyErrorToPlugins('onBeforeResponse', err)
                                 logRuntimeError(`https:upstream-stream:${originHost}:${getErrorKey(err)}`, '[proxy] upstream stream %s: %s', originHost + req.url, getErrorMessage(err))
-                                finishResponseWithProxyError(res)
+                                failUpstream(err)
                             }
                             if (routeChanged) proxyRes.headers['x-real-url'] = target
                             if (!intercepting) res.writeHead(proxyRes.statusCode, cleanHeadersForH2(proxyRes.headers))
@@ -737,7 +841,7 @@ proxyServer.on('connect', async (req, socket, head) => {
                                 } catch (err) {
                                     pluginIntercept.emitLegacyErrorToPlugins('onBeforeResponse', err)
                                     logRuntimeError(`https:response-handler:${originHost}:${getErrorKey(err)}`, '[proxy] upstream response handling %s: %s', originHost + req.url, getErrorMessage(err))
-                                    finishResponseWithProxyError(res)
+                                    failUpstream(err)
                                 }
                             })
                         } catch (err) {
@@ -751,12 +855,20 @@ proxyServer.on('connect', async (req, socket, head) => {
                                 logRuntimeError(`https:upstream:${originHost}:${getErrorKey(err)}`, '[proxy] upstream %s: %s', originHost + req.url, getErrorMessage(err))
                             }
                             pluginIntercept.emitLegacyErrorToPlugins('onBeforeResponse', err)
-                            finishResponseWithProxyError(res)
+                            failUpstream(err)
                         }
                         } catch (err) {
                             pluginIntercept.emitLegacyErrorToPlugins('onBeforeResponse', err)
                             logRuntimeError(`https:request-handler:${originHost}:${getErrorKey(err)}`, '[proxy] HTTPS request handling %s: %s', originHost + req.url, getErrorMessage(err))
-                            finishResponseWithProxyError(res)
+                            failProxyWithUpstreamError(res, {
+                                method: req.method,
+                                source,
+                                target: source,
+                                startTime: Date.now(),
+                                clientIdentity: requestClientIdentity,
+                                requestHeaders: req.headers,
+                                err,
+                            })
                         }
                     })
                 })