crewx 0.8.8-rc.2 → 0.8.8-rc.21

package/dist-server/domain/mcp/chromex-negotiate.controller.js

@@ -0,0 +1,77 @@
+"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.ChromexNegotiateController = void 0;
+const common_1 = require("@nestjs/common");
+const base_auth_guard_js_1 = require("../auth/guards/base-auth.guard.js");
+const chromex_negotiate_dto_js_1 = require("./chromex-negotiate.dto.js");
+const chromex_negotiate_service_js_1 = require("./chromex-negotiate.service.js");
+let ChromexNegotiateController = class ChromexNegotiateController {
+    negotiateService;
+    constructor(negotiateService) {
+        this.negotiateService = negotiateService;
+    }
+    async negotiate(dto) {
+        return this.negotiateService.negotiate(dto);
+    }
+    async approve(dto) {
+        return await this.negotiateService.approve(dto.requestId, {
+            expiresIn: dto.expiresIn,
+            scope: dto.scope,
+        });
+    }
+    deny(dto) {
+        this.negotiateService.deny(dto.requestId, dto.reason);
+    }
+    async revokeSession(dto) {
+        await this.negotiateService.revokeSession(dto.tokenId);
+    }
+};
+exports.ChromexNegotiateController = ChromexNegotiateController;
+__decorate([
+    (0, common_1.Post)('negotiate'),
+    __param(0, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [chromex_negotiate_dto_js_1.NegotiateRequestDto]),
+    __metadata("design:returntype", Promise)
+], ChromexNegotiateController.prototype, "negotiate", null);
+__decorate([
+    (0, common_1.Post)('approve'),
+    (0, common_1.HttpCode)(200),
+    __param(0, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [chromex_negotiate_dto_js_1.ApproveRequestDto]),
+    __metadata("design:returntype", Promise)
+], ChromexNegotiateController.prototype, "approve", null);
+__decorate([
+    (0, common_1.Post)('deny'),
+    (0, common_1.HttpCode)(200),
+    __param(0, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [chromex_negotiate_dto_js_1.DenyRequestDto]),
+    __metadata("design:returntype", void 0)
+], ChromexNegotiateController.prototype, "deny", null);
+__decorate([
+    (0, common_1.Delete)('session'),
+    (0, common_1.HttpCode)(200),
+    __param(0, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [chromex_negotiate_dto_js_1.RevokeSessionDto]),
+    __metadata("design:returntype", Promise)
+], ChromexNegotiateController.prototype, "revokeSession", null);
+exports.ChromexNegotiateController = ChromexNegotiateController = __decorate([
+    (0, common_1.Controller)('api/chromex'),
+    (0, common_1.UseGuards)(base_auth_guard_js_1.BaseAuthGuard),
+    __metadata("design:paramtypes", [chromex_negotiate_service_js_1.ChromexNegotiateService])
+], ChromexNegotiateController);

package/dist-server/domain/mcp/chromex-negotiate.dto.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 __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.ChromexTokenResponseDto = exports.RevokeSessionDto = exports.DenyRequestDto = exports.ApproveRequestDto = exports.NegotiateRequestDto = void 0;
+const class_validator_1 = require("class-validator");
+class NegotiateRequestDto {
+    agentId;
+    scope;
+    expiresIn;
+    tokenName;
+}
+exports.NegotiateRequestDto = NegotiateRequestDto;
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.MinLength)(1),
+    __metadata("design:type", String)
+], NegotiateRequestDto.prototype, "agentId", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.MinLength)(1),
+    __metadata("design:type", String)
+], NegotiateRequestDto.prototype, "scope", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsIn)(['30d', '90d', '1y']),
+    __metadata("design:type", String)
+], NegotiateRequestDto.prototype, "expiresIn", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], NegotiateRequestDto.prototype, "tokenName", void 0);
+class ApproveRequestDto {
+    requestId;
+    expiresIn;
+    scope;
+}
+exports.ApproveRequestDto = ApproveRequestDto;
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.MinLength)(1),
+    __metadata("design:type", String)
+], ApproveRequestDto.prototype, "requestId", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsIn)(['30d', '90d', '1y']),
+    __metadata("design:type", String)
+], ApproveRequestDto.prototype, "expiresIn", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], ApproveRequestDto.prototype, "scope", void 0);
+class DenyRequestDto {
+    requestId;
+    reason;
+}
+exports.DenyRequestDto = DenyRequestDto;
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.MinLength)(1),
+    __metadata("design:type", String)
+], DenyRequestDto.prototype, "requestId", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], DenyRequestDto.prototype, "reason", void 0);
+class RevokeSessionDto {
+    tokenId;
+}
+exports.RevokeSessionDto = RevokeSessionDto;
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.MinLength)(1),
+    __metadata("design:type", String)
+], RevokeSessionDto.prototype, "tokenId", void 0);
+class ChromexTokenResponseDto {
+    token; // crewx_<JWT> — Bearer로 사용
+    tokenId; // tok_... (revoke용)
+    jti; // JWT ID
+    expiresAt; // ISO 8601
+    scope;
+    agentId;
+    mcpSessionId;
+}
+exports.ChromexTokenResponseDto = ChromexTokenResponseDto;

