mcp-tenant-lib 0.3.7 → 0.4.0

package/dist/http.js

@@ -152,23 +152,21 @@ export function createHttpServer({ port, staticDir, initialSchema, initialValues
         if (pathname.startsWith('/t/')) {
             pathname = '/';
         }
-        const mountEntry = Object.entries(extraStaticMounts).find(([prefix]) => pathname === prefix || pathname.startsWith(`${prefix}/`));
+        // A single-file mount (e.g. "/main.js") only ever matches its own exact
+        // path — checked first so a directory mount rooted at "/" (see below)
+        // can't shadow it. A directory mount (no extension on its prefix, e.g.
+        // "/") matches its prefix or anything nested under it.
+        const singleFileMatch = Object.entries(extraStaticMounts).find(([prefix]) => path.extname(prefix) && pathname === prefix);
+        const dirMatch = Object.entries(extraStaticMounts).find(([prefix]) => !path.extname(prefix) && (pathname === prefix || pathname.startsWith(`${prefix}/`)));
         let filePath;
-        if (mountEntry) {
-            const [prefix, dir] = mountEntry;
-            if (path.extname(prefix)) {
-                // A prefix with a file extension (e.g. "/main.js") is a single-file
-                // mount — `dir` is that file's parent directory, and any request
-                // exactly matching `prefix` resolves straight to it, no index.html
-                // fallback. Lets a consumer serve one fixed-URL asset (e.g. an
-                // embed script referenced by other pages as "<server>/main.js")
-                // from a build directory that also happens to hold other files.
-                filePath = path.join(dir, path.basename(prefix));
-            }
-            else {
-                const rest = pathname.slice(prefix.length);
-                filePath = path.join(dir, rest === '' || rest === '/' ? '/index.html' : rest);
-            }
+        if (singleFileMatch) {
+            const [prefix, dir] = singleFileMatch;
+            filePath = path.join(dir, path.basename(prefix));
+        }
+        else if (dirMatch) {
+            const [prefix, dir] = dirMatch;
+            const rest = pathname.slice(prefix.length);
+            filePath = path.join(dir, rest === '' || rest === '/' ? '/index.html' : rest);
         }
         else {
             filePath = path.join(staticDir, pathname === '/' ? '/index.html' : pathname);

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { Store, Tenant, tenants, getOrCreateTenant, disposeTenant, startIdleSweep, isValidChannelName, sanitizeChannelName, dashboardEvents } from './tenant.js';
+export { Store, Tenant, tenants, getOrCreateTenant, disposeTenant, startIdleSweep, startEmptySweep, isValidChannelName, sanitizeChannelName, dashboardEvents } from './tenant.js';
 export { buildMcpServer, type RegisterToolsFn, type McpServerIdentity } from './mcp.js';
 export { createHttpServer, type CreateHttpServerOptions } from './http.js';
 export { attachWebSocketServer } from './ws.js';

package/dist/index.js

@@ -1,4 +1,4 @@
-export { Store, Tenant, tenants, getOrCreateTenant, disposeTenant, startIdleSweep, isValidChannelName, sanitizeChannelName, dashboardEvents } from './tenant.js';
+export { Store, Tenant, tenants, getOrCreateTenant, disposeTenant, startIdleSweep, startEmptySweep, isValidChannelName, sanitizeChannelName, dashboardEvents } from './tenant.js';
 export { buildMcpServer } from './mcp.js';
 export { createHttpServer } from './http.js';
 export { attachWebSocketServer } from './ws.js';

package/dist/persistence.js

@@ -94,5 +94,15 @@ export function enablePersistence(filePath) {
             writeToDisk();
     }, WRITE_DEBOUNCE_MS);
     pollInterval.unref();
+    // A change followed by a kill within WRITE_DEBOUNCE_MS never reaches the
+    // poll loop above, so the process's last bit of state would silently be
+    // lost on an otherwise-ordinary Ctrl+C. Force one final synchronous write
+    // before actually exiting so a quick restart doesn't drop it.
+    for (const signal of ['SIGINT', 'SIGTERM']) {
+        process.on(signal, () => {
+            writeToDisk();
+            process.exit(0);
+        });
+    }
     return { seededIds };
 }

package/dist/tenant.d.ts

@@ -79,6 +79,17 @@ export declare class Tenant<TSchema, TValues> {
     lastStateChangeAt: number;
     wsClients: Set<WebSocket>;
     connections: Map<string, TenantConnection>;
+    /**
+     * Timestamp this tenant's connection count last dropped to zero, or
+     * `undefined` while it has at least one live connection. Distinct from
+     * `lastActivityAt` (bumped by ordinary traffic, drives the multi-hour
+     * general idle sweep) — this backs a much shorter "orphaned channel"
+     * sweep (see startEmptySweep) aimed at the "closed the tab" case: a
+     * channel nobody is connected to anymore, as opposed to one that's just
+     * quiet. Cleared the moment any connection registers again, so a normal
+     * ~2s client reconnect never trips the short timeout.
+     */
+    emptyAt: number | undefined;
     lastActivityAt: number;
     pendingCalls: Map<string, {
         resolve: (v: unknown) => void;
@@ -212,4 +223,5 @@ declare const tenants: Map<string, Tenant<any, any>>;
 declare function getOrCreateTenant<TSchema, TValues>(id: string, initialSchema: TSchema, initialValues: TValues): Tenant<TSchema, TValues>;
 declare function disposeTenant(id: string): void;
 declare function startIdleSweep(onSweep: (id: string) => void): NodeJS.Timeout;
-export { tenants, getOrCreateTenant, disposeTenant, startIdleSweep, isValidChannelName, sanitizeChannelName };
+declare function startEmptySweep(onSweep: (id: string) => void): NodeJS.Timeout;
+export { tenants, getOrCreateTenant, disposeTenant, startIdleSweep, startEmptySweep, isValidChannelName, sanitizeChannelName };

package/dist/tenant.js

@@ -86,6 +86,17 @@ export class Tenant {
     lastStateChangeAt = 0;
     wsClients;
     connections = new Map();
+    /**
+     * Timestamp this tenant's connection count last dropped to zero, or
+     * `undefined` while it has at least one live connection. Distinct from
+     * `lastActivityAt` (bumped by ordinary traffic, drives the multi-hour
+     * general idle sweep) — this backs a much shorter "orphaned channel"
+     * sweep (see startEmptySweep) aimed at the "closed the tab" case: a
+     * channel nobody is connected to anymore, as opposed to one that's just
+     * quiet. Cleared the moment any connection registers again, so a normal
+     * ~2s client reconnect never trips the short timeout.
+     */
+    emptyAt;
     #legacyManifest;
     #legacySummary;
     lastActivityAt;
@@ -159,6 +170,7 @@ export class Tenant {
     registerConnection(id, socket) {
         this.connections.set(id, { id, socket, manifest: [], summary: undefined, label: undefined });
         this.wsClients.add(socket);
+        this.emptyAt = undefined;
         notifyDashboard();
     }
     updateConnectionManifest(id, manifest, summary, label) {
@@ -189,6 +201,8 @@ export class Tenant {
         if (conn)
             this.wsClients.delete(conn.socket);
         this.connections.delete(id);
+        if (this.connections.size === 0)
+            this.emptyAt ??= Date.now();
         this.syncManifestToolRegistries();
         notifyDashboard();
     }
@@ -470,4 +484,34 @@ function startIdleSweep(onSweep) {
     sweepInterval.unref();
     return sweepInterval;
 }
-export { tenants, getOrCreateTenant, disposeTenant, startIdleSweep, isValidChannelName, sanitizeChannelName };
+/**
+ * Much shorter, separate sweep aimed at "the browser tab closed" rather
+ * than "the connection went quiet" (that's TENANT_IDLE_TIMEOUT_MS/
+ * startIdleSweep above, which looks at traffic on a tenant that still has a
+ * live connection). This one only fires on tenants that have had ZERO
+ * connections for more than TENANT_EMPTY_TIMEOUT_MS — see Tenant.emptyAt.
+ * The server has no direct "tab closed" signal (a clean close and a brief
+ * network drop look identical), so this grace window doubles as the
+ * reconnect-tolerance budget: the client's own retry loop
+ * (client-bridge.ts) reconnects within ~2s of a drop, comfortably under the
+ * default, so a real reconnect always beats the sweep; a channel that stays
+ * empty past it is treated as abandoned.
+ */
+const TENANT_EMPTY_TIMEOUT_MS = envMs('TENANT_EMPTY_TIMEOUT_MS', 15_000);
+const TENANT_EMPTY_SWEEP_INTERVAL_MS = envMs('TENANT_EMPTY_SWEEP_INTERVAL_MS', 5_000);
+function startEmptySweep(onSweep) {
+    const sweepInterval = setInterval(() => {
+        const now = Date.now();
+        for (const [id, tenant] of tenants) {
+            if (id === 'default')
+                continue;
+            if (tenant.emptyAt !== undefined && now - tenant.emptyAt > TENANT_EMPTY_TIMEOUT_MS) {
+                onSweep(id);
+                disposeTenant(id);
+            }
+        }
+    }, TENANT_EMPTY_SWEEP_INTERVAL_MS);
+    sweepInterval.unref();
+    return sweepInterval;
+}
+export { tenants, getOrCreateTenant, disposeTenant, startIdleSweep, startEmptySweep, isValidChannelName, sanitizeChannelName };

package/dist/types.d.ts

@@ -63,6 +63,20 @@ export interface SubmitMessage {
 export interface InterruptMessage {
     type: 'interrupt';
 }
+/**
+ * Sent by a page that is intentionally switching this socket off its
+ * current channel (e.g. a connect-flow "rename to a different channel")
+ * before it opens a fresh socket on the new one — distinct from an ordinary
+ * unclean close (network drop, tab crash), which carries no such signal.
+ * Lets the server dispose the old tenant immediately once this was its last
+ * connection, instead of waiting out the empty-tenant grace window (see
+ * Tenant.emptyAt / startEmptySweep in tenant.ts) for a channel the page
+ * itself just told us it's done with. A no-op if other connections remain
+ * on the tenant, or if it has already been disposed.
+ */
+export interface LeaveChannelMessage {
+    type: 'leave_channel';
+}
 export interface ToolParamSpec {
     type: 'string' | 'number' | 'boolean';
     description?: string;
@@ -125,4 +139,4 @@ export interface RenameConnectionMessage {
     type: 'rename_connection';
     appLabel: string;
 }
-export type ClientMessage = SetMessage | SubmitMessage | InterruptMessage | RegisterToolsMessage | CallResultMessage | RenameConnectionMessage | ResyncMessage;
+export type ClientMessage = SetMessage | SubmitMessage | InterruptMessage | RegisterToolsMessage | CallResultMessage | RenameConnectionMessage | ResyncMessage | LeaveChannelMessage;

package/dist/ws.js

@@ -107,6 +107,18 @@ export function attachWebSocketServer(httpServer, port, initialSchema, initialVa
                     ? `[ws] resync from connection=${connectionId}: restoring tenant "${tenantId}" state pushed back by the browser`
                     : `[ws] resync from connection=${connectionId}: ignored — tenant "${tenantId}" already has state at least as recent`);
             }
+            if (msg.type === 'leave_channel') {
+                // The page told us — as opposed to just dropping — that it's done
+                // with this channel (e.g. switching to a different one). Remove
+                // this connection now rather than waiting for the socket's own
+                // 'close' event, so a tenant this was the last connection on
+                // becomes empty (and eligible for startEmptySweep) immediately;
+                // the socket is closed right after, which would otherwise fire the
+                // same removeConnection redundantly — guarded there by connections
+                // no longer having this id.
+                console.error(`[ws] connection ${connectionId} left tenant=${tenantId} (${t.connections.size - 1} connection(s) remaining)`);
+                t.removeConnection(connectionId);
+            }
         });
         ws.on('close', (code, reason) => {
             console.error(`[ws] connection closed: tenant=${tenantId} connection=${connectionId} code=${code} reason=${reason.toString() || '(none)'}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-tenant-lib",
-  "version": "0.3.7",
+  "version": "0.4.0",
   "type": "module",
   "description": "Generic tenant/session bookkeeping + MCP wiring, reusable across projects.",
   "repository": {