@memo-code/memo 0.8.0 → 0.8.5

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

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

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

@@ -0,0 +1,20 @@
+"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.WorkspacesModule = void 0;
+const common_1 = require("@nestjs/common");
+const workspaces_service_1 = require("./workspaces.service");
+let WorkspacesModule = class WorkspacesModule {
+};
+exports.WorkspacesModule = WorkspacesModule;
+exports.WorkspacesModule = WorkspacesModule = __decorate([
+    (0, common_1.Module)({
+        providers: [workspaces_service_1.WorkspacesService],
+        exports: [workspaces_service_1.WorkspacesService],
+    })
+], WorkspacesModule);

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

@@ -0,0 +1,38 @@
+import { ServerConfigService } from '../config/server-config.service';
+import type { WorkspaceFsListResult, WorkspaceRecord } from './workspaces.types';
+export declare class WorkspacesService {
+    private readonly serverConfigService;
+    private historyHydrated;
+    constructor(serverConfigService: ServerConfigService);
+    list(): Promise<{
+        items: WorkspaceRecord[];
+    }>;
+    getById(id: string): Promise<WorkspaceRecord | null>;
+    resolveWorkspace(input: {
+        workspaceId?: string;
+        cwd?: string;
+    }): Promise<WorkspaceRecord>;
+    ensureByCwd(cwd: string, name?: string, options?: {
+        validateReadable?: boolean;
+    }): Promise<WorkspaceRecord>;
+    add(input: {
+        cwd?: unknown;
+        name?: unknown;
+    }): Promise<{
+        created: boolean;
+        item: WorkspaceRecord;
+    }>;
+    update(workspaceId: string, input: {
+        name?: unknown;
+    }): Promise<{
+        updated: boolean;
+        item: WorkspaceRecord;
+    }>;
+    remove(workspaceId: string): Promise<{
+        deleted: boolean;
+    }>;
+    touchLastUsed(workspaceId: string): Promise<void>;
+    listDirectories(pathInput: string | undefined): Promise<WorkspaceFsListResult>;
+    private hydrateFromHistoryIfNeeded;
+    private resolveReadableDirectory;
+}

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