package/dist-server/domain/mcp/chromex-negotiate.service.js

@@ -0,0 +1,249 @@
+"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.ChromexNegotiateService = void 0;
+const common_1 = require("@nestjs/common");
+const path_1 = require("path");
+const os_1 = require("os");
+const nanoid_1 = require("nanoid");
+const token_service_js_1 = require("../token/token.service.js");
+const browser_session_store_js_1 = require("./browser-session.store.js");
+const mcp_constants_js_1 = require("./mcp.constants.js");
+const NEGOTIATE_TIMEOUT_MS = 60_000;
+const PROCESSED_TTL_MS = 5 * 60_000;
+let ChromexNegotiateService = class ChromexNegotiateService {
+    tokenService;
+    browserSessions;
+    pendingRequests = new Map();
+    pendingAgentIds = new Set();
+    processedRequests = new Set();
+    db;
+    constructor(tokenService, browserSessions) {
+        this.tokenService = tokenService;
+        this.browserSessions = browserSessions;
+    }
+    onModuleInit() {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const Database = require('better-sqlite3');
+        const dbPath = process.env.CREWX_DB ?? (0, path_1.join)((0, os_1.homedir)(), '.crewx', 'crewx.db');
+        this.db = new Database(dbPath);
+        this.db.exec('PRAGMA journal_mode = WAL');
+        this.db.exec('PRAGMA busy_timeout = 5000');
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS chromex_audit_log (
+        id         INTEGER PRIMARY KEY AUTOINCREMENT,
+        timestamp  TEXT NOT NULL DEFAULT (datetime('now')),
+        agent_id   TEXT NOT NULL,
+        action     TEXT NOT NULL,
+        jti        TEXT,
+        scope      TEXT,
+        tab_url    TEXT,
+        tool_name  TEXT,
+        result     TEXT,
+        detail     TEXT
+      )
+    `);
+    }
+    onModuleDestroy() {
+        try {
+            this.db?.close();
+        }
+        catch {
+            // ignore close errors during shutdown
+        }
+    }
+    async negotiate(dto) {
+        if (this.pendingAgentIds.has(dto.agentId)) {
+            throw new common_1.ConflictException('Negotiate already pending for this agent');
+        }
+        const browserSession = this.browserSessions.getLatestBrowserSession();
+        if (!browserSession) {
+            throw new common_1.HttpException({ reason: 'no_browser_connected' }, 503);
+        }
+        const requestId = 'req_' + (0, nanoid_1.nanoid)(21);
+        const expiresIn = dto.expiresIn ?? '90d';
+        const negotiateExpiresAt = new Date(Date.now() + NEGOTIATE_TIMEOUT_MS).toISOString();
+        const tokenName = dto.tokenName ?? `${dto.agentId}-${new Date().toISOString().slice(0, 7)}`;
+        const payload = {
+            jsonrpc: '2.0',
+            method: mcp_constants_js_1.CHROMEX_EVENTS.NEGOTIATE_REQUEST,
+            params: {
+                requestId,
+                agentId: dto.agentId,
+                scope: dto.scope,
+                expiresIn,
+                mcpSessionId: browserSession.id,
+                tokenName,
+                negotiateExpiresAt,
+            },
+        };
+        this.pendingAgentIds.add(dto.agentId);
+        // log when the negotiate request is registered
+        this.auditLog({
+            agentId: dto.agentId,
+            action: 'negotiate',
+            scope: dto.scope,
+            result: 'success',
+        }).catch(() => { });
+        return new Promise((resolvePromise, rejectPromise) => {
+            let unregisterDisconnect = () => { };
+            const resolve = (value) => {
+                clearTimeout(timeout);
+                unregisterDisconnect();
+                resolvePromise(value);
+            };
+            const reject = (reason) => {
+                clearTimeout(timeout);
+                unregisterDisconnect();
+                rejectPromise(reason);
+            };
+            const timeout = setTimeout(() => {
+                if (this.pendingRequests.has(requestId)) {
+                    const entry = this.pendingRequests.get(requestId);
+                    this.pendingRequests.delete(requestId);
+                    this.pendingAgentIds.delete(dto.agentId);
+                    this.processedRequests.add(requestId);
+                    this.scheduleProcessedCleanup(requestId);
+                    this.auditLog({
+                        agentId: dto.agentId,
+                        action: 'timeout',
+                        scope: entry.scope,
+                        result: 'timeout',
+                    }).catch(() => { });
+                    reject(new common_1.HttpException({ reason: 'timeout' }, 408));
+                }
+            }, NEGOTIATE_TIMEOUT_MS);
+            this.pendingRequests.set(requestId, {
+                agentId: dto.agentId,
+                scope: dto.scope,
+                expiresIn,
+                mcpSessionId: browserSession.id,
+                tokenName: dto.tokenName,
+                resolve,
+                reject,
+                timeout,
+            });
+            unregisterDisconnect = this.browserSessions.onSseDisconnect(browserSession.id, () => {
+                if (this.pendingRequests.has(requestId)) {
+                    this.pendingRequests.delete(requestId);
+                    this.pendingAgentIds.delete(dto.agentId);
+                    this.processedRequests.add(requestId);
+                    this.scheduleProcessedCleanup(requestId);
+                    reject(new common_1.HttpException({ reason: 'no_browser_connected' }, 503));
+                }
+            });
+            const pushed = this.browserSessions.pushNotification(browserSession.id, payload);
+            if (!pushed) {
+                this.pendingRequests.delete(requestId);
+                this.pendingAgentIds.delete(dto.agentId);
+                this.processedRequests.add(requestId);
+                this.scheduleProcessedCleanup(requestId);
+                reject(new common_1.HttpException({ reason: 'no_browser_connected' }, 503));
+            }
+        });
+    }
+    async approve(requestId, overrides) {
+        if (this.processedRequests.has(requestId))
+            return undefined;
+        const entry = this.pendingRequests.get(requestId);
+        if (!entry)
+            throw new common_1.NotFoundException('Negotiate request not found');
+        this.pendingRequests.delete(requestId);
+        this.pendingAgentIds.delete(entry.agentId);
+        this.processedRequests.add(requestId);
+        this.scheduleProcessedCleanup(requestId);
+        clearTimeout(entry.timeout);
+        try {
+            const expiresIn = overrides?.expiresIn ?? entry.expiresIn;
+            const scope = overrides?.scope ?? entry.scope;
+            const { token, meta } = await this.tokenService.createToken({
+                name: entry.tokenName ?? `${entry.agentId}-${new Date().toISOString().slice(0, 10)}`,
+                expiresIn,
+                agentScope: entry.agentId,
+                browserScope: scope,
+            }, 'negotiate');
+            this.auditLog({
+                agentId: entry.agentId,
+                action: 'approve',
+                jti: meta.jti,
+                scope,
+                result: 'success',
+            }).catch(() => { });
+            const response = {
+                token,
+                tokenId: meta.id,
+                jti: meta.jti,
+                expiresAt: meta.expiresAt,
+                scope,
+                agentId: entry.agentId,
+                mcpSessionId: entry.mcpSessionId,
+            };
+            entry.resolve(response);
+            return response;
+        }
+        catch (err) {
+            entry.reject(err);
+            throw err;
+        }
+    }
+    deny(requestId, reason = 'user_denied') {
+        if (this.processedRequests.has(requestId))
+            return;
+        const entry = this.pendingRequests.get(requestId);
+        if (!entry)
+            throw new common_1.NotFoundException('Negotiate request not found');
+        this.pendingRequests.delete(requestId);
+        this.pendingAgentIds.delete(entry.agentId);
+        this.processedRequests.add(requestId);
+        this.scheduleProcessedCleanup(requestId);
+        clearTimeout(entry.timeout);
+        this.auditLog({
+            agentId: entry.agentId,
+            action: 'deny',
+            scope: entry.scope,
+            result: 'denied',
+            detail: { reason },
+        }).catch(() => { });
+        entry.reject(new common_1.HttpException({ reason }, 403));
+    }
+    async revokeSession(tokenId) {
+        await this.tokenService.revokeToken(tokenId);
+    }
+    getPendingRequests() {
+        return Array.from(this.pendingRequests.entries()).map(([requestId, entry]) => ({
+            requestId,
+            agentId: entry.agentId,
+            scope: entry.scope,
+            expiresIn: entry.expiresIn,
+            tokenName: entry.tokenName,
+        }));
+    }
+    logAudit(params) {
+        void this.auditLog(params);
+    }
+    async auditLog(params) {
+        if (!this.db)
+            return;
+        this.db
+            .prepare(`INSERT INTO chromex_audit_log (agent_id, action, jti, scope, tab_url, tool_name, result, detail)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(params.agentId, params.action, params.jti ?? null, params.scope ?? null, params.tabUrl ?? null, params.toolName ?? null, params.result, params.detail ? JSON.stringify(params.detail) : null);
+    }
+    scheduleProcessedCleanup(requestId) {
+        setTimeout(() => this.processedRequests.delete(requestId), PROCESSED_TTL_MS);
+    }
+};
+exports.ChromexNegotiateService = ChromexNegotiateService;
+exports.ChromexNegotiateService = ChromexNegotiateService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [token_service_js_1.TokenService,
+        browser_session_store_js_1.BrowserSessionStore])
+], ChromexNegotiateService);

