@memo-code/memo 0.7.3 → 0.8.5

package/dist/web/server/ws/rpc-router.service.js

@@ -0,0 +1,275 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RpcRouterService = void 0;
+const common_1 = require("@nestjs/common");
+const chat_service_1 = require("../chat/chat.service");
+const mcp_service_1 = require("../mcp/mcp.service");
+const sessions_service_1 = require("../sessions/sessions.service");
+const skills_service_1 = require("../skills/skills.service");
+const workspaces_service_1 = require("../workspaces/workspaces.service");
+const session_runtime_registry_service_1 = require("./session-runtime-registry.service");
+const ws_errors_1 = require("./ws.errors");
+function asObject(input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input)) {
+        return {};
+    }
+    return input;
+}
+function requireString(input, key, code = 'BAD_REQUEST') {
+    const value = input[key];
+    if (typeof value !== 'string' || !value.trim()) {
+        throw new ws_errors_1.WsRpcError(code, `${key} is required`);
+    }
+    return value.trim();
+}
+function asString(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+let RpcRouterService = class RpcRouterService {
+    sessionsService;
+    chatService;
+    mcpService;
+    skillsService;
+    workspacesService;
+    sessionRegistry;
+    constructor(sessionsService, chatService, mcpService, skillsService, workspacesService, sessionRegistry) {
+        this.sessionsService = sessionsService;
+        this.chatService = chatService;
+        this.mcpService = mcpService;
+        this.skillsService = skillsService;
+        this.workspacesService = workspacesService;
+        this.sessionRegistry = sessionRegistry;
+    }
+    async dispatch(context, method, params) {
+        const input = asObject(params);
+        if (method === 'sessions.list') {
+            return this.sessionsService.list(input);
+        }
+        if (method === 'sessions.detail') {
+            const sessionId = requireString(input, 'sessionId');
+            return this.sessionsService.getSessionDetail(sessionId);
+        }
+        if (method === 'sessions.events') {
+            const sessionId = requireString(input, 'sessionId');
+            return this.sessionsService.getSessionEvents(sessionId, input);
+        }
+        if (method === 'sessions.remove') {
+            const sessionId = requireString(input, 'sessionId');
+            return this.chatService.deleteSession(sessionId);
+        }
+        if (method === 'chat.session.create') {
+            const mode = input.toolPermissionMode;
+            return this.chatService.createSession({
+                providerName: asString(input.providerName),
+                workspaceId: asString(input.workspaceId),
+                cwd: asString(input.cwd),
+                toolPermissionMode: mode === 'none' || mode === 'once' || mode === 'full'
+                    ? mode
+                    : undefined,
+                activeMcpServers: Array.isArray(input.activeMcpServers)
+                    ? input.activeMcpServers.filter((item) => typeof item === 'string')
+                    : undefined,
+            });
+        }
+        if (method === 'chat.providers.list') {
+            return this.chatService.listProviders();
+        }
+        if (method === 'chat.runtimes.list') {
+            return this.chatService.listRuntimeBadges({
+                workspaceId: asString(input.workspaceId),
+            });
+        }
+        if (method === 'chat.session.state') {
+            const sessionId = requireString(input, 'sessionId');
+            this.sessionRegistry.requireOwner(sessionId, context.connectionId);
+            return this.chatService.getSessionState(sessionId);
+        }
+        if (method === 'chat.session.attach') {
+            const sessionId = requireString(input, 'sessionId');
+            this.sessionRegistry.claim(sessionId, context.connectionId);
+            try {
+                return await this.chatService.attachSession(sessionId);
+            }
+            catch (error) {
+                this.sessionRegistry.release(sessionId, context.connectionId);
+                throw error;
+            }
+        }
+        if (method === 'chat.session.close') {
+            const sessionId = requireString(input, 'sessionId');
+            this.sessionRegistry.requireOwner(sessionId, context.connectionId);
+            const result = this.chatService.closeSession(sessionId);
+            this.sessionRegistry.release(sessionId, context.connectionId);
+            return result;
+        }
+        if (method === 'chat.files.suggest') {
+            const sessionId = asString(input.sessionId);
+            if (sessionId) {
+                this.sessionRegistry.requireOwner(sessionId, context.connectionId);
+            }
+            const query = typeof input.query === 'string' ? input.query : '';
+            const limit = typeof input.limit === 'number' && Number.isFinite(input.limit)
+                ? input.limit
+                : undefined;
+            return this.chatService.suggestFiles({
+                query,
+                limit,
+                sessionId,
+                workspaceId: asString(input.workspaceId),
+            });
+        }
+        if (method === 'chat.input.submit') {
+            const sessionId = requireString(input, 'sessionId');
+            const text = requireString(input, 'input');
+            this.sessionRegistry.requireOwner(sessionId, context.connectionId);
+            return this.chatService.submitInput(sessionId, text);
+        }
+        if (method === 'chat.turn.cancel') {
+            const sessionId = requireString(input, 'sessionId');
+            this.sessionRegistry.requireOwner(sessionId, context.connectionId);
+            return this.chatService.cancelCurrentTurn(sessionId);
+        }
+        if (method === 'chat.session.compact') {
+            const sessionId = requireString(input, 'sessionId');
+            this.sessionRegistry.requireOwner(sessionId, context.connectionId);
+            return this.chatService.compactSession(sessionId);
+        }
+        if (method === 'chat.approval.respond') {
+            const sessionId = requireString(input, 'sessionId');
+            const fingerprint = requireString(input, 'fingerprint');
+            const decision = input.decision;
+            if (decision !== 'once' &&
+                decision !== 'session' &&
+                decision !== 'deny') {
+                throw new ws_errors_1.WsRpcError('BAD_REQUEST', 'decision must be once | session | deny');
+            }
+            this.sessionRegistry.requireOwner(sessionId, context.connectionId);
+            return this.chatService.applyApprovalDecision(sessionId, fingerprint, decision);
+        }
+        if (method === 'mcp.servers.list') {
+            return this.mcpService.list();
+        }
+        if (method === 'mcp.servers.get') {
+            return this.mcpService.get(requireString(input, 'name'));
+        }
+        if (method === 'mcp.servers.create') {
+            const name = requireString(input, 'name');
+            return this.mcpService.create(name, input.config);
+        }
+        if (method === 'mcp.servers.update') {
+            const name = requireString(input, 'name');
+            return this.mcpService.update(name, input.config);
+        }
+        if (method === 'mcp.servers.remove') {
+            return this.mcpService.remove(requireString(input, 'name'));
+        }
+        if (method === 'mcp.servers.login') {
+            const name = requireString(input, 'name');
+            const scopes = Array.isArray(input.scopes)
+                ? input.scopes.filter((item) => typeof item === 'string')
+                : undefined;
+            return this.mcpService.login(name, scopes);
+        }
+        if (method === 'mcp.servers.logout') {
+            return this.mcpService.logout(requireString(input, 'name'));
+        }
+        if (method === 'mcp.active.set') {
+            if (!Array.isArray(input.names)) {
+                throw new ws_errors_1.WsRpcError('BAD_REQUEST', 'names must be string[]');
+            }
+            const names = input.names
+                .filter((item) => typeof item === 'string')
+                .map((item) => item.trim())
+                .filter(Boolean);
+            return this.mcpService.setActive(names);
+        }
+        if (method === 'skills.list') {
+            return this.skillsService.list({
+                scope: input.scope,
+                q: input.q,
+                workspaceId: input.workspaceId,
+            });
+        }
+        if (method === 'skills.get') {
+            return this.skillsService.get(requireString(input, 'id'));
+        }
+        if (method === 'skills.create') {
+            return this.skillsService.create({
+                scope: input.scope,
+                name: input.name,
+                description: input.description,
+                content: input.content,
+                workspaceId: input.workspaceId,
+            });
+        }
+        if (method === 'skills.update') {
+            return this.skillsService.update(requireString(input, 'id'), {
+                description: input.description,
+                content: input.content,
+            });
+        }
+        if (method === 'skills.remove') {
+            return this.skillsService.remove(requireString(input, 'id'));
+        }
+        if (method === 'skills.active.set') {
+            if (!Array.isArray(input.ids)) {
+                throw new ws_errors_1.WsRpcError('BAD_REQUEST', 'ids must be string[]');
+            }
+            const ids = input.ids
+                .filter((item) => typeof item === 'string')
+                .map((item) => item.trim())
+                .filter(Boolean);
+            return this.skillsService.setActive(ids);
+        }
+        if (method === 'workspace.list') {
+            return this.workspacesService.list();
+        }
+        if (method === 'workspace.add') {
+            return this.workspacesService.add({
+                cwd: input.cwd,
+                name: input.name,
+            });
+        }
+        if (method === 'workspace.update') {
+            return this.workspacesService.update(requireString(input, 'workspaceId'), {
+                name: input.name,
+            });
+        }
+        if (method === 'workspace.remove') {
+            const workspaceId = requireString(input, 'workspaceId');
+            const sessionsResult = await this.sessionsService.removeSessionsByWorkspace(workspaceId);
+            const workspaceResult = await this.workspacesService.remove(workspaceId);
+            return {
+                ...workspaceResult,
+                deletedSessions: sessionsResult.deletedSessions,
+            };
+        }
+        if (method === 'workspace.fs.list') {
+            const path = asString(input.path);
+            return this.workspacesService.listDirectories(path);
+        }
+        throw new ws_errors_1.WsRpcError('METHOD_NOT_FOUND', `Unknown method: ${method}`);
+    }
+};
+exports.RpcRouterService = RpcRouterService;
+exports.RpcRouterService = RpcRouterService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [sessions_service_1.SessionsService,
+        chat_service_1.ChatService,
+        mcp_service_1.McpService,
+        skills_service_1.SkillsService,
+        workspaces_service_1.WorkspacesService,
+        session_runtime_registry_service_1.SessionRuntimeRegistry])
+], RpcRouterService);

