@memo-code/memo 0.7.3 → 0.8.5

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

@@ -0,0 +1,38 @@
+import type { FileSuggestion, LiveSessionState, SessionRuntimeBadge, SessionTurnStep } from '@memo-code/core';
+export type ChatSnapshotTurn = {
+    turn: number;
+    input: string;
+    assistant: string;
+    status: string;
+    errorMessage?: string;
+    steps?: SessionTurnStep[];
+};
+export type ChatSessionSnapshot = {
+    state: LiveSessionState;
+    turns: ChatSnapshotTurn[];
+};
+export type CreateLiveSessionInput = {
+    providerName?: string;
+    workspaceId?: string;
+    cwd?: string;
+    toolPermissionMode?: 'none' | 'once' | 'full';
+    activeMcpServers?: string[];
+};
+export type ChatProviderRecord = {
+    name: string;
+    model: string;
+    isCurrent: boolean;
+};
+export type SessionInputResult = {
+    accepted: boolean;
+    kind: 'turn' | 'command';
+    status: 'ok' | 'error' | 'cancelled';
+    message?: string;
+};
+export type ChatRuntimeListResponse = {
+    items: SessionRuntimeBadge[];
+};
+export type ChatFileSuggestionsResponse = {
+    items: FileSuggestion[];
+};
+export type { LiveSessionState };

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

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

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

@@ -0,0 +1 @@
+export declare const REQUEST_ID_HEADER = "x-request-id";

package/dist/web/server/common/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REQUEST_ID_HEADER = void 0;
+exports.REQUEST_ID_HEADER = 'x-request-id';

package/dist/web/server/common/filters/api-error.filter.d.ts

@@ -0,0 +1,7 @@
+import { ArgumentsHost, ExceptionFilter } from '@nestjs/common';
+export declare class ApiErrorFilter implements ExceptionFilter {
+    private readonly logger;
+    catch(exception: unknown, host: ArgumentsHost): void;
+    private parseHttpException;
+    private normalizeMessage;
+}

package/dist/web/server/common/filters/api-error.filter.js

@@ -0,0 +1,95 @@
+"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 ApiErrorFilter_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiErrorFilter = void 0;
+const common_1 = require("@nestjs/common");
+const constants_1 = require("../constants");
+let ApiErrorFilter = ApiErrorFilter_1 = class ApiErrorFilter {
+    logger = new common_1.Logger(ApiErrorFilter_1.name);
+    catch(exception, host) {
+        const http = host.switchToHttp();
+        const request = http.getRequest();
+        const response = http.getResponse();
+        const requestId = request.requestId ||
+            (typeof response.locals?.requestId === 'string'
+                ? response.locals.requestId
+                : undefined) ||
+            (typeof response.getHeader(constants_1.REQUEST_ID_HEADER) === 'string'
+                ? response.getHeader(constants_1.REQUEST_ID_HEADER)
+                : undefined) ||
+            'unknown';
+        let statusCode = common_1.HttpStatus.INTERNAL_SERVER_ERROR;
+        let payload = {
+            code: 'INTERNAL_SERVER_ERROR',
+            message: 'Internal server error',
+        };
+        if (exception instanceof common_1.HttpException) {
+            statusCode = exception.getStatus();
+            payload = this.parseHttpException(exception, statusCode);
+        }
+        else if (exception instanceof Error) {
+            payload = {
+                code: 'INTERNAL_SERVER_ERROR',
+                message: exception.message || 'Internal server error',
+            };
+        }
+        this.logger.error(`${request.method} ${request.originalUrl} -> ${statusCode} reqId=${requestId} message="${payload.message}"`, exception instanceof Error ? exception.stack : undefined);
+        response.status(statusCode).json({
+            success: false,
+            error: payload,
+            meta: {
+                requestId,
+                timestamp: new Date().toISOString(),
+                path: request.originalUrl,
+            },
+        });
+    }
+    parseHttpException(exception, statusCode) {
+        const fallbackCode = typeof common_1.HttpStatus[statusCode] === 'string'
+            ? String(common_1.HttpStatus[statusCode])
+            : 'HTTP_EXCEPTION';
+        const fallbackMessage = exception.message || 'Request failed';
+        const response = exception.getResponse();
+        if (typeof response === 'string') {
+            return {
+                code: fallbackCode,
+                message: response,
+            };
+        }
+        if (!response || typeof response !== 'object') {
+            return {
+                code: fallbackCode,
+                message: fallbackMessage,
+            };
+        }
+        const record = response;
+        const message = this.normalizeMessage(record.message) ?? fallbackMessage;
+        const code = typeof record.code === 'string' ? record.code : fallbackCode;
+        const details = record.details;
+        return {
+            code,
+            message,
+            ...(details === undefined ? {} : { details }),
+        };
+    }
+    normalizeMessage(raw) {
+        if (typeof raw === 'string')
+            return raw;
+        if (Array.isArray(raw)) {
+            const items = raw.filter((item) => typeof item === 'string');
+            if (items.length > 0)
+                return items.join('; ');
+        }
+        return null;
+    }
+};
+exports.ApiErrorFilter = ApiErrorFilter;
+exports.ApiErrorFilter = ApiErrorFilter = ApiErrorFilter_1 = __decorate([
+    (0, common_1.Catch)()
+], ApiErrorFilter);

