@memo-code/memo 0.7.3 → 0.8.5

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

@@ -0,0 +1,217 @@
+"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.SessionsService = void 0;
+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 core_1 = require("@memo-code/core");
+const workspaces_service_1 = require("../workspaces/workspaces.service");
+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 parsePage(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        const normalized = Math.floor(value);
+        return normalized > 0 ? normalized : undefined;
+    }
+    if (typeof value === 'string') {
+        const parsed = Number.parseInt(value, 10);
+        return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+    }
+    return undefined;
+}
+function parseSortBy(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    if (value === 'updatedAt' ||
+        value === 'startedAt' ||
+        value === 'project' ||
+        value === 'title') {
+        return value;
+    }
+    return undefined;
+}
+function parseOrder(value) {
+    if (value === 'asc' || value === 'desc')
+        return value;
+    return undefined;
+}
+function parseString(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+let SessionsService = class SessionsService {
+    workspacesService;
+    sessionsDir = (0, node_path_1.resolve)((0, node_path_1.join)(resolveMemoHome(), 'sessions'));
+    historyIndex = new core_1.HistoryIndex({
+        sessionsDir: this.sessionsDir,
+    });
+    constructor(workspacesService) {
+        this.workspacesService = workspacesService;
+    }
+    async list(query) {
+        const normalized = {
+            page: parsePage(query.page),
+            pageSize: parsePage(query.pageSize),
+            sortBy: parseSortBy(query.sortBy),
+            order: parseOrder(query.order),
+            project: parseString(query.project),
+            workspaceId: parseString(query.workspaceId),
+            dateFrom: parseString(query.dateFrom),
+            dateTo: parseString(query.dateTo),
+            q: parseString(query.q),
+        };
+        if (normalized.workspaceId) {
+            const workspace = await this.workspacesService.getById(normalized.workspaceId);
+            if (!workspace) {
+                return {
+                    items: [],
+                    page: normalized.page ?? 1,
+                    pageSize: normalized.pageSize ?? 20,
+                    total: 0,
+                    totalPages: 0,
+                };
+            }
+            normalized.workspaceCwd = workspace.cwd;
+        }
+        return this.historyIndex.list(normalized);
+    }
+    async getSessionDetail(sessionId) {
+        const detail = await this.historyIndex.getSessionDetail(sessionId);
+        if (!detail) {
+            throw new common_1.NotFoundException('Session not found');
+        }
+        return {
+            ...detail,
+            workspaceId: detail.workspaceId || (0, core_1.workspaceIdFromCwd)(detail.cwd),
+        };
+    }
+    async getSessionEvents(sessionId, query) {
+        const normalized = {
+            cursor: parseString(query.cursor),
+            limit: parsePage(query.limit),
+        };
+        const events = await this.historyIndex.getSessionEvents(sessionId, normalized.cursor, normalized.limit);
+        if (!events) {
+            throw new common_1.NotFoundException('Session not found');
+        }
+        return events;
+    }
+    async listAllSessionSummaries() {
+        return this.historyIndex.getAllSummaries();
+    }
+    async removeSession(sessionId) {
+        const target = sessionId.trim();
+        if (!target) {
+            throw new common_1.NotFoundException('Session not found');
+        }
+        const detail = await this.historyIndex.getSessionDetail(target);
+        if (!detail) {
+            throw new common_1.NotFoundException('Session not found');
+        }
+        await this.removeSessionFile(detail.filePath);
+        await this.historyIndex.refresh();
+        return { deleted: true };
+    }
+    async removeSessionsByWorkspace(workspaceId) {
+        const target = workspaceId.trim();
+        if (!target) {
+            throw new common_1.NotFoundException('workspace not found');
+        }
+        const workspace = await this.workspacesService.getById(target);
+        if (!workspace) {
+            throw new common_1.NotFoundException('workspace not found');
+        }
+        const workspaceCwd = (0, core_1.normalizeWorkspacePath)(workspace.cwd);
+        const summaries = await this.historyIndex.getAllSummaries();
+        const filePaths = Array.from(new Set(summaries
+            .filter((summary) => (0, core_1.normalizeWorkspacePath)(summary.cwd) === workspaceCwd)
+            .map((summary) => summary.filePath)
+            .filter((filePath) => typeof filePath === 'string' && filePath.trim().length > 0)));
+        let deletedSessions = 0;
+        for (const filePath of filePaths) {
+            const deleted = await this.removeSessionFile(filePath);
+            if (deleted) {
+                deletedSessions += 1;
+            }
+        }
+        await this.historyIndex.refresh();
+        return { deleted: true, deletedSessions };
+    }
+    normalizeSafeSessionFilePath(filePath) {
+        const resolvedPath = (0, node_path_1.resolve)(filePath);
+        if (!resolvedPath.endsWith('.jsonl')) {
+            throw new Error(`Refusing to remove non-jsonl session file: ${resolvedPath}`);
+        }
+        if (resolvedPath === this.sessionsDir ||
+            !resolvedPath.startsWith(`${this.sessionsDir}${node_path_1.sep}`)) {
+            throw new Error(`Refusing to remove file outside sessions dir: ${resolvedPath}`);
+        }
+        return resolvedPath;
+    }
+    async removeSessionFile(filePath) {
+        const safePath = this.normalizeSafeSessionFilePath(filePath);
+        try {
+            const info = await (0, promises_1.lstat)(safePath);
+            if (!info.isFile() || info.isSymbolicLink()) {
+                throw new Error(`Refusing to remove non-regular file: ${safePath}`);
+            }
+        }
+        catch (error) {
+            const code = error?.code;
+            if (code === 'ENOENT')
+                return false;
+            throw error;
+        }
+        try {
+            await (0, promises_1.unlink)(safePath);
+        }
+        catch (error) {
+            const code = error?.code;
+            if (code === 'ENOENT')
+                return false;
+            throw error;
+        }
+        await this.pruneEmptyParentDirectories(safePath);
+        return true;
+    }
+    async pruneEmptyParentDirectories(filePath) {
+        let current = (0, node_path_1.dirname)(filePath);
+        while (current !== this.sessionsDir &&
+            current.startsWith(`${this.sessionsDir}${node_path_1.sep}`)) {
+            try {
+                await (0, promises_1.rmdir)(current);
+            }
+            catch (error) {
+                const code = error?.code;
+                if (code === 'ENOENT' || code === 'ENOTEMPTY') {
+                    break;
+                }
+                throw error;
+            }
+            current = (0, node_path_1.dirname)(current);
+        }
+    }
+};
+exports.SessionsService = SessionsService;
+exports.SessionsService = SessionsService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [workspaces_service_1.WorkspacesService])
+], SessionsService);

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

