@next-open-ai/openbot 0.2.8 → 0.6.6

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;
+        };
+    }>;
+}

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

@@ -0,0 +1,229 @@
+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, Res, HttpException, HttpStatus, } from '@nestjs/common';
+import { readFile } from 'fs/promises';
+import { resolve } from 'path';
+import { homedir } from 'os';
+import { existsSync } from 'fs';
+import { SavedItemsService } from './saved-items.service.js';
+import { WorkspaceService } from '../workspace/workspace.service.js';
+import { ConfigService } from '../config/config.service.js';
+import { getOpenbotWorkspaceDir } from '../../core/agent/agent-dir.js';
+const IMAGE_EXT_MIME = {
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    png: 'image/png',
+    gif: 'image/gif',
+    webp: 'image/webp',
+    svg: 'image/svg+xml',
+    bmp: 'image/bmp',
+    ico: 'image/x-icon',
+};
+function mimeFromPath(filePath) {
+    const ext = filePath.split('.').pop()?.toLowerCase() || '';
+    return IMAGE_EXT_MIME[ext] || 'application/octet-stream';
+}
+function safeFilenameFromUrl(url, contentType) {
+    try {
+        const u = new URL(url);
+        const pathname = u.pathname || '';
+        const segment = pathname.split('/').filter(Boolean).pop() || '';
+        const decoded = decodeURIComponent(segment);
+        const base = decoded.replace(/[^a-zA-Z0-9._-]/g, '_').slice(0, 180);
+        if (base)
+            return base;
+    }
+    catch (_) { }
+    const ct = (contentType || '').split(';')[0].trim().toLowerCase();
+    let ext = 'bin';
+    if (ct.includes('image/'))
+        ext = ct.replace('image/', '').trim() || 'png';
+    else if (ct.includes('text/html'))
+        ext = 'html';
+    else if (ct.includes('text/plain'))
+        ext = 'txt';
+    return `download_${Date.now()}.${ext}`;
+}
+let SavedItemsController = class SavedItemsController {
+    savedItemsService;
+    workspaceService;
+    configService;
+    constructor(savedItemsService, workspaceService, configService) {
+        this.savedItemsService = savedItemsService;
+        this.workspaceService = workspaceService;
+        this.configService = configService;
+    }
+    async list(tagId, workspace) {
+        const data = await this.savedItemsService.findAll({ tagId, workspace });
+        return { success: true, data };
+    }
+    async imageProxy(url, res) {
+        if (!url?.trim())
+            throw new HttpException('url is required', HttpStatus.BAD_REQUEST);
+        const decoded = decodeURIComponent(url.trim());
+        if (decoded.startsWith('file://') || decoded.startsWith('file:/')) {
+            try {
+                let pathPart;
+                try {
+                    const u = new URL(decoded);
+                    pathPart = (u.pathname || decoded).replace(/^\/([a-z]:)/i, '$1');
+                }
+                catch {
+                    pathPart = decoded.replace(/^file:\/+/, '').replace(/^\/([a-z]:)/i, '$1');
+                }
+                const absolutePath = resolve(pathPart);
+                const home = homedir();
+                const workspaceRoot = getOpenbotWorkspaceDir();
+                if (!absolutePath.startsWith(resolve(home)) &&
+                    !absolutePath.startsWith(resolve(workspaceRoot))) {
+                    throw new HttpException('Local file path not allowed', HttpStatus.FORBIDDEN);
+                }
+                if (!existsSync(absolutePath)) {
+                    throw new HttpException('File not found', HttpStatus.NOT_FOUND);
+                }
+                const buffer = await readFile(absolutePath);
+                const contentType = mimeFromPath(absolutePath);
+                res.setHeader('Content-Type', contentType);
+                res.send(buffer);
+            }
+            catch (e) {
+                if (e instanceof HttpException)
+                    throw e;
+                throw new HttpException('Local file read failed', HttpStatus.BAD_GATEWAY);
+            }
+            return;
+        }
+        try {
+            const resFetch = await fetch(decoded, { redirect: 'follow' });
+            if (!resFetch.ok)
+                throw new HttpException('Upstream failed', HttpStatus.BAD_GATEWAY);
+            const contentType = resFetch.headers.get('content-type') || 'application/octet-stream';
+            res.setHeader('Content-Type', contentType);
+            const arr = new Uint8Array(await resFetch.arrayBuffer());
+            res.send(Buffer.from(arr));
+        }
+        catch (e) {
+            if (e instanceof HttpException)
+                throw e;
+            throw new HttpException('Proxy failed', HttpStatus.BAD_GATEWAY);
+        }
+    }
+    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 };
+    }
+    /**
+     * 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.
+     */
+    async downloadToWorkspace(id, body) {
+        const item = await this.savedItemsService.findById(id);
+        if (!item)
+            throw new HttpException('Saved item not found', HttpStatus.NOT_FOUND);
+        const workspace = (body?.workspace ?? '').trim() ||
+            this.configService.getDefaultAgentId(await this.configService.getConfig());
+        let buffer;
+        let contentType;
+        try {
+            const res = await fetch(item.url, { redirect: 'follow' });
+            if (!res.ok) {
+                throw new HttpException(`Failed to fetch URL: ${res.status} ${res.statusText}`, HttpStatus.BAD_GATEWAY);
+            }
+            contentType = res.headers.get('content-type') || undefined;
+            const arr = new Uint8Array(await res.arrayBuffer());
+            buffer = Buffer.from(arr);
+        }
+        catch (err) {
+            if (err instanceof HttpException)
+                throw err;
+            const msg = err instanceof Error ? err.message : String(err);
+            throw new HttpException(`Download failed: ${msg}`, HttpStatus.BAD_GATEWAY);
+        }
+        const filename = safeFilenameFromUrl(item.url, contentType);
+        if ((body?.targetDir ?? '').trim()) {
+            const absolutePath = await this.workspaceService.writeFileToDir(body.targetDir.trim(), filename, buffer);
+            return { success: true, data: { absolutePath, targetDir: body.targetDir.trim() } };
+        }
+        const relativePath = await this.workspaceService.writeFileInFavorite(workspace, filename, buffer);
+        return { success: true, data: { relativePath, workspace } };
+    }
+};
+__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('image-proxy'),
+    __param(0, Query('url')),
+    __param(1, Res({ passthrough: false })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], SavedItemsController.prototype, "imageProxy", 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);
+__decorate([
+    Post(':id/download-to-workspace'),
+    __param(0, Param('id')),
+    __param(1, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], SavedItemsController.prototype, "downloadToWorkspace", null);
+SavedItemsController = __decorate([
+    Controller('saved-items'),
+    __metadata("design:paramtypes", [SavedItemsService,
+        WorkspaceService,
+        ConfigService])
+], 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,25 @@
+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 { ConfigModule } from '../config/config.module.js';
+import { WorkspaceModule } from '../workspace/workspace.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, ConfigModule, WorkspaceModule],
+        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 };