@next-open-ai/openclawx 0.6.6

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

@@ -0,0 +1,213 @@
+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);
+};
+import { Injectable, ConflictException, BadRequestException, NotFoundException } from '@nestjs/common';
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import { join } from 'path';
+import { existsSync } from 'fs';
+import { homedir } from 'os';
+/** 工作空间名仅允许英文、数字、下划线、连字符 */
+const WORKSPACE_NAME_REGEX = /^[a-zA-Z0-9_-]+$/;
+/** 缺省智能体 ID / 工作空间名，不可删除；对应目录 ~/.openbot/workspace/default */
+export const DEFAULT_AGENT_ID = 'default';
+/** 主智能体（default）的默认展示名 */
+const DEFAULT_AGENT_NAME = '主智能体';
+let AgentConfigService = class AgentConfigService {
+    configDir;
+    agentsPath;
+    constructor() {
+        const homeDir = process.env.HOME || process.env.USERPROFILE || homedir();
+        this.configDir = join(homeDir, '.openbot', 'desktop');
+        this.agentsPath = join(this.configDir, 'agents.json');
+    }
+    async ensureConfigDir() {
+        if (!existsSync(this.configDir)) {
+            await mkdir(this.configDir, { recursive: true });
+        }
+    }
+    async readAgentsFile() {
+        await this.ensureConfigDir();
+        if (!existsSync(this.agentsPath)) {
+            return { agents: [] };
+        }
+        const content = await readFile(this.agentsPath, 'utf-8');
+        try {
+            const data = JSON.parse(content);
+            return Array.isArray(data.agents) ? data : { agents: [] };
+        }
+        catch {
+            return { agents: [] };
+        }
+    }
+    async writeAgentsFile(data) {
+        await this.ensureConfigDir();
+        await writeFile(this.agentsPath, JSON.stringify(data, null, 2), 'utf-8');
+    }
+    /** 确保 default 工作空间目录存在 */
+    async ensureDefaultWorkspace() {
+        const homeDir = process.env.HOME || process.env.USERPROFILE || homedir();
+        const workspaceRoot = join(homeDir, '.openbot', 'workspace', DEFAULT_AGENT_ID);
+        const skillsDir = join(workspaceRoot, 'skills');
+        if (!existsSync(workspaceRoot)) {
+            await mkdir(skillsDir, { recursive: true });
+        }
+        else if (!existsSync(skillsDir)) {
+            await mkdir(skillsDir, { recursive: true });
+        }
+    }
+    defaultAgent(overrides) {
+        return {
+            id: DEFAULT_AGENT_ID,
+            name: DEFAULT_AGENT_NAME,
+            workspace: DEFAULT_AGENT_ID,
+            isDefault: true,
+            ...overrides,
+        };
+    }
+    async listAgents() {
+        await this.ensureDefaultWorkspace();
+        const file = await this.readAgentsFile();
+        const others = file.agents.filter((a) => a.id !== DEFAULT_AGENT_ID);
+        const defaultEntry = file.agents.find((a) => a.id === DEFAULT_AGENT_ID);
+        const mainAgent = defaultEntry
+            ? { ...defaultEntry, isDefault: true }
+            : this.defaultAgent();
+        return [mainAgent, ...others].map((a) => (a.id === DEFAULT_AGENT_ID ? { ...a, isDefault: true } : a));
+    }
+    async getAgent(id) {
+        if (id === DEFAULT_AGENT_ID) {
+            await this.ensureDefaultWorkspace();
+        }
+        const file = await this.readAgentsFile();
+        const found = file.agents.find((a) => a.id === id);
+        if (found)
+            return { ...found, isDefault: found.id === DEFAULT_AGENT_ID };
+        if (id === DEFAULT_AGENT_ID)
+            return this.defaultAgent();
+        return null;
+    }
+    async createAgent(params) {
+        const { name, workspace } = params;
+        if (workspace === DEFAULT_AGENT_ID) {
+            throw new BadRequestException('工作空间名 default 为系统保留（主智能体），请使用其他名称');
+        }
+        if (!workspace || !WORKSPACE_NAME_REGEX.test(workspace)) {
+            throw new BadRequestException('工作空间名必须为英文、数字、下划线或连字符');
+        }
+        const trimmedName = (name || workspace).trim() || workspace;
+        const file = await this.readAgentsFile();
+        if (file.agents.some((a) => a.workspace === workspace || a.id === workspace)) {
+            throw new ConflictException('该工作空间名已存在');
+        }
+        const homeDir = process.env.HOME || process.env.USERPROFILE || homedir();
+        const workspaceRoot = join(homeDir, '.openbot', 'workspace', workspace);
+        const skillsDir = join(workspaceRoot, 'skills');
+        if (!existsSync(workspaceRoot)) {
+            await mkdir(skillsDir, { recursive: true });
+        }
+        else if (!existsSync(skillsDir)) {
+            await mkdir(skillsDir, { recursive: true });
+        }
+        const agent = {
+            id: workspace,
+            name: trimmedName,
+            workspace,
+            provider: undefined,
+            model: undefined,
+        };
+        file.agents.push(agent);
+        await this.writeAgentsFile(file);
+        return agent;
+    }
+    async updateAgent(id, updates) {
+        if (id === DEFAULT_AGENT_ID) {
+            await this.ensureDefaultWorkspace();
+        }
+        const file = await this.readAgentsFile();
+        let idx = file.agents.findIndex((a) => a.id === id);
+        if (idx < 0) {
+            if (id === DEFAULT_AGENT_ID) {
+                file.agents.unshift(this.defaultAgent());
+                idx = 0;
+            }
+            else {
+                throw new NotFoundException('智能体不存在');
+            }
+        }
+        const agent = file.agents[idx];
+        if (agent.id !== DEFAULT_AGENT_ID && updates.name !== undefined) {
+            agent.name = (updates.name || agent.workspace).trim() || agent.workspace;
+        }
+        if (updates.provider !== undefined)
+            agent.provider = updates.provider;
+        if (updates.model !== undefined)
+            agent.model = updates.model;
+        if (updates.modelItemCode !== undefined)
+            agent.modelItemCode = updates.modelItemCode;
+        if (updates.mcpServers !== undefined)
+            agent.mcpServers = updates.mcpServers;
+        await this.writeAgentsFile(file);
+        return { ...agent, isDefault: agent.id === DEFAULT_AGENT_ID };
+    }
+    async deleteAgent(id) {
+        if (id === DEFAULT_AGENT_ID) {
+            throw new BadRequestException('主智能体（default）不可删除');
+        }
+        const file = await this.readAgentsFile();
+        const idx = file.agents.findIndex((a) => a.id === id);
+        if (idx < 0) {
+            throw new NotFoundException('智能体不存在');
+        }
+        file.agents.splice(idx, 1);
+        await this.writeAgentsFile(file);
+    }
+    /**
+     * 根据 config 的 defaultProvider / defaultModel / defaultModelItemCode 及 configuredModels 同步 agents.json 中缺省智能体的 provider、model、modelItemCode。
+     * 在桌面保存配置（如修改默认模型）后调用，保证 agents 与 config 一致。
+     */
+    async syncDefaultAgentFromConfig(config) {
+        const list = config.configuredModels ?? [];
+        let provider = config.defaultProvider?.trim();
+        let model = config.defaultModel?.trim();
+        let modelItemCode = config.defaultModelItemCode?.trim();
+        if (modelItemCode && list.length) {
+            const item = list.find((m) => m.modelItemCode === modelItemCode);
+            if (item) {
+                provider = item.provider;
+                model = item.modelId;
+            }
+        }
+        if (!provider || !model)
+            return;
+        if (!modelItemCode && list.length) {
+            const item = list.find((m) => m.provider === provider && m.modelId === model);
+            if (item?.modelItemCode)
+                modelItemCode = item.modelItemCode;
+        }
+        await this.ensureDefaultWorkspace();
+        const file = await this.readAgentsFile();
+        let idx = file.agents.findIndex((a) => a.id === DEFAULT_AGENT_ID);
+        if (idx < 0) {
+            file.agents.unshift(this.defaultAgent({ provider, model, modelItemCode }));
+            idx = 0;
+        }
+        else {
+            const agent = file.agents[idx];
+            agent.provider = provider;
+            agent.model = model;
+            agent.modelItemCode = modelItemCode;
+        }
+        await this.writeAgentsFile(file);
+    }
+};
+AgentConfigService = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [])
+], AgentConfigService);
+export { AgentConfigService };

