@winspan/claude-forge 8.41.0 → 8.51.0

package/src/web/routes/static.ts

@@ -0,0 +1,67 @@
+import express from 'express';
+import type { Application } from 'express';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { logger } from '../../core/utils/logger.js';
+import type { RouteContext } from './types.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+function findStaticDir(): string | null {
+  const candidates = [
+    path.join(__dirname, '..', 'static'),           // dist/web/routes -> dist/web/static
+    path.join(__dirname, '../../..', 'src/web/static'), // dev: src/web/routes -> src/web/static
+  ];
+  return candidates.find(d => fs.existsSync(d)) ?? null;
+}
+
+/**
+ * Static assets — Vite-built UI + cache headers + SPA fallback.
+ *
+ * index.html: no-cache (always fetch latest, avoids stale UI after deploy)
+ * /assets/*:  immutable, content-hashed, safe to cache for a year.
+ *
+ * SPA fallback MUST be registered last so it doesn't shadow any API route;
+ * that constraint is enforced by splitting into `registerStaticAssets` (runs
+ * early, sets up express.static) and `registerStaticFallback` (runs last).
+ */
+export function registerStaticAssets(app: Application, _ctx: RouteContext): void {
+  const staticDir = findStaticDir();
+  if (!staticDir) {
+    logger.warn('[Web] Static directory not found; UI will not be served.');
+    return;
+  }
+
+  app.use(express.static(staticDir, {
+    setHeaders: (res, filePath) => {
+      if (filePath.endsWith('index.html')) {
+        res.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate');
+        res.setHeader('Pragma', 'no-cache');
+        res.setHeader('Expires', '0');
+      } else if (filePath.includes('/assets/')) {
+        res.setHeader('Cache-Control', 'public, max-age=31536000, immutable');
+      }
+    },
+  }));
+
+  app.get('/', (_req, res) => {
+    res.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate');
+    res.sendFile('index.html', { root: staticDir });
+  });
+
+  logger.info(`[Web] Serving static files from ${staticDir}`);
+}
+
+/**
+ * SPA catch-all — must be registered last. Routes any non-/api path to
+ * index.html so the frontend router handles deep links on refresh.
+ */
+export function registerStaticFallback(app: Application, _ctx: RouteContext): void {
+  const staticDir = findStaticDir();
+  if (!staticDir) return;
+  app.get(/^(?!\/api).*$/, (_req, res) => {
+    res.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate');
+    res.sendFile('index.html', { root: staticDir });
+  });
+}

package/src/web/routes/stats.ts

@@ -0,0 +1,50 @@
+import type { Application } from 'express';
+import type { RouteContext } from './types.js';
+
+/**
+ * /api/stats — System-wide statistics for the Dashboard.
+ *
+ * H2 Phase 3: 替换原 db.prepare 直写 SQL 为 SQLiteStorage facade 聚合方法。
+ * 响应 shape 保持不变（前端契约）：totalSessions / totalEvents / toolUsage /
+ * dailyActivity / skillInvocations。
+ */
+export function registerStatsRoutes(app: Application, ctx: RouteContext): void {
+  const { storage } = ctx;
+
+  app.get('/api/stats', (_req, res) => {
+    const totalEvents = storage.countAllEvents();
+    const totalSessions = storage.countAllSessions();
+
+    // Tool usage distribution (top 15)
+    const toolRows = storage.aggregateToolUsage({ limit: 15 });
+    const toolUsage: Record<string, number> = {};
+    for (const r of toolRows) {
+      toolUsage[r.tool_name] = r.count;
+    }
+
+    // Daily activity (last 7 days)
+    // 旧 SQL: timestamp >= date('now', '-7 days')
+    // 新口径：调用方计算 ISO 字符串，传给 facade。
+    const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString();
+    const dailyRows = storage.aggregateDailyEventCounts({ since: sevenDaysAgo });
+    const sessionDailyRows = storage.aggregateDailySessionCounts({ since: sevenDaysAgo });
+
+    const sessionMap = new Map(sessionDailyRows.map(r => [r.date, r.count]));
+    const dailyActivity = dailyRows.map(r => ({
+      date: r.date,
+      eventCount: r.count,
+      sessionCount: sessionMap.get(r.date) || 0,
+    }));
+
+    // Skill invocation count
+    const skillCount = storage.countAllSkillInvocations();
+
+    res.json({
+      totalSessions,
+      totalEvents,
+      toolUsage,
+      dailyActivity,
+      skillInvocations: skillCount,
+    });
+  });
+}

