@chatroomcp/chatroom 0.1.5 → 0.1.6

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.js

@@ -59,14 +59,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;

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);