package/dist/server/agents/agents.controller.d.ts

@@ -0,0 +1,41 @@
+import { AgentsService } from './agents.service.js';
+export declare class AgentsController {
+    private readonly agentsService;
+    constructor(agentsService: AgentsService);
+    createSession(body: {
+        id?: string;
+        agentId?: string;
+        workspace?: string;
+        provider?: string;
+        model?: string;
+        title?: string;
+        type?: 'chat' | 'scheduled' | 'system';
+    }): Promise<{
+        success: boolean;
+        data: import("./agents.service.js").AgentSession;
+    }>;
+    getSessions(): {
+        success: boolean;
+        data: import("./agents.service.js").AgentSession[];
+    };
+    getSession(id: string): {
+        success: boolean;
+        data: import("./agents.service.js").AgentSession;
+    };
+    deleteSession(id: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    getHistory(id: string): {
+        success: boolean;
+        data: import("./agents.service.js").ChatMessage[];
+    };
+    appendMessage(id: string, body: {
+        role: 'user' | 'assistant';
+        content: string;
+        toolCalls?: any[];
+        contentParts?: any[];
+    }): {
+        success: boolean;
+    };
+}

package/dist/server/agents/agents.controller.js

@@ -0,0 +1,118 @@
+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); }
+};
+import { Controller, Get, Post, Delete, Body, Param, Header, HttpException, HttpStatus, } from '@nestjs/common';
+import { AgentsService } from './agents.service.js';
+let AgentsController = class AgentsController {
+    agentsService;
+    constructor(agentsService) {
+        this.agentsService = agentsService;
+    }
+    async createSession(body) {
+        try {
+            const session = await this.agentsService.createSession(body);
+            return {
+                success: true,
+                data: session,
+            };
+        }
+        catch (error) {
+            throw new HttpException(error.message || 'Failed to create session', HttpStatus.INTERNAL_SERVER_ERROR);
+        }
+    }
+    getSessions() {
+        const sessions = this.agentsService.getSessions();
+        return {
+            success: true,
+            data: sessions,
+        };
+    }
+    getSession(id) {
+        const session = this.agentsService.getSession(id);
+        if (!session) {
+            throw new HttpException('Session not found', HttpStatus.NOT_FOUND);
+        }
+        return {
+            success: true,
+            data: session,
+        };
+    }
+    async deleteSession(id) {
+        await this.agentsService.deleteSession(id);
+        return {
+            success: true,
+            message: 'Session deleted',
+        };
+    }
+    getHistory(id) {
+        const history = this.agentsService.getMessageHistory(id);
+        return {
+            success: true,
+            data: history,
+        };
+    }
+    appendMessage(id, body) {
+        this.agentsService.appendMessage(id, body.role, body.content, {
+            toolCalls: body.toolCalls,
+            contentParts: body.contentParts,
+        });
+        return { success: true };
+    }
+};
+__decorate([
+    Post('sessions'),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], AgentsController.prototype, "createSession", null);
+__decorate([
+    Get('sessions'),
+    Header('Cache-Control', 'no-store'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], AgentsController.prototype, "getSessions", null);
+__decorate([
+    Get('sessions/:id'),
+    __param(0, Param('id')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", void 0)
+], AgentsController.prototype, "getSession", null);
+__decorate([
+    Delete('sessions/:id'),
+    __param(0, Param('id')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], AgentsController.prototype, "deleteSession", null);
+__decorate([
+    Get('sessions/:id/history'),
+    __param(0, Param('id')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", void 0)
+], AgentsController.prototype, "getHistory", null);
+__decorate([
+    Post('sessions/:id/messages'),
+    __param(0, Param('id')),
+    __param(1, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", void 0)
+], AgentsController.prototype, "appendMessage", null);
+AgentsController = __decorate([
+    Controller('agents'),
+    __metadata("design:paramtypes", [AgentsService])
+], AgentsController);
+export { AgentsController };

package/dist/server/agents/agents.gateway.d.ts

@@ -0,0 +1,21 @@
+import { OnGatewayInit, OnGatewayConnection, OnGatewayDisconnect } from '@nestjs/websockets';
+import { Server, Socket } from 'socket.io';
+import { AgentsService } from './agents.service.js';
+export declare class AgentsGateway implements OnGatewayInit, OnGatewayConnection, OnGatewayDisconnect {
+    private readonly agentsService;
+    server: Server;
+    private sessionSubscriptions;
+    constructor(agentsService: AgentsService);
+    afterInit(server: Server): void;
+    handleConnection(client: Socket): void;
+    handleDisconnect(client: Socket): void;
+    handleSubscribeSession(client: Socket, payload: {
+        sessionId: string;
+    }): {
+        success: boolean;
+    };
+    handleUnsubscribeSession(client: Socket): {
+        success: boolean;
+    };
+    broadcastMessageComplete(sessionId: string, content: string): void;
+}

package/dist/server/agents/agents.gateway.js

@@ -0,0 +1,103 @@
+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);
+};
+import { WebSocketGateway, WebSocketServer, SubscribeMessage, } from '@nestjs/websockets';
+import { Server, Socket } from 'socket.io';
+import { AgentsService } from './agents.service.js';
+let AgentsGateway = class AgentsGateway {
+    agentsService;
+    server;
+    sessionSubscriptions = new Map();
+    constructor(agentsService) {
+        this.agentsService = agentsService;
+    }
+    afterInit(server) {
+        console.log('WebSocket Gateway initialized');
+    }
+    handleConnection(client) {
+        console.log(`Client connected: ${client.id}`);
+    }
+    handleDisconnect(client) {
+        console.log(`Client disconnected: ${client.id}`);
+        // Clean up subscriptions
+        const subscriptions = this.sessionSubscriptions.get(client.id);
+        if (subscriptions) {
+            subscriptions.forEach(unsubscribe => unsubscribe());
+            this.sessionSubscriptions.delete(client.id);
+        }
+    }
+    handleSubscribeSession(client, payload) {
+        const { sessionId } = payload;
+        console.log(`Client ${client.id} subscribing to session ${sessionId}`);
+        // Unsubscribe from previous session if any
+        const existingSubscriptions = this.sessionSubscriptions.get(client.id);
+        if (existingSubscriptions) {
+            existingSubscriptions.forEach(unsubscribe => unsubscribe());
+        }
+        const subscriptions = new Map();
+        // Subscribe to agent chunks
+        const unsubChunk = this.agentsService.addEventListener('agent.chunk', (data) => {
+            client.emit('agent_chunk', data);
+        });
+        subscriptions.set('chunk', unsubChunk);
+        // Subscribe to tool events
+        const unsubTool = this.agentsService.addEventListener('agent.tool', (data) => {
+            client.emit('agent_tool', data);
+        });
+        subscriptions.set('tool', unsubTool);
+        // Subscribe to message completion
+        const unsubComplete = this.agentsService.addEventListener('message_complete', (data) => {
+            // Ensure we only emit for the subscribed session
+            if (data.sessionId === sessionId) {
+                client.emit('message_complete', data);
+            }
+        });
+        subscriptions.set('complete', unsubComplete);
+        this.sessionSubscriptions.set(client.id, subscriptions);
+        return { success: true };
+    }
+    handleUnsubscribeSession(client) {
+        const subscriptions = this.sessionSubscriptions.get(client.id);
+        if (subscriptions) {
+            subscriptions.forEach(unsubscribe => unsubscribe());
+            this.sessionSubscriptions.delete(client.id);
+        }
+        return { success: true };
+    }
+    // Broadcast message completion to all clients
+    broadcastMessageComplete(sessionId, content) {
+        this.server.emit('message_complete', { sessionId, content });
+    }
+};
+__decorate([
+    WebSocketServer(),
+    __metadata("design:type", Server)
+], AgentsGateway.prototype, "server", void 0);
+__decorate([
+    SubscribeMessage('subscribe_session'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Socket, Object]),
+    __metadata("design:returntype", void 0)
+], AgentsGateway.prototype, "handleSubscribeSession", null);
+__decorate([
+    SubscribeMessage('unsubscribe_session'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Socket]),
+    __metadata("design:returntype", void 0)
+], AgentsGateway.prototype, "handleUnsubscribeSession", null);
+AgentsGateway = __decorate([
+    WebSocketGateway({
+        cors: {
+            origin: ['http://localhost:5173', 'http://localhost:38081'],
+            credentials: true,
+        },
+    }),
+    __metadata("design:paramtypes", [AgentsService])
+], AgentsGateway);
+export { AgentsGateway };

package/dist/server/agents/agents.module.d.ts

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

package/dist/server/agents/agents.module.js

@@ -0,0 +1,20 @@
+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;
+};
+import { Module } from '@nestjs/common';
+import { AgentsController } from './agents.controller.js';
+import { AgentsService } from './agents.service.js';
+import { AgentsGateway } from './agents.gateway.js';
+let AgentsModule = class AgentsModule {
+};
+AgentsModule = __decorate([
+    Module({
+        controllers: [AgentsController],
+        providers: [AgentsService, AgentsGateway],
+        exports: [AgentsService],
+    })
+], AgentsModule);
+export { AgentsModule };

