@memo-code/memo 0.8.0 → 0.8.5

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

@@ -0,0 +1,326 @@
+"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 ServerConfigService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerConfigService = void 0;
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const common_1 = require("@nestjs/common");
+const yaml_1 = require("yaml");
+const workspaces_utils_1 = require("../workspaces/workspaces.utils");
+const DEFAULT_ACCESS_TOKEN_TTL_SECONDS = 15 * 60;
+const DEFAULT_REFRESH_TOKEN_TTL_SECONDS = 30 * 24 * 60 * 60;
+const DEFAULT_ALLOWED_CORS_HOSTS = [
+    'localhost',
+    '127.0.0.1',
+    '::1',
+    '*.ngrok-free.app',
+];
+const DEFAULT_WORKSPACE_ROOT_PATH = '/';
+function expandHomePath(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 expandHomePath(memoHome);
+}
+async function pathExists(path) {
+    try {
+        await (0, promises_1.access)(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function resolveServerConfigPath() {
+    const explicitPath = process.env.MEMO_SERVER_CONFIG;
+    if (explicitPath) {
+        return expandHomePath(explicitPath);
+    }
+    const memoHome = resolveMemoHome();
+    const yamlPath = (0, node_path_1.join)(memoHome, 'server.yaml');
+    const jsonPath = (0, node_path_1.join)(memoHome, 'server.json');
+    if (await pathExists(yamlPath))
+        return yamlPath;
+    if (await pathExists(jsonPath))
+        return jsonPath;
+    return yamlPath;
+}
+function randomSecret(bytes) {
+    return (0, node_crypto_1.randomBytes)(bytes).toString('hex');
+}
+function randomPassword() {
+    return (0, node_crypto_1.randomBytes)(12).toString('base64url');
+}
+function readString(value) {
+    if (typeof value !== 'string')
+        return null;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function readAuthString(value) {
+    if (typeof value === 'string') {
+        return readString(value);
+    }
+    if (typeof value === 'number' ||
+        typeof value === 'boolean' ||
+        typeof value === 'bigint') {
+        const normalized = String(value).trim();
+        return normalized.length > 0 ? normalized : null;
+    }
+    return null;
+}
+function normalizePositiveInt(value, fallback) {
+    if (typeof value === 'number' && Number.isInteger(value) && value > 0)
+        return value;
+    if (typeof value === 'string') {
+        const parsed = Number.parseInt(value, 10);
+        if (Number.isFinite(parsed) && parsed > 0)
+            return parsed;
+    }
+    return fallback;
+}
+function normalizeAllowedHosts(input) {
+    if (!Array.isArray(input))
+        return [...DEFAULT_ALLOWED_CORS_HOSTS];
+    const hosts = input
+        .map((item) => (typeof item === 'string' ? item.trim() : ''))
+        .filter((item) => item.length > 0);
+    if (hosts.length === 0)
+        return [...DEFAULT_ALLOWED_CORS_HOSTS];
+    return Array.from(new Set(hosts));
+}
+function normalizeWorkspaceRootPath(value) {
+    if (typeof value !== 'string' || !value.trim()) {
+        return DEFAULT_WORKSPACE_ROOT_PATH;
+    }
+    return (0, workspaces_utils_1.normalizeWorkspacePath)(value);
+}
+function normalizeWorkspaceRecords(input) {
+    if (!Array.isArray(input)) {
+        return { items: [], changed: true };
+    }
+    const now = new Date().toISOString();
+    const byId = new Map();
+    let changed = false;
+    for (const item of input) {
+        if (!item || typeof item !== 'object' || Array.isArray(item)) {
+            changed = true;
+            continue;
+        }
+        const record = item;
+        const rawCwd = readString(record.cwd);
+        if (!rawCwd) {
+            changed = true;
+            continue;
+        }
+        const cwd = (0, workspaces_utils_1.normalizeWorkspacePath)(rawCwd);
+        const id = readString(record.id) ?? (0, workspaces_utils_1.workspaceIdFromCwd)(cwd);
+        const name = readString(record.name) ?? (0, workspaces_utils_1.defaultWorkspaceName)(cwd);
+        const createdAt = readString(record.createdAt) ?? now;
+        const lastUsedAt = readString(record.lastUsedAt) ?? createdAt;
+        if (id !== record.id ||
+            name !== record.name ||
+            cwd !== record.cwd ||
+            createdAt !== record.createdAt ||
+            lastUsedAt !== record.lastUsedAt) {
+            changed = true;
+        }
+        byId.set(id, {
+            id,
+            name,
+            cwd,
+            createdAt,
+            lastUsedAt,
+        });
+    }
+    const items = Array.from(byId.values()).sort((a, b) => a.cwd.localeCompare(b.cwd));
+    if (items.length !== input.length) {
+        changed = true;
+    }
+    return {
+        items,
+        changed,
+    };
+}
+function parseConfigByExtension(raw, configPath) {
+    if (!raw.trim())
+        return {};
+    const ext = (0, node_path_1.extname)(configPath).toLowerCase();
+    if (ext === '.json') {
+        try {
+            return JSON.parse(raw);
+        }
+        catch (err) {
+            throw new Error(`Failed to parse ${configPath}: ${err.message}. Please fix the JSON format.`);
+        }
+    }
+    try {
+        return (0, yaml_1.parse)(raw) ?? {};
+    }
+    catch (err) {
+        throw new Error(`Failed to parse ${configPath}: ${err.message}. Please fix the YAML format.`);
+    }
+}
+let ServerConfigService = ServerConfigService_1 = class ServerConfigService {
+    logger = new common_1.Logger(ServerConfigService_1.name);
+    configPath = null;
+    config = null;
+    async load() {
+        if (this.config)
+            return this.config;
+        const { configPath, config, generated } = await this.readOrCreateConfig();
+        this.configPath = configPath;
+        this.config = config;
+        if (generated) {
+            this.logger.warn([
+                `Created web-server auth config: ${configPath}`,
+                `username="${config.auth.username}"`,
+                `password="${config.auth.password}"`,
+                'Please change the password after first login.',
+            ].join(' | '));
+        }
+        return config;
+    }
+    getConfigPath() {
+        if (this.configPath)
+            return this.configPath;
+        const configured = process.env.MEMO_SERVER_CONFIG;
+        if (configured)
+            return expandHomePath(configured);
+        return (0, node_path_1.join)(resolveMemoHome(), 'server.yaml');
+    }
+    getLoadedConfig() {
+        if (!this.config) {
+            throw new Error('Server config is not loaded yet. Call load() first.');
+        }
+        return this.config;
+    }
+    async updateConfig(mutator) {
+        const current = await this.load();
+        const next = mutator(current);
+        const normalized = this.normalizeParsedConfig(next).config;
+        const configPath = this.getConfigPath();
+        await this.writeConfig(configPath, normalized);
+        this.config = normalized;
+        return normalized;
+    }
+    async readOrCreateConfig() {
+        const configPath = await resolveServerConfigPath();
+        try {
+            await (0, promises_1.access)(configPath);
+        }
+        catch {
+            const created = this.createDefaultConfig();
+            await this.writeConfig(configPath, created);
+            return { configPath, config: created, generated: true };
+        }
+        const raw = await (0, promises_1.readFile)(configPath, 'utf8');
+        const parsed = parseConfigByExtension(raw, configPath);
+        const normalized = this.normalizeParsedConfig(parsed);
+        if (normalized.rewriteRequired) {
+            await this.writeConfig(configPath, normalized.config);
+        }
+        return { configPath, config: normalized.config, generated: false };
+    }
+    createDefaultConfig() {
+        return {
+            auth: {
+                username: 'memo',
+                password: randomPassword(),
+                accessTokenSecret: randomSecret(32),
+                refreshTokenSecret: randomSecret(48),
+                accessTokenTtlSeconds: DEFAULT_ACCESS_TOKEN_TTL_SECONDS,
+                refreshTokenTtlSeconds: DEFAULT_REFRESH_TOKEN_TTL_SECONDS,
+            },
+            security: {
+                corsAllowedHosts: [...DEFAULT_ALLOWED_CORS_HOSTS],
+            },
+            workspaces: [],
+            workspaceBrowser: {
+                rootPath: DEFAULT_WORKSPACE_ROOT_PATH,
+            },
+        };
+    }
+    normalizeParsedConfig(parsed) {
+        let rewriteRequired = false;
+        const username = readAuthString(parsed.auth?.username) ?? 'memo';
+        if (!readAuthString(parsed.auth?.username))
+            rewriteRequired = true;
+        const password = readAuthString(parsed.auth?.password) ?? 'memo';
+        if (!readAuthString(parsed.auth?.password))
+            rewriteRequired = true;
+        const accessTokenSecret = readAuthString(parsed.auth?.accessTokenSecret) ?? randomSecret(32);
+        if (!readAuthString(parsed.auth?.accessTokenSecret))
+            rewriteRequired = true;
+        const refreshTokenSecret = readAuthString(parsed.auth?.refreshTokenSecret) ?? randomSecret(48);
+        if (!readAuthString(parsed.auth?.refreshTokenSecret))
+            rewriteRequired = true;
+        const accessTokenTtlSeconds = normalizePositiveInt(parsed.auth?.accessTokenTtlSeconds, DEFAULT_ACCESS_TOKEN_TTL_SECONDS);
+        if (accessTokenTtlSeconds !== parsed.auth?.accessTokenTtlSeconds)
+            rewriteRequired = true;
+        const refreshTokenTtlSeconds = normalizePositiveInt(parsed.auth?.refreshTokenTtlSeconds, DEFAULT_REFRESH_TOKEN_TTL_SECONDS);
+        if (refreshTokenTtlSeconds !== parsed.auth?.refreshTokenTtlSeconds)
+            rewriteRequired = true;
+        const corsAllowedHosts = normalizeAllowedHosts(parsed.security?.corsAllowedHosts);
+        if (!Array.isArray(parsed.security?.corsAllowedHosts) ||
+            corsAllowedHosts.length !== parsed.security.corsAllowedHosts.length) {
+            rewriteRequired = true;
+        }
+        const normalizedWorkspaces = normalizeWorkspaceRecords(parsed.workspaces);
+        if (normalizedWorkspaces.changed) {
+            rewriteRequired = true;
+        }
+        const workspaceRootPath = normalizeWorkspaceRootPath(parsed.workspaceBrowser?.rootPath);
+        if (workspaceRootPath !== parsed.workspaceBrowser?.rootPath) {
+            rewriteRequired = true;
+        }
+        return {
+            config: {
+                auth: {
+                    username,
+                    password,
+                    accessTokenSecret,
+                    refreshTokenSecret,
+                    accessTokenTtlSeconds,
+                    refreshTokenTtlSeconds,
+                },
+                security: {
+                    corsAllowedHosts,
+                },
+                workspaces: normalizedWorkspaces.items,
+                workspaceBrowser: {
+                    rootPath: workspaceRootPath,
+                },
+            },
+            rewriteRequired,
+        };
+    }
+    async writeConfig(configPath, config) {
+        await (0, promises_1.mkdir)((0, node_path_1.dirname)(configPath), { recursive: true });
+        const ext = (0, node_path_1.extname)(configPath).toLowerCase();
+        const content = ext === '.json'
+            ? `${JSON.stringify(config, null, 2)}\n`
+            : (0, yaml_1.stringify)(config);
+        await (0, promises_1.writeFile)(configPath, content, {
+            encoding: 'utf8',
+            mode: 0o600,
+        });
+    }
+};
+exports.ServerConfigService = ServerConfigService;
+exports.ServerConfigService = ServerConfigService = ServerConfigService_1 = __decorate([
+    (0, common_1.Injectable)()
+], ServerConfigService);

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,193 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const yaml_1 = require("yaml");
+const vitest_1 = require("vitest");
+vitest_1.vi.mock('../workspaces/workspaces.utils', () => ({
+    defaultWorkspaceName: (cwd) => cwd.split('/').filter(Boolean).at(-1) ?? 'workspace',
+    normalizeWorkspacePath: (input) => input.replace(/\\/g, '/'),
+    workspaceIdFromCwd: (cwd) => `workspace-${cwd.replace(/[^a-zA-Z0-9]/g, '_')}`,
+}));
+const server_config_service_1 = require("./server-config.service");
+function snapshotEnv() {
+    return {
+        memoHome: process.env.MEMO_HOME,
+        serverConfig: process.env.MEMO_SERVER_CONFIG,
+    };
+}
+function restoreEnv(snapshot) {
+    if (snapshot.memoHome === undefined) {
+        delete process.env.MEMO_HOME;
+    }
+    else {
+        process.env.MEMO_HOME = snapshot.memoHome;
+    }
+    if (snapshot.serverConfig === undefined) {
+        delete process.env.MEMO_SERVER_CONFIG;
+    }
+    else {
+        process.env.MEMO_SERVER_CONFIG = snapshot.serverConfig;
+    }
+}
+const tempRoots = [];
+(0, vitest_1.afterEach)(async () => {
+    while (tempRoots.length > 0) {
+        const item = tempRoots.pop();
+        if (!item)
+            continue;
+        await (0, promises_1.rm)(item, { recursive: true, force: true });
+    }
+});
+(0, vitest_1.describe)('ServerConfigService', () => {
+    (0, vitest_1.test)('preserves configured password scalar when normalizing config', async () => {
+        const envSnapshot = snapshotEnv();
+        const memoHome = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'memo-web-server-config-'));
+        tempRoots.push(memoHome);
+        process.env.MEMO_HOME = memoHome;
+        delete process.env.MEMO_SERVER_CONFIG;
+        const configPath = (0, node_path_1.join)(memoHome, 'server.yaml');
+        await (0, promises_1.writeFile)(configPath, [
+            'auth:',
+            '  username: memo',
+            '  password: 123456',
+            'security:',
+            '  corsAllowedHosts:',
+            '    - localhost',
+            '',
+        ].join('\n'), 'utf8');
+        try {
+            const first = await new server_config_service_1.ServerConfigService().load();
+            node_assert_1.default.strictEqual(first.auth.password, '123456');
+            const persisted = (0, yaml_1.parse)(await (0, promises_1.readFile)(configPath, 'utf8'));
+            node_assert_1.default.strictEqual(typeof persisted.auth?.password, 'string', 'password should persist as string after normalization rewrite');
+            node_assert_1.default.strictEqual(persisted.auth?.password, '123456');
+            const second = await new server_config_service_1.ServerConfigService().load();
+            node_assert_1.default.strictEqual(second.auth.password, '123456');
+        }
+        finally {
+            restoreEnv(envSnapshot);
+        }
+    });
+    (0, vitest_1.test)('creates default yaml config when missing', async () => {
+        const envSnapshot = snapshotEnv();
+        const memoHome = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'memo-web-server-default-'));
+        tempRoots.push(memoHome);
+        process.env.MEMO_HOME = memoHome;
+        delete process.env.MEMO_SERVER_CONFIG;
+        const service = new server_config_service_1.ServerConfigService();
+        try {
+            const loaded = await service.load();
+            const configPath = (0, node_path_1.join)(memoHome, 'server.yaml');
+            const persisted = (0, yaml_1.parse)(await (0, promises_1.readFile)(configPath, 'utf8'));
+            node_assert_1.default.strictEqual(service.getConfigPath(), configPath);
+            node_assert_1.default.strictEqual(loaded.auth.username, 'memo');
+            node_assert_1.default.ok(loaded.auth.password.length > 0);
+            node_assert_1.default.strictEqual(persisted.auth?.username, 'memo');
+            node_assert_1.default.strictEqual(typeof persisted.auth?.password, 'string');
+        }
+        finally {
+            restoreEnv(envSnapshot);
+        }
+    });
+    (0, vitest_1.test)('loads explicit JSON config path and normalizes malformed fields', async () => {
+        const envSnapshot = snapshotEnv();
+        const memoHome = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'memo-web-server-json-'));
+        tempRoots.push(memoHome);
+        const configPath = (0, node_path_1.join)(memoHome, 'custom-server.json');
+        process.env.MEMO_HOME = memoHome;
+        process.env.MEMO_SERVER_CONFIG = configPath;
+        await (0, promises_1.writeFile)(configPath, JSON.stringify({
+            auth: {
+                username: true,
+                password: 12345,
+                accessTokenSecret: '',
+                refreshTokenSecret: '',
+                accessTokenTtlSeconds: -1,
+                refreshTokenTtlSeconds: 'abc',
+            },
+            security: {
+                corsAllowedHosts: [],
+            },
+            workspaces: [
+                { id: 'same', name: 'workspace-a', cwd: '/tmp/workspace-a' },
+                { id: 'same', name: 'workspace-b', cwd: '/tmp/workspace-a' },
+                { foo: 'invalid' },
+            ],
+            workspaceBrowser: {
+                rootPath: '',
+            },
+        }, null, 2), 'utf8');
+        const service = new server_config_service_1.ServerConfigService();
+        try {
+            const loaded = await service.load();
+            node_assert_1.default.strictEqual(loaded.auth.username, 'true');
+            node_assert_1.default.strictEqual(loaded.auth.password, '12345');
+            node_assert_1.default.strictEqual(loaded.workspaces.length, 1);
+            node_assert_1.default.strictEqual(loaded.workspaceBrowser.rootPath, '/');
+            node_assert_1.default.ok(loaded.security.corsAllowedHosts.length > 0);
+            const persisted = JSON.parse(await (0, promises_1.readFile)(configPath, 'utf8'));
+            node_assert_1.default.strictEqual(Array.isArray(persisted.workspaces), true);
+            node_assert_1.default.strictEqual(persisted.workspaces?.length, 1);
+            node_assert_1.default.ok((persisted.auth?.accessTokenSecret?.length ?? 0) > 0);
+            node_assert_1.default.ok((persisted.auth?.refreshTokenSecret?.length ?? 0) > 0);
+        }
+        finally {
+            restoreEnv(envSnapshot);
+        }
+    });
+    (0, vitest_1.test)('throws clear parsing error for invalid json config', async () => {
+        const envSnapshot = snapshotEnv();
+        const memoHome = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'memo-web-server-bad-json-'));
+        tempRoots.push(memoHome);
+        const configPath = (0, node_path_1.join)(memoHome, 'server.json');
+        process.env.MEMO_HOME = memoHome;
+        process.env.MEMO_SERVER_CONFIG = configPath;
+        await (0, promises_1.writeFile)(configPath, '{"auth": ', 'utf8');
+        try {
+            await node_assert_1.default.rejects(() => new server_config_service_1.ServerConfigService().load(), /Failed to parse .*server\.json/);
+        }
+        finally {
+            restoreEnv(envSnapshot);
+        }
+    });
+    (0, vitest_1.test)('updateConfig persists normalized updates', async () => {
+        const envSnapshot = snapshotEnv();
+        const memoHome = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'memo-web-server-update-'));
+        tempRoots.push(memoHome);
+        process.env.MEMO_HOME = memoHome;
+        delete process.env.MEMO_SERVER_CONFIG;
+        const service = new server_config_service_1.ServerConfigService();
+        try {
+            await service.load();
+            const updated = await service.updateConfig((config) => ({
+                ...config,
+                security: {
+                    corsAllowedHosts: ['example.com', 'localhost'],
+                },
+                workspaceBrowser: {
+                    rootPath: '/tmp/root',
+                },
+            }));
+            node_assert_1.default.deepStrictEqual(updated.security.corsAllowedHosts, [
+                'example.com',
+                'localhost',
+            ]);
+            node_assert_1.default.strictEqual(updated.workspaceBrowser.rootPath, '/tmp/root');
+            const persisted = (0, yaml_1.parse)(await (0, promises_1.readFile)((0, node_path_1.join)(memoHome, 'server.yaml'), 'utf8'));
+            node_assert_1.default.deepStrictEqual(persisted.security?.corsAllowedHosts, [
+                'example.com',
+                'localhost',
+            ]);
+            node_assert_1.default.strictEqual(persisted.workspaceBrowser?.rootPath, '/tmp/root');
+        }
+        finally {
+            restoreEnv(envSnapshot);
+        }
+    });
+});

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

