fix: include probe-* route/service modules excluded by overly-broad gitignore

The .gitignore debug rule 'probe-*.js' was unanchored and recursively
matched src/routes/probe-*.routes.js and src/services/probe-*.service.js,
so 13 required source files were never committed. The Docker/CI container
crashed at startup with MODULE_NOT_FOUND (works on Windows due to its
case-insensitive, non-git-aware local fs). Anchored debug rules to repo
root and added the missing modules.

Author: weidu12123

.gitignore

@@ -15,12 +15,12 @@ test-results/
 __pycache__/
 
 # Debug / 临时文件
-_debug*.txt
-_debug*.js
-_rescue_logs*.txt
+/_debug*.txt
+/_debug*.js
+/_rescue_logs*.txt
 *.tmp
-probe-*.js
-fix-claude-mcp.js
+/probe-*.js
+/fix-claude-mcp.js
 
 # 部署脚本（含服务器凭据，仅本地使用）
 deploy.js

src/routes/probe-agent.routes.js

@@ -0,0 +1,220 @@
+'use strict';
+
+const express = require('express');
+const { PORT } = require('../config/env');
+
+function resolveServerUrl(req) {
+  const proto = req.headers['x-forwarded-proto'] || req.protocol || 'http';
+  const host = req.headers['x-forwarded-host'] || req.headers.host || `localhost:${PORT}`;
+  return `${proto}://${host}`.replace(/\/$/, '');
+}
+
+function parseTimeQuery(value, fallback) {
+  if (value === undefined || value === null || value === '') return fallback;
+  const numeric = Number(value);
+  if (Number.isFinite(numeric)) return numeric;
+  return new Date(String(value)).getTime();
+}
+
+function createProbeAgentPublicRouter({ probeAgentService }) {
+  const router = express.Router();
+
+  router.post('/agent/probe/register', (req, res, next) => {
+    try {
+      const result = probeAgentService.registerAgent(req.body || {});
+      res.json({ ok: true, ...result });
+    } catch (error) {
+      next(error);
+    }
+  });
+
+  router.post('/agent/probe/report', (req, res, next) => {
+    try {
+      const agent = probeAgentService.authenticateAgent(req.headers.authorization);
+      if (!agent) return res.status(401).json({ ok: false, error: 'agent token 无效' });
+      const result = probeAgentService.saveReport(agent, req.body || {});
+      return res.json({ ok: true, ...result });
+    } catch (error) {
+      next(error);
+    }
+  });
+
+  router.get('/agent/probe/commands/next', async (req, res, next) => {
+    try {
+      const agent = probeAgentService.authenticateAgent(req.headers.authorization);
+      if (!agent) return res.status(401).json({ ok: false, error: 'agent token 无效' });
+      const command = await probeAgentService.waitForNextCommand(agent);
+      if (!command) return res.status(204).end();
+      return res.json({ ok: true, command });
+    } catch (error) {
+      next(error);
+    }
+  });
+
+  router.post('/agent/probe/commands/:commandId/result', (req, res, next) => {
+    try {
+      const agent = probeAgentService.authenticateAgent(req.headers.authorization);
+      if (!agent) return res.status(401).json({ ok: false, error: 'agent token 无效' });
+      const result = probeAgentService.completeCommand(agent, req.params.commandId, req.body || {});
+      return res.json(result);
+    } catch (error) {
+      next(error);
+    }
+  });
+
+  return router;
+}
+
+function createProbeAgentAdminRouter({ probeAgentService, probeAgentInstallerService, probeAggregatorService }) {
+  const router = express.Router();
+
+  router.post('/probe-agents/:hostId/install-token', (req, res, next) => {
+    try {
+      const result = probeAgentService.generateInstallToken(req.params.hostId);
+      const serverUrl = String(req.body?.serverUrl || resolveServerUrl(req)).replace(/\/$/, '');
+      res.json({
+        ok: true,
+        ...result,
+        serverUrl,
+        config: {
+          hostId: result.hostId,
+          installToken: result.installToken,
+          serverUrl,
+          registerUrl: `${serverUrl}/api/agent/probe/register`,
+          reportUrl: `${serverUrl}/api/agent/probe/report`,
+        },
+      });
+    } catch (error) {
+      next(error);
+    }
+  });
+
+  router.post('/probe-agents/:hostId/install', async (req, res, next) => {
+    try {
+      if (!probeAgentInstallerService) return res.status(501).json({ ok: false, error: 'Agent 安装器未启用' });
+      const serverUrl = String(req.body?.serverUrl || resolveServerUrl(req)).replace(/\/$/, '');
+      const intervalSec = typeof req.body?.intervalSec === 'number' ? req.body.intervalSec : undefined;
+      const relayUpstreamId = typeof req.body?.relayUpstreamId === 'string' ? req.body.relayUpstreamId : undefined;
+      const install = await probeAgentInstallerService.install(req.params.hostId, {
+        serverUrl,
+        intervalSec,
+        relayUpstreamId,
+        clientIp: req.ip,
+      });
+      res.json({
+        ok: true,
+        hostId: install.hostId,
+        expiresAt: install.expiresAt,
+        serverUrl: install.serverUrl || serverUrl,
+        relayUpstreamId: install.relayUpstreamId,
+        result: install.result,
+      });
+    } catch (error) {
+      next(error);
+    }
+  });
+
+  router.post('/probe-agents/:hostId/uninstall', async (req, res, next) => {
+    try {
+      if (!probeAgentInstallerService) return res.status(501).json({ ok: false, error: 'Agent 安装器未启用' });
+      const result = await probeAgentInstallerService.uninstall(req.params.hostId, { clientIp: req.ip });
+      res.json({ ok: true, ...result });
+    } catch (error) {
+      next(error);
+    }
+  });
+
+  router.post('/probe-agents/:hostId/revoke', (req, res, next) => {
+    try {
+      res.json(probeAgentService.revokeAgent(req.params.hostId));
+    } catch (error) {
+      next(error);
+    }
+  });
+
+  router.post('/probe-agents/:hostId/restart', async (req, res, next) => {
+    try {
+      if (!probeAgentInstallerService) return res.status(501).json({ ok: false, error: 'Agent 安装器未启用' });
+      const result = await probeAgentInstallerService.restart(req.params.hostId, { clientIp: req.ip });
+      res.json({ ok: true, ...result });
+    } catch (error) {
+      next(error);
+    }
+  });
+
+  router.get('/probe-agents/:hostId/logs', async (req, res, next) => {
+    try {
+      if (!probeAgentInstallerService) return res.status(501).json({ ok: false, error: 'Agent 安装器未启用' });
+      const lines = parseInt(req.query.lines, 10) || 200;
+      const result = await probeAgentInstallerService.fetchLogs(req.params.hostId, { clientIp: req.ip, lines });
+      res.json({ ok: true, ...result });
+    } catch (error) {
+      next(error);
+    }
+  });
+
+  router.get('/probe-agents/:hostId/samples', (req, res, next) => {
+    try {
+      const minutes = parseInt(req.query.minutes, 10);
+      const sinceMs = Number.isFinite(minutes) && minutes > 0
+        ? Math.min(minutes, 60 * 24) * 60 * 1000
+        : 60 * 60 * 1000;
+      const samples = probeAgentService.getSampleHistory(req.params.hostId, { sinceMs });
+      res.json({ ok: true, hostId: req.params.hostId, sinceMs, samples });
+    } catch (error) {
+      next(error);
+    }
+  });
+
+  router.post('/probe-agents/samples-bulk', (req, res, next) => {
+    try {
+      const minutes = Number(req.body?.minutes);
+      const sinceMs = Number.isFinite(minutes) && minutes > 0
+        ? Math.min(minutes, 60 * 24) * 60 * 1000
+        : 60 * 60 * 1000;
+      const hostIds = Array.isArray(req.body?.hostIds) ? req.body.hostIds.filter((id) => typeof id === 'string').slice(0, 200) : [];
+      const result = {};
+      for (const hostId of hostIds) {
+        result[hostId] = probeAgentService.getSampleHistory(hostId, { sinceMs });
+      }
+      res.json({ ok: true, sinceMs, samples: result });
+    } catch (error) {
+      next(error);
+    }
+  });
+
+  router.get('/probe-agents/:hostId/timeseries', (req, res, next) => {
+    try {
+      if (!probeAggregatorService) return res.status(501).json({ ok: false, error: '聚合服务未启用' });
+      const now = Date.now();
+      const to = parseTimeQuery(req.query.to, now);
+      const from = parseTimeQuery(req.query.from, to - 24 * 60 * 60 * 1000);
+      if (!Number.isFinite(from) || !Number.isFinite(to) || from >= to) {
+        return res.status(400).json({ ok: false, error: 'from/to 参数非法' });
+      }
+      const resolution = typeof req.query.resolution === 'string' ? req.query.resolution : 'auto';
+      const result = probeAggregatorService.listTimeseries(req.params.hostId, {
+        fromMs: from,
+        toMs: to,
+        resolution,
+      });
+      res.json({
+        ok: true,
+        hostId: req.params.hostId,
+        fromMs: from,
+        toMs: to,
+        resolution: result.resolution,
+        points: result.points,
+      });
+    } catch (error) {
+      next(error);
+    }
+  });
+
+  return router;
+}
+
+module.exports = {
+  createProbeAgentAdminRouter,
+  createProbeAgentPublicRouter,
+};

