@blackbelt-technology/pi-agent-dashboard 0.3.0 → 0.4.0

package/packages/server/src/routes/system-routes.ts

@@ -5,6 +5,7 @@ import type { FastifyInstance } from "fastify";
 import type { SessionManager } from "../memory-session-manager.js";
 import type { PreferencesStore } from "../preferences-store.js";
 import type { MetaPersistence } from "../meta-persistence.js";
+import type { DirectoryService } from "../directory-service.js";
 import type { ServerConfig } from "../server.js";
 import type { ApiResponse } from "@blackbelt-technology/pi-dashboard-shared/types.js";
 import type { NetworkGuard } from "./route-deps.js";
@@ -12,7 +13,8 @@ import { detectEditors, EDITORS } from "../editor-registry.js";
 import { detectCodeServerBinary, resetDetectionCache } from "../editor-detection.js";
 import { readConfigRedacted, writeConfigPartial } from "../config-api.js";
 import { createTunnel, deleteTunnel, getTunnelStatus } from "../tunnel.js";
-import { spawn } from "node:child_process";
+import { spawnRestart } from "../restart-helper.js";
+import { spawn } from "@blackbelt-technology/pi-dashboard-shared/platform/exec.js";
 import path from "node:path";
 import os from "node:os";
 import { localhostGuard, netmaskToCidrBits, networkAddress } from "../localhost-guard.js";
@@ -27,9 +29,10 @@ export function registerSystemRoutes(
     config: ServerConfig;
     networkGuard: NetworkGuard;
     version?: string;
+    directoryService?: DirectoryService;
   },
 ) {
-  const { sessionManager, preferencesStore, metaPersistence, config, networkGuard, version } = deps;
+  const { sessionManager, preferencesStore, metaPersistence, config, networkGuard, version, directoryService } = deps;
   const serverStartTime = Date.now();
 
   // Editor detection endpoint
@@ -127,6 +130,9 @@ export function registerSystemRoutes(
           await (fastify as any)._reloadAuth(reloaded.auth);
         }
       }
+      if (partial.openspec !== undefined && directoryService) {
+        directoryService.reconfigurePolling(reloaded.openspec);
+      }
 
       return { success: true, restartRequired: result.restartRequired };
     },