package/dist/server/agents/agents.service.d.ts

@@ -0,0 +1,63 @@
+import { DatabaseService } from '../database/database.service.js';
+export type SessionType = 'scheduled' | 'chat' | 'system';
+export interface AgentSession {
+    id: string;
+    createdAt: number;
+    lastActiveAt: number;
+    messageCount: number;
+    status: 'idle' | 'active' | 'error';
+    /** 绑定的智能体 ID，不选则为 default（主智能体） */
+    agentId?: string;
+    workspace?: string;
+    provider?: string;
+    model?: string;
+    title?: string;
+    preview?: string;
+    type?: SessionType;
+}
+export interface ChatMessage {
+    id: string;
+    sessionId: string;
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    timestamp: number;
+    toolCalls?: any[];
+}
+/**
+ * Agents service: session + history storage in SQLite.
+ * Conversation is done via frontend -> Gateway (WebSocket) -> agent; NestJS is not in the chat path.
+ */
+export declare class AgentsService {
+    private readonly db;
+    private eventListeners;
+    constructor(db: DatabaseService);
+    addEventListener(event: string, listener: (data: any) => void): () => void;
+    private emitEvent;
+    private rowToSession;
+    private rowToMessage;
+    createSession(options?: {
+        id?: string;
+        agentId?: string;
+        workspace?: string;
+        provider?: string;
+        model?: string;
+        title?: string;
+        type?: SessionType;
+    }): Promise<AgentSession>;
+    /** 获取或创建会话（指定 id 时复用同一会话，用于定时任务固定 sessionId） */
+    getOrCreateSession(sessionId: string, options?: {
+        agentId?: string;
+        workspace?: string;
+        title?: string;
+        type?: SessionType;
+    }): Promise<AgentSession>;
+    getSessions(): AgentSession[];
+    getSession(sessionId: string): AgentSession | undefined;
+    deleteSession(sessionId: string): Promise<void>;
+    getMessageHistory(sessionId: string): ChatMessage[];
+    addAssistantMessage(sessionId: string, content: string): void;
+    appendMessage(sessionId: string, role: 'user' | 'assistant', content: string, options?: {
+        toolCalls?: any[];
+        contentParts?: any[];
+    }): void;
+}