@@ -0,0 +1,27 @@
+export type ServerAuthConfig = {
+    username: string;
+    password: string;
+    accessTokenSecret: string;
+    refreshTokenSecret: string;
+    accessTokenTtlSeconds: number;
+    refreshTokenTtlSeconds: number;
+};
+export type ServerSecurityConfig = {
+    corsAllowedHosts: string[];
+};
+export type ServerWorkspaceRecord = {
+    id: string;
+    name: string;
+    cwd: string;
+    createdAt: string;
+    lastUsedAt: string;
+};
+export type ServerWorkspaceBrowserConfig = {
+    rootPath: string;
+};
+export type ServerRuntimeConfig = {
+    auth: ServerAuthConfig;
+    security: ServerSecurityConfig;
+    workspaces: ServerWorkspaceRecord[];
+    workspaceBrowser: ServerWorkspaceBrowserConfig;
+};

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

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

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

@@ -0,0 +1 @@
+export {};

package/dist/web/server/main.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const server_1 = require("./server");
+function parsePort(value) {
+    if (!value)
+        return undefined;
+    const parsed = Number.parseInt(value, 10);
+    if (Number.isInteger(parsed) && parsed > 0 && parsed <= 65535)
+        return parsed;
+    return undefined;
+}
+async function bootstrap() {
+    await (0, server_1.startMemoWebServer)({
+        host: process.env.MEMO_WEB_HOST ?? process.env.HOST,
+        port: parsePort(process.env.MEMO_WEB_PORT ?? process.env.PORT),
+        staticDir: process.env.MEMO_WEB_STATIC_DIR,
+    });
+}
+void bootstrap();

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

@@ -0,0 +1,38 @@
+import { McpService } from './mcp.service';
+type UpsertMcpBody = {
+    name?: unknown;
+    config?: unknown;
+};
+type LoginBody = {
+    scopes?: unknown;
+};
+type ActiveBody = {
+    names?: unknown;
+};
+export declare class McpController {
+    private readonly mcpService;
+    constructor(mcpService: 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(body: UpsertMcpBody): Promise<{
+        created: true;
+    }>;
+    update(name: string, body: UpsertMcpBody): Promise<{
+        updated: true;
+    }>;
+    remove(name: string): Promise<{
+        deleted: true;
+    }>;
+    login(name: string, body: LoginBody): Promise<{
+        loggedIn: true;
+    }>;
+    logout(name: string): Promise<{
+        loggedOut: true;
+    }>;
+    setActive(body: ActiveBody): Promise<{
+        active: string[];
+    }>;
+}
+export {};