@memo-code/memo 0.7.3 → 0.8.5

package/dist/web/server/mcp/mcp.controller.js

@@ -0,0 +1,126 @@
+"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 __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpController = void 0;
+const common_1 = require("@nestjs/common");
+const mcp_service_1 = require("./mcp.service");
+function requiredName(value) {
+    if (typeof value !== 'string' || !value.trim()) {
+        throw new common_1.BadRequestException('name is required');
+    }
+    return value.trim();
+}
+let McpController = class McpController {
+    mcpService;
+    constructor(mcpService) {
+        this.mcpService = mcpService;
+    }
+    async list() {
+        return this.mcpService.list();
+    }
+    async get(name) {
+        return this.mcpService.get(name);
+    }
+    async create(body) {
+        const name = requiredName(body.name);
+        return this.mcpService.create(name, body.config);
+    }
+    async update(name, body) {
+        return this.mcpService.update(name, body.config);
+    }
+    async remove(name) {
+        return this.mcpService.remove(name);
+    }
+    async login(name, body) {
+        const scopes = Array.isArray(body.scopes)
+            ? body.scopes.filter((item) => typeof item === 'string')
+            : undefined;
+        return this.mcpService.login(name, scopes);
+    }
+    async logout(name) {
+        return this.mcpService.logout(name);
+    }
+    async setActive(body) {
+        if (!Array.isArray(body.names)) {
+            throw new common_1.BadRequestException('names must be string[]');
+        }
+        const names = body.names
+            .filter((item) => typeof item === 'string')
+            .map((item) => item.trim())
+            .filter(Boolean);
+        return this.mcpService.setActive(names);
+    }
+};
+exports.McpController = McpController;
+__decorate([
+    (0, common_1.Get)('servers'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], McpController.prototype, "list", null);
+__decorate([
+    (0, common_1.Get)('servers/:name'),
+    __param(0, (0, common_1.Param)('name')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], McpController.prototype, "get", null);
+__decorate([
+    (0, common_1.Post)('servers'),
+    __param(0, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], McpController.prototype, "create", null);
+__decorate([
+    (0, common_1.Put)('servers/:name'),
+    __param(0, (0, common_1.Param)('name')),
+    __param(1, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], McpController.prototype, "update", null);
+__decorate([
+    (0, common_1.Delete)('servers/:name'),
+    __param(0, (0, common_1.Param)('name')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], McpController.prototype, "remove", null);
+__decorate([
+    (0, common_1.Post)('servers/:name/login'),
+    __param(0, (0, common_1.Param)('name')),
+    __param(1, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], McpController.prototype, "login", null);
+__decorate([
+    (0, common_1.Post)('servers/:name/logout'),
+    __param(0, (0, common_1.Param)('name')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], McpController.prototype, "logout", null);
+__decorate([
+    (0, common_1.Put)('active'),
+    __param(0, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], McpController.prototype, "setActive", null);
+exports.McpController = McpController = __decorate([
+    (0, common_1.Controller)('api/mcp'),
+    __metadata("design:paramtypes", [mcp_service_1.McpService])
+], McpController);

package/dist/web/server/mcp/mcp.module.d.ts

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

package/dist/web/server/mcp/mcp.module.js

@@ -0,0 +1,22 @@
+"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.McpModule = void 0;
+const common_1 = require("@nestjs/common");
+const mcp_controller_1 = require("./mcp.controller");
+const mcp_service_1 = require("./mcp.service");
+let McpModule = class McpModule {
+};
+exports.McpModule = McpModule;
+exports.McpModule = McpModule = __decorate([
+    (0, common_1.Module)({
+        controllers: [mcp_controller_1.McpController],
+        providers: [mcp_service_1.McpService],
+        exports: [mcp_service_1.McpService],
+    })
+], McpModule);

package/dist/web/server/mcp/mcp.service.d.ts

@@ -0,0 +1,25 @@
+export declare class McpService {
+    list(): Promise<{
+        items: import("@memo-code/core", { with: { "resolution-mode": "import" } }).McpServerRecord[];
+    }>;
+    get(name: string): Promise<import("@memo-code/core", { with: { "resolution-mode": "import" } }).McpServerRecord>;
+    create(name: string, configInput: unknown): Promise<{
+        created: true;
+    }>;
+    update(name: string, configInput: unknown): Promise<{
+        updated: true;
+    }>;
+    remove(name: string): Promise<{
+        deleted: true;
+    }>;
+    login(name: string, scopes: string[] | undefined): Promise<{
+        loggedIn: true;
+    }>;
+    logout(name: string): Promise<{
+        loggedOut: true;
+    }>;
+    setActive(names: string[]): Promise<{
+        active: string[];
+    }>;
+    private wrap;
+}

package/dist/web/server/mcp/mcp.service.js

@@ -0,0 +1,56 @@
+"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.McpService = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@memo-code/core");
+let McpService = class McpService {
+    async list() {
+        return this.wrap(() => (0, core_1.listMcpServers)());
+    }
+    async get(name) {
+        return this.wrap(() => (0, core_1.getMcpServer)(name));
+    }
+    async create(name, configInput) {
+        return this.wrap(() => (0, core_1.createMcpServer)(name, configInput));
+    }
+    async update(name, configInput) {
+        return this.wrap(() => (0, core_1.updateMcpServer)(name, configInput));
+    }
+    async remove(name) {
+        return this.wrap(() => (0, core_1.removeMcpServer)(name));
+    }
+    async login(name, scopes) {
+        return this.wrap(() => (0, core_1.loginMcpServer)(name, scopes));
+    }
+    async logout(name) {
+        return this.wrap(() => (0, core_1.logoutMcpServer)(name));
+    }
+    async setActive(names) {
+        return this.wrap(() => (0, core_1.setActiveMcpServers)(names));
+    }
+    async wrap(fn) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            if (error instanceof core_1.McpAdminError) {
+                if (error.code === 'NOT_FOUND') {
+                    throw new common_1.NotFoundException(error.message);
+                }
+                throw new common_1.BadRequestException(error.message);
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            throw new common_1.InternalServerErrorException(message || 'mcp operation failed');
+        }
+    }
+};
+exports.McpService = McpService;
+exports.McpService = McpService = __decorate([
+    (0, common_1.Injectable)()
+], McpService);

package/dist/web/server/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

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

@@ -0,0 +1,18 @@
+import type { NestExpressApplication } from '@nestjs/platform-express';
+export type StartMemoWebServerOptions = {
+    host?: string;
+    port?: number;
+    staticDir?: string;
+};
+export type StartedMemoWebServer = {
+    app: NestExpressApplication;
+    host: string;
+    port: number;
+    staticDir: string | null;
+    configPath: string;
+    url: string;
+    close: () => Promise<void>;
+};
+export declare function startMemoWebServer(options?: StartMemoWebServerOptions): Promise<StartedMemoWebServer>;
+export declare function defaultMemoWebHost(): string;
+export declare function defaultMemoWebPort(): number;

package/dist/web/server/server.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startMemoWebServer = startMemoWebServer;
+exports.defaultMemoWebHost = defaultMemoWebHost;
+exports.defaultMemoWebPort = defaultMemoWebPort;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const app_module_1 = require("./app.module");
+const auth_service_1 = require("./auth/auth.service");
+const server_config_service_1 = require("./config/server-config.service");
+const stream_service_1 = require("./stream/stream.service");
+const ws_gateway_service_1 = require("./ws/ws-gateway.service");
+const DEFAULT_HOST = '127.0.0.1';
+const DEFAULT_PORT = 5494;
+const BUILTIN_ALLOWED_CORS_HOSTS = ['*.ngrok-free.app'];
+function parsePort(value, fallback) {
+    if (typeof value !== 'number')
+        return fallback;
+    if (Number.isInteger(value) && value > 0 && value <= 65535)
+        return value;
+    return fallback;
+}
+function allowCorsOrigin(origin, allowedHosts) {
+    if (!origin)
+        return true;
+    try {
+        const url = new URL(origin);
+        const hostname = url.hostname.trim().toLowerCase();
+        if (!hostname)
+            return false;
+        const normalizedAllowedHosts = allowedHosts
+            .map((item) => item.trim().toLowerCase())
+            .filter((item) => item.length > 0);
+        return normalizedAllowedHosts.some((pattern) => {
+            if (pattern === '*')
+                return true;
+            if (pattern === hostname)
+                return true;
+            if (pattern.startsWith('*.')) {
+                const suffix = pattern.slice(1);
+                return hostname.endsWith(suffix);
+            }
+            if (pattern.startsWith('.')) {
+                return hostname === pattern.slice(1) || hostname.endsWith(pattern);
+            }
+            return false;
+        });
+    }
+    catch {
+        return false;
+    }
+}
+function normalizeHost(value) {
+    if (!value)
+        return DEFAULT_HOST;
+    const trimmed = value.trim();
+    return trimmed || DEFAULT_HOST;
+}
+function resolveStaticDir(staticDir) {
+    if (!staticDir)
+        return null;
+    const resolved = (0, node_path_1.resolve)(staticDir);
+    const indexPath = (0, node_path_1.join)(resolved, 'index.html');
+    if (!(0, node_fs_1.existsSync)(indexPath))
+        return null;
+    return resolved;
+}
+function setupStaticHosting(app, staticDir, logger) {
+    if (!staticDir) {
+        logger.warn('web-ui static directory is not configured or missing index.html');
+        return;
+    }
+    app.useStaticAssets(staticDir, { index: false });
+    const expressApp = app.getHttpAdapter().getInstance();
+    const indexPath = (0, node_path_1.join)(staticDir, 'index.html');
+    expressApp.get(/^\/(?!api(?:\/|$)|healthz$).*/, (_req, res) => {
+        res.sendFile(indexPath);
+    });
+    logger.log(`Serving web-ui static files from ${staticDir}`);
+}
+async function startMemoWebServer(options = {}) {
+    const logger = new common_1.Logger('WebServer');
+    const app = await core_1.NestFactory.create(app_module_1.AppModule);
+    const configService = app.get(server_config_service_1.ServerConfigService);
+    const config = await configService.load();
+    const effectiveAllowedCorsHosts = Array.from(new Set([
+        ...config.security.corsAllowedHosts,
+        ...BUILTIN_ALLOWED_CORS_HOSTS,
+    ]));
+    const corsOptions = {
+        origin: (origin, callback) => {
+            if (allowCorsOrigin(origin, effectiveAllowedCorsHosts)) {
+                callback(null, true);
+                return;
+            }
+            callback(new Error('CORS origin is not allowed'));
+        },
+        credentials: true,
+        methods: ['GET', 'POST', 'DELETE', 'OPTIONS'],
+        allowedHeaders: ['Content-Type', 'Authorization', 'x-request-id'],
+    };
+    app.enableCors(corsOptions);
+    const host = normalizeHost(options.host);
+    const port = parsePort(options.port, DEFAULT_PORT);
+    const staticDir = resolveStaticDir(options.staticDir);
+    setupStaticHosting(app, staticDir, logger);
+    const streamService = app.get(stream_service_1.StreamService);
+    const wsGatewayService = app.get(ws_gateway_service_1.WsGatewayService);
+    const authService = app.get(auth_service_1.AuthService);
+    streamService.attach({
+        httpServer: app.getHttpServer(),
+        verifyAccessToken: (token) => authService.verifyAccessToken(token),
+    });
+    wsGatewayService.attach({
+        httpServer: app.getHttpServer(),
+        verifyAccessToken: (token) => authService.verifyAccessToken(token),
+    });
+    await app.listen(port, host);
+    const url = `http://${host}:${port}`;
+    logger.log(`Memo web-server started at ${url}`);
+    logger.log(`Using auth config: ${configService.getConfigPath()}`);
+    logger.log(`Allowed CORS hosts: ${effectiveAllowedCorsHosts.join(', ')}`);
+    return {
+        app,
+        host,
+        port,
+        staticDir,
+        configPath: configService.getConfigPath(),
+        url,
+        close: async () => {
+            await app.close();
+        },
+    };
+}
+function defaultMemoWebHost() {
+    return DEFAULT_HOST;
+}
+function defaultMemoWebPort() {
+    return DEFAULT_PORT;
+}

package/dist/web/server/sessions/sessions.controller.d.ts

@@ -0,0 +1,8 @@
+import { SessionsService } from './sessions.service';
+export declare class SessionsController {
+    private readonly sessionsService;
+    constructor(sessionsService: SessionsService);
+    listSessions(query: Record<string, unknown>): Promise<import("@memo-code/core", { with: { "resolution-mode": "import" } }).SessionListResponse>;
+    getSession(sessionId: string): Promise<import("@memo-code/core", { with: { "resolution-mode": "import" } }).SessionDetail>;
+    getSessionEvents(sessionId: string, query: Record<string, unknown>): Promise<import("@memo-code/core", { with: { "resolution-mode": "import" } }).SessionEventsResponse>;
+}

package/dist/web/server/sessions/sessions.controller.js

@@ -0,0 +1,59 @@
+"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 __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionsController = void 0;
+const common_1 = require("@nestjs/common");
+const sessions_service_1 = require("./sessions.service");
+let SessionsController = class SessionsController {
+    sessionsService;
+    constructor(sessionsService) {
+        this.sessionsService = sessionsService;
+    }
+    async listSessions(query) {
+        return this.sessionsService.list(query);
+    }
+    async getSession(sessionId) {
+        return this.sessionsService.getSessionDetail(sessionId);
+    }
+    async getSessionEvents(sessionId, query) {
+        return this.sessionsService.getSessionEvents(sessionId, query);
+    }
+};
+exports.SessionsController = SessionsController;
+__decorate([
+    (0, common_1.Get)(),
+    __param(0, (0, common_1.Query)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], SessionsController.prototype, "listSessions", null);
+__decorate([
+    (0, common_1.Get)(':id'),
+    __param(0, (0, common_1.Param)('id')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], SessionsController.prototype, "getSession", null);
+__decorate([
+    (0, common_1.Get)(':id/events'),
+    __param(0, (0, common_1.Param)('id')),
+    __param(1, (0, common_1.Query)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], SessionsController.prototype, "getSessionEvents", null);
+exports.SessionsController = SessionsController = __decorate([
+    (0, common_1.Controller)('api/sessions'),
+    __metadata("design:paramtypes", [sessions_service_1.SessionsService])
+], SessionsController);

package/dist/web/server/sessions/sessions.module.d.ts

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

package/dist/web/server/sessions/sessions.module.js

@@ -0,0 +1,24 @@
+"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.SessionsModule = void 0;
+const common_1 = require("@nestjs/common");
+const workspaces_module_1 = require("../workspaces/workspaces.module");
+const sessions_controller_1 = require("./sessions.controller");
+const sessions_service_1 = require("./sessions.service");
+let SessionsModule = class SessionsModule {
+};
+exports.SessionsModule = SessionsModule;
+exports.SessionsModule = SessionsModule = __decorate([
+    (0, common_1.Module)({
+        imports: [workspaces_module_1.WorkspacesModule],
+        controllers: [sessions_controller_1.SessionsController],
+        providers: [sessions_service_1.SessionsService],
+        exports: [sessions_service_1.SessionsService],
+    })
+], SessionsModule);

package/dist/web/server/sessions/sessions.service.d.ts

@@ -0,0 +1,22 @@
+import { WorkspacesService } from '../workspaces/workspaces.service';
+import type { SessionDetail, SessionEventsResponse, SessionListResponse } from './sessions.types';
+export declare class SessionsService {
+    private readonly workspacesService;
+    private readonly sessionsDir;
+    private readonly historyIndex;
+    constructor(workspacesService: WorkspacesService);
+    list(query: Record<string, unknown>): Promise<SessionListResponse>;
+    getSessionDetail(sessionId: string): Promise<SessionDetail>;
+    getSessionEvents(sessionId: string, query: Record<string, unknown>): Promise<SessionEventsResponse>;
+    listAllSessionSummaries(): Promise<import("@memo-code/core", { with: { "resolution-mode": "import" } }).SessionListItem[]>;
+    removeSession(sessionId: string): Promise<{
+        deleted: boolean;
+    }>;
+    removeSessionsByWorkspace(workspaceId: string): Promise<{
+        deleted: boolean;
+        deletedSessions: number;
+    }>;
+    private normalizeSafeSessionFilePath;
+    private removeSessionFile;
+    private pruneEmptyParentDirectories;
+}