@@ -213,42 +219,23 @@ export function registerSystemRoutes(
 
       // Find the TypeScript loader from process.execArgv (--import <loader>)
       const importIdx = process.execArgv.indexOf("--import");
-      const loaderArgs = importIdx >= 0 ? ["--import", process.execArgv[importIdx + 1]] : [];
+      const loader = importIdx >= 0 ? (process.execArgv[importIdx + 1] ?? "") : "";
 
       // Allow overriding dev mode via request body
       const useDev = request.body?.dev ?? config.dev;
-      const args = ["start"];
-      if (useDev) args.push("--dev");
-
-      // Spawn a shell script that:
-      // 1. Waits for the old server's port to be free (up to 10s)
-      // 2. Starts the new server
-      // 3. Verifies health (up to 10s)
-      // 4. If health check fails, logs error
-      const port = config.port;
-      const nodeCmd = `${JSON.stringify(process.execPath)} ${loaderArgs.map(a => JSON.stringify(a)).join(" ")} ${JSON.stringify(cliPath)} ${args.join(" ")}`;
-      const script = [
-        // Wait for port to be free
-        `for i in $(seq 1 20); do`,
-        `  lsof -i :${port} -sTCP:LISTEN >/dev/null 2>&1 || break`,
-        `  sleep 0.5`,
-        `done`,
-        // Start new server
-        nodeCmd,
-        // Verify health
-        `for i in $(seq 1 20); do`,
-        `  curl -sf http://localhost:${port}/api/health >/dev/null 2>&1 && exit 0`,
-        `  sleep 0.5`,
-        `done`,
-        `echo "[dashboard] Restart health check failed" >&2`,
-      ].join("\n");
+      const extraArgs: string[] = [];
+      if (useDev) extraArgs.push("--dev");
 
-      const child = spawn("sh", ["-c", script], {
-        detached: true,
-        stdio: "ignore",
-        env: { ...process.env },
+      // Cross-platform restart: spawns a detached Node orchestrator that
+      // polls the port via net, spawns the new server, polls /api/health
+      // via http. No dependency on sh/lsof/curl — works on Windows too.
+      // See change: fix-windows-server-parity.
+      spawnRestart({
+        cliPath,
+        loader,
+        port: config.port,
+        extraArgs,
       });
-      child.unref();
 
       setTimeout(() => process.exit(0), 200);
       return { ok: true };

package/packages/server/src/routes/tool-routes.ts

@@ -0,0 +1,153 @@
+/**
+ * REST routes for the tool registry.
+ *
+ *   GET    /api/tools                → list all resolutions
+ *   GET    /api/tools/:name          → single resolution
+ *   POST   /api/tools/rescan         → invalidate + refresh (all or one)
+ *   PUT    /api/tools/:name          → set override path
+ *   DELETE /api/tools/:name          → clear override
+ *   POST   /api/tools/diagnostics    → text/plain export
+ *
+ * Every route is guarded by the same network guard used by /api/config.
+ *
+ * See change: consolidate-tool-resolution (specs/tool-settings-ui).
+ */
+import type { FastifyInstance } from "fastify";
+import type { ApiResponse } from "@blackbelt-technology/pi-dashboard-shared/types.js";
+import type {
+  Resolution,
+  ToolRegistry,
+} from "@blackbelt-technology/pi-dashboard-shared/tool-registry/index.js";
+import { UnknownToolError } from "@blackbelt-technology/pi-dashboard-shared/tool-registry/index.js";
+import type { NetworkGuard } from "./route-deps.js";
+
+export interface ToolRoutesDeps {
+  registry: ToolRegistry;
+  networkGuard: NetworkGuard;
+}
+
+/**
+ * Format a plain-text diagnostics export. One tool per block, one line
+ * per attempted strategy. Used by the Settings panel's "Export diagnostics"
+ * action and by bug-report attachments.
+ */
+export function formatDiagnostics(tools: Resolution[]): string {
+  const lines: string[] = [];
+  lines.push(`# pi-dashboard tool diagnostics — ${new Date().toISOString()}`);
+  lines.push("");
+  for (const t of tools) {
+    const header = t.ok
+      ? `[ok]    ${t.name} (${t.source}) → ${t.path}`
+      : `[miss]  ${t.name} → not found`;
+    lines.push(header);
+    for (const entry of t.tried) {
+      lines.push(`          - ${entry.strategy}: ${entry.result}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+export function registerToolRoutes(
+  fastify: FastifyInstance,
+  { registry, networkGuard }: ToolRoutesDeps,
+): void {
+  // ── GET /api/tools ─────────────────────────────────────────────────
+  fastify.get(
+    "/api/tools",
+    { preHandler: networkGuard },
+    async () => {
+      return { success: true, data: { tools: registry.list() } } satisfies ApiResponse<{
+        tools: Resolution[];
+      }>;
+    },
+  );
+
+  // ── GET /api/tools/:name ───────────────────────────────────────────
+  fastify.get<{ Params: { name: string } }>(
+    "/api/tools/:name",
+    { preHandler: networkGuard },
+    async (request, reply) => {
+      const { name } = request.params;
+      if (!registry.has(name)) {
+        reply.status(404);
+        return { success: false, error: `Unknown tool: ${name}` } satisfies ApiResponse;
+      }
+      return { success: true, data: registry.resolve(name) } satisfies ApiResponse<Resolution>;
+    },
+  );
+
+  // ── POST /api/tools/rescan ─────────────────────────────────────────
+  fastify.post<{ Body: { name?: string } }>(
+    "/api/tools/rescan",
+    { preHandler: networkGuard },
+    async (request, reply) => {
+      const name = request.body?.name;
+      if (name !== undefined) {
+        if (!registry.has(name)) {
+          reply.status(404);
+          return { success: false, error: `Unknown tool: ${name}` } satisfies ApiResponse;
+        }
+        registry.rescan(name);
+      } else {
+        registry.rescan();
+      }
+      return { success: true, data: { tools: registry.list() } } satisfies ApiResponse<{
+        tools: Resolution[];
+      }>;
+    },
+  );
+
+  // ── PUT /api/tools/:name ───────────────────────────────────────────
+  fastify.put<{ Params: { name: string }; Body: { path?: string } }>(
+    "/api/tools/:name",
+    { preHandler: networkGuard },
+    async (request, reply) => {
+      const { name } = request.params;
+      const overridePath = request.body?.path;
+      if (typeof overridePath !== "string" || !overridePath.trim()) {
+        reply.status(400);
+        return { success: false, error: "body.path is required (non-empty string)" } satisfies ApiResponse;
+      }
+      try {
+        registry.setOverride(name, overridePath.trim());
+      } catch (err) {
+        if (err instanceof UnknownToolError) {
+          reply.status(404);
+          return { success: false, error: err.message } satisfies ApiResponse;
+        }
+        throw err;
+      }
+      return { success: true, data: registry.resolve(name) } satisfies ApiResponse<Resolution>;
+    },
+  );
+
+  // ── DELETE /api/tools/:name ────────────────────────────────────────
+  fastify.delete<{ Params: { name: string } }>(
+    "/api/tools/:name",
+    { preHandler: networkGuard },
+    async (request, reply) => {
+      const { name } = request.params;
+      try {
+        registry.clearOverride(name);
+      } catch (err) {
+        if (err instanceof UnknownToolError) {
+          reply.status(404);
+          return { success: false, error: err.message } satisfies ApiResponse;
+        }
+        throw err;
+      }
+      return { success: true, data: registry.resolve(name) } satisfies ApiResponse<Resolution>;
+    },
+  );
+
+  // ── POST /api/tools/diagnostics ────────────────────────────────────
+  fastify.post(
+    "/api/tools/diagnostics",
+    { preHandler: networkGuard },
+    async (_request, reply) => {
+      reply.type("text/plain; charset=utf-8");
+      return formatDiagnostics(registry.list());
+    },
+  );
+}

package/packages/server/src/server-pid.ts

@@ -6,6 +6,7 @@ import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
 import { isDashboardRunning } from "@blackbelt-technology/pi-dashboard-shared/server-identity.js";
+import { isProcessAlive } from "@blackbelt-technology/pi-dashboard-shared/platform/process.js";
 
 const DEFAULT_PID_PATH = path.join(os.homedir(), ".pi", "dashboard", "server.pid");
 
@@ -14,16 +15,11 @@ export interface ServerPidOptions {
 }
 
 /**
- * Check if a process with the given PID is alive.
+ * Re-export the platform's liveness primitive so existing importers of
+ * `server-pid.ts::isProcessAlive` keep working. See change:
+ * route-kill-paths-through-platform.
  */
-export function isProcessAlive(pid: number): boolean {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
+export { isProcessAlive };
 
 /**
  * Write the current process PID to the PID file.

package/packages/server/src/server.ts

@@ -47,6 +47,12 @@ import { registerRecommendedRoutes, invalidateRecommendedCache } from "./routes/
 import { registerPiCoreRoutes } from "./routes/pi-core-routes.js";
 import { PiCoreChecker } from "./pi-core-checker.js";
 import { PiCoreUpdater } from "./pi-core-updater.js";
+import { registerToolRoutes } from "./routes/tool-routes.js";
+import { registerBootstrapRoutes } from "./routes/bootstrap-routes.js";
+import { createBootstrapState, type BootstrapStateStore } from "./bootstrap-state.js";
+import { createBootstrapQueue } from "./bootstrap-queue.js";
+import { bootstrapInstall } from "@blackbelt-technology/pi-dashboard-shared/bootstrap-install.js";
+import { getDefaultRegistry } from "@blackbelt-technology/pi-dashboard-shared/tool-registry/index.js";
 import { registerProviderRoutes } from "./routes/provider-routes.js";
 import { PackageManagerWrapper } from "./package-manager-wrapper.js";
 import { createEditorManager, type EditorManager } from "./editor-manager.js";
@@ -73,6 +79,8 @@ export interface ServerConfig {
   maxWsBufferBytes?: number;
   /** Editor (code-server) config */
   editor: import("@blackbelt-technology/pi-dashboard-shared/config.js").EditorConfig;
+  /** OpenSpec polling config (interval, concurrency, change detection, jitter) */
+  openspec?: import("@blackbelt-technology/pi-dashboard-shared/config.js").OpenSpecPollConfig;
   /** Merged trusted networks from config */
   resolvedTrustedNetworks?: string[];
   /** CORS allowed origins from config */
@@ -85,6 +93,14 @@ export interface DashboardServer {
   sessionManager: SessionManager;
   eventStore: EventStore;
   browserGateway: BrowserGateway;
+  /**
+   * Bootstrap state store. Exposed so the CLI can flip status during
+   * degraded-mode first-run (`pi-dashboard` without pi installed) and
+   * so the REST handler for `/api/bootstrap/upgrade-pi` can orchestrate
+   * async installs without reaching back through closures.
+   * See change: unified-bootstrap-install.
+   */
+  bootstrapState: BootstrapStateStore;
   /** Resolved HTTP port after start() (useful for port:0 in tests). Returns null if not listening. */
   httpPort(): number | null;
   /** Resolved pi gateway port after start(). Returns null if not listening. */
@@ -94,9 +110,20 @@ export interface DashboardServer {
 export async function createServer(config: ServerConfig): Promise<DashboardServer> {
   // Ensure bridge extension is registered in pi's global settings
   // (needed for bundled installs where pi can't discover it from package.json)
+  //
+  // __serverDir = <repo>/packages/server/src
+  // baseDir MUST be <repo>/ so findBundledExtension resolves
+  // <repo>/packages/extension. Three levels up, not two.
   const __serverDir = path.dirname(fileURLToPath(import.meta.url));
-  const extPath = findBundledExtension(path.resolve(__serverDir, "..", ".."));
-  if (extPath) registerBridgeExtension(extPath);
+  const extPath = findBundledExtension(path.resolve(__serverDir, "..", "..", ".."));
+  if (extPath) {
+    registerBridgeExtension(extPath);
+    console.log(`[dashboard] Bridge extension registered: ${extPath}`);
+  } else {
+    console.warn(`[dashboard] Bridge extension NOT found (searched from ${__serverDir}). ` +
+      `Sessions will spawn but never connect to the gateway. ` +
+      `Manually add the extension path to ~/.pi/agent/settings.json packages[] as a workaround.`);
+  }
 
   // Run migration from sessions.json + state.json if needed
   if (needsMigration()) {
@@ -161,7 +188,7 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
     knownSessionIds.add(s.id);
   }
 
-  const directoryService = createDirectoryService(preferencesStore, sessionManager);
+  const directoryService = createDirectoryService(preferencesStore, sessionManager, config.openspec);
 
   // mDNS peer discovery state
   let mdnsBrowser: DashboardBrowser | null = null;
@@ -329,6 +356,33 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
     fastify.get("/auth/status", async () => ({ authenticated: true, authEnabled: false }));
   }
 
+  // ── Bootstrap state + queue ──────────────────────────────────────
+  // Declared here (before session-api registration) so the session
+  // routes can gate spawn operations on bootstrap status.
+  // See change: unified-bootstrap-install.
+  const bootstrapState = createBootstrapState();
+  const bootstrapQueue = createBootstrapQueue();
+  let lastBootstrapStatus: "ready" | "installing" | "failed" = "ready";
+  const unsubscribeBootstrap = bootstrapState.subscribe((snapshot) => {
+    browserGateway.broadcastToAll({
+      type: "bootstrap_status_update",
+      state: snapshot,
+    });
+    // Flush queued pi-dependent operations on ready transition.
+    if (lastBootstrapStatus !== "ready" && snapshot.status === "ready") {
+      void bootstrapQueue.flushAll();
+    }
+    lastBootstrapStatus = snapshot.status;
+  });
+  const unsubscribeQueueComplete = bootstrapQueue.onTicketComplete((evt) => {
+    browserGateway.broadcastToAll({
+      type: "bootstrap_ticket_complete",
+      ticketId: evt.ticketId,
+      success: evt.success,
+      error: evt.error,
+    });
+  });
+
   // Session control REST API (wraps WebSocket-only operations)
   registerSessionApi(fastify, {
     sessionManager,
@@ -336,6 +390,8 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
     browserGateway,
     pendingForkRegistry,
     pendingDashboardSpawns,
+    bootstrapState,
+    bootstrapQueue,
   });
 
   // Register route modules
@@ -350,12 +406,118 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
     preferencesStore,
     directoryService,
     networkGuard,
+    bootstrapState,
     onOpenSpecChanged: (cwd) => {
       const data = directoryService.getOpenSpecData(cwd);
       if (data) browserGateway.broadcastToAll({ type: "openspec_update", cwd, data });
     },
   });
-  registerSystemRoutes(fastify, { sessionManager, preferencesStore, metaPersistence, config, networkGuard, version: pkgVersion });
+  registerSystemRoutes(fastify, { sessionManager, preferencesStore, metaPersistence, config, networkGuard, version: pkgVersion, directoryService });
+  registerToolRoutes(fastify, { registry: getDefaultRegistry(), networkGuard });
+
+  // ── Bootstrap REST routes ────────────────────────────────────────
+  // The routes module is registered here; state + queue are declared
+  // above (before session-api) so session routes can see them.
+  registerBootstrapRoutes(fastify, {
+    bootstrapState,
+    networkGuard,
+    triggerUpgradePi: async () => {
+      const packages = ["@mariozechner/pi-coding-agent"];
+      bootstrapState.setLastInstallPackages(packages);
+      bootstrapState.set({
+        status: "installing",
+        progress: { step: "@mariozechner/pi-coding-agent", output: "starting upgrade…" },
+        error: undefined,
+      });
+      try {
+        const res = await bootstrapInstall({
+          packages,
+          progress: (p) => {
+            bootstrapState.set({
+              progress: { step: p.step, output: p.output },
+            });
+          },
+        });
+        if (res.ok) {
+          bootstrapState.set({
+            status: "ready",
+            progress: undefined,
+            error: undefined,
+          });
+          // Broadcast /reload to connected sessions so they pick up the
+          // new pi version. Mirrors the pi-core update pattern above.
+          const connectedIds = piGateway.getConnectedSessionIds();
+          for (const sid of connectedIds) {
+            const session = sessionManager.get(sid);
+            if (session && session.status !== "ended") {
+              piGateway.sendToSession(sid, {
+                type: "send_prompt",
+                sessionId: sid,
+                text: "/reload",
+              });
+            }
+          }
+        } else {
+          bootstrapState.set({
+            status: "failed",
+            error: { message: res.error },
+            progress: undefined,
+          });
+        }
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        bootstrapState.set({
+          status: "failed",
+          error: { message },
+          progress: undefined,
+        });
+      }
+    },
+    triggerRetry: async () => {
+      // Retry re-runs the EXACT package set from the last failed install.
+      // Falls back to the default first-run set if no prior install was
+      // recorded (edge case: manual retry before any install attempt).
+      const prev = bootstrapState.getLastInstallPackages();
+      const packages = prev.length > 0
+        ? prev
+        : ["@mariozechner/pi-coding-agent", "@fission-ai/openspec", "tsx"];
+      bootstrapState.set({
+        status: "installing",
+        progress: { step: "retry", output: `restarting install (${packages.length} pkg${packages.length === 1 ? "" : "s"})…` },
+        error: undefined,
+      });
+      try {
+        const res = await bootstrapInstall({
+          packages,
+          progress: (p) => {
+            bootstrapState.set({
+              progress: { step: p.step, output: p.output },
+            });
+          },
+        });
+        if (res.ok) {
+          bootstrapState.set({
+            status: "ready",
+            progress: undefined,
+            error: undefined,
+          });
+        } else {
+          bootstrapState.set({
+            status: "failed",
+            error: { message: res.error },
+            progress: undefined,
+          });
+        }
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        bootstrapState.set({
+          status: "failed",
+          error: { message },
+          progress: undefined,
+        });
+      }
+    },
+  });
   // Package management
   const packageManagerWrapper = new PackageManagerWrapper();
 
@@ -374,6 +536,7 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
       scope: result.scope,
       success: result.success,
       error: result.error,
+      diagnostics: result.diagnostics,
       sessionsReloaded: (result as any).sessionsReloaded,
     } as any);
     if (result.success) invalidateRecommendedCache();
@@ -432,6 +595,7 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
   registerPiCoreRoutes(fastify, {
     piCoreChecker,
     piCoreUpdater,
+    bootstrapState,
     onUpdateComplete: (payload) => {
       browserGateway.broadcastToAll({
         type: "pi_core_update_complete",
@@ -441,6 +605,17 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
     },
   });
 
+  // Warm pi-coding-agent module import + DefaultPackageManager instances
+  // on startup so the first user request to /api/packages/* doesn't pay
+  // the 3-5s cold-load cost. Runs in background; errors are swallowed
+  // (user-visible flow surfaces any real problem with the full diagnostic
+  // trail via the OperationResult.diagnostics field).
+  // See change: consolidate-tool-resolution.
+  void Promise.allSettled([
+    packageManagerWrapper.listInstalled("global"),
+    packageManagerWrapper.listInstalled("local"),
+  ]);
+
   // Editor (code-server) routes and proxy.
   // NOTE: routes are *registered* here but cannot dispatch until fastify.listen runs
   // inside server.start(). The orphan sweep in editorPidRegistry.cleanupOrphans()
@@ -453,17 +628,38 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
   registerKnownServersRoutes(fastify, { networkGuard, getPeerServers: () => peerServers });
   registerProviderRoutes(fastify, { networkGuard, piGateway, browserGateway });
 
-  // Serve static files / SPA fallback
-  // Search order: npm package → workspace sibling → legacy dist/client
+  // Serve static files / SPA fallback.
+  //
+  // Resolution strategies, in order:
+  //  1. Node module resolver — works in ANY install layout
+  //     (flat `node_modules/`, scoped, nested, pnpm, whatever).
+  //  2. Sibling-to-server in the installed @scope layout.
+  //  3. Monorepo workspace sibling.
+  //  4. Legacy dist/client.
+  //
+  // Same class of bug as commits 40a1319 (bridge auto-registration)
+  // and e11f5eb (server-launcher.ts resolve): sibling-path arithmetic
+  // that works in the dev repo silently returns wrong paths in the
+  // installed node_modules layout. require.resolve identifies packages
+  // by name, which is the only canonical identity across layouts.
   const __dirname = path.dirname(fileURLToPath(import.meta.url));
-  const clientSearchPaths = [
-    // Installed as npm dependency
-    path.join(__dirname, "../../node_modules/@blackbelt-technology/pi-dashboard-web/dist"),
+  const clientSearchPaths: string[] = [];
+  try {
+    const webPkgJson = createRequire(import.meta.url).resolve("@blackbelt-technology/pi-dashboard-web/package.json");
+    clientSearchPaths.push(path.join(path.dirname(webPkgJson), "dist"));
+  } catch {
+    // Web package not resolvable — fall through to path-based search.
+  }
+  clientSearchPaths.push(
+    // Installed as scoped sibling of server
+    path.join(__dirname, "..", "..", "pi-dashboard-web", "dist"),
+    // Installed in a parent node_modules (hoisted)
+    path.join(__dirname, "..", "..", "..", "@blackbelt-technology", "pi-dashboard-web", "dist"),
     // Monorepo workspace sibling
     path.join(__dirname, "../../client/dist"),
     // Legacy path
     path.join(__dirname, "../../dist/client"),
-  ];
+  );
   const clientDir = clientSearchPaths.find(p => existsSync(path.join(p, "index.html"))) ?? "";
   const hasProductionBuild = !!clientDir;
   if (!hasProductionBuild) {
@@ -548,6 +744,7 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
     sessionManager,
     eventStore,
     browserGateway,
+    bootstrapState,
 
     httpPort() {
       const addr = fastify.server.address();
@@ -670,6 +867,10 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
       preferencesStore.flush();
       preferencesStore.dispose();
 
+      unsubscribeBootstrap();
+      unsubscribeQueueComplete();
+      bootstrapState.dispose();
+      bootstrapQueue.clear("server shutting down");
       await deleteTunnel(config.port);
       piGateway.stop();
       for (const client of browserGateway.wss.clients) {