@next-open-ai/openbot 0.1.1

package/dist/memory/vector-store.d.ts

@@ -0,0 +1,15 @@
+import type { InfoType, MemoryMetadata } from "./types.js";
+export declare function getChroma(): Promise<{
+    client: null;
+    collection: null;
+}>;
+export declare function addToStore(id: string, embedding: number[], document: string, metadata: MemoryMetadata): Promise<void>;
+export type MemoryFilter = {
+    infotype?: InfoType;
+    sessionId?: string;
+};
+export declare function queryStore(queryEmbedding: number[], topK?: number, filter?: MemoryFilter): Promise<{
+    document: string;
+    metadata: MemoryMetadata;
+    distance?: number;
+}[]>;

package/dist/memory/vector-store.js

@@ -0,0 +1,65 @@
+import { join } from "node:path";
+import { LocalIndex } from "vectra";
+import { getOpenbotAgentDir } from "../agent/agent-dir.js";
+const INDEX_DIR_NAME = "memory";
+let indexDir = null;
+let index = null;
+function getIndexDir() {
+    if (!indexDir) {
+        indexDir = join(getOpenbotAgentDir(), INDEX_DIR_NAME);
+    }
+    return indexDir;
+}
+async function getIndex() {
+    if (index)
+        return index;
+    const path = getIndexDir();
+    index = new LocalIndex(path);
+    if (!(await index.isIndexCreated())) {
+        await index.createIndex();
+    }
+    return index;
+}
+/** Vectra 返回 score（相似度 0~1，越大越相似）；转为 distance = 1 - score，与现有 API 一致 */
+function scoreToDistance(score) {
+    return 1 - score;
+}
+export async function getChroma() {
+    await getIndex();
+    return { client: null, collection: null };
+}
+export async function addToStore(id, embedding, document, metadata) {
+    const idx = await getIndex();
+    await idx.upsertItem({
+        id,
+        vector: embedding,
+        metadata: {
+            document,
+            infotype: metadata.infotype,
+            sessionId: metadata.sessionId,
+            createdAt: metadata.createdAt,
+        },
+    });
+}
+export async function queryStore(queryEmbedding, topK = 10, filter) {
+    const idx = await getIndex();
+    const vectraFilter = filter && (filter.infotype != null || filter.sessionId != null)
+        ? {
+            ...(filter.infotype != null && { infotype: { $eq: filter.infotype } }),
+            ...(filter.sessionId != null && { sessionId: { $eq: filter.sessionId } }),
+        }
+        : undefined;
+    const results = await idx.queryItems(queryEmbedding, "", topK, vectraFilter);
+    return results.map((r) => {
+        const meta = (r.item.metadata ?? {});
+        return {
+            document: String(meta.document ?? ""),
+            metadata: {
+                infotype: meta.infotype,
+                sessionId: String(meta.sessionId ?? ""),
+                createdAt: String(meta.createdAt ?? ""),
+            },
+            distance: scoreToDistance(r.score),
+        };
+    });
+}

package/dist/server/agent-config/agent-config.controller.d.ts

@@ -0,0 +1,30 @@
+import { AgentConfigService, AgentConfigItem } from './agent-config.service.js';
+export declare class AgentConfigController {
+    private readonly agentConfigService;
+    constructor(agentConfigService: AgentConfigService);
+    listAgents(): Promise<{
+        success: boolean;
+        data: AgentConfigItem[];
+    }>;
+    getAgent(id: string): Promise<{
+        success: boolean;
+        data: null;
+    } | {
+        success: boolean;
+        data: AgentConfigItem;
+    }>;
+    createAgent(body: {
+        name: string;
+        workspace: string;
+    }): Promise<{
+        success: boolean;
+        data: AgentConfigItem;
+    }>;
+    updateAgent(id: string, body: Partial<Pick<AgentConfigItem, 'name' | 'provider' | 'model'>>): Promise<{
+        success: boolean;
+        data: AgentConfigItem;
+    }>;
+    deleteAgent(id: string): Promise<{
+        success: boolean;
+    }>;
+}

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