@@ -0,0 +1,378 @@
+"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.WorkspacesService = void 0;
+const node_fs_1 = require("node:fs");
+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 server_config_service_1 = require("../config/server-config.service");
+const workspaces_utils_1 = require("./workspaces.utils");
+const MAX_DIRECTORY_ITEMS = 200;
+function resolveMemoHome() {
+    const memoHome = process.env.MEMO_HOME;
+    if (!memoHome || !memoHome.trim())
+        return (0, node_path_1.join)((0, node_os_1.homedir)(), '.memo');
+    if (!memoHome.startsWith('~'))
+        return memoHome;
+    return (0, node_path_1.join)((0, node_os_1.homedir)(), memoHome.slice(1));
+}
+function toWorkspaceRecord(input) {
+    return {
+        id: input.id,
+        name: input.name,
+        cwd: input.cwd,
+        createdAt: input.createdAt,
+        lastUsedAt: input.lastUsedAt,
+    };
+}
+function byNameThenPath(a, b) {
+    const nameResult = a.name.localeCompare(b.name, undefined, {
+        sensitivity: 'base',
+    });
+    if (nameResult !== 0)
+        return nameResult;
+    return a.cwd.localeCompare(b.cwd);
+}
+function extractCwdFromHistoryLog(raw) {
+    const lines = raw.split('\n');
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+            continue;
+        const event = parsed;
+        if (event.type !== 'session_start')
+            continue;
+        const meta = event.meta;
+        if (!meta || typeof meta !== 'object' || Array.isArray(meta))
+            continue;
+        const cwd = meta.cwd;
+        if (typeof cwd !== 'string' || !cwd.trim())
+            continue;
+        return (0, workspaces_utils_1.normalizeWorkspacePath)(cwd);
+    }
+    return null;
+}
+async function collectHistoryCwds() {
+    const sessionsDir = (0, node_path_1.join)(resolveMemoHome(), 'sessions');
+    const results = new Set();
+    const walk = async (dirPath) => {
+        let entries;
+        try {
+            entries = await (0, promises_1.readdir)(dirPath, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.isSymbolicLink())
+                continue;
+            const fullPath = (0, node_path_1.join)(dirPath, entry.name);
+            if (entry.isDirectory()) {
+                await walk(fullPath);
+                continue;
+            }
+            if (!entry.isFile() || !entry.name.endsWith('.jsonl'))
+                continue;
+            try {
+                const raw = await (0, promises_1.readFile)(fullPath, 'utf8');
+                const cwd = extractCwdFromHistoryLog(raw);
+                if (cwd) {
+                    results.add(cwd);
+                }
+            }
+            catch {
+            }
+        }
+    };
+    await walk((0, node_path_1.resolve)(sessionsDir));
+    return Array.from(results.values()).sort((a, b) => a.localeCompare(b));
+}
+function isWithinRoot(path, rootPath) {
+    const normalizedPath = (0, workspaces_utils_1.normalizeWorkspacePath)(path);
+    const normalizedRoot = (0, workspaces_utils_1.normalizeWorkspacePath)(rootPath);
+    if (normalizedRoot === '/')
+        return true;
+    if (normalizedPath === normalizedRoot)
+        return true;
+    return normalizedPath.startsWith(`${normalizedRoot}/`);
+}
+let WorkspacesService = class WorkspacesService {
+    serverConfigService;
+    historyHydrated = false;
+    constructor(serverConfigService) {
+        this.serverConfigService = serverConfigService;
+    }
+    async list() {
+        await this.hydrateFromHistoryIfNeeded();
+        const config = await this.serverConfigService.load();
+        return {
+            items: config.workspaces.map(toWorkspaceRecord).sort(byNameThenPath),
+        };
+    }
+    async getById(id) {
+        const target = id.trim();
+        if (!target)
+            return null;
+        const config = await this.serverConfigService.load();
+        const found = config.workspaces.find((item) => item.id === target);
+        return found ? toWorkspaceRecord(found) : null;
+    }
+    async resolveWorkspace(input) {
+        const workspaceId = input.workspaceId?.trim();
+        if (workspaceId) {
+            const found = await this.getById(workspaceId);
+            if (!found) {
+                throw new common_1.NotFoundException(`workspace not found: ${workspaceId}`);
+            }
+            return found;
+        }
+        const cwd = input.cwd?.trim();
+        if (cwd) {
+            return this.ensureByCwd(cwd);
+        }
+        throw new common_1.BadRequestException('workspaceId is required');
+    }
+    async ensureByCwd(cwd, name, options) {
+        const normalizedCwd = options?.validateReadable === false
+            ? (0, workspaces_utils_1.normalizeWorkspacePath)(cwd)
+            : await this.resolveReadableDirectory(cwd);
+        const id = (0, workspaces_utils_1.workspaceIdFromCwd)(normalizedCwd);
+        const existing = await this.getById(id);
+        if (existing) {
+            if (name && name.trim() && existing.name !== name.trim()) {
+                const renamed = await this.update(existing.id, { name });
+                return renamed.item;
+            }
+            return existing;
+        }
+        const now = new Date().toISOString();
+        const next = {
+            id,
+            cwd: normalizedCwd,
+            name: (0, workspaces_utils_1.normalizeWorkspaceName)(name ?? (0, workspaces_utils_1.defaultWorkspaceName)(normalizedCwd), normalizedCwd),
+            createdAt: now,
+            lastUsedAt: now,
+        };
+        await this.serverConfigService.updateConfig((config) => {
+            return {
+                ...config,
+                workspaces: [...config.workspaces, next].sort((a, b) => a.cwd.localeCompare(b.cwd)),
+            };
+        });
+        return next;
+    }
+    async add(input) {
+        const cwd = typeof input.cwd === 'string' ? input.cwd.trim() : '';
+        if (!cwd) {
+            throw new common_1.BadRequestException('cwd is required');
+        }
+        const name = typeof input.name === 'string' ? input.name.trim() : undefined;
+        const item = await this.ensureByCwd(cwd, name);
+        return { created: true, item };
+    }
+    async update(workspaceId, input) {
+        const id = workspaceId.trim();
+        if (!id) {
+            throw new common_1.BadRequestException('workspaceId is required');
+        }
+        const found = await this.getById(id);
+        if (!found) {
+            throw new common_1.NotFoundException('workspace not found');
+        }
+        const name = typeof input.name === 'string' ? input.name.trim() : '';
+        if (!name) {
+            throw new common_1.BadRequestException('name is required');
+        }
+        const next = {
+            ...found,
+            name,
+            lastUsedAt: new Date().toISOString(),
+        };
+        await this.serverConfigService.updateConfig((config) => ({
+            ...config,
+            workspaces: config.workspaces.map((item) => item.id === id ? next : item),
+        }));
+        return { updated: true, item: next };
+    }
+    async remove(workspaceId) {
+        const id = workspaceId.trim();
+        if (!id) {
+            throw new common_1.BadRequestException('workspaceId is required');
+        }
+        const found = await this.getById(id);
+        if (!found) {
+            throw new common_1.NotFoundException('workspace not found');
+        }
+        await this.serverConfigService.updateConfig((config) => ({
+            ...config,
+            workspaces: config.workspaces.filter((item) => item.id !== id),
+        }));
+        return { deleted: true };
+    }
+    async touchLastUsed(workspaceId) {
+        const id = workspaceId.trim();
+        if (!id)
+            return;
+        await this.serverConfigService.updateConfig((config) => ({
+            ...config,
+            workspaces: config.workspaces.map((item) => item.id === id
+                ? {
+                    ...item,
+                    lastUsedAt: new Date().toISOString(),
+                }
+                : item),
+        }));
+    }
+    async listDirectories(pathInput) {
+        const config = await this.serverConfigService.load();
+        const rootPath = config.workspaceBrowser.rootPath || '/';
+        const rootRealPath = await this.resolveReadableDirectory(rootPath);
+        let requestedPath = pathInput?.trim() ? pathInput.trim() : rootRealPath;
+        if (!pathInput?.trim() && rootRealPath === '/') {
+            try {
+                requestedPath = await this.resolveReadableDirectory((0, node_os_1.homedir)());
+            }
+            catch {
+                requestedPath = rootRealPath;
+            }
+        }
+        const targetPath = await this.resolveReadableDirectory(requestedPath);
+        if (!isWithinRoot(targetPath, rootRealPath)) {
+            throw new common_1.BadRequestException('path is outside workspace browser root');
+        }
+        let entries;
+        try {
+            entries = await (0, promises_1.readdir)(targetPath, { withFileTypes: true });
+        }
+        catch {
+            throw new common_1.BadRequestException('failed to read directory');
+        }
+        const sortedEntries = entries
+            .filter((entry) => !entry.name.startsWith('.'))
+            .sort((a, b) => a.name.localeCompare(b.name, undefined, { sensitivity: 'base' }));
+        const items = [];
+        for (const entry of sortedEntries) {
+            if (items.length >= MAX_DIRECTORY_ITEMS)
+                break;
+            const candidate = (0, node_path_1.resolve)(targetPath, entry.name);
+            let directoryPath = null;
+            if (entry.isDirectory()) {
+                directoryPath = (0, workspaces_utils_1.normalizeWorkspacePath)(candidate);
+            }
+            else if (entry.isSymbolicLink()) {
+                try {
+                    const linked = (0, workspaces_utils_1.normalizeWorkspacePath)(await (0, promises_1.realpath)(candidate));
+                    const linkedStat = await (0, promises_1.stat)(linked);
+                    if (!linkedStat.isDirectory())
+                        continue;
+                    if (!isWithinRoot(linked, rootRealPath))
+                        continue;
+                    directoryPath = linked;
+                }
+                catch {
+                    continue;
+                }
+            }
+            else {
+                continue;
+            }
+            if (!directoryPath)
+                continue;
+            let readable = true;
+            try {
+                await (0, promises_1.access)(directoryPath, node_fs_1.constants.R_OK | node_fs_1.constants.X_OK);
+            }
+            catch {
+                readable = false;
+            }
+            items.push({
+                name: entry.name,
+                path: directoryPath,
+                kind: 'dir',
+                readable,
+            });
+        }
+        const parent = (0, node_path_1.dirname)(targetPath);
+        const parentPath = targetPath === rootRealPath || !isWithinRoot(parent, rootRealPath)
+            ? null
+            : (0, workspaces_utils_1.normalizeWorkspacePath)(parent);
+        return {
+            path: (0, workspaces_utils_1.normalizeWorkspacePath)(targetPath),
+            parentPath,
+            items,
+        };
+    }
+    async hydrateFromHistoryIfNeeded() {
+        if (this.historyHydrated)
+            return;
+        this.historyHydrated = true;
+        const config = await this.serverConfigService.load();
+        if (config.workspaces.length > 0)
+            return;
+        const cwds = await collectHistoryCwds();
+        if (cwds.length === 0)
+            return;
+        const now = new Date().toISOString();
+        const hydrated = cwds.map((cwd) => ({
+            id: (0, workspaces_utils_1.workspaceIdFromCwd)(cwd),
+            cwd,
+            name: (0, workspaces_utils_1.defaultWorkspaceName)(cwd),
+            createdAt: now,
+            lastUsedAt: now,
+        }));
+        await this.serverConfigService.updateConfig((current) => ({
+            ...current,
+            workspaces: hydrated,
+        }));
+    }
+    async resolveReadableDirectory(path) {
+        const normalizedPath = (0, workspaces_utils_1.normalizeWorkspacePath)(path);
+        let realPath;
+        try {
+            realPath = (0, workspaces_utils_1.normalizeWorkspacePath)(await (0, promises_1.realpath)(normalizedPath));
+        }
+        catch {
+            throw new common_1.BadRequestException(`directory does not exist: ${path}`);
+        }
+        let directoryStat;
+        try {
+            directoryStat = await (0, promises_1.stat)(realPath);
+        }
+        catch {
+            throw new common_1.BadRequestException(`directory is not accessible: ${path}`);
+        }
+        if (!directoryStat.isDirectory()) {
+            throw new common_1.BadRequestException(`path is not a directory: ${path}`);
+        }
+        try {
+            await (0, promises_1.access)(realPath, node_fs_1.constants.R_OK | node_fs_1.constants.X_OK);
+        }
+        catch {
+            throw new common_1.BadRequestException(`directory is not readable: ${path}`);
+        }
+        return realPath;
+    }
+};
+exports.WorkspacesService = WorkspacesService;
+exports.WorkspacesService = WorkspacesService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [server_config_service_1.ServerConfigService])
+], WorkspacesService);

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