package/src/web/routes/status.ts

@@ -0,0 +1,30 @@
+import type { Application } from 'express';
+import type { RouteContext } from './types.js';
+
+/**
+ * Status / health endpoints for the daemon and background worker.
+ */
+export function registerStatusRoutes(app: Application, ctx: RouteContext): void {
+  const { storage } = ctx;
+
+  // Worker auth probe: legacy endpoint kept for UI backwards-compat.
+  // The background worker subsystem was removed alongside the methodology
+  // system (v8.36.0 hard deprecation B.1); the probe now always reports
+  // unavailable so the UI hides background-mode affordances.
+  app.get('/api/worker-auth-status', (_req, res) => {
+    res.json({
+      available: false,
+      reason: 'background worker subsystem removed (methodology deprecation)',
+    });
+  });
+
+  // Dashboard: daemon status
+  app.get('/api/status', (_req, res) => {
+    res.json({
+      pid: process.pid,
+      uptime: process.uptime(),
+      memory: process.memoryUsage(),
+      eventCount: storage.countEvents(),
+    });
+  });
+}

package/src/web/routes/tasks.ts

@@ -0,0 +1,193 @@
+import { z } from 'zod';
+import type { Application } from 'express';
+import type { RouteContext } from './types.js';
+import { truncateField } from './_helpers.js';
+import { getFilePath, getUserPrompt } from '../../core/event-fields.js';
+
+/**
+ * /api/tasks — Task execution view.
+ *
+ * Provides a complete view of a task's execution process:
+ *   - GET /api/tasks          — list + filter + paginate tasks
+ *   - GET /api/tasks/projects — distinct project paths that have tasks
+ *   - GET /api/tasks/:taskId  — full execution detail for a single task
+ */
+
+const TaskListQuery = z.object({
+  limit:   z.coerce.number().int().min(1).default(50).transform(v => Math.min(v, 200)),
+  offset:  z.coerce.number().int().min(0).default(0),
+  /** multi-value: ?project=/a&project=/b  OR  ?project=/a */
+  project: z.union([z.string(), z.array(z.string())]).optional(),
+  from:    z.string().optional(),
+  to:      z.string().optional(),
+  search:  z.string().max(100).optional(),
+  session: z.string().optional(),
+});
+
+export function registerTasksRoutes(app: Application, ctx: RouteContext): void {
+  const { storage } = ctx;
+
+  // ── GET /api/tasks/projects — distinct project paths ──────────────────────
+  // Must be registered BEFORE /:taskId to avoid 'projects' being treated as an id.
+  app.get('/api/tasks/projects', (_req, res) => {
+    const projects = storage.queryTaskProjects();
+    res.json(projects);
+  });
+
+  // ── GET /api/tasks — paginated + filtered list ─────────────────────────────
+  app.get('/api/tasks', (req, res) => {
+    const parsed = TaskListQuery.safeParse(req.query);
+    if (!parsed.success) {
+      res.status(400).json({ error: 'Invalid query parameters', details: parsed.error.flatten() });
+      return;
+    }
+
+    const { limit, offset, project, from, to, search, session } = parsed.data;
+
+    const result = storage.queryTasksFiltered({
+      limit,
+      offset,
+      project,
+      from,
+      to,
+      search,
+      session_id: session,
+    });
+
+    res.json(result);
+  });
+
+  // ── GET /api/tasks/:taskId — full execution detail ─────────────────────────
+  app.get('/api/tasks/:taskId', (req, res) => {
+    const taskId = req.params.taskId;
+
+    // H1: PK direct fetch (was: queryTasks({limit:5000}).find)
+    const task = storage.getTask(taskId);
+    if (!task) {
+      res.status(404).json({ error: 'Task not found' });
+      return;
+    }
+
+    // H1: JOIN task_events (was: queryEvents({limit:5000}) + Set.has filter)
+    const taskEvents = storage.queryEventsByTaskId(taskId, { limit: 5000 });
+
+    // ── Injections ──────────────────────────────────────────────────────
+    // H1: JOIN task_events (was: queryInjections({limit:500}) + Set.has filter)
+    const allInjections = storage.queryInjectionsByTaskId(taskId);
+    const injections = allInjections
+      .map(inj => ({
+        id: inj.id,
+        timestamp: inj.timestamp,
+        source_handler: inj.source_handler,
+        injection_type: inj.injection_type,
+        content: inj.content.slice(0, 1000),
+        content_length: inj.content.length,
+        truncated: inj.content.length > 1000,
+      }));
+
+    // ── Timeline ────────────────────────────────────────────────────────
+    const timeline = taskEvents
+      .filter(e => e.tool_name && (e.hook_type === 'PreToolUse' || e.hook_type === 'PostToolUse'))
+      .reduce<Array<{
+        timestamp: string;
+        tool_name: string;
+        hook_type: string;
+        input: unknown;
+        output: unknown;
+        is_agent_call: boolean;
+        agent_detail?: { subagent_type?: string; name?: string; prompt?: string };
+      }>>((acc, e) => {
+        // Deduplicate: only keep PreToolUse entries (PostToolUse is supplementary)
+        if (e.hook_type === 'PostToolUse') {
+          // Attach output to the matching PreToolUse entry if exists
+          const pre = acc.find(
+            a => a.tool_name === e.tool_name && !a.output && a.timestamp <= e.timestamp,
+          );
+          if (pre) {
+            pre.output = truncateField(e.tool_output);
+          }
+          return acc;
+        }
+
+        const toolInput = e.tool_input ?? null;
+        const isAgentCall = e.tool_name === 'Agent' || e.tool_name === 'Task';
+
+        const entry: (typeof acc)[number] = {
+          timestamp: e.timestamp,
+          tool_name: e.tool_name!,
+          hook_type: e.hook_type,
+          input: truncateField(toolInput),
+          output: truncateField(e.tool_output),
+          is_agent_call: isAgentCall,
+        };
+
+        if (isAgentCall && toolInput) {
+          entry.agent_detail = {
+            subagent_type: typeof toolInput.subagent_type === 'string' ? toolInput.subagent_type : undefined,
+            name: typeof toolInput.name === 'string' ? toolInput.name : undefined,
+            prompt: typeof toolInput.prompt === 'string'
+              ? toolInput.prompt
+              : undefined,
+          };
+        }
+
+        acc.push(entry);
+        return acc;
+      }, []);
+
+    // ── Skill Invocations ───────────────────────────────────────────────
+    // H1: SQL window filter (was: querySkillInvocations({limit:200}) + JS time filter)
+    const allSkillInvocations = storage.querySkillInvocationsByTaskWindow(taskId);
+
+    const skillInvocations = allSkillInvocations
+      .map(si => ({
+        id: si.id,
+        skill_id: si.skill_id,
+        agent_id: si.agent_id,
+        invocation_type: si.invocation_type,
+        reason: si.reason,
+        workflow: si.workflow,
+        phase: si.phase,
+        feature_slug: si.feature_slug,
+        success: si.success === 1,
+        error: si.error,
+        timestamp: si.timestamp,
+      }));
+
+    // ── Artifacts ───────────────────────────────────────────────────────
+    const artifacts = [...new Set(
+      taskEvents
+        .filter(e =>
+          (e.tool_name === 'Edit' || e.tool_name === 'Write') &&
+          getFilePath(e),
+        )
+        .map(e => getFilePath(e)!),
+    )];
+
+    // ── User Prompts ────────────────────────────────────────────────────
+    const userPrompts = taskEvents
+      .filter(e => e.hook_type === 'UserPromptSubmit' && getUserPrompt(e))
+      .map(e => ({
+        timestamp: e.timestamp,
+        content: getUserPrompt(e),
+      }));
+
+    res.json({
+      task: {
+        id: task.id,
+        session_id: task.session_id,
+        title: task.title,
+        description: task.description,
+        start_time: task.start_time,
+        end_time: task.end_time,
+        status: task.status,
+        event_count: task.event_count,
+      },
+      userPrompts,
+      injections,
+      timeline,
+      skillInvocations,
+      artifacts,
+    });
+  });
+}

