@next-open-ai/openclawx 0.6.6

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

@@ -0,0 +1,123 @@
+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 } from '@nestjs/common';
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import { join } from 'path';
+import { existsSync } from 'fs';
+import { getProviderSupport, syncDesktopConfigToModelsJson } from '../../core/config/desktop-config.js';
+import { AgentConfigService } from '../agent-config/agent-config.service.js';
+let ConfigService = class ConfigService {
+    agentConfigService;
+    configPath;
+    config;
+    constructor(agentConfigService) {
+        this.agentConfigService = agentConfigService;
+        const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+        const configDir = join(homeDir, '.openbot', 'desktop');
+        this.configPath = join(configDir, 'config.json');
+        // Ensure config directory exists
+        if (!existsSync(configDir)) {
+            mkdir(configDir, { recursive: true });
+        }
+        this.config = this.getDefaultConfig();
+        this.loadConfig();
+    }
+    getDefaultConfig() {
+        return {
+            gatewayUrl: 'ws://localhost:38080',
+            defaultProvider: 'deepseek',
+            defaultModel: 'deepseek-chat',
+            defaultAgentId: 'default',
+            theme: 'dark',
+            maxAgentSessions: 5,
+            providers: {},
+            configuredModels: [],
+            rag: undefined,
+        };
+    }
+    /** 当前缺省智能体 id */
+    getDefaultAgentId(config) {
+        const c = config ?? this.config;
+        return (c.defaultAgentId ?? 'default').trim() || 'default';
+    }
+    async loadConfig() {
+        try {
+            if (existsSync(this.configPath)) {
+                const content = await readFile(this.configPath, 'utf-8');
+                this.config = { ...this.getDefaultConfig(), ...JSON.parse(content) };
+                this.config.defaultAgentId = this.getDefaultAgentId(this.config);
+            }
+        }
+        catch (error) {
+            console.error('Error loading config:', error);
+        }
+    }
+    /** 每次获取前从磁盘重新读取，保证打开配置界面时显示最新（含 CLI 写入的配置） */
+    async getConfig() {
+        await this.loadConfig();
+        return this.config;
+    }
+    async updateConfig(updates) {
+        this.config = { ...this.config, ...updates };
+        this.config.defaultAgentId = this.getDefaultAgentId(this.config);
+        const p = this.config.defaultProvider;
+        const m = this.config.defaultModel;
+        const list = this.config.configuredModels ?? [];
+        if (p && m && list.length) {
+            const item = list.find((x) => x.provider === p && x.modelId === m);
+            if (item?.modelItemCode)
+                this.config.defaultModelItemCode = item.modelItemCode;
+        }
+        await this.saveConfig();
+        await this.agentConfigService.syncDefaultAgentFromConfig(this.config).catch((err) => console.warn('[ConfigService] syncDefaultAgentFromConfig failed', err));
+        await syncDesktopConfigToModelsJson().catch((err) => console.warn('[ConfigService] syncDesktopConfigToModelsJson failed', err));
+        return this.config;
+    }
+    async saveConfig() {
+        try {
+            await writeFile(this.configPath, JSON.stringify(this.config, null, 2));
+        }
+        catch (error) {
+            console.error('Error saving config:', error);
+            throw error;
+        }
+    }
+    /** 支持的 provider 列表（来自 provider-support.json，供配置时下拉） */
+    async getProviders() {
+        const support = await getProviderSupport();
+        return Object.keys(support);
+    }
+    /** 某 provider 下的可用模型（来自 provider-support）；可按 type 筛选（llm/embedding/image/audio/video） */
+    async getModels(provider, type) {
+        const support = await getProviderSupport();
+        const entry = support[provider];
+        if (!entry?.models?.length)
+            return [];
+        let list = entry.models.map((m) => ({
+            id: m.id,
+            name: m.name || m.id,
+            types: m.types && m.types.length > 0 ? m.types : ["llm"],
+        }));
+        if (type && type.trim()) {
+            const t = type.trim().toLowerCase();
+            list = list.filter((m) => m.types?.includes(t));
+        }
+        return list;
+    }
+    /** 完整 provider 目录（支持列表 + 各 provider 的模型），供前端一次拉取 */
+    async getProviderSupport() {
+        return getProviderSupport();
+    }
+};
+ConfigService = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [AgentConfigService])
+], ConfigService);
+export { ConfigService };

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

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

package/dist/server/database/database.module.js

