@chatroomcp/chatroom 0.1.5 → 0.1.7

package/dist/plugins/cloud/api-client.d.ts

@@ -3,10 +3,6 @@ import { type CloudEntitlement, type CloudLeaseState, type CloudServiceId } from
 declare const recoveryCredentialSchema: z.ZodObject<{
     recoveryKey: z.ZodString;
 }, z.core.$strict>;
-declare const registrationSchema: z.ZodObject<{
-    installationId: z.ZodString;
-    registered: z.ZodLiteral<true>;
-}, z.core.$strict>;
 declare const sessionSchema: z.ZodObject<{
     purchaseToken: z.ZodString;
     managementUrl: z.ZodString;
@@ -29,15 +25,9 @@ declare const restoreSchema: z.ZodObject<{
     publicPrefix: z.ZodNullable<z.ZodString>;
     recoveryKey: z.ZodString;
 }, z.core.$strict>;
-declare const prefixSchema: z.ZodObject<{
-    publicPrefix: z.ZodString;
-    mcpUrl: z.ZodString;
-    webUrl: z.ZodString;
-}, z.core.$strict>;
 export declare class CloudApiClient {
     private readonly baseUrl;
     constructor(baseUrl: string);
-    registerDevice(identity: DeviceIdentity): Promise<z.infer<typeof registrationSchema>>;
     createManagementSession(identity: DeviceIdentity): Promise<z.infer<typeof sessionSchema>>;
     status(identity: DeviceIdentity, purchaseToken: string | null): Promise<{
         managementSessionActive: boolean;
@@ -49,7 +39,6 @@ export declare class CloudApiClient {
     }>;
     restore(identity: DeviceIdentity, recoveryKey: string): Promise<z.infer<typeof restoreSchema>>;
     replaceRecoveryKey(identity: DeviceIdentity): Promise<z.infer<typeof recoveryCredentialSchema>>;
-    setPrefix(identity: DeviceIdentity, prefix: string): Promise<z.infer<typeof prefixSchema>>;
     lease(identity: DeviceIdentity, requestedServices: CloudServiceId[]): Promise<CloudLeaseState>;
     private devicePost;
 }

package/dist/plugins/cloud/api-client.js

@@ -7,12 +7,6 @@ const recoveryCredentialSchema = z
     recoveryKey: z.string().regex(/^crr\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/),
 })
     .strict();
-const registrationSchema = z
-    .object({
-    installationId: z.string().uuid(),
-    registered: z.literal(true),
-})
-    .strict();
 const sessionSchema = z
     .object({
     purchaseToken: z.string().min(24),
@@ -36,22 +30,11 @@ const restoreSchema = z
     recoveryKey: z.string().regex(/^crr\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/),
 })
     .strict();