package/dist/web/server/common/interceptors/api-response.interceptor.d.ts

@@ -0,0 +1,15 @@
+import { CallHandler, ExecutionContext, NestInterceptor, StreamableFile } from '@nestjs/common';
+import { type Observable } from 'rxjs';
+type ApiSuccessMeta = {
+    requestId: string;
+    timestamp: string;
+};
+type ApiSuccessEnvelope<T> = {
+    success: true;
+    data: T;
+    meta: ApiSuccessMeta;
+};
+export declare class ApiResponseInterceptor<T> implements NestInterceptor<T, ApiSuccessEnvelope<T> | StreamableFile> {
+    intercept(context: ExecutionContext, next: CallHandler<T>): Observable<ApiSuccessEnvelope<T> | StreamableFile>;
+}
+export {};

package/dist/web/server/common/interceptors/api-response.interceptor.js

@@ -0,0 +1,51 @@
+"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.ApiResponseInterceptor = void 0;
+const common_1 = require("@nestjs/common");
+const rxjs_1 = require("rxjs");
+const constants_1 = require("../constants");
+function resolveRequestId(request, response) {
+    if (request.requestId && request.requestId.trim().length > 0)
+        return request.requestId;
+    const fromLocals = response.locals
+        ?.requestId;
+    if (typeof fromLocals === 'string' && fromLocals.trim().length > 0)
+        return fromLocals;
+    const fromHeader = response.getHeader(constants_1.REQUEST_ID_HEADER);
+    if (typeof fromHeader === 'string' && fromHeader.trim().length > 0)
+        return fromHeader;
+    return 'unknown';
+}
+let ApiResponseInterceptor = class ApiResponseInterceptor {
+    intercept(context, next) {
+        if (context.getType() !== 'http') {
+            return next.handle();
+        }
+        const http = context.switchToHttp();
+        const request = http.getRequest();
+        const response = http.getResponse();
+        const requestId = resolveRequestId(request, response);
+        return next.handle().pipe((0, rxjs_1.map)((data) => {
+            if (data instanceof common_1.StreamableFile)
+                return data;
+            return {
+                success: true,
+                data: (data ?? null),
+                meta: {
+                    requestId,
+                    timestamp: new Date().toISOString(),
+                },
+            };
+        }));
+    }
+};
+exports.ApiResponseInterceptor = ApiResponseInterceptor;
+exports.ApiResponseInterceptor = ApiResponseInterceptor = __decorate([
+    (0, common_1.Injectable)()
+], ApiResponseInterceptor);