package/dist/web/server/ws/session-runtime-registry.service.d.ts

@@ -0,0 +1,37 @@
+type RuntimeRecord = {
+    ownerConnectionId: string;
+    runtimeHandle?: unknown;
+    historyFilePath?: string;
+    workspaceId?: string;
+    status?: 'idle' | 'running' | 'closed';
+    updatedAt?: string;
+};
+export declare class SessionRuntimeRegistry {
+    private readonly sessionMap;
+    private readonly connectionSessions;
+    claim(sessionId: string, connectionId: string): void;
+    release(sessionId: string, connectionId: string): void;
+    releaseAll(connectionId: string): string[];
+    isOwner(sessionId: string, connectionId: string): boolean;
+    requireOwner(sessionId: string, connectionId: string): void;
+    setRuntime(sessionId: string, runtimeHandle: unknown): void;
+    setHistoryFilePath(sessionId: string, historyFilePath: string): void;
+    setWorkspaceId(sessionId: string, workspaceId: string): void;
+    setStatus(sessionId: string, status: 'idle' | 'running' | 'closed'): void;
+    listAll(): Array<{
+        sessionId: string;
+        ownerConnectionId: string;
+        workspaceId?: string;
+        status?: 'idle' | 'running' | 'closed';
+        updatedAt?: string;
+    }>;
+    listByWorkspace(workspaceId: string): Array<{
+        sessionId: string;
+        ownerConnectionId: string;
+        workspaceId?: string;
+        status?: 'idle' | 'running' | 'closed';
+        updatedAt?: string;
+    }>;
+    get(sessionId: string): RuntimeRecord | null;
+}
+export {};

