@memo-code/memo 0.8.5 → 0.8.6

package/dist/web/server/ws/ws-gateway.service.js

@@ -1,473 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var WsGatewayService_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WsGatewayService = void 0;
-const node_crypto_1 = require("node:crypto");
-const common_1 = require("@nestjs/common");
-const ws_1 = require("ws");
-const stream_service_1 = require("../stream/stream.service");
-const rpc_router_service_1 = require("./rpc-router.service");
-const session_runtime_registry_service_1 = require("./session-runtime-registry.service");
-const ws_errors_1 = require("./ws.errors");
-const ws_event_bus_service_1 = require("./ws-event-bus.service");
-const WS_PATH = '/api/ws';
-const MAX_REQUEST_BYTES = 256 * 1024;
-const MAX_REQUESTS_PER_MINUTE = 120;
-const REQUEST_TIMEOUT_MS = 20_000;
-function readBearerTokenFromHeader(authorization) {
-    if (!authorization)
-        return null;
-    const raw = Array.isArray(authorization) ? authorization[0] : authorization;
-    if (!raw)
-        return null;
-    const [scheme, token] = raw.split(' ');
-    if (scheme !== 'Bearer' || !token)
-        return null;
-    const trimmed = token.trim();
-    return trimmed.length > 0 ? trimmed : null;
-}
-function asRpcRequest(input) {
-    if (!input || typeof input !== 'object' || Array.isArray(input)) {
-        throw new ws_errors_1.WsRpcError('BAD_FRAME', 'Invalid frame payload');
-    }
-    const frame = input;
-    if (frame.type !== 'rpc.request') {
-        throw new ws_errors_1.WsRpcError('BAD_FRAME', 'Frame type must be rpc.request');
-    }
-    if (typeof frame.id !== 'string' || !frame.id.trim()) {
-        throw new ws_errors_1.WsRpcError('BAD_FRAME', 'Frame id is required');
-    }
-    if (typeof frame.method !== 'string' || !frame.method.trim()) {
-        throw new ws_errors_1.WsRpcError('BAD_FRAME', 'Frame method is required');
-    }
-    return {
-        id: frame.id,
-        type: 'rpc.request',
-        method: frame.method,
-        params: frame.params,
-    };
-}
-function rawByteLength(raw) {
-    if (typeof raw === 'string') {
-        return Buffer.byteLength(raw);
-    }
-    if (raw instanceof ArrayBuffer) {
-        return raw.byteLength;
-    }
-    if (Array.isArray(raw)) {
-        return raw.reduce((total, chunk) => total + chunk.byteLength, 0);
-    }
-    return raw.byteLength;
-}
-function rawToUtf8(raw) {
-    if (typeof raw === 'string') {
-        return raw;
-    }
-    if (raw instanceof ArrayBuffer) {
-        return Buffer.from(raw).toString('utf8');
-    }
-    if (Array.isArray(raw)) {
-        return Buffer.concat(raw.map((chunk) => Buffer.from(chunk))).toString('utf8');
-    }
-    return raw.toString('utf8');
-}
-let WsGatewayService = WsGatewayService_1 = class WsGatewayService {
-    rpcRouter;
-    streamService;
-    sessionRegistry;
-    eventBus;
-    logger = new common_1.Logger(WsGatewayService_1.name);
-    connections = new Map();
-    wsServer = null;
-    attached = false;
-    globalStreamUnsubscribe = null;
-    constructor(rpcRouter, streamService, sessionRegistry, eventBus) {
-        this.rpcRouter = rpcRouter;
-        this.streamService = streamService;
-        this.sessionRegistry = sessionRegistry;
-        this.eventBus = eventBus;
-    }
-    attach(options) {
-        if (this.attached)
-            return;
-        this.attached = true;
-        this.wsServer = new ws_1.WebSocketServer({ noServer: true });
-        this.globalStreamUnsubscribe = this.streamService.subscribeAll((sessionId, payload) => {
-            const data = this.mapRuntimeStatusPayload(sessionId, payload);
-            if (!data)
-                return;
-            this.sessionRegistry.setWorkspaceId(sessionId, data.workspaceId);
-            this.sessionRegistry.setStatus(sessionId, data.status);
-            this.broadcastEventToAll('chat.runtime.status', data);
-        });
-        options.httpServer.on('upgrade', (request, socket, head) => {
-            const requestUrl = new URL(request.url ?? '/', 'http://127.0.0.1');
-            if (requestUrl.pathname !== WS_PATH || !this.wsServer)
-                return;
-            this.wsServer.handleUpgrade(request, socket, head, (ws) => {
-                void this.handleConnection(ws, request, options.verifyAccessToken);
-            });
-        });
-    }
-    async onModuleDestroy() {
-        if (!this.wsServer)
-            return;
-        if (this.globalStreamUnsubscribe) {
-            this.globalStreamUnsubscribe();
-            this.globalStreamUnsubscribe = null;
-        }
-        for (const connection of this.connections.values()) {
-            for (const unsubscribe of connection.sessionSubscriptions.values()) {
-                unsubscribe();
-            }
-            connection.sessionSubscriptions.clear();
-            connection.socket.close(1001, 'server shutdown');
-        }
-        this.connections.clear();
-        await new Promise((resolve) => {
-            this.wsServer?.close(() => resolve());
-        });
-        this.wsServer = null;
-    }
-    async handleConnection(socket, request, verifyAccessToken) {
-        const requestUrl = new URL(request.url ?? '/', 'http://127.0.0.1');
-        const queryToken = requestUrl.searchParams.get('accessToken')?.trim() ?? null;
-        const headerToken = readBearerTokenFromHeader(request.headers.authorization);
-        const accessToken = headerToken ?? queryToken;
-        if (!accessToken) {
-            socket.close(ws_errors_1.WS_CLOSE_UNAUTHORIZED, 'UNAUTHORIZED');
-            return;
-        }
-        let payload;
-        try {
-            payload = await verifyAccessToken(accessToken);
-        }
-        catch {
-            socket.close(ws_errors_1.WS_CLOSE_UNAUTHORIZED, 'UNAUTHORIZED');
-            return;
-        }
-        const connection = {
-            id: (0, node_crypto_1.randomUUID)(),
-            socket,
-            username: payload.sub,
-            requestWindow: [],
-            sessionSubscriptions: new Map(),
-        };
-        this.connections.set(connection.id, connection);
-        socket.on('message', (raw) => {
-            void this.handleMessage(connection, raw);
-        });
-        socket.on('close', () => {
-            this.cleanupConnection(connection.id);
-        });
-        socket.on('error', (error) => {
-            this.logger.warn(`ws connection error: ${error.message}`);
-            this.cleanupConnection(connection.id);
-        });
-    }
-    async handleMessage(connection, raw) {
-        if (rawByteLength(raw) > MAX_REQUEST_BYTES) {
-            connection.socket.close(1009, 'FRAME_TOO_LARGE');
-            return;
-        }
-        const now = Date.now();
-        let removeCount = 0;
-        while (removeCount < connection.requestWindow.length &&
-            now - connection.requestWindow[removeCount] >= 60_000) {
-            removeCount += 1;
-        }
-        if (removeCount > 0) {
-            connection.requestWindow.splice(0, removeCount);
-        }
-        connection.requestWindow.push(now);
-        if (connection.requestWindow.length > MAX_REQUESTS_PER_MINUTE) {
-            this.sendRpcError(connection, null, new ws_errors_1.WsRpcError('RATE_LIMITED', 'Too many requests on this websocket connection.'));
-            return;
-        }
-        let parsed;
-        try {
-            const payload = JSON.parse(rawToUtf8(raw));
-            parsed = asRpcRequest(payload);
-        }
-        catch (error) {
-            const wsError = error instanceof ws_errors_1.WsRpcError
-                ? error
-                : new ws_errors_1.WsRpcError('BAD_FRAME', error instanceof Error ? error.message : 'Invalid frame');
-            this.sendRpcError(connection, null, wsError);
-            return;
-        }
-        const timer = setTimeout(() => {
-            settled = true;
-            this.sendRpcError(connection, parsed.id, new ws_errors_1.WsRpcError('TIMEOUT', `RPC timeout after ${REQUEST_TIMEOUT_MS}ms`));
-        }, REQUEST_TIMEOUT_MS);
-        let settled = false;
-        try {
-            const result = await this.rpcRouter.dispatch({
-                connectionId: connection.id,
-                username: connection.username,
-            }, parsed.method, parsed.params);
-            if (parsed.method === 'chat.session.attach') {
-                const params = parsed.params &&
-                    typeof parsed.params === 'object' &&
-                    !Array.isArray(parsed.params)
-                    ? parsed.params
-                    : {};
-                const sessionId = typeof params.sessionId === 'string' ? params.sessionId : '';
-                if (sessionId) {
-                    this.bindSession(connection, sessionId);
-                }
-                const snapshot = result;
-                if (snapshot?.state?.workspaceId) {
-                    this.sessionRegistry.setWorkspaceId(sessionId, snapshot.state.workspaceId);
-                }
-                this.sendEvent(connection, 'chat.session.snapshot', {
-                    sessionId,
-                    state: snapshot.state,
-                    turns: snapshot.turns,
-                });
-            }
-            if (parsed.method === 'chat.session.close' ||
-                parsed.method === 'sessions.remove') {
-                const params = parsed.params &&
-                    typeof parsed.params === 'object' &&
-                    !Array.isArray(parsed.params)
-                    ? parsed.params
-                    : {};
-                const sessionId = typeof params.sessionId === 'string' ? params.sessionId : '';
-                if (sessionId) {
-                    this.unbindSession(connection, sessionId);
-                }
-            }
-            if (parsed.method === 'workspace.add' ||
-                parsed.method === 'workspace.update' ||
-                parsed.method === 'workspace.remove') {
-                this.broadcastEventToAll('workspace.changed', {
-                    action: parsed.method,
-                    payload: result,
-                });
-            }
-            if (settled)
-                return;
-            settled = true;
-            this.sendRpcSuccess(connection, parsed.id, result);
-        }
-        catch (error) {
-            if (settled)
-                return;
-            settled = true;
-            const wsError = this.toWsRpcError(error);
-            this.sendRpcError(connection, parsed.id, wsError);
-            if (parsed.method === 'chat.session.attach' &&
-                wsError.code === 'SESSION_OCCUPIED') {
-                connection.socket.close(ws_errors_1.WS_CLOSE_SESSION_OCCUPIED, 'SESSION_OCCUPIED');
-            }
-            if (parsed.method === 'chat.session.attach' &&
-                wsError.code === 'SESSION_NOT_FOUND') {
-                connection.socket.close(ws_errors_1.WS_CLOSE_NOT_FOUND, 'SESSION_NOT_FOUND');
-            }
-        }
-        finally {
-            clearTimeout(timer);
-        }
-    }
-    bindSession(connection, sessionId) {
-        if (connection.sessionSubscriptions.has(sessionId)) {
-            return;
-        }
-        const unsubscribe = this.streamService.subscribe(sessionId, (payload) => {
-            const mapped = this.mapStreamPayload(sessionId, payload);
-            if (!mapped)
-                return;
-            this.sendEvent(connection, mapped.topic, mapped.data);
-        });
-        connection.sessionSubscriptions.set(sessionId, unsubscribe);
-    }
-    unbindSession(connection, sessionId) {
-        const unsubscribe = connection.sessionSubscriptions.get(sessionId);
-        if (unsubscribe) {
-            unsubscribe();
-            connection.sessionSubscriptions.delete(sessionId);
-        }
-    }
-    cleanupConnection(connectionId) {
-        const connection = this.connections.get(connectionId);
-        if (!connection)
-            return;
-        const released = this.sessionRegistry.releaseAll(connection.id);
-        for (const sessionId of released) {
-            this.unbindSession(connection, sessionId);
-        }
-        for (const sessionId of Array.from(connection.sessionSubscriptions.keys())) {
-            this.unbindSession(connection, sessionId);
-        }
-        this.connections.delete(connectionId);
-    }
-    mapStreamPayload(sessionId, payload) {
-        if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
-            return null;
-        }
-        const frame = payload;
-        if (frame.type === 'turn.start') {
-            return {
-                topic: 'chat.turn.start',
-                data: { sessionId, ...frame.payload },
-            };
-        }
-        if (frame.type === 'assistant.chunk') {
-            return {
-                topic: 'chat.turn.chunk',
-                data: { sessionId, ...frame.payload },
-            };
-        }
-        if (frame.type === 'turn.final') {
-            return {
-                topic: 'chat.turn.final',
-                data: { sessionId, ...frame.payload },
-            };
-        }
-        if (frame.type === 'session.status') {
-            return {
-                topic: 'chat.session.status',
-                data: { sessionId, ...frame.payload },
-            };
-        }
-        if (frame.type === 'session.snapshot') {
-            return {
-                topic: 'chat.session.state',
-                data: { sessionId, state: frame.payload },
-            };
-        }
-        if (frame.type === 'system.message') {
-            return {
-                topic: 'chat.system.message',
-                data: { sessionId, ...frame.payload },
-            };
-        }
-        if (frame.type === 'approval.request') {
-            return {
-                topic: 'chat.approval.request',
-                data: { sessionId, ...frame.payload },
-            };
-        }
-        if (frame.type === 'tool.action') {
-            return {
-                topic: 'chat.tool.action',
-                data: { sessionId, ...frame.payload },
-            };
-        }
-        if (frame.type === 'tool.observation') {
-            return {
-                topic: 'chat.tool.observation',
-                data: { sessionId, ...frame.payload },
-            };
-        }
-        if (frame.type === 'error') {
-            return {
-                topic: 'chat.error',
-                data: { sessionId, ...frame.payload },
-            };
-        }
-        return null;
-    }
-    mapRuntimeStatusPayload(sessionId, payload) {
-        if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
-            return null;
-        }
-        const frame = payload;
-        if (frame.type !== 'session.status')
-            return null;
-        const workspaceId = frame.payload.workspaceId;
-        const updatedAt = frame.payload.updatedAt;
-        if (typeof workspaceId !== 'string' || !workspaceId.trim())
-            return null;
-        if (typeof updatedAt !== 'string' || !updatedAt.trim())
-            return null;
-        return {
-            sessionId,
-            status: frame.payload.status,
-            workspaceId,
-            updatedAt,
-        };
-    }
-    sendRpcSuccess(connection, id, data) {
-        const response = {
-            id,
-            type: 'rpc.response',
-            ok: true,
-            data,
-        };
-        this.sendSerialized(connection, JSON.stringify(response));
-    }
-    sendRpcError(connection, id, error) {
-        const response = {
-            id: id ?? (0, node_crypto_1.randomUUID)(),
-            type: 'rpc.response',
-            ok: false,
-            error: {
-                code: error.code,
-                message: error.message,
-                ...(error.details === undefined ? {} : { details: error.details }),
-            },
-        };
-        this.sendSerialized(connection, JSON.stringify(response));
-    }
-    sendEvent(connection, topic, data) {
-        const eventFrame = this.eventBus.create(topic, data);
-        this.sendSerialized(connection, JSON.stringify(eventFrame));
-    }
-    broadcastEventToAll(topic, data) {
-        if (this.connections.size === 0)
-            return;
-        const eventFrame = this.eventBus.create(topic, data);
-        const encoded = JSON.stringify(eventFrame);
-        for (const connection of this.connections.values()) {
-            this.sendSerialized(connection, encoded);
-        }
-    }
-    sendSerialized(connection, encoded) {
-        if (connection.socket.readyState !== connection.socket.OPEN) {
-            return;
-        }
-        try {
-            connection.socket.send(encoded);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            this.logger.warn(`ws send failed connection=${connection.id}: ${message}`);
-            this.cleanupConnection(connection.id);
-        }
-    }
-    toWsRpcError(error) {
-        if (error instanceof ws_errors_1.WsRpcError) {
-            return error;
-        }
-        if (error && typeof error === 'object' && 'message' in error) {
-            const message = typeof error.message === 'string'
-                ? (error.message ?? 'Request failed')
-                : 'Request failed';
-            if (message.toLowerCase().includes('not found') ||
-                message.toLowerCase().includes('session not found')) {
-                return new ws_errors_1.WsRpcError('SESSION_NOT_FOUND', message);
-            }
-            return new ws_errors_1.WsRpcError('RPC_ERROR', message);
-        }
-        return new ws_errors_1.WsRpcError('RPC_ERROR', 'Request failed');
-    }
-};
-exports.WsGatewayService = WsGatewayService;
-exports.WsGatewayService = WsGatewayService = WsGatewayService_1 = __decorate([
-    (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [rpc_router_service_1.RpcRouterService,
-        stream_service_1.StreamService,
-        session_runtime_registry_service_1.SessionRuntimeRegistry,
-        ws_event_bus_service_1.WsEventBus])
-], WsGatewayService);