@@ -0,0 +1,18 @@
+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 { Global, Module } from '@nestjs/common';
+import { DatabaseService } from './database.service.js';
+let DatabaseModule = class DatabaseModule {
+};
+DatabaseModule = __decorate([
+    Global(),
+    Module({
+        providers: [DatabaseService],
+        exports: [DatabaseService],
+    })
+], DatabaseModule);
+export { DatabaseModule };

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

@@ -0,0 +1,26 @@
+import { OnModuleDestroy, OnModuleInit } from '@nestjs/common';
+/** RunResult compatible with better-sqlite3 for callers that use .changes / .lastInsertRowid */
+export interface RunResult {
+    changes: number;
+    lastInsertRowid: number;
+}
+export declare class DatabaseService implements OnModuleInit, OnModuleDestroy {
+    private sqlDb;
+    private dbPath;
+    private initPromise;
+    onModuleInit(): Promise<void>;
+    private doInit;
+    private getDb;
+    private runMigrations;
+    run(sql: string, params?: unknown[]): RunResult;
+    /**
+     * 使用文件 DB 时立即落盘。每次 run() 写入后都会调用，保证「每次保存马上写到磁盘」。
+     * 落盘失败时重新抛出，便于上层返回错误、前端不乐观更新，避免「删了但重启又出现」。
+     */
+    private persistIfFile;
+    /** 供删除等关键操作后显式落盘，确保删除结果持久化 */
+    persist(): void;
+    get<T>(sql: string, params?: unknown[]): T | undefined;
+    all<T>(sql: string, params?: unknown[]): T[];
+    onModuleDestroy(): void;
+}

package/dist/server/database/database.service.js