package/src/web/routes/token-usage.ts

@@ -0,0 +1,20 @@
+import type { Application } from 'express';
+import type { RouteContext } from './types.js';
+
+/**
+ * /api/token-usage/* — token usage queries by session.
+ */
+export function registerTokenUsageRoutes(app: Application, ctx: RouteContext): void {
+  const { storage } = ctx;
+
+  app.get('/api/token-usage/session/:sessionId', (req, res) => {
+    const sessionId = req.params.sessionId;
+    try {
+      const usage = storage.getTokenUsageBySession(sessionId);
+      const details = storage.listTokenUsage({ session_id: sessionId, limit: 100 });
+      res.json({ ...usage, details });
+    } catch (err) {
+      res.status(500).json({ error: String(err) });
+    }
+  });
+}

package/src/web/routes/trace.ts

@@ -0,0 +1,126 @@
+/**
+ * /api/trace/:commit — Trace a git commit to its forge session(s).
+ *
+ * Reads git notes from the project directory to find associated session IDs,
+ * then queries storage for session details.
+ */
+
+import type { Application } from 'express';
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import type { RouteContext } from './types.js';
+
+export function registerTraceRoutes(app: Application, ctx: RouteContext): void {
+  const { storage } = ctx;
+
+  app.get('/api/trace/:commit', (req, res) => {
+    const commitRef = req.params.commit;
+    const projectPath = req.query.project as string | undefined;
+
+    if (!projectPath) {
+      res.status(400).json({ error: 'Query parameter "project" is required' });
+      return;
+    }
+
+    // Security: validate projectPath to prevent command injection
+    // 1. Must be an absolute path
+    if (!path.isAbsolute(projectPath)) {
+      res.status(400).json({ error: 'Project path must be absolute' });
+      return;
+    }
+
+    // 2. Must exist and be a directory
+    try {
+      const stats = fs.statSync(projectPath);
+      if (!stats.isDirectory()) {
+        res.status(400).json({ error: 'Project path must be a directory' });
+        return;
+      }
+    } catch {
+      res.status(400).json({ error: 'Project path does not exist' });
+      return;
+    }
+
+    // 3. Must contain a .git directory
+    const gitDir = path.join(projectPath, '.git');
+    if (!fs.existsSync(gitDir)) {
+      res.status(400).json({ error: 'Project path is not a git repository' });
+      return;
+    }
+
+    // 1. Resolve commit hash
+    let commitHash: string;
+    let commitMessage: string;
+    try {
+      commitHash = execFileSync('git', ['rev-parse', commitRef], {
+        cwd: projectPath, stdio: 'pipe', timeout: 5000,
+      }).toString().trim();
+    } catch {
+      res.status(404).json({ error: `Cannot resolve commit "${commitRef}"` });
+      return;
+    }
+
+    try {
+      commitMessage = execFileSync('git', ['log', '-1', '--format=%s', commitHash], {
+        cwd: projectPath, stdio: 'pipe', timeout: 5000,
+      }).toString().trim();
+    } catch {
+      commitMessage = '';
+    }
+
+    // 2. Read git notes
+    let noteContent: string;
+    try {
+      noteContent = execFileSync('git', ['notes', 'show', commitHash], {
+        cwd: projectPath, stdio: 'pipe', timeout: 5000,
+      }).toString().trim();
+    } catch {
+      res.json({ commit: commitHash, message: commitMessage, sessions: [] });
+      return;
+    }
+
+    // 3. Parse session IDs
+    const sessionIds = noteContent
+      .split('\n')
+      .filter(line => line.startsWith('forge-session:'))
+      .map(line => line.replace('forge-session:', '').trim());
+
+    if (sessionIds.length === 0) {
+      res.json({ commit: commitHash, message: commitMessage, sessions: [] });
+      return;
+    }
+
+    // 4. Query session details
+    // H2 Phase 3: 改用 facade 聚合方法，消除 db.prepare 直写。
+    const allSessions = storage.querySessions({ limit: 5000 });
+    const sessionDetails = sessionIds.map(sid => {
+      const session = allSessions.find(s => s.session_id === sid || s.session_id.startsWith(sid));
+      if (!session) return { session_id: sid, found: false };
+
+      const fullId = session.session_id;
+      const start = new Date(session.start_time);
+      const end = new Date(session.end_time);
+      const durationMin = Math.round((end.getTime() - start.getTime()) / 60000);
+
+      const eventBreakdown = storage.aggregateHookTypeBySession(fullId);
+      const agentRows = storage.aggregateAgentTypeBySession(fullId);
+      const skillIds = storage.queryDistinctSkillIdsBySession(fullId);
+
+      return {
+        session_id: fullId,
+        found: true,
+        first_prompt: session.first_prompt,
+        start_time: session.start_time,
+        end_time: session.end_time,
+        duration_min: durationMin,
+        event_count: session.event_count,
+        event_breakdown: Object.fromEntries(eventBreakdown.map(r => [r.hook_type, r.count])),
+        agent_calls: agentRows.filter(r => r.agent_type).map(r => ({ type: r.agent_type, count: r.count })),
+        skills: skillIds,
+      };
+    });
+
+    res.json({ commit: commitHash, message: commitMessage, sessions: sessionDetails });
+  });
+}

