mcp-tenant-lib 0.3.4 → 0.3.5

package/dist/tenant.d.ts

@@ -56,6 +56,16 @@ export declare class Tenant<TSchema, TValues> {
      * list_fields read should be able to see that they're done.
      */
     submitted: boolean;
+    /**
+     * Timestamp of the most recent real edit to `store` (a field value
+     * changing) or a successfully-applied `restoreState` (see below) —
+     * distinct from `lastActivityAt`, which also counts reads/pings and
+     * drives idle-sweep instead. Used solely to arbitrate `resync` messages
+     * (ws.ts) when more than one browser tab reconnects to the same
+     * recreated tenant: whichever tab's last edit is newer wins, rather than
+     * whichever tab's resync happens to reach the server first.
+     */
+    lastStateChangeAt: number;
     wsClients: Set<WebSocket>;
     connections: Map<string, TenantConnection>;
     lastActivityAt: number;
@@ -139,6 +149,27 @@ export declare class Tenant<TSchema, TValues> {
     rejectCall(id: string, error: string): void;
     touch(): void;
     applyState(schema: TSchema, values: TValues): void;
+    /**
+     * Restores schema/values/submitted from a browser page's own live state
+     * after this tenant was recreated empty (see the `recreated` init flag in
+     * ws.ts) — unlike applyState (used by define_form to redefine a form),
+     * this preserves `submitted` as reported by the page rather than always
+     * resetting it, since a resync is recovering prior state, not starting a
+     * new round.
+     *
+     * `changedAt` is the pushing page's own last-local-edit timestamp
+     * (Date.now() when the user or agent last changed a field in that tab —
+     * see mcp-form's client). When two tabs both reconnect to the same
+     * recreated tenant, each pushes its own resync independently; without
+     * this guard, whichever happens to reach the server first would win,
+     * which has nothing to do with which tab actually has the fresher data.
+     * Comparing against `lastStateChangeAt` (bumped by every real edit,
+     * including a previously-applied resync) means an older resync arriving
+     * after a newer one — or after the tenant was already touched some other
+     * way, e.g. an agent's set_field — is ignored rather than clobbering it.
+     * Returns whether the resync was applied.
+     */
+    restoreState(schema: TSchema, values: TValues, submitted: boolean, changedAt: number): boolean;
     broadcastReinit(): void;
     broadcastUpdate(field: string, value: unknown): void;
     dispose(): void;

package/dist/tenant.js

@@ -59,6 +59,16 @@ export class Tenant {
      * list_fields read should be able to see that they're done.
      */
     submitted = false;
+    /**
+     * Timestamp of the most recent real edit to `store` (a field value
+     * changing) or a successfully-applied `restoreState` (see below) —
+     * distinct from `lastActivityAt`, which also counts reads/pings and
+     * drives idle-sweep instead. Used solely to arbitrate `resync` messages
+     * (ws.ts) when more than one browser tab reconnects to the same
+     * recreated tenant: whichever tab's last edit is newer wins, rather than
+     * whichever tab's resync happens to reach the server first.
+     */
+    lastStateChangeAt = 0;
     wsClients;
     connections = new Map();
     #legacyManifest;
@@ -102,7 +112,7 @@ export class Tenant {
     constructor(id, initialSchema, initialValues) {
         this.id = id;
         this.schema = initialSchema;
-        this.store = new Store(initialValues);
+        this.store = new Store(initialValues); // placeholder; #attachStore below wires the real onChange listener
         this.submitBus = new EventEmitter();
         this.submitBus.setMaxListeners(0);
         this.submitBus.on('newListener', (event) => {
@@ -117,7 +127,7 @@ export class Tenant {
         });
         this.wsClients = new Set();
         this.lastActivityAt = Date.now();
-        this.store.onChange((field, value) => this.broadcastUpdate(field, value));
+        this.#attachStore(this.store);
     }
     /**
      * Legacy/no-WS path: registers a manifest with no real connection behind
@@ -292,14 +302,51 @@ export class Tenant {
     touch() {
         this.lastActivityAt = Date.now();
     }
+    #attachStore(store) {
+        this.store = store;
+        this.store.onChange((field, value) => {
+            this.lastStateChangeAt = Date.now();
+            this.broadcastUpdate(field, value);
+        });
+    }
     applyState(schema, values) {
         this.store.dispose();
         this.schema = schema;
-        this.store = new Store(values);
+        this.#attachStore(new Store(values));
         this.submitted = false;
-        this.store.onChange((field, value) => this.broadcastUpdate(field, value));
         this.broadcastReinit();
     }
+    /**
+     * Restores schema/values/submitted from a browser page's own live state
+     * after this tenant was recreated empty (see the `recreated` init flag in
+     * ws.ts) — unlike applyState (used by define_form to redefine a form),
+     * this preserves `submitted` as reported by the page rather than always
+     * resetting it, since a resync is recovering prior state, not starting a
+     * new round.
+     *
+     * `changedAt` is the pushing page's own last-local-edit timestamp
+     * (Date.now() when the user or agent last changed a field in that tab —
+     * see mcp-form's client). When two tabs both reconnect to the same
+     * recreated tenant, each pushes its own resync independently; without
+     * this guard, whichever happens to reach the server first would win,
+     * which has nothing to do with which tab actually has the fresher data.
+     * Comparing against `lastStateChangeAt` (bumped by every real edit,
+     * including a previously-applied resync) means an older resync arriving
+     * after a newer one — or after the tenant was already touched some other
+     * way, e.g. an agent's set_field — is ignored rather than clobbering it.
+     * Returns whether the resync was applied.
+     */
+    restoreState(schema, values, submitted, changedAt) {
+        if (changedAt < this.lastStateChangeAt)
+            return false;
+        this.store.dispose();
+        this.schema = schema;
+        this.#attachStore(new Store(values));
+        this.submitted = submitted;
+        this.lastStateChangeAt = changedAt;
+        this.broadcastReinit();
+        return true;
+    }
     broadcastReinit() {
         const payload = JSON.stringify({ type: 'reinit', schema: this.schema, state: this.store.snapshot(), waiting: this.waiting, submitted: this.submitted });
         for (const client of this.wsClients) {

package/dist/types.d.ts

@@ -4,7 +4,14 @@ export interface SubmitPayload {
     [field: string]: unknown;
 }
 export type ServerMessage<TSchema = unknown, TValues = unknown> = {
-    type: 'init' | 'reinit';
+    type: 'init';
+    schema: TSchema;
+    state: TValues;
+    waiting: boolean;
+    submitted: boolean;
+    recreated: boolean;
+} | {
+    type: 'reinit';
     schema: TSchema;
     state: TValues;
     waiting: boolean;
@@ -25,6 +32,31 @@ export interface SetMessage {
     field: string;
     value: unknown;
 }
+/**
+ * Sent by a page that reconnects to a tenant the server reports as
+ * `recreated` (see the `init` message) — i.e. the in-memory tenant was
+ * lost, most commonly an MCP server restart, while this page's own JS
+ * runtime (and therefore its last-known schema/values) survived because
+ * the tab itself never reloaded. Lets the still-live browser page push its
+ * state back up as the source of truth instead of accepting the server's
+ * freshly-recreated default state. The server applies it via the same
+ * path as define_form (Tenant.applyState) and rebroadcasts `reinit` to any
+ * other connected tabs.
+ */
+export interface ResyncMessage<TSchema = unknown, TValues = unknown> {
+    type: 'resync';
+    schema: TSchema;
+    values: TValues;
+    submitted: boolean;
+    /**
+     * The pushing page's own last-local-edit timestamp (Date.now()) — lets
+     * the server arbitrate when two tabs both resync the same recreated
+     * tenant, favoring whichever has the more recently edited data rather
+     * than whichever resync message happens to arrive first. See
+     * Tenant.restoreState in mcp-tenant-lib for the comparison.
+     */
+    changedAt: number;
+}
 export interface SubmitMessage {
     type: 'submit';
 }
@@ -93,4 +125,4 @@ export interface RenameConnectionMessage {
     type: 'rename_connection';
     appLabel: string;
 }
-export type ClientMessage = SetMessage | SubmitMessage | InterruptMessage | RegisterToolsMessage | CallResultMessage | RenameConnectionMessage;
+export type ClientMessage = SetMessage | SubmitMessage | InterruptMessage | RegisterToolsMessage | CallResultMessage | RenameConnectionMessage | ResyncMessage;

package/dist/ws.js

@@ -60,7 +60,7 @@ export function attachWebSocketServer(httpServer, port, initialSchema, initialVa
             if (state)
                 state.isAlive = true;
         });
-        ws.send(JSON.stringify({ type: 'init', schema: t.schema, state: t.store.snapshot(), waiting: t.waiting, submitted: t.submitted }));
+        ws.send(JSON.stringify({ type: 'init', schema: t.schema, state: t.store.snapshot(), waiting: t.waiting, submitted: t.submitted, recreated }));
         ws.on('message', (raw) => {
             t.touch();
             let msg;
@@ -92,6 +92,12 @@ export function attachWebSocketServer(httpServer, port, initialSchema, initialVa
                 else
                     t.resolveCall(msg.id, msg.result);
             }
+            if (msg.type === 'resync') {
+                const applied = t.restoreState(msg.schema, msg.values, msg.submitted, msg.changedAt);
+                console.error(applied
+                    ? `[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`);
+            }
         });
         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.4",
+  "version": "0.3.5",
   "type": "module",
   "description": "Generic tenant/session bookkeeping + MCP wiring, reusable across projects.",
   "repository": {