package/dist/web/server/ws/ws.errors.d.ts

@@ -1,8 +0,0 @@
-export declare class WsRpcError extends Error {
-    readonly code: string;
-    readonly details?: unknown | undefined;
-    constructor(code: string, message: string, details?: unknown | undefined);
-}
-export declare const WS_CLOSE_UNAUTHORIZED = 4401;
-export declare const WS_CLOSE_NOT_FOUND = 4404;
-export declare const WS_CLOSE_SESSION_OCCUPIED = 4409;

package/dist/web/server/ws/ws.errors.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WS_CLOSE_SESSION_OCCUPIED = exports.WS_CLOSE_NOT_FOUND = exports.WS_CLOSE_UNAUTHORIZED = exports.WsRpcError = void 0;
-class WsRpcError extends Error {
-    code;
-    details;
-    constructor(code, message, details) {
-        super(message);
-        this.code = code;
-        this.details = details;
-    }
-}
-exports.WsRpcError = WsRpcError;
-exports.WS_CLOSE_UNAUTHORIZED = 4401;
-exports.WS_CLOSE_NOT_FOUND = 4404;
-exports.WS_CLOSE_SESSION_OCCUPIED = 4409;

package/dist/web/server/ws/ws.types.d.ts

@@ -1,34 +0,0 @@
-import type { WebSocket } from 'ws';
-export type RpcRequestFrame = {
-    id: string;
-    type: 'rpc.request';
-    method: string;
-    params?: unknown;
-};
-export type RpcResponseFrame = {
-    id: string;
-    type: 'rpc.response';
-    ok: true;
-    data: unknown;
-} | {
-    id: string;
-    type: 'rpc.response';
-    ok: false;
-    error: {
-        code: string;
-        message: string;
-        details?: unknown;
-    };
-};
-export type RpcEventFrame = {
-    type: 'event';
-    topic: string;
-    data: unknown;
-    seq: number;
-    ts: string;
-};
-export type WsConnectionContext = {
-    id: string;
-    socket: WebSocket;
-    username: string;
-};

package/dist/web/server/ws/ws.types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });