@next-open-ai/openbot 0.2.8 → 0.3.2

package/dist/core/mcp/types.d.ts

@@ -0,0 +1,72 @@
+/**
+ * MCP (Model Context Protocol) 相关类型定义。
+ * 仅实现 Client 端 Tools 能力；Resources/Prompts 类型预留扩展。
+ */
+/** stdio 传输：通过子进程 stdin/stdout 进行 JSON-RPC 通信 */
+export interface McpServerConfigStdio {
+    transport: "stdio";
+    /** 可执行路径（禁止从用户输入拼接，需白名单或配置） */
+    command: string;
+    /** 命令行参数 */
+    args?: string[];
+    /** 环境变量（可选，合并到 process.env） */
+    env?: Record<string, string>;
+}
+/** SSE/HTTP 远程传输：通过 URL POST JSON-RPC 请求 */
+export interface McpServerConfigSse {
+    transport: "sse";
+    /** 远程 MCP 服务地址（如 https://example.com/mcp） */
+    url: string;
+    /** 可选请求头（如 Authorization） */
+    headers?: Record<string, string>;
+}
+/** 单条 MCP 服务器配置（由调用方在创建 Session 时传入，与 Skill 类似） */
+export type McpServerConfig = McpServerConfigStdio | McpServerConfigSse;
+/** MCP 协议中 Tool 的 inputSchema 为 JSON Schema 对象 */
+export interface McpToolInputSchema {
+    type?: string;
+    properties?: Record<string, unknown>;
+    required?: string[];
+    [key: string]: unknown;
+}
+/** MCP tools/list 返回的单个工具描述 */
+export interface McpTool {
+    name: string;
+    description?: string;
+    inputSchema?: McpToolInputSchema;
+}
+/** MCP tools/call 返回的 content 项 */
+export interface McpToolCallContentItem {
+    type: "text";
+    text: string;
+}
+/** MCP tools/call 的 result */
+export interface McpToolCallResult {
+    content: McpToolCallContentItem[];
+    isError?: boolean;
+}
+/** JSON-RPC 2.0 请求 */
+export interface JsonRpcRequest {
+    jsonrpc: "2.0";
+    id: number | string;
+    method: string;
+    params?: unknown;
+}
+/** JSON-RPC 2.0 成功响应 */
+export interface JsonRpcResponse<T = unknown> {
+    jsonrpc: "2.0";
+    id: number | string;
+    result?: T;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+/** 传输层抽象：stdio / sse 等实现此接口供 McpClient 使用 */
+export interface IMcpTransport {
+    start(): Promise<void>;
+    request(req: JsonRpcRequest, timeoutMs?: number): Promise<JsonRpcResponse>;
+    close(): Promise<void>;
+    readonly isConnected: boolean;
+}

package/dist/core/mcp/types.js

@@ -0,0 +1,5 @@
+/**
+ * MCP (Model Context Protocol) 相关类型定义。
+ * 仅实现 Client 端 Tools 能力；Resources/Prompts 类型预留扩展。
+ */
+export {};

package/dist/core/tools/bookmark-tool.d.ts

@@ -0,0 +1,9 @@
+import type { ToolDefinition } from "@mariozechner/pi-coding-agent";
+/**
+ * 获取当前系统中已维护的标签列表，供保存 URL 时选择匹配的标签。
+ */
+export declare function createGetBookmarkTagsTool(): ToolDefinition;
+/**
+ * 将 URL 保存为收藏，并关联指定标签（标签名须与 get_bookmark_tags 返回的一致）。
+ */
+export declare function createSaveBookmarkTool(): ToolDefinition;

package/dist/core/tools/bookmark-tool.js

@@ -0,0 +1,118 @@
+import { Type } from "@sinclair/typebox";
+import { getBackendBaseUrl } from "../../gateway/backend-url.js";
+const GetBookmarkTagsSchema = Type.Object({});
+const SaveBookmarkSchema = Type.Object({
+    url: Type.String({ description: "要收藏的 URL" }),
+    title: Type.Optional(Type.String({ description: "可选标题" })),
+    tagNames: Type.Optional(Type.Array(Type.String(), {
+        description: "标签名称列表，须与系统中已维护的标签一致。保存前应先用 get_bookmark_tags 获取可用标签。",
+    })),
+});
+async function apiGet(path) {
+    const base = getBackendBaseUrl();
+    if (!base) {
+        throw new Error("收藏功能需要在前端/桌面环境中使用，当前无法访问后端。");
+    }
+    const res = await fetch(`${base.replace(/\/$/, "")}/server-api${path}`, {
+        method: "GET",
+        headers: { "Content-Type": "application/json" },
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`请求失败: ${res.status} ${text}`);
+    }
+    return res.json();
+}
+async function apiPost(path, body) {
+    const base = getBackendBaseUrl();
+    if (!base) {
+        throw new Error("收藏功能需要在前端/桌面环境中使用，当前无法访问后端。");
+    }
+    const res = await fetch(`${base.replace(/\/$/, "")}/server-api${path}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`请求失败: ${res.status} ${text}`);
+    }
+    return res.json();
+}
+/**
+ * 获取当前系统中已维护的标签列表，供保存 URL 时选择匹配的标签。
+ */
+export function createGetBookmarkTagsTool() {
+    return {
+        name: "get_bookmark_tags",
+        label: "Get Bookmark Tags",
+        description: "获取系统中已维护的收藏标签列表。在用户要求保存链接时，应先调用本工具获取可用标签，再根据用户意图匹配最合适的标签名，并用 save_bookmark 保存。",
+        parameters: GetBookmarkTagsSchema,
+        execute: async (_toolCallId, _params, _signal, _onUpdate, _ctx) => {
+            try {
+                const json = await apiGet("/tags");
+                const data = json.data ?? [];
+                const names = data.map((t) => t.name);
+                const text = names.length > 0
+                    ? `当前可用标签：${names.join("、")}。请根据用户意图选择匹配的标签名用于 save_bookmark。`
+                    : "当前暂无标签。请在设置中先添加标签，或使用 save_bookmark 时不传 tagNames。";
+                return {
+                    content: [{ type: "text", text }],
+                    details: { tags: data },
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return {
+                    content: [{ type: "text", text: `获取标签失败: ${msg}` }],
+                    details: undefined,
+                };
+            }
+        },
+    };
+}
+/**
+ * 将 URL 保存为收藏，并关联指定标签（标签名须与 get_bookmark_tags 返回的一致）。
+ */
+export function createSaveBookmarkTool() {
+    return {
+        name: "save_bookmark",
+        label: "Save Bookmark",
+        description: "将用户提供的 URL 保存到收藏库，并可关联一个或多个标签。标签名必须使用 get_bookmark_tags 返回的已有标签；若用户未指定标签，可根据上下文推断或留空。",
+        parameters: SaveBookmarkSchema,
+        execute: async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
+            const url = (params.url ?? "").trim();
+            if (!url) {
+                return {
+                    content: [{ type: "text", text: "请提供要收藏的 URL。" }],
+                    details: undefined,
+                };
+            }
+            try {
+                const json = await apiPost("/saved-items", {
+                    url,
+                    title: params.title?.trim() || undefined,
+                    tagNames: params.tagNames?.length ? params.tagNames.map((n) => n.trim()).filter(Boolean) : undefined,
+                });
+                const data = json.data;
+                const tagStr = data?.tagNames?.length ? `，标签：${data.tagNames.join("、")}` : "";
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `已收藏：${data?.url ?? url}${tagStr}`,
+                        },
+                    ],
+                    details: data,
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return {
+                    content: [{ type: "text", text: `保存失败: ${msg}` }],
+                    details: undefined,
+                };
+            }
+        },
+    };
+}

package/dist/core/tools/index.d.ts

@@ -1,3 +1,4 @@
 export { createBrowserTool, closeBrowser } from "./browser-tool.js";
 export { createSaveExperienceTool } from "./save-experience-tool.js";
 export { createInstallSkillTool } from "./install-skill-tool.js";
+export { createGetBookmarkTagsTool, createSaveBookmarkTool } from "./bookmark-tool.js";

package/dist/core/tools/index.js

@@ -1,3 +1,4 @@
 export { createBrowserTool, closeBrowser } from "./browser-tool.js";
 export { createSaveExperienceTool } from "./save-experience-tool.js";
 export { createInstallSkillTool } from "./install-skill-tool.js";
+export { createGetBookmarkTagsTool, createSaveBookmarkTool } from "./bookmark-tool.js";

package/dist/gateway/methods/agent-chat.js

@@ -64,6 +64,7 @@ async function handleAgentChatInner(client, targetSessionId, message, params) {
             apiKey,
             maxSessions: maxAgentSessions,
             targetAgentId: effectiveTargetAgentId,
+            mcpServers: agentConfig?.mcpServers,
         });
     }
     catch (err) {

package/dist/gateway/methods/install-skill-from-upload.d.ts

@@ -0,0 +1,14 @@
+export interface InstallFromUploadBody {
+    /** zip 文件 buffer */
+    buffer: Buffer;
+    scope?: "global" | "workspace";
+    workspace?: string;
+}
+export interface InstallFromUploadResult {
+    success: true;
+    data: {
+        installDir: string;
+        name: string;
+    };
+}
+export declare function handleInstallSkillFromUpload(body: InstallFromUploadBody): Promise<InstallFromUploadResult>;

package/dist/gateway/methods/install-skill-from-upload.js

@@ -0,0 +1,13 @@
+/**
+ * 在 Gateway 层处理 POST /server-api/skills/install-from-upload，
+ * 接收 multipart zip 文件，委托核心 installer 解压并安装到全局或工作区。
+ */
+import { installSkillFromUpload } from "../../core/installer/index.js";
+export async function handleInstallSkillFromUpload(body) {
+    const { buffer, scope = "global", workspace = "default" } = body;
+    if (!buffer || !Buffer.isBuffer(buffer) || buffer.length === 0) {
+        throw new Error("请上传 zip 文件");
+    }
+    const result = await installSkillFromUpload(buffer, { scope, workspace });
+    return { success: true, data: { installDir: result.installDir, name: result.name } };
+}

package/dist/gateway/methods/run-scheduled-task.js

@@ -55,6 +55,7 @@ export async function handleRunScheduledTask(req, res) {
             provider,
             modelId,
             apiKey,
+            mcpServers: agentConfig?.mcpServers,
         });
         let assistantContent = "";
         let turnPromptTokens = 0;

package/dist/gateway/server.js

@@ -31,7 +31,9 @@ import { handleSse } from "./sse-handler.js";
 import { handleVoiceUpgrade } from "./voice-handler.js";
 import { handleConnection } from "./connection-handler.js";
 import { handleRunScheduledTask } from "./methods/run-scheduled-task.js";
+import multer from "multer";
 import { handleInstallSkillFromPath } from "./methods/install-skill-from-path.js";
+import { handleInstallSkillFromUpload } from "./methods/install-skill-from-upload.js";
 import { setBackendBaseUrl } from "./backend-url.js";
 import { ensureDesktopConfigInitialized } from "../core/config/desktop-config.js";
 import { createNestAppEmbedded } from "../server/bootstrap.js";
@@ -66,6 +68,10 @@ export async function startGatewayServer(port = 38080) {
     gatewayExpress.post(PATHS.RUN_SCHEDULED_TASK, async (req, res) => {
         await handleRunScheduledTask(req, res);
     });
+    const uploadZip = multer({
+        storage: multer.memoryStorage(),
+        limits: { fileSize: 10 * 1024 * 1024 },
+    });
     gatewayExpress.post(`${PATHS.SERVER_API}/skills/install-from-path`, async (req, res) => {
         const body = await new Promise((resolve, reject) => {
             const chunks = [];
@@ -88,6 +94,24 @@ export async function startGatewayServer(port = 38080) {
             res.status(code).json({ success: false, message });
         }
     });
+    gatewayExpress.post(`${PATHS.SERVER_API}/skills/install-from-upload`, authHookServerApi, uploadZip.single("file"), async (req, res) => {
+        try {
+            const file = req.file;
+            const buffer = file?.buffer;
+            if (!buffer || !Buffer.isBuffer(buffer)) {
+                return res.status(400).json({ success: false, message: "请上传 zip 文件" });
+            }
+            const scope = req.body?.scope === "workspace" ? "workspace" : "global";
+            const workspace = req.body?.workspace ?? "default";
+            const result = await handleInstallSkillFromUpload({ buffer, scope, workspace });
+            res.status(200).json(result);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const code = message.includes("请上传") || message.includes("SKILL.md") || message.includes("目录") || message.includes("10MB") ? 400 : 500;
+            res.status(code).json({ success: false, message });
+        }
+    });
     gatewayExpress.use(PATHS.SERVER_API, authHookServerApi, nestExpress);
     gatewayExpress.use(PATHS.CHANNEL, authHookChannel, (req, res) => handleChannel(req, res));
     gatewayExpress.use(PATHS.SSE, authHookSse, (req, res) => handleSse(req, res));

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

@@ -20,7 +20,7 @@ export declare class AgentConfigController {
         success: boolean;
         data: AgentConfigItem;
     }>;
-    updateAgent(id: string, body: Partial<Pick<AgentConfigItem, 'name' | 'provider' | 'model' | 'modelItemCode'>>): Promise<{
+    updateAgent(id: string, body: Partial<Pick<AgentConfigItem, 'name' | 'provider' | 'model' | 'modelItemCode' | 'mcpServers'>>): Promise<{
         success: boolean;
         data: AgentConfigItem;
     }>;

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

@@ -1,3 +1,4 @@
+import type { McpServerConfig } from '../../core/mcp/index.js';
 /** 缺省智能体 ID / 工作空间名，不可删除；对应目录 ~/.openbot/workspace/default */
 export declare const DEFAULT_AGENT_ID = "default";
 /**
@@ -14,6 +15,8 @@ export interface AgentConfigItem {
     modelItemCode?: string;
     /** 是否为系统缺省智能体（主智能体），不可删除 */
     isDefault?: boolean;
+    /** MCP 服务器配置列表，创建 Session 时传入（与 Skill 类似） */
+    mcpServers?: McpServerConfig[];
 }
 export declare class AgentConfigService {
     private configDir;
@@ -31,7 +34,7 @@ export declare class AgentConfigService {
         name: string;
         workspace: string;
     }): Promise<AgentConfigItem>;
-    updateAgent(id: string, updates: Partial<Pick<AgentConfigItem, 'name' | 'provider' | 'model' | 'modelItemCode'>>): Promise<AgentConfigItem>;
+    updateAgent(id: string, updates: Partial<Pick<AgentConfigItem, 'name' | 'provider' | 'model' | 'modelItemCode' | 'mcpServers'>>): Promise<AgentConfigItem>;
     deleteAgent(id: string): Promise<void>;
     /**
      * 根据 config 的 defaultProvider / defaultModel / defaultModelItemCode 及 configuredModels 同步 agents.json 中缺省智能体的 provider、model、modelItemCode。

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

@@ -150,6 +150,8 @@ let AgentConfigService = class AgentConfigService {
             agent.model = updates.model;
         if (updates.modelItemCode !== undefined)
             agent.modelItemCode = updates.modelItemCode;
+        if (updates.mcpServers !== undefined)
+            agent.mcpServers = updates.mcpServers;
         await this.writeAgentsFile(file);
         return { ...agent, isDefault: agent.id === DEFAULT_AGENT_ID };
     }

package/dist/server/agents/agents.controller.js

@@ -10,7 +10,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-import { Controller, Get, Post, Delete, Body, Param, HttpException, HttpStatus, } from '@nestjs/common';
+import { Controller, Get, Post, Delete, Body, Param, Header, HttpException, HttpStatus, } from '@nestjs/common';
 import { AgentsService } from './agents.service.js';
 let AgentsController = class AgentsController {
     agentsService;
@@ -47,10 +47,7 @@ let AgentsController = class AgentsController {
         };
     }
     async deleteSession(id) {
-        const deleted = await this.agentsService.deleteSession(id);
-        if (!deleted) {
-            throw new HttpException('Session not found', HttpStatus.NOT_FOUND);
-        }
+        await this.agentsService.deleteSession(id);
         return {
             success: true,
             message: 'Session deleted',
@@ -80,6 +77,7 @@ __decorate([
 ], AgentsController.prototype, "createSession", null);
 __decorate([
     Get('sessions'),
+    Header('Cache-Control', 'no-store'),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", void 0)

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

@@ -53,7 +53,7 @@ export declare class AgentsService {
     }): Promise<AgentSession>;
     getSessions(): AgentSession[];
     getSession(sessionId: string): AgentSession | undefined;
-    deleteSession(sessionId: string): Promise<boolean>;
+    deleteSession(sessionId: string): Promise<void>;
     getMessageHistory(sessionId: string): ChatMessage[];
     addAssistantMessage(sessionId: string, content: string): void;
     appendMessage(sessionId: string, role: 'user' | 'assistant', content: string, options?: {

package/dist/server/agents/agents.service.js

@@ -135,9 +135,11 @@ let AgentsService = class AgentsService {
         return r ? this.rowToSession(r) : undefined;
     }
     async deleteSession(sessionId) {
-        agentManager.deleteSession(sessionId);
         const result = this.db.run('DELETE FROM sessions WHERE id = ?', [sessionId]);
-        return result.changes > 0;
+        if (result.changes > 0) {
+            this.db.persist();
+        }
+        agentManager.deleteSession(sessionId);
     }
     getMessageHistory(sessionId) {
         const rows = this.db.all('SELECT * FROM chat_messages WHERE session_id = ? ORDER BY timestamp ASC', [sessionId]);

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