@@ -0,0 +1,18 @@
+import type { SessionDetail, SessionEventsResponse, SessionListResponse } from '@memo-code/core';
+export type ListSessionsQuery = {
+    page?: number;
+    pageSize?: number;
+    sortBy?: 'updatedAt' | 'startedAt' | 'project' | 'title';
+    order?: 'asc' | 'desc';
+    project?: string;
+    workspaceId?: string;
+    workspaceCwd?: string;
+    dateFrom?: string;
+    dateTo?: string;
+    q?: string;
+};
+export type SessionEventsQuery = {
+    cursor?: string;
+    limit?: number;
+};
+export type { SessionDetail, SessionEventsResponse, SessionListResponse };

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

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

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

@@ -0,0 +1,31 @@
+import { SkillsService } from './skills.service';
+type CreateSkillBody = {
+    scope?: unknown;
+    workspaceId?: unknown;
+    name?: unknown;
+    description?: unknown;
+    content?: unknown;
+};
+type UpdateSkillBody = {
+    description?: unknown;
+    content?: unknown;
+};
+export declare class SkillsController {
+    private readonly skillsService;
+    constructor(skillsService: SkillsService);
+    list(query: Record<string, unknown>): Promise<{
+        items: import("@memo-code/core", { with: { "resolution-mode": "import" } }).SkillRecord[];
+    }>;
+    get(id: string): Promise<import("@memo-code/core", { with: { "resolution-mode": "import" } }).SkillDetail>;
+    create(body: CreateSkillBody): Promise<{
+        created: true;
+        item: import("@memo-code/core", { with: { "resolution-mode": "import" } }).SkillRecord;
+    }>;
+    update(id: string, body: UpdateSkillBody): Promise<{
+        updated: true;
+    }>;
+    remove(id: string): Promise<{
+        deleted: true;
+    }>;
+}
+export {};

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

