@next-open-ai/openbot 0.2.1 → 0.3.2

package/dist/server/app.module.js

@@ -15,6 +15,7 @@ import { UsersModule } from './users/users.module.js';
 import { WorkspaceModule } from './workspace/workspace.module.js';
 import { TasksModule } from './tasks/tasks.module.js';
 import { UsageModule } from './usage/usage.module.js';
+import { SavedItemsModule } from './saved-items/saved-items.module.js';
 let AppModule = class AppModule {
 };
 AppModule = __decorate([
@@ -30,6 +31,7 @@ AppModule = __decorate([
             WorkspaceModule,
             TasksModule,
             UsageModule,
+            SavedItemsModule,
         ],
     })
 ], AppModule);

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

@@ -13,6 +13,13 @@ export declare class DatabaseService implements OnModuleInit, OnModuleDestroy {
     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

@@ -6,7 +6,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { Injectable } from '@nestjs/common';
 import { mkdirSync, existsSync, readFileSync, writeFileSync } from 'fs';
-import { join } from 'path';
+import { join, resolve } from 'path';
 import { homedir } from 'os';
 let DatabaseService = class DatabaseService {
     sqlDb = null;
@@ -25,7 +25,8 @@ let DatabaseService = class DatabaseService {
             ? ':memory:'
             : pathEnv ?? join(process.env.OPENBOT_DB_DIR ?? defaultDir, 'openbot.db');
         if (path !== ':memory:') {
-            const dir = path.endsWith('.db') ? join(path, '..') : path;
+            const resolvedPath = resolve(path);
+            const dir = resolvedPath.endsWith('.db') ? join(resolvedPath, '..') : resolvedPath;
             if (!existsSync(dir)) {
                 mkdirSync(dir, { recursive: true });
             }
@@ -38,18 +39,23 @@ let DatabaseService = class DatabaseService {
             this.dbPath = ':memory:';
         }
         else {
-            if (existsSync(path)) {
-                const buf = readFileSync(path);
+            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 = path;
+            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) {
@@ -127,6 +133,28 @@ let DatabaseService = class DatabaseService {
           );
           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) {
@@ -148,11 +176,32 @@ let DatabaseService = class DatabaseService {
     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);

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

@@ -0,0 +1,26 @@
+import { SavedItemsService } from './saved-items.service.js';
+export declare class SavedItemsController {
+    private readonly savedItemsService;
+    constructor(savedItemsService: SavedItemsService);
+    list(tagId?: string, workspace?: string): Promise<{
+        success: boolean;
+        data: import("./saved-items.service.js").SavedItem[];
+    }>;
+    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;
+    }>;
+}

package/dist/server/saved-items/saved-items.controller.js

@@ -0,0 +1,78 @@
+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, Query, HttpException, HttpStatus, } from '@nestjs/common';
+import { SavedItemsService } from './saved-items.service.js';
+let SavedItemsController = class SavedItemsController {
+    savedItemsService;
+    constructor(savedItemsService) {
+        this.savedItemsService = savedItemsService;
+    }
+    async list(tagId, workspace) {
+        const data = await this.savedItemsService.findAll({ tagId, workspace });
+        return { success: true, data };
+    }
+    async get(id) {
+        const data = await this.savedItemsService.findById(id);
+        if (!data)
+            throw new HttpException('Saved item not found', HttpStatus.NOT_FOUND);
+        return { success: true, data };
+    }
+    async create(body) {
+        const data = await this.savedItemsService.create({
+            url: body.url,
+            title: body.title,
+            workspace: body.workspace,
+            tagNames: body.tagNames,
+            tagIds: body.tagIds,
+        });
+        return { success: true, data };
+    }
+    async delete(id) {
+        await this.savedItemsService.delete(id);
+        return { success: true };
+    }
+};
+__decorate([
+    Get(),
+    __param(0, Query('tagId')),
+    __param(1, Query('workspace')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], SavedItemsController.prototype, "list", null);
+__decorate([
+    Get(':id'),
+    __param(0, Param('id')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], SavedItemsController.prototype, "get", null);
+__decorate([
+    Post(),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], SavedItemsController.prototype, "create", null);
+__decorate([
+    Delete(':id'),
+    __param(0, Param('id')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], SavedItemsController.prototype, "delete", null);
+SavedItemsController = __decorate([
+    Controller('saved-items'),
+    __metadata("design:paramtypes", [SavedItemsService])
+], SavedItemsController);
+export { SavedItemsController };

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

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

package/dist/server/saved-items/saved-items.module.js

@@ -0,0 +1,23 @@
+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 { DatabaseModule } from '../database/database.module.js';
+import { TagsService } from './tags.service.js';
+import { TagsController } from './tags.controller.js';
+import { SavedItemsService } from './saved-items.service.js';
+import { SavedItemsController } from './saved-items.controller.js';
+let SavedItemsModule = class SavedItemsModule {
+};
+SavedItemsModule = __decorate([
+    Module({
+        imports: [DatabaseModule],
+        controllers: [TagsController, SavedItemsController],
+        providers: [TagsService, SavedItemsService],
+        exports: [TagsService, SavedItemsService],
+    })
+], SavedItemsModule);
+export { SavedItemsModule };

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

@@ -0,0 +1,31 @@
+import { DatabaseService } from '../database/database.service.js';
+import { TagsService } from './tags.service.js';
+export interface SavedItem {
+    id: string;
+    url: string;
+    title: string | null;
+    workspace: string;
+    createdAt: number;
+    tagIds: string[];
+    tagNames?: string[];
+}
+export declare class SavedItemsService {
+    private readonly db;
+    private readonly tagsService;
+    constructor(db: DatabaseService, tagsService: TagsService);
+    private getTagIdsForItem;
+    private rowToSavedItem;
+    create(dto: {
+        url: string;
+        title?: string;
+        workspace?: string;
+        tagNames?: string[];
+        tagIds?: string[];
+    }): Promise<SavedItem>;
+    findAll(options?: {
+        tagId?: string;
+        workspace?: string;
+    }): Promise<SavedItem[]>;
+    findById(id: string): Promise<SavedItem | null>;
+    delete(id: string): Promise<void>;
+}

package/dist/server/saved-items/saved-items.service.js

@@ -0,0 +1,105 @@
+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, NotFoundException } from '@nestjs/common';
+import { DatabaseService } from '../database/database.service.js';
+import { TagsService } from './tags.service.js';
+import { randomUUID } from 'crypto';
+let SavedItemsService = class SavedItemsService {
+    db;
+    tagsService;
+    constructor(db, tagsService) {
+        this.db = db;
+        this.tagsService = tagsService;
+    }
+    async getTagIdsForItem(savedItemId) {
+        const rows = this.db.all('SELECT tag_id FROM saved_item_tags WHERE saved_item_id = ?', [savedItemId]);
+        return rows.map((r) => r.tag_id);
+    }
+    async rowToSavedItem(row) {
+        const tagIds = await this.getTagIdsForItem(row.id);
+        const tagNames = [];
+        for (const tagId of tagIds) {
+            const tag = await this.tagsService.findById(tagId);
+            if (tag)
+                tagNames.push(tag.name);
+        }
+        return {
+            id: row.id,
+            url: row.url,
+            title: row.title,
+            workspace: row.workspace,
+            createdAt: row.created_at,
+            tagIds,
+            tagNames,
+        };
+    }
+    async create(dto) {
+        const url = (dto.url ?? '').trim();
+        if (!url)
+            throw new Error('url is required');
+        const workspace = (dto.workspace ?? 'default').trim() || 'default';
+        const title = dto.title?.trim() ?? null;
+        const id = randomUUID();
+        const createdAt = Date.now();
+        this.db.run('INSERT INTO saved_items (id, url, title, workspace, created_at) VALUES (?, ?, ?, ?, ?)', [id, url, title, workspace, createdAt]);
+        let tagIds = [];
+        if (dto.tagIds?.length) {
+            tagIds = dto.tagIds;
+        }
+        else if (dto.tagNames?.length) {
+            for (const name of dto.tagNames) {
+                const tag = await this.tagsService.findByName(name.trim());
+                if (tag)
+                    tagIds.push(tag.id);
+            }
+        }
+        for (const tagId of tagIds) {
+            this.db.run('INSERT INTO saved_item_tags (saved_item_id, tag_id) VALUES (?, ?)', [id, tagId]);
+        }
+        const row = { id, url, title, workspace, created_at: createdAt };
+        return this.rowToSavedItem(row);
+    }
+    async findAll(options) {
+        let sql = 'SELECT id, url, title, workspace, created_at FROM saved_items WHERE 1=1';
+        const params = [];
+        if (options?.workspace) {
+            sql += ' AND workspace = ?';
+            params.push(options.workspace);
+        }
+        if (options?.tagId) {
+            sql += ' AND id IN (SELECT saved_item_id FROM saved_item_tags WHERE tag_id = ?)';
+            params.push(options.tagId);
+        }
+        sql += ' ORDER BY created_at DESC';
+        const rows = this.db.all(sql, params);
+        const result = [];
+        for (const row of rows) {
+            result.push(await this.rowToSavedItem(row));
+        }
+        return result;
+    }
+    async findById(id) {
+        const row = this.db.get('SELECT id, url, title, workspace, created_at FROM saved_items WHERE id = ?', [id]);
+        return row ? this.rowToSavedItem(row) : null;
+    }
+    async delete(id) {
+        const item = await this.findById(id);
+        if (!item)
+            throw new NotFoundException('收藏不存在');
+        this.db.run('DELETE FROM saved_item_tags WHERE saved_item_id = ?', [id]);
+        this.db.run('DELETE FROM saved_items WHERE id = ?', [id]);
+    }
+};
+SavedItemsService = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [DatabaseService,
+        TagsService])
+], SavedItemsService);
+export { SavedItemsService };

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

@@ -0,0 +1,30 @@
+import { TagsService } from './tags.service.js';
+export declare class TagsController {
+    private readonly tagsService;
+    constructor(tagsService: TagsService);
+    list(): Promise<{
+        success: boolean;
+        data: import("./tags.service.js").Tag[];
+    }>;
+    get(id: string): Promise<{
+        success: boolean;
+        data: import("./tags.service.js").Tag;
+    }>;
+    create(body: {
+        name: string;
+        sortOrder?: number;
+    }): Promise<{
+        success: boolean;
+        data: import("./tags.service.js").Tag;
+    }>;
+    update(id: string, body: {
+        name?: string;
+        sortOrder?: number;
+    }): Promise<{
+        success: boolean;
+        data: import("./tags.service.js").Tag;
+    }>;
+    delete(id: string): Promise<{
+        success: boolean;
+    }>;
+}

package/dist/server/saved-items/tags.controller.js

@@ -0,0 +1,85 @@
+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, HttpException, HttpStatus } from '@nestjs/common';
+import { TagsService } from './tags.service.js';
+let TagsController = class TagsController {
+    tagsService;
+    constructor(tagsService) {
+        this.tagsService = tagsService;
+    }
+    async list() {
+        const data = await this.tagsService.findAll();
+        return { success: true, data };
+    }
+    async get(id) {
+        const data = await this.tagsService.findById(id);
+        if (!data)
+            throw new HttpException('Tag not found', HttpStatus.NOT_FOUND);
+        return { success: true, data };
+    }
+    async create(body) {
+        const data = await this.tagsService.create({
+            name: body.name,
+            sortOrder: body.sortOrder,
+        });
+        return { success: true, data };
+    }
+    async update(id, body) {
+        const data = await this.tagsService.update(id, body);
+        return { success: true, data };
+    }
+    async delete(id) {
+        await this.tagsService.delete(id);
+        return { success: true };
+    }
+};
+__decorate([
+    Get(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], TagsController.prototype, "list", null);
+__decorate([
+    Get(':id'),
+    __param(0, Param('id')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], TagsController.prototype, "get", null);
+__decorate([
+    Post(),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], TagsController.prototype, "create", null);
+__decorate([
+    Put(':id'),
+    __param(0, Param('id')),
+    __param(1, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], TagsController.prototype, "update", null);
+__decorate([
+    Delete(':id'),
+    __param(0, Param('id')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], TagsController.prototype, "delete", null);
+TagsController = __decorate([
+    Controller('tags'),
+    __metadata("design:paramtypes", [TagsService])
+], TagsController);
+export { TagsController };

package/dist/server/saved-items/tags.service.d.ts

@@ -0,0 +1,24 @@
+import { DatabaseService } from '../database/database.service.js';
+export interface Tag {
+    id: string;
+    name: string;
+    sortOrder: number;
+    createdAt: number;
+}
+export declare class TagsService {
+    private readonly db;
+    constructor(db: DatabaseService);
+    private rowToTag;
+    findAll(): Promise<Tag[]>;
+    findById(id: string): Promise<Tag | null>;
+    findByName(name: string): Promise<Tag | null>;
+    create(dto: {
+        name: string;
+        sortOrder?: number;
+    }): Promise<Tag>;
+    update(id: string, dto: {
+        name?: string;
+        sortOrder?: number;
+    }): Promise<Tag>;
+    delete(id: string): Promise<void>;
+}

package/dist/server/saved-items/tags.service.js

@@ -0,0 +1,84 @@
+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, NotFoundException } from '@nestjs/common';
+import { DatabaseService } from '../database/database.service.js';
+import { randomUUID } from 'crypto';
+let TagsService = class TagsService {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    rowToTag(row) {
+        return {
+            id: row.id,
+            name: row.name,
+            sortOrder: row.sort_order,
+            createdAt: row.created_at,
+        };
+    }
+    async findAll() {
+        const rows = this.db.all('SELECT id, name, sort_order, created_at FROM tags ORDER BY sort_order ASC, name ASC', []);
+        return rows.map((r) => this.rowToTag(r));
+    }
+    async findById(id) {
+        const row = this.db.get('SELECT id, name, sort_order, created_at FROM tags WHERE id = ?', [id]);
+        return row ? this.rowToTag(row) : null;
+    }
+    async findByName(name) {
+        const row = this.db.get('SELECT id, name, sort_order, created_at FROM tags WHERE name = ?', [
+            name.trim(),
+        ]);
+        return row ? this.rowToTag(row) : null;
+    }
+    async create(dto) {
+        const name = (dto.name ?? '').trim();
+        if (!name)
+            throw new ConflictException('标签名不能为空');
+        const existing = await this.findByName(name);
+        if (existing)
+            throw new ConflictException('该标签名已存在');
+        const id = randomUUID();
+        const sortOrder = dto.sortOrder ?? 0;
+        const createdAt = Date.now();
+        this.db.run('INSERT INTO tags (id, name, sort_order, created_at) VALUES (?, ?, ?, ?)', [id, name, sortOrder, createdAt]);
+        return { id, name, sortOrder, createdAt };
+    }
+    async update(id, dto) {
+        const tag = await this.findById(id);
+        if (!tag)
+            throw new NotFoundException('标签不存在');
+        if (dto.name !== undefined) {
+            const name = dto.name.trim();
+            if (!name)
+                throw new ConflictException('标签名不能为空');
+            const existing = await this.findByName(name);
+            if (existing && existing.id !== id)
+                throw new ConflictException('该标签名已存在');
+            this.db.run('UPDATE tags SET name = ? WHERE id = ?', [name, id]);
+            tag.name = name;
+        }
+        if (dto.sortOrder !== undefined) {
+            this.db.run('UPDATE tags SET sort_order = ? WHERE id = ?', [dto.sortOrder, id]);
+            tag.sortOrder = dto.sortOrder;
+        }
+        return tag;
+    }
+    async delete(id) {
+        const tag = await this.findById(id);
+        if (!tag)
+            throw new NotFoundException('标签不存在');
+        this.db.run('DELETE FROM tags WHERE id = ?', [id]);
+    }
+};
+TagsService = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [DatabaseService])
+], TagsService);
+export { TagsService };

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

@@ -51,6 +51,8 @@ export declare class SkillsService {
     getSkillContent(name: string): Promise<string | null>;
     /** 仅返回指定工作区下的技能（文件目录管理，不涉及 SQLite） */
     getSkillsForWorkspace(workspaceName: string): Promise<Skill[]>;
+    /** 从 skill.json 或 package.json 解析出 Skill（兼容无 SKILL.md 的 npm 风格技能目录） */
+    private parseSkillJson;
     getSkillContentForWorkspace(workspaceName: string, name: string): Promise<string | null>;
     /** 在工作区下新增技能（创建目录 + SKILL.md） */
     addSkill(workspaceName: string, name: string, options?: {