package/dist-server/domain/mcp/mcp-auth.guard.js

@@ -14,41 +14,54 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.McpAuthGuard = void 0;
 const common_1 = require("@nestjs/common");
+const token_service_js_1 = require("../token/token.service.js");
 const mcp_constants_js_1 = require("./mcp.constants.js");
+const ip_utils_js_1 = require("../auth/utils/ip.utils.js");
 let McpAuthGuard = class McpAuthGuard {
+    tokenService;
     tokenInfo;
-    constructor(tokenInfo) {
+    constructor(tokenService, tokenInfo) {
+        this.tokenService = tokenService;
         this.tokenInfo = tokenInfo;
     }
-    canActivate(context) {
+    async canActivate(context) {
         const request = context.switchToHttp().getRequest();
-        // Extract token: Authorization header takes priority over query parameter
-        const bearerToken = this.extractTokenFromHeader(request)
-            ?? this.extractTokenFromQuery(request);
-        if (!bearerToken) {
-            throw new common_1.UnauthorizedException('Missing authentication token');
+        const rawToken = this.extractToken(request);
+        if (rawToken) {
+            // DB JWT token validation
+            const claims = await this.tokenService.validateToken(rawToken);
+            if (claims) {
+                request.tokenClaims = claims;
+                return true;
+            }
+            // Legacy fallback: existing Chrome X installs may still store the generated
+            // MCP bearer token from server startup instead of a DB-backed crewx_ token.
+            if (rawToken === this.tokenInfo.token)
+                return true;
         }
-        if (bearerToken !== this.tokenInfo.token) {
-            throw new common_1.UnauthorizedException('Invalid bearer token');
+        if (this.isLocalRequest(request))
+            return true;
+        if (!rawToken) {
+            throw new common_1.UnauthorizedException('Bearer token required');
         }
-        return true;
+        throw new common_1.UnauthorizedException('Invalid token');
     }
-    extractTokenFromHeader(request) {
+    isLocalRequest(request) {
+        const ip = request.socket?.remoteAddress;
+        if (!(0, ip_utils_js_1.isLoopback)(ip))
+            return false;
+        const host = (request.headers['host'] ?? '').split(':')[0];
+        return host === 'localhost' || host === '127.0.0.1' || host === '[::1]';
+    }
+    extractToken(request) {
         const authHeader = request.headers['authorization'] || request.headers['Authorization'];
-        if (!authHeader || typeof authHeader !== 'string') {
-            return null;
-        }
-        const prefix = 'Bearer ';
-        if (!authHeader.startsWith(prefix)) {
-            return null;
+        if (typeof authHeader === 'string' && authHeader.startsWith('Bearer ')) {
+            const token = authHeader.slice(7).trim();
+            return token || null;
         }
-        const token = authHeader.slice(prefix.length).trim();
-        return token || null;
-    }
-    extractTokenFromQuery(request) {
-        const token = request.query['token'];
-        if (typeof token === 'string' && token.length > 0) {
-            return token;
+        const queryToken = request.query['token'];
+        if (typeof queryToken === 'string' && queryToken.length > 0) {
+            return queryToken;
         }
         return null;
     }
@@ -56,6 +69,7 @@ let McpAuthGuard = class McpAuthGuard {
 exports.McpAuthGuard = McpAuthGuard;
 exports.McpAuthGuard = McpAuthGuard = __decorate([
     (0, common_1.Injectable)(),
-    __param(0, (0, common_1.Inject)(mcp_constants_js_1.MCP_TOKEN)),
-    __metadata("design:paramtypes", [Object])
+    __param(0, (0, common_1.Inject)(token_service_js_1.TokenService)),
+    __param(1, (0, common_1.Inject)(mcp_constants_js_1.MCP_TOKEN)),
+    __metadata("design:paramtypes", [token_service_js_1.TokenService, Object])
 ], McpAuthGuard);

package/dist-server/domain/mcp/mcp.constants.js

@@ -1,4 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MCP_TOKEN = void 0;
+exports.CHROMEX_EVENTS = exports.MCP_TOKEN = void 0;
 exports.MCP_TOKEN = 'MCP_TOKEN';
+exports.CHROMEX_EVENTS = {
+    NEGOTIATE_REQUEST: 'chromex/negotiate',
+};

package/dist-server/domain/mcp/mcp.controller.js

@@ -25,7 +25,7 @@ let McpController = McpController_1 = class McpController {
     constructor(mcpService) {
         this.mcpService = mcpService;
     }
-    async handleMcp(body, sessionId, clientType, res) {
+    async handleMcp(body, sessionId, clientType, req, res) {
         this.logger.debug(`MCP request [session=${sessionId ?? 'none'}]: ${JSON.stringify(body)}`);
         // JSON-RPC response from extension (has result or error, no method)
         // Must be checked BEFORE validateRequest — responses have no method field
@@ -45,7 +45,7 @@ let McpController = McpController_1 = class McpController {
             res.status(200).json(validationError);
             return;
         }
-        const result = await this.mcpService.handleRequest(body, sessionId, clientType);
+        const result = await this.mcpService.handleRequest(body, sessionId, clientType, req);
         // Notifications return null
         if (result === null) {
             this.logger.debug(`Notification processed: ${body.method}`);
@@ -97,9 +97,10 @@ __decorate([
     __param(0, (0, common_1.Body)()),
     __param(1, (0, common_1.Headers)(MCP_SESSION_HEADER)),
     __param(2, (0, common_1.Headers)('x-client-type')),
-    __param(3, (0, common_1.Res)()),
+    __param(3, (0, common_1.Req)()),
+    __param(4, (0, common_1.Res)()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, Object, Object]),
+    __metadata("design:paramtypes", [Object, Object, Object, Object, Object]),
     __metadata("design:returntype", Promise)
 ], McpController.prototype, "handleMcp", null);
 __decorate([

package/dist-server/domain/mcp/mcp.module.js

@@ -17,15 +17,19 @@ const tool_router_service_js_1 = require("./tool-router.service.js");
 const mcp_constants_js_1 = require("./mcp.constants.js");
 const crewx_module_js_1 = require("../../modules/crewx.module.js");
 const repository_1 = require("@crewx/sdk/repository");
+const token_module_js_1 = require("../token/token.module.js");
+const chromex_negotiate_controller_js_1 = require("./chromex-negotiate.controller.js");
+const chromex_negotiate_service_js_1 = require("./chromex-negotiate.service.js");
 let McpModule = class McpModule {
 };
 exports.McpModule = McpModule;
 exports.McpModule = McpModule = __decorate([
     (0, common_1.Module)({
-        imports: [crewx_module_js_1.CrewxModule],
-        controllers: [mcp_controller_js_1.McpController],
+        imports: [crewx_module_js_1.CrewxModule, token_module_js_1.TokenModule],
+        controllers: [mcp_controller_js_1.McpController, chromex_negotiate_controller_js_1.ChromexNegotiateController],
         providers: [
             mcp_service_js_1.McpService,
+            chromex_negotiate_service_js_1.ChromexNegotiateService,
             browser_session_store_js_1.BrowserSessionStore,
             tool_router_service_js_1.ToolRouterService,
             {