package/dist/web/server/ws/session-runtime-registry.service.js

@@ -0,0 +1,118 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionRuntimeRegistry = void 0;
+const common_1 = require("@nestjs/common");
+const ws_errors_1 = require("./ws.errors");
+let SessionRuntimeRegistry = class SessionRuntimeRegistry {
+    sessionMap = new Map();
+    connectionSessions = new Map();
+    claim(sessionId, connectionId) {
+        const existing = this.sessionMap.get(sessionId);
+        if (existing && existing.ownerConnectionId !== connectionId) {
+            throw new ws_errors_1.WsRpcError('SESSION_OCCUPIED', `Session ${sessionId} is already attached by another connection.`);
+        }
+        this.sessionMap.set(sessionId, {
+            ownerConnectionId: connectionId,
+            runtimeHandle: existing?.runtimeHandle,
+            historyFilePath: existing?.historyFilePath,
+            workspaceId: existing?.workspaceId,
+            status: existing?.status,
+            updatedAt: new Date().toISOString(),
+        });
+        let set = this.connectionSessions.get(connectionId);
+        if (!set) {
+            set = new Set();
+            this.connectionSessions.set(connectionId, set);
+        }
+        set.add(sessionId);
+    }
+    release(sessionId, connectionId) {
+        const record = this.sessionMap.get(sessionId);
+        if (!record)
+            return;
+        if (record.ownerConnectionId !== connectionId)
+            return;
+        this.sessionMap.delete(sessionId);
+        const set = this.connectionSessions.get(connectionId);
+        if (!set)
+            return;
+        set.delete(sessionId);
+        if (set.size === 0) {
+            this.connectionSessions.delete(connectionId);
+        }
+    }
+    releaseAll(connectionId) {
+        const set = this.connectionSessions.get(connectionId);
+        if (!set || set.size === 0)
+            return [];
+        const released = Array.from(set.values());
+        for (const sessionId of released) {
+            const record = this.sessionMap.get(sessionId);
+            if (record && record.ownerConnectionId === connectionId) {
+                this.sessionMap.delete(sessionId);
+            }
+        }
+        this.connectionSessions.delete(connectionId);
+        return released;
+    }
+    isOwner(sessionId, connectionId) {
+        const record = this.sessionMap.get(sessionId);
+        return record?.ownerConnectionId === connectionId;
+    }
+    requireOwner(sessionId, connectionId) {
+        if (!this.isOwner(sessionId, connectionId)) {
+            throw new ws_errors_1.WsRpcError('SESSION_NOT_ATTACHED', `Session ${sessionId} is not attached.`);
+        }
+    }
+    setRuntime(sessionId, runtimeHandle) {
+        const record = this.sessionMap.get(sessionId);
+        if (!record)
+            return;
+        record.runtimeHandle = runtimeHandle;
+    }
+    setHistoryFilePath(sessionId, historyFilePath) {
+        const record = this.sessionMap.get(sessionId);
+        if (!record)
+            return;
+        record.historyFilePath = historyFilePath;
+    }
+    setWorkspaceId(sessionId, workspaceId) {
+        const record = this.sessionMap.get(sessionId);
+        if (!record)
+            return;
+        record.workspaceId = workspaceId;
+        record.updatedAt = new Date().toISOString();
+    }
+    setStatus(sessionId, status) {
+        const record = this.sessionMap.get(sessionId);
+        if (!record)
+            return;
+        record.status = status;
+        record.updatedAt = new Date().toISOString();
+    }
+    listAll() {
+        return Array.from(this.sessionMap.entries()).map(([sessionId, value]) => ({
+            sessionId,
+            ownerConnectionId: value.ownerConnectionId,
+            workspaceId: value.workspaceId,
+            status: value.status,
+            updatedAt: value.updatedAt,
+        }));
+    }
+    listByWorkspace(workspaceId) {
+        return this.listAll().filter((item) => item.workspaceId === workspaceId);
+    }
+    get(sessionId) {
+        return this.sessionMap.get(sessionId) ?? null;
+    }
+};
+exports.SessionRuntimeRegistry = SessionRuntimeRegistry;
+exports.SessionRuntimeRegistry = SessionRuntimeRegistry = __decorate([
+    (0, common_1.Injectable)()
+], SessionRuntimeRegistry);