package/src/web/routes/types.ts

@@ -0,0 +1,57 @@
+/**
+ * Shared types & helpers for route modules.
+ */
+
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+import { homedir } from 'os';
+import type { SQLiteStorage } from '../../core/storage/sqlite.js';
+import type { SkillRegistry } from '../../skills/registry.js';
+import { FORGE_PATHS } from '../../core/constants.js';
+
+export interface RouteContext {
+  storage: SQLiteStorage;
+  skillRegistry?: SkillRegistry;
+}
+
+/**
+ * Resolve the concrete on-disk path + backup dir for a patchable target.
+ */
+export function resolvePatchTarget(
+  targetType: string,
+  targetName: string,
+): { filePath: string; backupDir: string } {
+  // Security: prevent path traversal attacks
+  if (!targetName || targetName.includes('/') || targetName.includes('\\') || targetName.includes('..')) {
+    throw new Error('Invalid target name: path traversal detected');
+  }
+
+  if (targetType === 'skill') {
+    return {
+      filePath: path.join(homedir(), '.claude', 'skills', `${targetName}.md`),
+      backupDir: FORGE_PATHS.backups('skills'),
+    };
+  }
+  if (targetType === 'routing_rule') {
+    return {
+      filePath: FORGE_PATHS.routingYaml(),
+      backupDir: FORGE_PATHS.backups('routing'),
+    };
+  }
+  throw new Error(`Unsupported targetType: ${targetType}`);
+}
+
+/**
+ * Locate the static assets directory.
+ */
+export function resolveStaticDir(moduleUrl: string): string | null {
+  const dir = path.dirname(fileURLToPath(moduleUrl));
+  const candidates = [
+    path.join(dir, '..', 'static'),
+    path.join(dir, '../../../src/web/static'),
+    path.join(dir, '../static'),
+    path.join(dir, '../../src/web/static'),
+  ];
+  return candidates.find(d => fs.existsSync(d)) ?? null;
+}