@@ -0,0 +1,86 @@
+"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.SkillsController = void 0;
+const common_1 = require("@nestjs/common");
+const skills_service_1 = require("./skills.service");
+let SkillsController = class SkillsController {
+    skillsService;
+    constructor(skillsService) {
+        this.skillsService = skillsService;
+    }
+    async list(query) {
+        return this.skillsService.list({
+            scope: query.scope,
+            q: query.q,
+            workspaceId: query.workspaceId,
+        });
+    }
+    async get(id) {
+        return this.skillsService.get(id);
+    }
+    async create(body) {
+        return this.skillsService.create({
+            ...body,
+            workspaceId: body.workspaceId,
+        });
+    }
+    async update(id, body) {
+        return this.skillsService.update(id, body);
+    }
+    async remove(id) {
+        return this.skillsService.remove(id);
+    }
+};
+exports.SkillsController = SkillsController;
+__decorate([
+    (0, common_1.Get)(),
+    __param(0, (0, common_1.Query)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], SkillsController.prototype, "list", 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)
+], SkillsController.prototype, "get", null);
+__decorate([
+    (0, common_1.Post)(),
+    __param(0, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], SkillsController.prototype, "create", null);
+__decorate([
+    (0, common_1.Put)(':id'),
+    __param(0, (0, common_1.Param)('id')),
+    __param(1, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], SkillsController.prototype, "update", null);
+__decorate([
+    (0, common_1.Delete)(':id'),
+    __param(0, (0, common_1.Param)('id')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], SkillsController.prototype, "remove", null);
+exports.SkillsController = SkillsController = __decorate([
+    (0, common_1.Controller)('api/skills'),
+    __metadata("design:paramtypes", [skills_service_1.SkillsService])
+], SkillsController);

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

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

package/dist/web/server/skills/skills.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.SkillsModule = void 0;
+const common_1 = require("@nestjs/common");
+const workspaces_module_1 = require("../workspaces/workspaces.module");
+const skills_controller_1 = require("./skills.controller");
+const skills_service_1 = require("./skills.service");
+let SkillsModule = class SkillsModule {
+};
+exports.SkillsModule = SkillsModule;
+exports.SkillsModule = SkillsModule = __decorate([
+    (0, common_1.Module)({
+        imports: [workspaces_module_1.WorkspacesModule],
+        controllers: [skills_controller_1.SkillsController],
+        providers: [skills_service_1.SkillsService],
+        exports: [skills_service_1.SkillsService],
+    })
+], SkillsModule);

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

@@ -0,0 +1,38 @@
+import { WorkspacesService } from '../workspaces/workspaces.service';
+export declare class SkillsService {
+    private readonly workspacesService;
+    constructor(workspacesService: WorkspacesService);
+    list(options: {
+        scope?: unknown;
+        q?: unknown;
+        workspaceId?: unknown;
+    }): Promise<{
+        items: import("@memo-code/core", { with: { "resolution-mode": "import" } }).SkillRecord[];
+    }>;
+    get(id: string): Promise<import("@memo-code/core", { with: { "resolution-mode": "import" } }).SkillDetail>;
+    create(input: {
+        scope?: unknown;
+        name?: unknown;
+        description?: unknown;
+        content?: unknown;
+        workspaceId?: unknown;
+    }): Promise<{
+        created: true;
+        item: import("@memo-code/core", { with: { "resolution-mode": "import" } }).SkillRecord;
+    }>;
+    update(id: string, input: {
+        description?: unknown;
+        content?: unknown;
+    }): Promise<{
+        updated: true;
+    }>;
+    remove(id: string): Promise<{
+        deleted: true;
+    }>;
+    setActive(ids: string[]): Promise<{
+        active: string[];
+    }>;
+    private listWorkspaceCwds;
+    private resolveWorkspaceCwd;
+    private wrap;
+}

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

@@ -0,0 +1,97 @@
+"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.SkillsService = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@memo-code/core");
+const workspaces_service_1 = require("../workspaces/workspaces.service");
+let SkillsService = class SkillsService {
+    workspacesService;
+    constructor(workspacesService) {
+        this.workspacesService = workspacesService;
+    }
+    async list(options) {
+        const workspaceCwd = await this.resolveWorkspaceCwd(options.workspaceId, {
+            requiredWhenProjectScope: options.scope === 'project',
+        });
+        return this.wrap(() => (0, core_1.listSkills)({
+            scope: options.scope,
+            q: options.q,
+            workspaceCwd,
+        }));
+    }
+    async get(id) {
+        const workspaceCwds = await this.listWorkspaceCwds();
+        return this.wrap(() => (0, core_1.getSkill)(id, { workspaceCwds }));
+    }
+    async create(input) {
+        const workspaceCwd = await this.resolveWorkspaceCwd(input.workspaceId, {
+            requiredWhenProjectScope: input.scope === 'project',
+        });
+        return this.wrap(() => (0, core_1.createSkill)({
+            scope: input.scope,
+            name: input.name,
+            description: input.description,
+            content: input.content,
+            workspaceCwd,
+        }));
+    }
+    async update(id, input) {
+        const workspaceCwds = await this.listWorkspaceCwds();
+        return this.wrap(() => (0, core_1.updateSkill)(id, input, { workspaceCwds }));
+    }
+    async remove(id) {
+        const workspaceCwds = await this.listWorkspaceCwds();
+        return this.wrap(() => (0, core_1.removeSkill)(id, { workspaceCwds }));
+    }
+    async setActive(ids) {
+        const workspaceCwds = await this.listWorkspaceCwds();
+        return this.wrap(() => (0, core_1.setActiveSkills)(ids, { workspaceCwds }));
+    }
+    async listWorkspaceCwds() {
+        const workspaces = await this.workspacesService.list();
+        return workspaces.items.map((item) => item.cwd);
+    }
+    async resolveWorkspaceCwd(workspaceId, options) {
+        const id = typeof workspaceId === 'string' ? workspaceId.trim() : '';
+        if (!id) {
+            if (options.requiredWhenProjectScope) {
+                throw new common_1.BadRequestException('workspaceId is required when scope=project');
+            }
+            return null;
+        }
+        const workspace = await this.workspacesService.getById(id);
+        if (!workspace) {
+            throw new common_1.NotFoundException('workspace not found');
+        }
+        return workspace.cwd;
+    }
+    async wrap(fn) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            if (error instanceof core_1.SkillsAdminError) {
+                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 || 'skills operation failed');
+        }
+    }
+};
+exports.SkillsService = SkillsService;
+exports.SkillsService = SkillsService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [workspaces_service_1.WorkspacesService])
+], SkillsService);

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

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