package/dist/web/server/common/middleware/request-logging.middleware.d.ts

@@ -0,0 +1,7 @@
+import { type NestMiddleware } from '@nestjs/common';
+import type { NextFunction, Response } from 'express';
+import type { AuthenticatedRequest } from '../../auth/auth.types';
+export declare class RequestLoggingMiddleware implements NestMiddleware {
+    private readonly logger;
+    use(request: AuthenticatedRequest, response: Response, next: NextFunction): void;
+}

package/dist/web/server/common/middleware/request-logging.middleware.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.RequestLoggingMiddleware = void 0;
+const node_crypto_1 = require("node:crypto");
+const common_1 = require("@nestjs/common");
+const constants_1 = require("../constants");
+function readHeaderValue(value) {
+    if (!value)
+        return null;
+    if (Array.isArray(value)) {
+        const first = value[0]?.trim();
+        return first && first.length > 0 ? first : null;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+let RequestLoggingMiddleware = class RequestLoggingMiddleware {
+    logger = new common_1.Logger('HTTP');
+    use(request, response, next) {
+        const existingRequestId = readHeaderValue(request.headers[constants_1.REQUEST_ID_HEADER]);
+        const requestId = existingRequestId ?? (0, node_crypto_1.randomUUID)();
+        const startedAt = Date.now();
+        request.requestId = requestId;
+        response.locals.requestId = requestId;
+        response.setHeader(constants_1.REQUEST_ID_HEADER, requestId);
+        response.on('finish', () => {
+            const durationMs = Date.now() - startedAt;
+            this.logger.log(`${request.method} ${request.originalUrl} ${response.statusCode} ${durationMs}ms reqId=${requestId}`);
+        });
+        next();
+    }
+};
+exports.RequestLoggingMiddleware = RequestLoggingMiddleware;
+exports.RequestLoggingMiddleware = RequestLoggingMiddleware = __decorate([
+    (0, common_1.Injectable)()
+], RequestLoggingMiddleware);

package/dist/web/server/config/memo-config.service.d.ts

@@ -0,0 +1,7 @@
+import type { MemoRuntimeConfig } from './memo-config.types';
+export declare class MemoConfigService {
+    private readonly configPath;
+    getConfigPath(): string;
+    load(): Promise<MemoRuntimeConfig>;
+    setActiveMcpServers(names: string[]): Promise<void>;
+}

package/dist/web/server/config/memo-config.service.js

@@ -0,0 +1,106 @@
+"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.MemoConfigService = void 0;
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const common_1 = require("@nestjs/common");
+const core_1 = require("@memo-code/core");
+const DEFAULT_PROVIDER = {
+    name: 'deepseek',
+    env_api_key: 'DEEPSEEK_API_KEY',
+    model: 'deepseek-chat',
+    base_url: 'https://api.deepseek.com',
+};
+function expandHome(path) {
+    if (!path.startsWith('~'))
+        return path;
+    return (0, node_path_1.join)((0, node_os_1.homedir)(), path.slice(1));
+}
+function resolveMemoHome() {
+    const memoHome = process.env.MEMO_HOME;
+    if (!memoHome)
+        return (0, node_path_1.join)((0, node_os_1.homedir)(), '.memo');
+    return expandHome(memoHome);
+}
+function readNonEmptyString(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function normalizeProviders(input) {
+    if (!Array.isArray(input)) {
+        return [DEFAULT_PROVIDER];
+    }
+    const providers = [];
+    for (const item of input) {
+        if (!item || typeof item !== 'object' || Array.isArray(item))
+            continue;
+        const record = item;
+        const name = readNonEmptyString(record.name);
+        if (!name)
+            continue;
+        providers.push({
+            name,
+            env_api_key: readNonEmptyString(record.env_api_key) ?? DEFAULT_PROVIDER.env_api_key,
+            model: readNonEmptyString(record.model) ?? DEFAULT_PROVIDER.model,
+            base_url: readNonEmptyString(record.base_url),
+        });
+    }
+    return providers.length > 0 ? providers : [DEFAULT_PROVIDER];
+}
+function normalizeCurrentProvider(currentProvider, providers) {
+    const current = readNonEmptyString(currentProvider);
+    if (current && providers.some((provider) => provider.name === current)) {
+        return current;
+    }
+    return providers[0]?.name ?? DEFAULT_PROVIDER.name;
+}
+function normalizeActiveMcpServers(input) {
+    if (!Array.isArray(input))
+        return [];
+    return Array.from(new Set(input
+        .filter((item) => typeof item === 'string')
+        .map((item) => item.trim())
+        .filter(Boolean)));
+}
+function normalizeMcpServers(input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input)) {
+        return {};
+    }
+    return input;
+}
+let MemoConfigService = class MemoConfigService {
+    configPath = (0, node_path_1.join)(resolveMemoHome(), 'config.toml');
+    getConfigPath() {
+        return this.configPath;
+    }
+    async load() {
+        const loaded = await (0, core_1.loadMemoConfig)();
+        const providers = normalizeProviders(loaded.config.providers);
+        return {
+            current_provider: normalizeCurrentProvider(loaded.config.current_provider, providers),
+            providers,
+            mcp_servers: normalizeMcpServers(loaded.config.mcp_servers),
+            active_mcp_servers: normalizeActiveMcpServers(loaded.config.active_mcp_servers),
+        };
+    }
+    async setActiveMcpServers(names) {
+        const loaded = await (0, core_1.loadMemoConfig)();
+        const nextConfig = {
+            ...loaded.config,
+            active_mcp_servers: normalizeActiveMcpServers(names),
+        };
+        await (0, core_1.writeMemoConfig)(loaded.configPath, nextConfig);
+    }
+};
+exports.MemoConfigService = MemoConfigService;
+exports.MemoConfigService = MemoConfigService = __decorate([
+    (0, common_1.Injectable)()
+], MemoConfigService);

package/dist/web/server/config/memo-config.types.d.ts

@@ -0,0 +1,6 @@
+import type { MCPServerConfig as MemoMcpServerConfig, MemoConfig, ProviderConfig as MemoProviderConfig } from '@memo-code/core';
+export type { MemoMcpServerConfig, MemoProviderConfig };
+export type MemoRuntimeConfig = Pick<MemoConfig, 'current_provider' | 'providers'> & {
+    mcp_servers: Record<string, MemoMcpServerConfig>;
+    active_mcp_servers: string[];
+};

package/dist/web/server/config/memo-config.types.js

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

package/dist/web/server/config/server-config.module.d.ts

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

package/dist/web/server/config/server-config.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.ServerConfigModule = void 0;
+const common_1 = require("@nestjs/common");
+const memo_config_service_1 = require("./memo-config.service");
+const server_config_service_1 = require("./server-config.service");
+let ServerConfigModule = class ServerConfigModule {
+};
+exports.ServerConfigModule = ServerConfigModule;
+exports.ServerConfigModule = ServerConfigModule = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({
+        providers: [server_config_service_1.ServerConfigService, memo_config_service_1.MemoConfigService],
+        exports: [server_config_service_1.ServerConfigService, memo_config_service_1.MemoConfigService],
+    })
+], ServerConfigModule);

package/dist/web/server/config/server-config.service.d.ts

@@ -0,0 +1,14 @@
+import type { ServerRuntimeConfig } from './server-config.types';
+export declare class ServerConfigService {
+    private readonly logger;
+    private configPath;
+    private config;
+    load(): Promise<ServerRuntimeConfig>;
+    getConfigPath(): string;
+    getLoadedConfig(): ServerRuntimeConfig;
+    updateConfig(mutator: (config: ServerRuntimeConfig) => ServerRuntimeConfig): Promise<ServerRuntimeConfig>;
+    private readOrCreateConfig;
+    private createDefaultConfig;
+    private normalizeParsedConfig;
+    private writeConfig;
+}