package/src/web/server.ts

@@ -0,0 +1,134 @@
+/**
+ * Web API server — Express entry for the Forge dashboard.
+ *
+ * server.ts is intentionally thin: it wires middleware, composes the route
+ * modules under src/web/routes/, and owns lifecycle (start/stop).
+ */
+
+import express from 'express';
+import type { SQLiteStorage } from '../core/storage/sqlite.js';
+import type { SkillRegistry } from '../skills/registry.js';
+import type { InvocationGuard } from '../skills/invocation-guard.js';
+import { logger } from '../core/utils/logger.js';
+import { ErrorHandler } from '../core/utils/error-handler.js';
+import { requireAuth } from './auth-middleware.js';
+import { mountMcpServer } from '../mcp/server.js';
+import { errorHandler, notFoundHandler } from './routes/error-handler.js';
+
+import type { RouteContext } from './routes/types.js';
+import { registerAuthRoutes } from './routes/auth.js';
+import { registerStaticAssets, registerStaticFallback } from './routes/static.js';
+import { registerStatusRoutes } from './routes/status.js';
+import { registerEventsRoutes } from './routes/events.js';
+import { registerSessionsRoutes } from './routes/sessions.js';
+import { registerTokenUsageRoutes } from './routes/token-usage.js';
+import { registerAIRoutes } from './routes/ai.js';
+import { registerPatchRoutes } from './routes/patch.js';
+import { registerSkillsRoutes } from './routes/skills.js';
+import { registerTasksRoutes } from './routes/tasks.js';
+import { registerStatsRoutes } from './routes/stats.js';
+import { registerSkillStatsRoutes } from './routes/skill-stats.js';
+import { registerRulesRoutes } from './routes/rules.js';
+import { registerDriftRoutes } from './routes/drift.js';
+import { registerTraceRoutes } from './routes/trace.js';
+import { registerReportsRoutes } from './routes/reports.js';
+import { registerInsightsRoutes } from './routes/insights.js';
+
+export interface WebServerOptions {
+  port: number;
+  storage: SQLiteStorage;
+  skillRegistry?: SkillRegistry;
+  invocationGuard?: InvocationGuard;
+}
+
+export class WebServer {
+  private app: express.Application;
+  private server: ReturnType<express.Application['listen']> | null = null;
+
+  constructor(private options: WebServerOptions) {
+    this.app = express();
+
+    // Security: limit request body size to prevent DoS attacks
+    this.app.use(express.json({ limit: '10mb' }));
+    this.app.use(express.urlencoded({ extended: true, limit: '10mb' }));
+
+    this.setupRoutes();
+  }
+
+  private setupRoutes(): void {
+    this.app.use('/api', (req, res, next) => {
+      if (req.method === 'GET') return next();
+      return requireAuth(req, res, next);
+    });
+
+    const ctx: RouteContext = {
+      storage: this.options.storage,
+      skillRegistry: this.options.skillRegistry,
+    };
+
+    // 1. Auth bootstrap
+    registerAuthRoutes(this.app, ctx);
+
+    // 2. Static assets (serves UI; fallback registered last)
+    registerStaticAssets(this.app, ctx);
+
+    // 3. API routes
+    registerStatusRoutes(this.app, ctx);
+    registerEventsRoutes(this.app, ctx);
+    registerSessionsRoutes(this.app, ctx);
+    registerTokenUsageRoutes(this.app, ctx);
+    registerAIRoutes(this.app, ctx);
+    registerPatchRoutes(this.app, ctx);
+    registerSkillsRoutes(this.app, ctx);
+    registerTasksRoutes(this.app, ctx);
+    registerStatsRoutes(this.app, ctx);
+    registerSkillStatsRoutes(this.app, ctx);
+    registerRulesRoutes(this.app, ctx);
+    registerDriftRoutes(this.app, ctx);
+    registerTraceRoutes(this.app, ctx);
+    registerReportsRoutes(this.app, ctx);
+    registerInsightsRoutes(this.app, ctx);
+
+    // 4. MCP server — mounted on /mcp (Streamable HTTP)
+    if (this.options.skillRegistry) {
+      mountMcpServer(this.app, {
+        skillRegistry: this.options.skillRegistry,
+        storage: this.options.storage,
+        guard: this.options.invocationGuard,
+      });
+    } else {
+      logger.warn('[MCP] Skipped mounting: skillRegistry not provided');
+    }
+
+    // 5. SPA catch-all — must be LAST
+    registerStaticFallback(this.app, ctx);
+
+    // 6. Error handlers — must be AFTER all routes
+    this.app.use(notFoundHandler);
+    this.app.use(errorHandler);
+  }
+
+  async start(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      this.server = this.app.listen(this.options.port, () => {
+        logger.info(`[Web] Server started on port ${this.options.port}`);
+        resolve();
+      });
+
+      this.server?.on('error', (error: any) => {
+        if (error.code === 'EADDRINUSE') {
+          ErrorHandler.handle(error, 'Web Server');
+        }
+        reject(error);
+      });
+    });
+  }
+
+  async stop(): Promise<void> {
+    if (this.server) {
+      return new Promise(resolve => {
+        this.server!.close(() => resolve());
+      });
+    }
+  }
+}