@@ -0,0 +1,253 @@
+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 { Injectable } from '@nestjs/common';
+import { mkdirSync, existsSync, readFileSync, writeFileSync } from 'fs';
+import { join, resolve } from 'path';
+import { homedir } from 'os';
+let DatabaseService = class DatabaseService {
+    sqlDb = null;
+    dbPath = null;
+    initPromise = null;
+    async onModuleInit() {
+        if (this.initPromise)
+            return this.initPromise;
+        this.initPromise = this.doInit();
+        return this.initPromise;
+    }
+    async doInit() {
+        const pathEnv = process.env.OPENBOT_DB_PATH;
+        const defaultDir = join(homedir(), '.openbot', 'desktop', 'data');
+        const path = pathEnv === ':memory:' || pathEnv === ''
+            ? ':memory:'
+            : pathEnv ?? join(process.env.OPENBOT_DB_DIR ?? defaultDir, 'openbot.db');
+        if (path !== ':memory:') {
+            const resolvedPath = resolve(path);
+            const dir = resolvedPath.endsWith('.db') ? join(resolvedPath, '..') : resolvedPath;
+            if (!existsSync(dir)) {
+                mkdirSync(dir, { recursive: true });
+            }
+        }
+        const initSqlJs = (await import('sql.js')).default;
+        const SQL = await initSqlJs();
+        let db;
+        if (path === ':memory:') {
+            db = new SQL.Database();
+            this.dbPath = ':memory:';
+        }
+        else {
+            const absolutePath = resolve(path);
+            if (existsSync(absolutePath)) {
+                const buf = readFileSync(absolutePath);
+                db = new SQL.Database(new Uint8Array(buf));
+            }
+            else {
+                db = new SQL.Database();
+            }
+            this.dbPath = absolutePath;
+        }
+        this.sqlDb = db;
+        db.run('PRAGMA foreign_keys = ON;');
+        this.runMigrations();
+        if (path !== ':memory:') {
+            this.persistIfFile();
+            console.log('[DatabaseService] Database file:', this.dbPath);
+        }
+    }
+    getDb() {
+        if (!this.sqlDb) {
+            throw new Error('Database not initialized. Ensure onModuleInit() has completed (Nest awaits it before listening).');
+        }
+        return this.sqlDb;
+    }
+    runMigrations() {
+        const db = this.getDb();
+        const ddl = `
+          CREATE TABLE IF NOT EXISTS sessions (
+            id TEXT PRIMARY KEY,
+            created_at INTEGER NOT NULL,
+            last_active_at INTEGER NOT NULL,
+            message_count INTEGER NOT NULL DEFAULT 0,
+            status TEXT NOT NULL DEFAULT 'idle',
+            agent_id TEXT DEFAULT 'default',
+            workspace TEXT,
+            provider TEXT,
+            model TEXT,
+            title TEXT,
+            preview TEXT,
+            type TEXT DEFAULT 'chat'
+          );
+          CREATE TABLE IF NOT EXISTS chat_messages (
+            id TEXT PRIMARY KEY,
+            session_id TEXT NOT NULL,
+            role TEXT NOT NULL,
+            content TEXT NOT NULL,
+            timestamp INTEGER NOT NULL,
+            tool_calls_json TEXT,
+            FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+          );
+          CREATE INDEX IF NOT EXISTS idx_chat_messages_session_id ON chat_messages(session_id);
+
+          CREATE TABLE IF NOT EXISTS scheduled_tasks (
+            id TEXT PRIMARY KEY,
+            workspace TEXT NOT NULL DEFAULT 'default',
+            message TEXT NOT NULL,
+            schedule_type TEXT NOT NULL,
+            run_at INTEGER,
+            cron_expr TEXT,
+            repeat_rule_json TEXT,
+            enabled INTEGER NOT NULL DEFAULT 1,
+            last_run_at INTEGER,
+            created_at INTEGER NOT NULL,
+            updated_at INTEGER NOT NULL
+          );
+          CREATE INDEX IF NOT EXISTS idx_scheduled_tasks_enabled ON scheduled_tasks(enabled);
+
+          CREATE TABLE IF NOT EXISTS scheduled_task_executions (
+            id TEXT PRIMARY KEY,
+            task_id TEXT NOT NULL,
+            ran_at INTEGER NOT NULL,
+            status TEXT NOT NULL,
+            session_id TEXT,
+            user_message TEXT NOT NULL,
+            assistant_content TEXT,
+            error_message TEXT,
+            created_at INTEGER NOT NULL,
+            FOREIGN KEY (task_id) REFERENCES scheduled_tasks(id) ON DELETE CASCADE
+          );
+          CREATE INDEX IF NOT EXISTS idx_task_executions_task_id ON scheduled_task_executions(task_id);
+
+          CREATE TABLE IF NOT EXISTS token_usage (
+            id TEXT PRIMARY KEY,
+            session_id TEXT NOT NULL,
+            source TEXT NOT NULL,
+            task_id TEXT,
+            execution_id TEXT,
+            prompt_tokens INTEGER NOT NULL DEFAULT 0,
+            completion_tokens INTEGER NOT NULL DEFAULT 0,
+            total_tokens INTEGER NOT NULL DEFAULT 0,
+            created_at INTEGER NOT NULL
+          );
+          CREATE INDEX IF NOT EXISTS idx_token_usage_session_id ON token_usage(session_id);
+          CREATE INDEX IF NOT EXISTS idx_token_usage_created_at ON token_usage(created_at);
+
+          CREATE TABLE IF NOT EXISTS tags (
+            id TEXT PRIMARY KEY,
+            name TEXT UNIQUE NOT NULL,
+            sort_order INTEGER NOT NULL DEFAULT 0,
+            created_at INTEGER NOT NULL
+          );
+          CREATE TABLE IF NOT EXISTS saved_items (
+            id TEXT PRIMARY KEY,
+            url TEXT NOT NULL,
+            title TEXT,
+            workspace TEXT NOT NULL DEFAULT 'default',
+            created_at INTEGER NOT NULL
+          );
+          CREATE TABLE IF NOT EXISTS saved_item_tags (
+            saved_item_id TEXT NOT NULL,
+            tag_id TEXT NOT NULL,
+            PRIMARY KEY (saved_item_id, tag_id),
+            FOREIGN KEY (saved_item_id) REFERENCES saved_items(id) ON DELETE CASCADE,
+            FOREIGN KEY (tag_id) REFERENCES tags(id) ON DELETE CASCADE
+          );
+          CREATE INDEX IF NOT EXISTS idx_saved_item_tags_tag_id ON saved_item_tags(tag_id);
+        `;
+        const statements = ddl.split(';').map((s) => s.trim()).filter(Boolean);
+        for (const stmt of statements) {
+            db.run(stmt + ';');
+        }
+        try {
+            const info = this.all('PRAGMA table_info(sessions)', []);
+            if (!info.some((c) => c.name === 'type')) {
+                db.run("ALTER TABLE sessions ADD COLUMN type TEXT DEFAULT 'chat';");
+            }
+            if (!info.some((c) => c.name === 'agent_id')) {
+                db.run("ALTER TABLE sessions ADD COLUMN agent_id TEXT DEFAULT 'default';");
+            }
+        }
+        catch (_) {
+            // ignore
+        }
+    }
+    run(sql, params = []) {
+        const db = this.getDb();
+        db.run(sql, params);
+        this.persistIfFile();
+        const rows = db.exec('SELECT changes() AS c, last_insert_rowid() AS id');
+        const c = rows[0]?.values?.[0]?.[0] ?? 0;
+        const id = rows[0]?.values?.[0]?.[1] ?? 0;
+        return { changes: Number(c), lastInsertRowid: Number(id) };
+    }
+    /**
+     * 使用文件 DB 时立即落盘。每次 run() 写入后都会调用，保证「每次保存马上写到磁盘」。
+     * 落盘失败时重新抛出，便于上层返回错误、前端不乐观更新，避免「删了但重启又出现」。
+     */
+    persistIfFile() {
+        if (!this.sqlDb || !this.dbPath || this.dbPath === ':memory:')
+            return;
+        try {
+            const data = this.sqlDb.export();
+            writeFileSync(this.dbPath, Buffer.from(data));
+        }
+        catch (e) {
+            console.error('[DatabaseService] Failed to persist database:', e);
+            throw e;
+        }
+    }
+    /** 供删除等关键操作后显式落盘，确保删除结果持久化 */
+    persist() {
+        this.persistIfFile();
+    }
+    get(sql, params = []) {
+        const db = this.getDb();
+        const stmt = db.prepare(sql);
+        try {
+            stmt.bind(params);
+            const hasRow = stmt.step();
+            return (hasRow ? stmt.getAsObject() : undefined);
+        }
+        finally {
+            stmt.free();
+        }
+    }
+    all(sql, params = []) {
+        const db = this.getDb();
+        const stmt = db.prepare(sql);
+        try {
+            stmt.bind(params);
+            const rows = [];
+            while (stmt.step()) {
+                rows.push(stmt.getAsObject());
+            }
+            return rows;
+        }
+        finally {
+            stmt.free();
+        }
+    }
+    onModuleDestroy() {
+        if (!this.sqlDb)
+            return;
+        if (this.dbPath && this.dbPath !== ':memory:') {
+            try {
+                const data = this.sqlDb.export();
+                writeFileSync(this.dbPath, Buffer.from(data));
+            }
+            catch (e) {
+                console.error('[DatabaseService] Failed to persist database:', e);
+            }
+        }
+        this.sqlDb.close();
+        this.sqlDb = null;
+        this.dbPath = null;
+        this.initPromise = null;
+    }
+};
+DatabaseService = __decorate([
+    Injectable()
+], DatabaseService);
+export { DatabaseService };