package/dist/web/server/stream/stream.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.StreamModule = void 0;
+const common_1 = require("@nestjs/common");
+const stream_service_1 = require("./stream.service");
+let StreamModule = class StreamModule {
+};
+exports.StreamModule = StreamModule;
+exports.StreamModule = StreamModule = __decorate([
+    (0, common_1.Module)({
+        providers: [stream_service_1.StreamService],
+        exports: [stream_service_1.StreamService],
+    })
+], StreamModule);

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

@@ -0,0 +1,26 @@
+import type { IncomingMessage } from 'node:http';
+import { OnModuleDestroy } from '@nestjs/common';
+import type { AccessTokenPayload } from '../auth/auth.types';
+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 StreamService implements OnModuleDestroy {
+    private readonly logger;
+    private readonly socketsBySession;
+    private readonly listenersBySession;
+    private readonly globalListeners;
+    private wsServer;
+    private attached;
+    attach(options: AttachOptions): void;
+    broadcast(sessionId: string, payload: unknown): void;
+    disconnectSession(sessionId: string): void;
+    subscribe(sessionId: string, listener: (payload: unknown) => void): () => void;
+    subscribeAll(listener: (sessionId: string, payload: unknown) => void): () => void;
+    onModuleDestroy(): Promise<void>;
+    private registerSocket;
+}
+export {};