@@ -0,0 +1 @@
+export type { WorkspaceDirEntry, WorkspaceFsListResult, WorkspaceRecord, SessionRuntimeBadge, } from '@memo-code/core';

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

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

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

@@ -0,0 +1 @@
+export { cwdBelongsToWorkspace, defaultWorkspaceName, normalizeWorkspaceName, normalizeWorkspacePath, workspaceIdFromCwd, } from '@memo-code/core';

package/dist/web/server/workspaces/workspaces.utils.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workspaceIdFromCwd = exports.normalizeWorkspacePath = exports.normalizeWorkspaceName = exports.defaultWorkspaceName = exports.cwdBelongsToWorkspace = void 0;
+var core_1 = require("@memo-code/core");
+Object.defineProperty(exports, "cwdBelongsToWorkspace", { enumerable: true, get: function () { return core_1.cwdBelongsToWorkspace; } });
+Object.defineProperty(exports, "defaultWorkspaceName", { enumerable: true, get: function () { return core_1.defaultWorkspaceName; } });
+Object.defineProperty(exports, "normalizeWorkspaceName", { enumerable: true, get: function () { return core_1.normalizeWorkspaceName; } });
+Object.defineProperty(exports, "normalizeWorkspacePath", { enumerable: true, get: function () { return core_1.normalizeWorkspacePath; } });
+Object.defineProperty(exports, "workspaceIdFromCwd", { enumerable: true, get: function () { return core_1.workspaceIdFromCwd; } });

package/dist/web/server/ws/rpc-router.service.d.ts

@@ -0,0 +1,20 @@
+import { ChatService } from '../chat/chat.service';
+import { McpService } from '../mcp/mcp.service';
+import { SessionsService } from '../sessions/sessions.service';
+import { SkillsService } from '../skills/skills.service';
+import { WorkspacesService } from '../workspaces/workspaces.service';
+import { SessionRuntimeRegistry } from './session-runtime-registry.service';
+export type RpcCallContext = {
+    connectionId: string;
+    username: string;
+};
+export declare class RpcRouterService {
+    private readonly sessionsService;
+    private readonly chatService;
+    private readonly mcpService;
+    private readonly skillsService;
+    private readonly workspacesService;
+    private readonly sessionRegistry;
+    constructor(sessionsService: SessionsService, chatService: ChatService, mcpService: McpService, skillsService: SkillsService, workspacesService: WorkspacesService, sessionRegistry: SessionRuntimeRegistry);
+    dispatch(context: RpcCallContext, method: string, params: unknown): Promise<unknown>;
+}