@arcote.tech/arc-host 0.3.4 → 0.4.1

package/src/middleware/ws.ts

@@ -0,0 +1,266 @@
+import { ScopedModel } from "@arcote.tech/arc";
+import { filterEventsForTokens } from "../event-auth";
+import type { ConnectedClient } from "../types";
+import type { ArcWsContext, ArcWsHandler } from "./types";
+
+// ---------------------------------------------------------------------------
+// View subscription tracking (per client)
+// ---------------------------------------------------------------------------
+
+const clientViewSubs = new Map<string, Map<string, () => void>>();
+
+export function cleanupClientSubs(clientId: string): void {
+  const subs = clientViewSubs.get(clientId);
+  if (subs) {
+    for (const unsub of subs.values()) unsub();
+    clientViewSubs.delete(clientId);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// scope:auth
+// ---------------------------------------------------------------------------
+
+export function scopeAuthHandler(): ArcWsHandler {
+  return async (client, message, ctx) => {
+    if (message.type !== "scope:auth") return false;
+    const decoded = ctx.verifyToken(message.token);
+    if (decoded) {
+      ctx.connectionManager.setScopeToken(
+        client.id,
+        message.scope,
+        decoded,
+        message.token,
+      );
+    }
+    return true;
+  };
+}
+
+// ---------------------------------------------------------------------------
+// sync-events — persist + broadcast
+// ---------------------------------------------------------------------------
+
+export function syncEventsHandler(): ArcWsHandler {
+  return async (client, message, ctx) => {
+    if (message.type !== "sync-events") return false;
+
+    const allTokens = ctx.connectionManager.getAllScopeTokens(client.id);
+    const token = allTokens.length > 0 ? allTokens[0] : null;
+
+    const persisted = await ctx.contextHandler.persistEvents(
+      message.events,
+      client.id,
+      token,
+    );
+    if (persisted.length === 0) return true;
+
+    // Broadcast to other authorized clients
+    for (const c of ctx.connectionManager.getAllClients()) {
+      if (c.id === client.id) continue;
+      const clientTokens = ctx.connectionManager.getAllScopeTokens(c.id);
+      const authorized = filterEventsForTokens(
+        clientTokens,
+        persisted,
+        ctx.contextHandler.getEventDefinitions(),
+      );
+      if (authorized.length > 0) {
+        ctx.connectionManager.sendToClient(c.id, {
+          type: "events",
+          events: authorized,
+        });
+      }
+    }
+
+    const last = persisted[persisted.length - 1];
+    ctx.connectionManager.updateLastSyncedEventId(client.id, last.hostId);
+    ctx.connectionManager.sendToClient(client.id, {
+      type: "sync-complete",
+      lastHostEventId: last.hostId,
+    });
+    return true;
+  };
+}
+
+// ---------------------------------------------------------------------------
+// request-sync — initial sync or catch-up
+// ---------------------------------------------------------------------------
+
+export function requestSyncHandler(): ArcWsHandler {
+  return async (client, message, ctx) => {
+    if (message.type !== "request-sync") return false;
+
+    const allTokens = ctx.connectionManager.getAllScopeTokens(client.id);
+    const token = allTokens.length > 0 ? allTokens[0] : null;
+    const events = await ctx.contextHandler.getEventsSince(
+      message.lastHostEventId,
+      token,
+    );
+
+    ctx.connectionManager.sendToClient(client.id, {
+      type: "events",
+      events,
+    });
+
+    if (events.length > 0) {
+      const last = events[events.length - 1];
+      ctx.connectionManager.updateLastSyncedEventId(client.id, last.hostId);
+      ctx.connectionManager.sendToClient(client.id, {
+        type: "sync-complete",
+        lastHostEventId: last.hostId,
+      });
+    } else {
+      ctx.connectionManager.sendToClient(client.id, {
+        type: "sync-complete",
+        lastHostEventId: message.lastHostEventId || "",
+      });
+    }
+    return true;
+  };
+}
+
+// ---------------------------------------------------------------------------
+// execute-command
+// ---------------------------------------------------------------------------
+
+export function executeCommandHandler(): ArcWsHandler {
+  return async (client, message, ctx) => {
+    if (message.type !== "execute-command") return false;
+
+    let rawToken: string | null = null;
+    if (client.scopeTokens.size > 0) {
+      rawToken = client.scopeTokens.values().next().value!.raw;
+    }
+
+    try {
+      const result = await ctx.contextHandler.executeCommand(
+        message.commandName,
+        message.params,
+        rawToken,
+      );
+      ctx.connectionManager.sendToClient(client.id, {
+        type: "command-result",
+        requestId: message.requestId,
+        result,
+      });
+    } catch (error) {
+      ctx.connectionManager.sendToClient(client.id, {
+        type: "command-result",
+        requestId: message.requestId,
+        error: (error as Error).message,
+      });
+    }
+    return true;
+  };
+}
+
+// ---------------------------------------------------------------------------
+// subscribe-view / unsubscribe-view — with scope-aware token selection
+// ---------------------------------------------------------------------------
+
+export function querySubscriptionHandler(): ArcWsHandler {
+  return async (client, message, ctx) => {
+    if (message.type === "subscribe-query") {
+      const { subscriptionId, descriptor, scope } = message;
+
+      // Pick the token matching the requested scope
+      const scopeToken = scope ? client.scopeTokens.get(scope) : null;
+      let rawToken = scopeToken?.raw ?? null;
+
+      // Fallback to first available token if no scope specified
+      if (!rawToken && client.scopeTokens.size > 0) {
+        rawToken = client.scopeTokens.values().next().value!.raw;
+      }
+
+      // Per-request scoped model with the right token
+      const scoped = new ScopedModel(ctx.contextHandler.getModel(), scope ?? "default");
+      if (rawToken) scoped.setToken(rawToken);
+
+      // Cache last result to avoid re-sending unchanged data
+      let lastResultJson = "";
+
+      const sendData = async () => {
+        try {
+          const data = await scoped.callQuery(descriptor);
+          const json = JSON.stringify(data ?? null);
+          if (json === lastResultJson) return; // No change — skip
+          lastResultJson = json;
+          ctx.connectionManager.sendToClient(client.id, {
+            type: "query-data",
+            subscriptionId,
+            data: data ?? null,
+          } as any);
+        } catch (err) {
+          console.error(`[Arc] Query subscription error:`, err);
+        }
+      };
+
+      // Initial data
+      sendData();
+
+      // Subscribe to SPECIFIC event types this element handles (not wildcard)
+      const element = ctx.contextHandler.getModel().context.get(descriptor.element);
+      const eventTypes = (element as any)?.getElements?.()?.map((e: any) => e.name) ?? [];
+
+      let debounceTimer: ReturnType<typeof setTimeout> | undefined;
+      const debouncedSend = () => {
+        if (debounceTimer) clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(() => sendData(), 50);
+      };
+
+      const unsubscribes: (() => void)[] = [];
+      if (eventTypes.length > 0) {
+        for (const eventType of eventTypes) {
+          unsubscribes.push(
+            ctx.contextHandler.getEventPublisher().subscribe(eventType, debouncedSend),
+          );
+        }
+      } else {
+        // Fallback to wildcard if no event types declared
+        unsubscribes.push(
+          ctx.contextHandler.getEventPublisher().subscribe("*", debouncedSend),
+        );
+      }
+
+      const cleanup = () => {
+        if (debounceTimer) clearTimeout(debounceTimer);
+        for (const unsub of unsubscribes) unsub();
+      };
+
+      // Track for cleanup on disconnect
+      if (!clientViewSubs.has(client.id)) {
+        clientViewSubs.set(client.id, new Map());
+      }
+      clientViewSubs.get(client.id)!.set(subscriptionId, cleanup);
+      return true;
+    }
+
+    if (message.type === "unsubscribe-query") {
+      const subs = clientViewSubs.get(client.id);
+      if (subs) {
+        const unsub = subs.get(message.subscriptionId);
+        if (unsub) {
+          unsub();
+          subs.delete(message.subscriptionId);
+        }
+      }
+      return true;
+    }
+
+    return false;
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Convenience: all Arc WS handlers
+// ---------------------------------------------------------------------------
+
+export function arcWsHandlers(): ArcWsHandler[] {
+  return [
+    scopeAuthHandler(),
+    syncEventsHandler(),
+    requestSyncHandler(),
+    executeCommandHandler(),
+    querySubscriptionHandler(),
+  ];
+}

package/src/types.ts

@@ -36,10 +36,8 @@ export interface TokenPayload {
 export interface ConnectedClient {
   /** Unique client ID */
   id: string;
-  /** Token payload (decoded) */
-  token: TokenPayload | null;
-  /** Raw JWT token string */
-  rawToken: string | null;
+  /** Scope tokens: Map<scope, { decoded, raw }> */
+  scopeTokens: Map<string, { decoded: TokenPayload; raw: string }>;
   /** Last synced host event ID */
   lastHostEventId: string | null;
   /** WebSocket instance */
@@ -86,6 +84,21 @@ export type ClientToHostMessage =
       commandName: string;
       params: any;
       requestId: string;
+    }
+  | {
+      type: "scope:auth";
+      scope: string;
+      token: string;
+    }
+  | {
+      type: "subscribe-query";
+      subscriptionId: string;
+      descriptor: { element: string; method: string; args: any[] };
+      scope?: string;
+    }
+  | {
+      type: "unsubscribe-query";
+      subscriptionId: string;
     };
 
 /**
@@ -109,4 +122,9 @@ export type HostToClientMessage =
   | {
       type: "error";
       message: string;
+    }
+  | {
+      type: "query-data";
+      subscriptionId: string;
+      data: any[];
     };

package/dist/src/arc-host.d.ts

@@ -1,81 +0,0 @@
-import type { ArcHostConfig } from "./types";
-/**
- * Arc Host - WebSocket server for real-time event sync
- */
-export declare class ArcHost {
-    private config;
-    private server;
-    private connectionManager;
-    private contextHandler;
-    private streamConnections;
-    private jwtSecret;
-    private port;
-    private streamIdCounter;
-    constructor(config: ArcHostConfig);
-    /**
-     * Start the host server
-     */
-    start(): Promise<void>;
-    /**
-     * Verify JWT token
-     * Supports both standard JWT (jsonwebtoken) and Arc's custom JWT format
-     */
-    private verifyToken;
-    /**
-     * Handle WebSocket message
-     */
-    private handleMessage;
-    /**
-     * Handle sync-events message
-     */
-    private handleSyncEvents;
-    /**
-     * Handle request-sync message (initial sync or catch-up)
-     */
-    private handleRequestSync;
-    /**
-     * Handle execute-command message
-     */
-    private handleExecuteCommand;
-    /**
-     * Send error to WebSocket
-     */
-    private sendError;
-    /**
-     * Setup Bun server
-     */
-    private setupServer;
-    /**
-     * Handle HTTP command request
-     * Supports both JSON and FormData (for file uploads)
-     */
-    private handleHttpCommand;
-    /**
-     * Parse command parameters from request body
-     * Handles both JSON and FormData (multipart/form-data for file uploads)
-     */
-    private parseCommandParams;
-    /**
-     * Handle HTTP query request
-     * Uses view.queryContext() to apply protections consistently with liveQuery
-     */
-    private handleHttpQuery;
-    /**
-     * Handle HTTP stream (SSE) request for live queries
-     */
-    private handleHttpStream;
-    /**
-     * Handle HTTP event sync request
-     */
-    private handleHttpEventSync;
-    /**
-     * Handle HTTP route request
-     * Matches path against registered routes and executes handler
-     */
-    private handleHttpRoute;
-    /**
-     * Stop the server
-     */
-    stop(): void;
-}
-//# sourceMappingURL=arc-host.d.ts.map

package/dist/src/arc-host.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"arc-host.d.ts","sourceRoot":"","sources":["../../src/arc-host.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACV,aAAa,EAId,MAAM,SAAS,CAAC;AAiBjB;;GAEG;AACH,qBAAa,OAAO;IASN,OAAO,CAAC,MAAM;IAR1B,OAAO,CAAC,MAAM,CAAyB;IACvC,OAAO,CAAC,iBAAiB,CAA2B;IACpD,OAAO,CAAC,cAAc,CAAkB;IACxC,OAAO,CAAC,iBAAiB,CAAuC;IAChE,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,eAAe,CAAK;gBAER,MAAM,EAAE,aAAa;IAQzC;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAS5B;;;OAGG;IACH,OAAO,CAAC,WAAW;IAuCnB;;OAEG;YACW,aAAa;IA4B3B;;OAEG;YACW,gBAAgB;IAgD9B;;OAEG;YACW,iBAAiB;IAkC/B;;OAEG;YACW,oBAAoB;IA0BlC;;OAEG;IACH,OAAO,CAAC,SAAS;IAIjB;;OAEG;IACH,OAAO,CAAC,WAAW;IA6JnB;;;OAGG;YACW,iBAAiB;IAqC/B;;;OAGG;YACW,kBAAkB;IAmChC;;;OAGG;YACW,eAAe;IAoD7B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IA+GxB;;OAEG;YACW,mBAAmB;IA4CjC;;;OAGG;YACW,eAAe;IA6H7B;;OAEG;IACH,IAAI,IAAI,IAAI;CASb"}