-const prefixSchema = z
-    .object({
-    publicPrefix: z.string().min(1),
-    mcpUrl: z.string().url(),
-    webUrl: z.string().url(),
-})
-    .strict();
 export class CloudApiClient {
     baseUrl;
     constructor(baseUrl) {
         this.baseUrl = baseUrl;
     }
-    async registerDevice(identity) {
-        const payload = { devicePublicKey: identity.devicePublicKey };
-        return registrationSchema.parse(await this.devicePost("/v1/device/register", "register", identity, payload));
-    }
     async createManagementSession(identity) {
         const payload = { devicePublicKey: identity.devicePublicKey };
         return sessionSchema.parse(await this.devicePost("/v1/device/session", "session", identity, payload));
@@ -71,10 +54,6 @@ export class CloudApiClient {
         const payload = { devicePublicKey: identity.devicePublicKey };
         return recoveryCredentialSchema.parse(await this.devicePost("/v1/device/recovery-key", "recovery-key", identity, payload));
     }
-    async setPrefix(identity, prefix) {
-        const payload = { devicePublicKey: identity.devicePublicKey, prefix };
-        return prefixSchema.parse(await this.devicePost("/v1/device/prefix", "prefix", identity, payload));
-    }
     async lease(identity, requestedServices) {
         const payload = {
             devicePublicKey: identity.devicePublicKey,

package/dist/plugins/cloud/controller.d.ts

@@ -24,7 +24,6 @@ export declare class CloudController {
     status(): CloudStatus;
     start(): Promise<void>;
     stop(): Promise<void>;
-    registerDevice(): Promise<CloudStatus>;
     managementUrl(): Promise<{
         url: string;
         expiresAt: string;
@@ -35,7 +34,6 @@ export declare class CloudController {
         recoveryKey: string;
     }>;
     replaceRecoveryKey(): Promise<string>;
-    setPrefix(prefix: string): Promise<CloudStatus>;
     setService(service: CloudServiceId, enabled: boolean): Promise<CloudStatus>;
     private refreshLeaseIfNeeded;
     private connectTunnel;

package/dist/plugins/cloud/controller.js

@@ -65,11 +65,6 @@ export class CloudController {
         if (this.state.lease)
             this.connection = "disconnected";
     }
-    async registerDevice() {
-        await this.api.registerDevice(this.identity());
-        this.lastError = null;
-        return this.status();
-    }
     async managementUrl() {
         const current = this.state.managementSession;
         if (current && Date.parse(current.expiresAt) > Date.now()) {
@@ -139,18 +134,6 @@ export class CloudController {
         const result = await this.api.replaceRecoveryKey(this.identity());
         return result.recoveryKey;
     }
-    async setPrefix(prefix) {
-        const result = await this.api.setPrefix(this.identity(), prefix);
-        this.state = { ...this.state, publicPrefix: result.publicPrefix };
-        await this.store.save(this.state);
-        if (!this.stopped && this.state.entitlements.length > 0) {
-            await this.refreshLeaseIfNeeded(true);
-            this.connectTunnel();
-            this.scheduleRenewal();
-        }
-        this.lastError = null;
-        return this.status();
-    }
     async setService(service, enabled) {
         if (!CLOUD_SERVICES.includes(service))
             throw new Error(`Unknown Cloud service: ${service}`);

package/dist/plugins/cloud/tunnel-client.d.ts

@@ -1,4 +1,8 @@
 import { type CloudLeaseState } from "./types.js";
+interface TunnelTimings {
+    readyTimeoutMs: number;
+    heartbeatIntervalMs: number;
+}
 export declare class CloudTunnelClient {
     private lease;
     private readonly identity;
@@ -6,11 +10,15 @@ export declare class CloudTunnelClient {
     private readonly callbacks;
     private socket;
     private reconnectTimer;
+    private readyTimer;
+    private heartbeatTimer;
+    private awaitingPong;
     private stopped;
     private attempts;
     private closeWhenIdle;
     private acceptingServices;
     private readonly streams;
+    private readonly timings;
     constructor(lease: CloudLeaseState, identity: {
         devicePrivateKey: string;
     }, local: {
@@ -20,7 +28,7 @@ export declare class CloudTunnelClient {
         onConnected(): void;
         onDisconnected(): void;
         onError(error: Error): void;
-    });
+    }, timings?: Partial<TunnelTimings>);
     start(): void;
     stop(): void;
     drainAndStop(): void;
@@ -32,5 +40,11 @@ export declare class CloudTunnelClient {
     private handleBinary;
     private send;
     private sendBinary;
+    private startReadyTimeout;
+    private clearReadyTimeout;
+    private startHeartbeat;
+    private clearSocketTimers;
+    private failSocket;
     private scheduleReconnect;
 }
+export {};

package/dist/plugins/cloud/tunnel-client.js

@@ -5,6 +5,8 @@ import { cloudServiceForPublicService, } from "./types.js";
 const PROTOCOL = "chatroom-tunnel-v1";
 const HIGH_WATER = 8 * 1024 * 1024;
 const LOW_WATER = 2 * 1024 * 1024;
+const READY_TIMEOUT_MS = 10_000;
+const HEARTBEAT_INTERVAL_MS = 20_000;
 export class CloudTunnelClient {
     lease;
     identity;
@@ -12,17 +14,25 @@ export class CloudTunnelClient {
     callbacks;
     socket = null;
     reconnectTimer = null;
+    readyTimer = null;
+    heartbeatTimer = null;
+    awaitingPong = false;
     stopped = true;
     attempts = 0;
     closeWhenIdle = null;
     acceptingServices;
     streams = new Map();
-    constructor(lease, identity, local, callbacks) {
+    timings;
+    constructor(lease, identity, local, callbacks, timings = {}) {
         this.lease = lease;
         this.identity = identity;
         this.local = local;
         this.callbacks = callbacks;
         this.acceptingServices = new Set(lease.services);
+        this.timings = {
+            readyTimeoutMs: timings.readyTimeoutMs ?? READY_TIMEOUT_MS,
+            heartbeatIntervalMs: timings.heartbeatIntervalMs ?? HEARTBEAT_INTERVAL_MS,
+        };
     }
     start() {
         if (!this.stopped)
@@ -39,6 +49,7 @@ export class CloudTunnelClient {
         if (this.reconnectTimer)
             clearTimeout(this.reconnectTimer);
         this.reconnectTimer = null;
+        this.clearSocketTimers();
         this.socket?.close();
         this.socket = null;
         for (const stream of this.streams.values())
@@ -51,6 +62,7 @@ export class CloudTunnelClient {
         if (this.reconnectTimer)
             clearTimeout(this.reconnectTimer);
         this.reconnectTimer = null;
+        this.clearSocketTimers();
         if (this.streams.size === 0) {
             this.closeWhenIdle = null;
             this.socket?.close();
@@ -59,14 +71,21 @@ export class CloudTunnelClient {
         this.closeWhenIdle = "stop";
     }
     updateLease(lease) {
-        const previousServices = this.lease.services;
-        const reconnect = lease.token !== this.lease.token ||
-            lease.tunnelUrl !== this.lease.tunnelUrl;
-        const removesService = previousServices.some((service) => !lease.services.includes(service));
+        const tunnelChanged = lease.tunnelUrl !== this.lease.tunnelUrl;
+        const removesService = this.lease.services.some((service) => !lease.services.includes(service));
         this.lease = lease;
         this.acceptingServices = new Set(lease.services);
-        if (!reconnect || this.stopped)
+        if (this.stopped)
             return;
+        // A new signed lease on the same tunnel is applied in-band. This keeps the
+        // current WebUI/API request alive while service permissions change.
+        if (!tunnelChanged) {
+            if (this.socket?.readyState === WebSocket.OPEN)
+                this.send({ type: "update-lease", lease: lease.token });
+            return;
+        }
+        // Changing the tunnel endpoint still requires a reconnect. If a service is
+        // being removed, let current streams finish before moving the connection.
         if (!removesService || this.streams.size === 0) {
             this.socket?.close();
             return;
@@ -79,6 +98,7 @@ export class CloudTunnelClient {
         const socket = new WebSocket(this.lease.tunnelUrl, PROTOCOL);
         this.socket = socket;
         socket.binaryType = "nodebuffer";
+        this.startReadyTimeout(socket);
         socket.on("message", (data, isBinary) => {
             try {
                 if (isBinary)
@@ -91,9 +111,15 @@ export class CloudTunnelClient {
                 socket.close();
             }
         });
-        socket.on("close", () => {
+        socket.on("pong", () => {
             if (this.socket === socket)
+                this.awaitingPong = false;
+        });
+        socket.on("close", () => {
+            if (this.socket === socket) {
+                this.clearSocketTimers();
                 this.socket = null;
+            }
             this.closeWhenIdle = null;
             for (const stream of this.streams.values())
                 stream.request.destroy();
@@ -102,7 +128,7 @@ export class CloudTunnelClient {
             if (!this.stopped)
                 this.scheduleReconnect();
         });
-        socket.on("error", (error) => this.callbacks.onError(error));
+        socket.on("error", (error) => this.failSocket(socket, error));
     }
     handleControl(message) {
         if (message.type === "challenge") {
@@ -115,6 +141,9 @@ export class CloudTunnelClient {
         }
         if (message.type === "ready") {
             this.attempts = 0;
+            this.clearReadyTimeout();
+            if (this.socket)
+                this.startHeartbeat(this.socket);
             this.callbacks.onConnected();
             return;
         }
@@ -241,6 +270,50 @@ export class CloudTunnelClient {
         socket.send(frame, { binary: true });
         return socket.bufferedAmount < HIGH_WATER;
     }
+    startReadyTimeout(socket) {
+        this.clearReadyTimeout();
+        this.readyTimer = setTimeout(() => {
+            this.readyTimer = null;
+            this.failSocket(socket, new Error("Tunnel connection timed out"));
+        }, this.timings.readyTimeoutMs);
+        this.readyTimer.unref();
+    }
+    clearReadyTimeout() {
+        if (this.readyTimer)
+            clearTimeout(this.readyTimer);
+        this.readyTimer = null;
+    }
+    startHeartbeat(socket) {
+        if (this.heartbeatTimer)
+            clearInterval(this.heartbeatTimer);
+        this.awaitingPong = false;
+        this.heartbeatTimer = setInterval(() => {
+            if (this.socket !== socket || socket.readyState !== WebSocket.OPEN)
+                return;
+            if (this.awaitingPong) {
+                this.failSocket(socket, new Error("Tunnel heartbeat timed out"));
+                return;
+            }
+            this.awaitingPong = true;
+            socket.ping();
+        }, this.timings.heartbeatIntervalMs);
+        this.heartbeatTimer.unref();
+    }
+    clearSocketTimers() {
+        this.clearReadyTimeout();
+        if (this.heartbeatTimer)
+            clearInterval(this.heartbeatTimer);
+        this.heartbeatTimer = null;
+        this.awaitingPong = false;
+    }
+    failSocket(socket, error) {
+        if (this.socket !== socket)
+            return;
+        this.callbacks.onError(error);
+        this.clearSocketTimers();
+        this.socket = null;
+        socket.terminate();
+    }
     scheduleReconnect() {
         if (this.reconnectTimer || this.stopped)
             return;

package/dist/plugins/web/http/cloud-api-router.js

@@ -5,7 +5,6 @@ import { asyncRoute } from "../../../presentation/http/http-utils.js";
 export function createCloudApiRouter(controller, operations) {
     const router = Router();
     router.get("/cloud/status", (_req, res) => res.json(controller.status()));
-    router.post("/cloud/register", asyncRoute(async (_req, res) => res.json(await operations.run({ pluginId: "cloud", source: "gui", action: "register" }, () => controller.registerDevice()))));
     router.post("/cloud/sync", asyncRoute(async (_req, res) => res.json(await operations.run({ pluginId: "cloud", source: "gui", action: "sync" }, () => controller.syncStatus()))));
     router.post("/cloud/management", asyncRoute(async (_req, res) => res.json(await operations.run({ pluginId: "cloud", source: "gui", action: "management" }, () => controller.managementUrl()))));
     router.post("/cloud/restore", asyncRoute(async (req, res) => {
@@ -16,18 +15,6 @@ export function createCloudApiRouter(controller, operations) {
         res.json(await operations.run({ pluginId: "cloud", source: "gui", action: "restore", input: body }, () => controller.restore(body.recoveryKey)));
     }));
     router.post("/cloud/recovery-key", asyncRoute(async (_req, res) => res.json(await operations.run({ pluginId: "cloud", source: "gui", action: "recovery-key.replace" }, async () => ({ recoveryKey: await controller.replaceRecoveryKey() })))));
-    router.post("/cloud/prefix", asyncRoute(async (req, res) => {
-        const body = z
-            .object({ prefix: z.string().min(1).max(64) })
-            .strict()
-            .parse(req.body);
-        res.json(await operations.run({
-            pluginId: "cloud",
-            source: "gui",
-            action: "prefix.set",
-            input: body,
-        }, () => controller.setPrefix(body.prefix)));
-    }));
     router.post("/cloud/services/:service", asyncRoute(async (req, res) => {
         const service = CLOUD_SERVICE_SCHEMA.parse(req.params.service);
         const body = z.object({ enabled: z.boolean() }).strict().parse(req.body);