@next-open-ai/openbot 0.1.1

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

@@ -0,0 +1,34 @@
+export interface AppConfig {
+    gatewayUrl: string;
+    defaultProvider: string;
+    defaultModel: string;
+    /** 缺省智能体 id */
+    defaultAgentId?: string;
+    theme: 'light' | 'dark';
+    /** 同时存在的聊天 AgentSession 上限，超过时淘汰最久未用的 */
+    maxAgentSessions?: number;
+    /** 登录用户名，未配置时使用缺省（与缺省密码 123456 搭配） */
+    loginUsername?: string;
+    /** 登录密码，未配置时使用缺省 123456 */
+    loginPassword?: string;
+    providers: {
+        [key: string]: {
+            apiKey?: string;
+            baseUrl?: string;
+        };
+    };
+}
+export declare class ConfigService {
+    private configPath;
+    private config;
+    constructor();
+    private getDefaultConfig;
+    /** 当前缺省智能体 id */
+    getDefaultAgentId(config?: AppConfig): string;
+    private loadConfig;
+    getConfig(): Promise<AppConfig>;
+    updateConfig(updates: Partial<AppConfig>): Promise<AppConfig>;
+    private saveConfig;
+    getProviders(): Promise<string[]>;
+    getModels(provider: string): Promise<string[]>;
+}

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