@@ -0,0 +1,83 @@
+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, Put, Delete, Body, Param } from '@nestjs/common';
+import { AgentConfigService } from './agent-config.service.js';
+let AgentConfigController = class AgentConfigController {
+    agentConfigService;
+    constructor(agentConfigService) {
+        this.agentConfigService = agentConfigService;
+    }
+    async listAgents() {
+        const agents = await this.agentConfigService.listAgents();
+        return { success: true, data: agents };
+    }
+    async getAgent(id) {
+        const agent = await this.agentConfigService.getAgent(id);
+        if (!agent) {
+            return { success: false, data: null };
+        }
+        return { success: true, data: agent };
+    }
+    async createAgent(body) {
+        const agent = await this.agentConfigService.createAgent(body);
+        return { success: true, data: agent };
+    }
+    async updateAgent(id, body) {
+        const agent = await this.agentConfigService.updateAgent(id, body);
+        return { success: true, data: agent };
+    }
+    async deleteAgent(id) {
+        await this.agentConfigService.deleteAgent(id);
+        return { success: true };
+    }
+};
+__decorate([
+    Get(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], AgentConfigController.prototype, "listAgents", null);
+__decorate([
+    Get(':id'),
+    __param(0, Param('id')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], AgentConfigController.prototype, "getAgent", null);
+__decorate([
+    Post(),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], AgentConfigController.prototype, "createAgent", null);
+__decorate([
+    Put(':id'),
+    __param(0, Param('id')),
+    __param(1, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], AgentConfigController.prototype, "updateAgent", null);
+__decorate([
+    Delete(':id'),
+    __param(0, Param('id')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], AgentConfigController.prototype, "deleteAgent", null);
+AgentConfigController = __decorate([
+    Controller('agent-config'),
+    __metadata("design:paramtypes", [AgentConfigService])
+], AgentConfigController);
+export { AgentConfigController };

package/dist/server/agent-config/agent-config.module.d.ts

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

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

@@ -0,0 +1,19 @@
+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 { AgentConfigService } from './agent-config.service.js';
+import { AgentConfigController } from './agent-config.controller.js';
+let AgentConfigModule = class AgentConfigModule {
+};
+AgentConfigModule = __decorate([
+    Module({
+        controllers: [AgentConfigController],
+        providers: [AgentConfigService],
+        exports: [AgentConfigService],
+    })
+], AgentConfigModule);
+export { AgentConfigModule };

package/dist/server/agent-config/agent-config.service.d.ts

@@ -0,0 +1,34 @@
+/** 缺省智能体 ID / 工作空间名，不可删除；对应目录 ~/.openbot/workspace/default */
+export declare const DEFAULT_AGENT_ID = "default";
+/**
+ * 智能体列表与配置使用文件存储（~/.openbot/desktop/agents.json），不使用 SQLite。
+ * 会话与消息历史使用 SQLite；Skills、工作空间文档为目录文件管理。
+ */
+export interface AgentConfigItem {
+    id: string;
+    name: string;
+    workspace: string;
+    provider?: string;
+    model?: string;
+    /** 是否为系统缺省智能体（主智能体），不可删除 */
+    isDefault?: boolean;
+}
+export declare class AgentConfigService {
+    private configDir;
+    private agentsPath;
+    constructor();
+    private ensureConfigDir;
+    private readAgentsFile;
+    private writeAgentsFile;
+    /** 确保 default 工作空间目录存在 */
+    private ensureDefaultWorkspace;
+    private defaultAgent;
+    listAgents(): Promise<AgentConfigItem[]>;
+    getAgent(id: string): Promise<AgentConfigItem | null>;
+    createAgent(params: {
+        name: string;
+        workspace: string;
+    }): Promise<AgentConfigItem>;
+    updateAgent(id: string, updates: Partial<Pick<AgentConfigItem, 'name' | 'provider' | 'model'>>): Promise<AgentConfigItem>;
+    deleteAgent(id: string): Promise<void>;
+}

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

@@ -0,0 +1,171 @@
+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;
+        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);
+    }
+};
+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,120 @@
+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, 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) {
+        const deleted = await this.agentsService.deleteSession(id);
+        if (!deleted) {
+            throw new HttpException('Session not found', HttpStatus.NOT_FOUND);
+        }
+        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'),
+    __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;
+}