package/dist/web/server/ws/ws-event-bus.service.d.ts

@@ -0,0 +1,5 @@
+import type { RpcEventFrame } from './ws.types';
+export declare class WsEventBus {
+    private seq;
+    create(topic: string, data: unknown): RpcEventFrame;
+}

package/dist/web/server/ws/ws-event-bus.service.js

@@ -0,0 +1,27 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WsEventBus = void 0;
+const common_1 = require("@nestjs/common");
+let WsEventBus = class WsEventBus {
+    seq = 0;
+    create(topic, data) {
+        this.seq += 1;
+        return {
+            type: 'event',
+            topic,
+            data,
+            seq: this.seq,
+            ts: new Date().toISOString(),
+        };
+    }
+};
+exports.WsEventBus = WsEventBus;
+exports.WsEventBus = WsEventBus = __decorate([
+    (0, common_1.Injectable)()
+], WsEventBus);

package/dist/web/server/ws/ws-gateway.module.d.ts

@@ -0,0 +1,2 @@
+export declare class WsGatewayModule {
+}

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

@@ -0,0 +1,42 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WsGatewayModule = void 0;
+const common_1 = require("@nestjs/common");
+const chat_module_1 = require("../chat/chat.module");
+const mcp_module_1 = require("../mcp/mcp.module");
+const sessions_module_1 = require("../sessions/sessions.module");
+const skills_module_1 = require("../skills/skills.module");
+const stream_module_1 = require("../stream/stream.module");
+const workspaces_module_1 = require("../workspaces/workspaces.module");
+const rpc_router_service_1 = require("./rpc-router.service");
+const session_runtime_registry_service_1 = require("./session-runtime-registry.service");
+const ws_event_bus_service_1 = require("./ws-event-bus.service");
+const ws_gateway_service_1 = require("./ws-gateway.service");
+let WsGatewayModule = class WsGatewayModule {
+};
+exports.WsGatewayModule = WsGatewayModule;
+exports.WsGatewayModule = WsGatewayModule = __decorate([
+    (0, common_1.Module)({
+        imports: [
+            sessions_module_1.SessionsModule,
+            chat_module_1.ChatModule,
+            mcp_module_1.McpModule,
+            skills_module_1.SkillsModule,
+            stream_module_1.StreamModule,
+            workspaces_module_1.WorkspacesModule,
+        ],
+        providers: [
+            ws_gateway_service_1.WsGatewayService,
+            rpc_router_service_1.RpcRouterService,
+            session_runtime_registry_service_1.SessionRuntimeRegistry,
+            ws_event_bus_service_1.WsEventBus,
+        ],
+        exports: [ws_gateway_service_1.WsGatewayService, session_runtime_registry_service_1.SessionRuntimeRegistry],
+    })
+], WsGatewayModule);