@@ -0,0 +1,91 @@
+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';
+let ConfigService = class ConfigService {
+    configPath;
+    config;
+    constructor() {
+        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:3000',
+            defaultProvider: 'deepseek',
+            defaultModel: 'deepseek-chat',
+            defaultAgentId: 'default',
+            theme: 'dark',
+            maxAgentSessions: 5,
+            providers: {},
+        };
+    }
+    /** 当前缺省智能体 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);
+        }
+    }
+    async getConfig() {
+        return this.config;
+    }
+    async updateConfig(updates) {
+        this.config = { ...this.config, ...updates };
+        this.config.defaultAgentId = this.getDefaultAgentId(this.config);
+        await this.saveConfig();
+        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;
+        }
+    }
+    async getProviders() {
+        return ['deepseek', 'dashscope', 'openai', 'anthropic'];
+    }
+    async getModels(provider) {
+        const modelMap = {
+            deepseek: ['deepseek-chat', 'deepseek-coder'],
+            dashscope: ['qwen-max', 'qwen-plus', 'qwen-turbo'],
+            openai: ['gpt-4', 'gpt-3.5-turbo'],
+            anthropic: ['claude-3-opus', 'claude-3-sonnet'],
+        };
+        return modelMap[provider] || [];
+    }
+};
+ConfigService = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [])
+], 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,11 @@
+import { OnModuleDestroy } from '@nestjs/common';
+import Database from 'better-sqlite3';
+export declare class DatabaseService implements OnModuleDestroy {
+    private db;
+    getDb(): Database.Database;
+    private runMigrations;
+    run(sql: string, params?: unknown[]): Database.RunResult;
+    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,137 @@
+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 Database from 'better-sqlite3';
+import { mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+let DatabaseService = class DatabaseService {
+    db = null;
+    getDb() {
+        if (!this.db) {
+            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 dir = path.endsWith('.db') ? join(path, '..') : path;
+                if (!existsSync(dir)) {
+                    mkdirSync(dir, { recursive: true });
+                }
+            }
+            this.db = new Database(path);
+            this.db.pragma('journal_mode = WAL');
+            this.runMigrations();
+        }
+        return this.db;
+    }
+    runMigrations() {
+        const db = this.db;
+        db.exec(`
+          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);
+        `);
+        // Add session type column if missing (scheduled vs chat)
+        try {
+            const info = db.prepare('PRAGMA table_info(sessions)').all();
+            if (!info.some((c) => c.name === 'type')) {
+                db.exec(`ALTER TABLE sessions ADD COLUMN type TEXT DEFAULT 'chat'`);
+            }
+            if (!info.some((c) => c.name === 'agent_id')) {
+                db.exec(`ALTER TABLE sessions ADD COLUMN agent_id TEXT DEFAULT 'default'`);
+            }
+        }
+        catch (_) {
+            // ignore
+        }
+    }
+    run(sql, params = []) {
+        return this.getDb().prepare(sql).run(...params);
+    }
+    get(sql, params = []) {
+        return this.getDb().prepare(sql).get(...params);
+    }
+    all(sql, params = []) {
+        return this.getDb().prepare(sql).all(...params);
+    }
+    onModuleDestroy() {
+        if (this.db) {
+            this.db.close();
+            this.db = 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,18 @@
+import { NestFactory } from '@nestjs/core';
+import { AppModule } from './app.module.js';
+async function bootstrap() {
+    const app = await NestFactory.create(AppModule, {
+        cors: true,
+    });
+    // Set global prefix
+    app.setGlobalPrefix('server-api');
+    // Enable CORS for frontend
+    app.enableCors({
+        origin: ['http://localhost:5173', 'http://localhost:3001'],
+        credentials: true,
+    });
+    const port = process.env.PORT || 3001;
+    await app.listen(port);
+    console.log(`🚀 OpenBot Desktop Server running on http://localhost:${port}`);
+}
+bootstrap();

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

@@ -0,0 +1,63 @@
+import { SkillsService } from './skills.service.js';
+import { AgentsService } from '../agents/agents.service.js';
+import { AgentConfigService } from '../agent-config/agent-config.service.js';
+export declare class SkillsController {
+    private readonly skillsService;
+    private readonly agentsService;
+    private readonly agentConfigService;
+    constructor(skillsService: SkillsService, agentsService: AgentsService, agentConfigService: AgentConfigService);
+    getSkills(workspace?: string, scope?: string): Promise<{
+        success: boolean;
+        data: import("./skills.service.js").Skill[];
+    }>;
+    /** 静态 POST 路由放在 :name 等参数路由之前，确保能被正确匹配 */
+    installSkill(body: {
+        url: string;
+        scope?: 'global' | 'workspace';
+        workspace?: string;
+        sessionId?: string;
+        /** 安装目标：具体 agentId，或 "global"|"all" 表示全局；优先于 sessionId */
+        targetAgentId?: string;
+    }): Promise<{
+        success: boolean;
+        data: {
+            stdout: string;
+            stderr: string;
+            installDir: string;
+        };
+    }>;
+    installSkillFromPath(body: {
+        path: string;
+        scope?: 'global' | 'workspace';
+        workspace?: string;
+        targetAgentId?: string;
+    }): Promise<{
+        success: boolean;
+        data: {
+            installDir: string;
+            name: string;
+        };
+    }>;
+    getSkill(name: string): Promise<{
+        success: boolean;
+        data: import("./skills.service.js").Skill;
+    }>;
+    getSkillContent(name: string, workspace?: string): Promise<{
+        success: boolean;
+        data: {
+            content: string;
+        };
+    }>;
+    addSkill(body: {
+        workspace: string;
+        name: string;
+        description?: string;
+        content?: string;
+    }): Promise<{
+        success: boolean;
+        data: import("./skills.service.js").Skill;
+    }>;
+    deleteSkill(name: string, workspace?: string, scope?: string): Promise<{
+        success: boolean;
+    }>;
+}

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