package/dist/server/main.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server/main.js

@@ -0,0 +1,9 @@
+/**
+ * OpenBot Desktop 后端入口（独立模式）。
+ * 内嵌到 Gateway 时由 gateway/server 调用 createNestAppEmbedded，不经过本文件。
+ */
+import { createNestAppStandalone } from './bootstrap.js';
+const port = Number(process.env.PORT) || 38081;
+createNestAppStandalone(port).then(() => {
+    console.log(`🚀 OpenBot Desktop Server running on http://localhost:${port}`);
+});

package/dist/server/saved-items/saved-items.controller.d.ts

@@ -0,0 +1,57 @@
+import type { Response } from 'express';
+import { SavedItemsService } from './saved-items.service.js';
+import { WorkspaceService } from '../workspace/workspace.service.js';
+import { ConfigService } from '../config/config.service.js';
+export declare class SavedItemsController {
+    private readonly savedItemsService;
+    private readonly workspaceService;
+    private readonly configService;
+    constructor(savedItemsService: SavedItemsService, workspaceService: WorkspaceService, configService: ConfigService);
+    list(tagId?: string, workspace?: string): Promise<{
+        success: boolean;
+        data: import("./saved-items.service.js").SavedItem[];
+    }>;
+    imageProxy(url: string, res: Response): Promise<void>;
+    get(id: string): Promise<{
+        success: boolean;
+        data: import("./saved-items.service.js").SavedItem;
+    }>;
+    create(body: {
+        url: string;
+        title?: string;
+        workspace?: string;
+        tagNames?: string[];
+        tagIds?: string[];
+    }): Promise<{
+        success: boolean;
+        data: import("./saved-items.service.js").SavedItem;
+    }>;
+    delete(id: string): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Download the saved item URL to workspace .favorite or to a user-chosen directory.
+     * Body: { workspace?: string, targetDir?: string }.
+     * If targetDir (absolute path) is provided, file is written there; otherwise to workspace/.favorite.
+     */
+    downloadToWorkspace(id: string, body: {
+        workspace?: string;
+        targetDir?: string;
+    }): Promise<{
+        success: boolean;
+        data: {
+            absolutePath: string;
+            targetDir: string;
+            relativePath?: undefined;
+            workspace?: undefined;
+        };
+    } | {
+        success: boolean;
+        data: {
+            relativePath: string;
+            workspace: string;
+            absolutePath?: undefined;
+            targetDir?: undefined;
+        };
+    }>;
+}