package/dist/web/server/ws/ws-gateway.service.d.ts

@@ -0,0 +1,42 @@
+import type { IncomingMessage } from 'node:http';
+import { OnModuleDestroy } from '@nestjs/common';
+import type { AccessTokenPayload } from '../auth/auth.types';
+import { StreamService } from '../stream/stream.service';
+import { RpcRouterService } from './rpc-router.service';
+import { SessionRuntimeRegistry } from './session-runtime-registry.service';
+import { WsEventBus } from './ws-event-bus.service';
+type AccessTokenVerifier = (token: string) => Promise<AccessTokenPayload>;
+type AttachOptions = {
+    httpServer: {
+        on: (event: 'upgrade', listener: (request: IncomingMessage, socket: import('node:net').Socket, head: Buffer) => void) => void;
+    };
+    verifyAccessToken: AccessTokenVerifier;
+};
+export declare class WsGatewayService implements OnModuleDestroy {
+    private readonly rpcRouter;
+    private readonly streamService;
+    private readonly sessionRegistry;
+    private readonly eventBus;
+    private readonly logger;
+    private readonly connections;
+    private wsServer;
+    private attached;
+    private globalStreamUnsubscribe;
+    constructor(rpcRouter: RpcRouterService, streamService: StreamService, sessionRegistry: SessionRuntimeRegistry, eventBus: WsEventBus);
+    attach(options: AttachOptions): void;
+    onModuleDestroy(): Promise<void>;
+    private handleConnection;
+    private handleMessage;
+    private bindSession;
+    private unbindSession;
+    private cleanupConnection;
+    private mapStreamPayload;
+    private mapRuntimeStatusPayload;
+    private sendRpcSuccess;
+    private sendRpcError;
+    private sendEvent;
+    private broadcastEventToAll;
+    private sendSerialized;
+    private toWsRpcError;
+}
+export {};