@@ -0,0 +1,194 @@
+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, Param, Query, Body, HttpException, HttpStatus } from '@nestjs/common';
+import { SkillsService } from './skills.service.js';
+import { AgentsService } from '../agents/agents.service.js';
+import { AgentConfigService } from '../agent-config/agent-config.service.js';
+let SkillsController = class SkillsController {
+    skillsService;
+    agentsService;
+    agentConfigService;
+    constructor(skillsService, agentsService, agentConfigService) {
+        this.skillsService = skillsService;
+        this.agentsService = agentsService;
+        this.agentConfigService = agentConfigService;
+    }
+    async getSkills(workspace, scope) {
+        if (scope === 'global') {
+            const skills = await this.skillsService.getGlobalSkills();
+            return { success: true, data: skills };
+        }
+        const skills = workspace
+            ? await this.skillsService.getSkillsForWorkspace(workspace)
+            : await this.skillsService.getSkills();
+        return { success: true, data: skills };
+    }
+    /** 静态 POST 路由放在 :name 等参数路由之前，确保能被正确匹配 */
+    async installSkill(body) {
+        const url = body?.url?.trim();
+        if (!url) {
+            throw new HttpException('url is required', HttpStatus.BAD_REQUEST);
+        }
+        let scope = body?.scope ?? 'global';
+        let workspace = body?.workspace;
+        const tid = (body?.targetAgentId ?? '').trim().toLowerCase();
+        if (tid === 'global' || tid === 'all') {
+            scope = 'global';
+            workspace = undefined;
+        }
+        else if (body?.targetAgentId?.trim()) {
+            const agent = await this.agentConfigService.getAgent(body.targetAgentId.trim());
+            if (agent?.workspace) {
+                scope = 'workspace';
+                workspace = agent.workspace;
+            }
+        }
+        else if (body?.sessionId) {
+            const session = this.agentsService.getSession(body.sessionId);
+            const agentId = session?.agentId ?? 'default';
+            const agent = await this.agentConfigService.getAgent(agentId);
+            if (agent?.workspace) {
+                scope = 'workspace';
+                workspace = agent.workspace;
+            }
+        }
+        const result = await this.skillsService.installSkillByUrl(url, {
+            scope,
+            workspace: scope === 'workspace' ? workspace ?? 'default' : undefined,
+        });
+        return { success: true, data: result };
+    }
+    async installSkillFromPath(body) {
+        const localPath = body?.path?.trim();
+        if (!localPath) {
+            throw new HttpException('path is required', HttpStatus.BAD_REQUEST);
+        }
+        let scope = body?.scope ?? 'global';
+        let workspace = body?.workspace;
+        const tid = (body?.targetAgentId ?? '').trim().toLowerCase();
+        if (tid === 'global' || tid === 'all') {
+            scope = 'global';
+            workspace = undefined;
+        }
+        else if (body?.targetAgentId?.trim()) {
+            const agent = await this.agentConfigService.getAgent(body.targetAgentId.trim());
+            if (agent?.workspace) {
+                scope = 'workspace';
+                workspace = agent.workspace;
+            }
+        }
+        const result = await this.skillsService.installSkillFromPath(localPath, {
+            scope,
+            workspace: scope === 'workspace' ? workspace ?? 'default' : undefined,
+        });
+        return { success: true, data: result };
+    }
+    async getSkill(name) {
+        const skill = await this.skillsService.getSkill(name);
+        if (!skill) {
+            throw new HttpException('Skill not found', HttpStatus.NOT_FOUND);
+        }
+        return { success: true, data: skill };
+    }
+    async getSkillContent(name, workspace) {
+        const content = workspace
+            ? await this.skillsService.getSkillContentForWorkspace(workspace, name)
+            : await this.skillsService.getSkillContent(name);
+        if (!content) {
+            throw new HttpException('Skill not found', HttpStatus.NOT_FOUND);
+        }
+        return { success: true, data: { content } };
+    }
+    async addSkill(body) {
+        const { workspace, name, description, content } = body;
+        if (!workspace || !name) {
+            throw new HttpException('workspace and name are required', HttpStatus.BAD_REQUEST);
+        }
+        const skill = await this.skillsService.addSkill(workspace, name, {
+            description,
+            content,
+        });
+        return { success: true, data: skill };
+    }
+    async deleteSkill(name, workspace, scope) {
+        if (scope === 'global') {
+            await this.skillsService.deleteGlobalSkill(name);
+            return { success: true };
+        }
+        if (!workspace) {
+            throw new HttpException('workspace query is required', HttpStatus.BAD_REQUEST);
+        }
+        await this.skillsService.deleteSkill(workspace, name);
+        return { success: true };
+    }
+};
+__decorate([
+    Get(),
+    __param(0, Query('workspace')),
+    __param(1, Query('scope')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], SkillsController.prototype, "getSkills", null);
+__decorate([
+    Post('install'),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], SkillsController.prototype, "installSkill", null);
+__decorate([
+    Post('install-from-path'),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], SkillsController.prototype, "installSkillFromPath", null);
+__decorate([
+    Get(':name'),
+    __param(0, Param('name')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], SkillsController.prototype, "getSkill", null);
+__decorate([
+    Get(':name/content'),
+    __param(0, Param('name')),
+    __param(1, Query('workspace')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], SkillsController.prototype, "getSkillContent", null);
+__decorate([
+    Post(),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], SkillsController.prototype, "addSkill", null);
+__decorate([
+    Delete(':name'),
+    __param(0, Param('name')),
+    __param(1, Query('workspace')),
+    __param(2, Query('scope')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String]),
+    __metadata("design:returntype", Promise)
+], SkillsController.prototype, "deleteSkill", null);
+SkillsController = __decorate([
+    Controller('skills'),
+    __metadata("design:paramtypes", [SkillsService,
+        AgentsService,
+        AgentConfigService])
+], SkillsController);
+export { SkillsController };

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

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

package/dist/server/skills/skills.module.js

@@ -0,0 +1,22 @@
+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 { SkillsController } from './skills.controller.js';
+import { SkillsService } from './skills.service.js';
+import { AgentsModule } from '../agents/agents.module.js';
+import { AgentConfigModule } from '../agent-config/agent-config.module.js';
+let SkillsModule = class SkillsModule {
+};
+SkillsModule = __decorate([
+    Module({
+        imports: [AgentsModule, AgentConfigModule],
+        controllers: [SkillsController],
+        providers: [SkillsService],
+        exports: [SkillsService],
+    })
+], SkillsModule);
+export { SkillsModule };

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

@@ -0,0 +1,63 @@
+export interface Skill {
+    name: string;
+    description: string;
+    path: string;
+    category?: string;
+    source?: 'system' | 'global' | 'workspace';
+    metadata?: any;
+}
+/** 技能目录与来源：全局=OPENBOT_AGENT_DIR/skills，系统=项目根/skills，工作区=OPENBOT_WORKSPACE_DIR/xxx/skills */
+export declare class SkillsService {
+    /** 待扫描的目录列表 */
+    private skillPaths;
+    constructor();
+    /** 指定工作区的 skills 目录绝对路径（受 OPENBOT_WORKSPACE_DIR 影响） */
+    getWorkspaceSkillsDir(workspaceName: string): string;
+    /** 全局技能目录（受 OPENBOT_AGENT_DIR 影响，默认 ~/.openbot/agent/skills） */
+    getGlobalSkillsDir(): string;
+    /** 仅返回全局技能（OPENBOT_AGENT_DIR/skills） */
+    getGlobalSkills(): Promise<Skill[]>;
+    /** 删除全局技能 */
+    deleteGlobalSkill(name: string): Promise<void>;
+    /**
+     * 通过 npx skills add 安装技能到指定目录。
+     * @param url 安装地址（Git 简写、URL 或 owner/repo@skill）
+     * @param options.scope 'global' 安装到 OPENBOT_AGENT_DIR/skills；'workspace' 安装到指定工作区的 skills
+     * @param options.workspace 当 scope 为 'workspace' 时的工作区名（对应 OPENBOT_WORKSPACE_DIR/<workspace>/skills）
+     */
+    installSkillByUrl(url: string, options?: {
+        scope?: 'global' | 'workspace';
+        workspace?: string;
+    }): Promise<{
+        stdout: string;
+        stderr: string;
+        installDir: string;
+    }>;
+    /**
+     * 从本地目录安装技能：将指定目录复制到目标 skills 目录。
+     * @param localPath 本地技能目录绝对路径（须包含 SKILL.md）
+     * @param options.scope 'global' 安装到全局；'workspace' 安装到指定工作区
+     * @param options.workspace 当 scope 为 'workspace' 时的工作区名
+     */
+    installSkillFromPath(localPath: string, options?: {
+        scope?: 'global' | 'workspace';
+        workspace?: string;
+    }): Promise<{
+        installDir: string;
+        name: string;
+    }>;
+    getSkills(): Promise<Skill[]>;
+    getSkill(name: string): Promise<Skill | null>;
+    getSkillContent(name: string): Promise<string | null>;
+    /** 仅返回指定工作区下的技能（文件目录管理，不涉及 SQLite） */
+    getSkillsForWorkspace(workspaceName: string): Promise<Skill[]>;
+    getSkillContentForWorkspace(workspaceName: string, name: string): Promise<string | null>;
+    /** 在工作区下新增技能（创建目录 + SKILL.md） */
+    addSkill(workspaceName: string, name: string, options?: {
+        description?: string;
+        content?: string;
+    }): Promise<Skill>;
+    /** 删除工作区下的技能目录；主智能体（default）下的 Skill 不可删除 */
+    deleteSkill(workspaceName: string, name: string): Promise<void>;
+    private parseSkillFile;
+}