src/routes/probe-alert.routes.js

@@ -0,0 +1,64 @@
+'use strict';
+
+const express = require('express');
+
+function createProbeAlertRouter({ alertService }) {
+  const router = express.Router();
+
+  router.get('/probe-alerts/rules', (req, res, next) => {
+    try {
+      res.json({ ok: true, rules: alertService.listRules() });
+    } catch (error) { next(error); }
+  });
+
+  router.post('/probe-alerts/rules', (req, res, next) => {
+    try {
+      const rule = alertService.createRule(req.body || {});
+      res.status(201).json({ ok: true, rule });
+    } catch (error) { next(error); }
+  });
+
+  router.put('/probe-alerts/rules/:id', (req, res, next) => {
+    try {
+      const rule = alertService.updateRule(req.params.id, req.body || {});
+      res.json({ ok: true, rule });
+    } catch (error) { next(error); }
+  });
+
+  router.delete('/probe-alerts/rules/:id', (req, res, next) => {
+    try {
+      alertService.deleteRule(req.params.id);
+      res.json({ ok: true });
+    } catch (error) { next(error); }
+  });
+
+  router.get('/probe-alerts/events', (req, res, next) => {
+    try {
+      const status = String(req.query.status || 'open');
+      const limit = parseInt(req.query.limit, 10);
+      const offset = parseInt(req.query.offset, 10);
+      const events = alertService.listEvents({ status, limit, offset });
+      res.json({ ok: true, events, openCount: alertService.countOpenEvents() });
+    } catch (error) { next(error); }
+  });
+
+  router.post('/probe-alerts/events/ack-all', (req, res, next) => {
+    try {
+      const result = alertService.ackOpenEvents();
+      res.json({ ok: true, ...result });
+    } catch (error) { next(error); }
+  });
+
+  router.post('/probe-alerts/events/:id/ack', (req, res, next) => {
+    try {
+      const result = alertService.ackEvent(req.params.id);
+      res.json({ ok: true, ...result });
+    } catch (error) { next(error); }
+  });
+
+  return router;
+}
+
+module.exports = {
+  createProbeAlertRouter,
+};

src/routes/probe-diag.routes.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const express = require('express');
+
+function createProbeDiagRouter({ diagService }) {
+  const router = express.Router();
+
+  function wrap(fn) {
+    return async (req, res, next) => {
+      try {
+        const result = await fn(req);
+        res.json({ ok: true, ...result });
+      } catch (error) {
+        next(error);
+      }
+    };
+  }
+
+  router.post('/probe-diag/:hostId/ping', wrap((req) => diagService.ping(req.params.hostId, {
+    target: req.body?.target,
+    count: req.body?.count,
+    timeoutSec: req.body?.timeoutSec,
+    clientIp: req.ip,
+  })));
+
+  router.post('/probe-diag/:hostId/http', wrap((req) => diagService.http(req.params.hostId, {
+    url: req.body?.url,
+    method: req.body?.method,
+    timeoutSec: req.body?.timeoutSec,
+    clientIp: req.ip,
+  })));
+
+  router.post('/probe-diag/:hostId/dns', wrap((req) => diagService.dns(req.params.hostId, {
+    name: req.body?.name,
+    clientIp: req.ip,
+  })));
+
+  return router;
+}
+
+module.exports = {
+  createProbeDiagRouter,
+};