@next-open-ai/openclawx 0.6.6

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/browser-tool.d.ts

@@ -0,0 +1,10 @@
+import type { AgentTool } from "@mariozechner/pi-agent-core";
+/**
+ * Create browser automation tool
+ * @param workspaceDir Optional workspace directory for downloads
+ */
+export declare function createBrowserTool(workspaceDir?: string): AgentTool<any>;
+/**
+ * Cleanup function to close browser on process exit
+ */
+export declare function closeBrowser(): Promise<void>;

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

@@ -0,0 +1,362 @@
+import { Type } from "@sinclair/typebox";
+import { BrowserManager } from "agent-browser/dist/browser.js";
+/**
+ * Browser tool schema - defines all possible browser actions
+ */
+const BrowserToolSchema = Type.Object({
+    action: Type.Union([
+        Type.Literal("navigate"),
+        Type.Literal("snapshot"),
+        Type.Literal("screenshot"),
+        Type.Literal("click"),
+        Type.Literal("type"),
+        Type.Literal("fill"),
+        Type.Literal("scroll"),
+        Type.Literal("extract"),
+        Type.Literal("wait"),
+        Type.Literal("back"),
+        Type.Literal("forward"),
+        Type.Literal("download"),
+        Type.Literal("close"),
+    ], { description: "Browser action to perform" }),
+    url: Type.Optional(Type.String({ description: "URL to navigate to (for navigate action) or download from (for download action)" })),
+    selector: Type.Optional(Type.String({ description: "CSS selector or ref (e.g., @e1) to target element" })),
+    text: Type.Optional(Type.String({ description: "Text to type or fill (for type/fill actions)" })),
+    direction: Type.Optional(Type.Union([
+        Type.Literal("up"),
+        Type.Literal("down"),
+        Type.Literal("left"),
+        Type.Literal("right"),
+    ], { description: "Scroll direction" })),
+    pixels: Type.Optional(Type.Number({ description: "Number of pixels to scroll" })),
+    interactive: Type.Optional(Type.Boolean({ description: "Get only interactive elements in snapshot" })),
+    fullPage: Type.Optional(Type.Boolean({ description: "Take full page screenshot" })),
+    timeout: Type.Optional(Type.Number({ description: "Timeout in milliseconds for wait action" })),
+    downloadPath: Type.Optional(Type.String({ description: "Local path to save downloaded file (for download action)" })),
+});
+/**
+ * Shared browser manager instance
+ */
+let browserManager = null;
+/**
+ * Get or create browser manager instance
+ */
+async function getBrowserManager() {
+    if (!browserManager) {
+        browserManager = new BrowserManager();
+    }
+    // Launch browser if not already launched
+    if (!browserManager.isLaunched()) {
+        await browserManager.launch({
+            action: "launch",
+            id: "default",
+            headless: true,
+            viewport: { width: 1280, height: 720 },
+        });
+    }
+    return browserManager;
+}
+/**
+ * Create browser automation tool
+ * @param workspaceDir Optional workspace directory for downloads
+ */
+export function createBrowserTool(workspaceDir) {
+    return {
+        name: "browser",
+        label: "Browser",
+        description: [
+            "Control a headless browser for web automation.",
+            "Actions: navigate (go to URL), snapshot (get page content with refs), screenshot (capture image),",
+            "click (click element), type (type text), fill (clear and fill input), scroll (scroll page),",
+            "extract (get text from element), wait (wait for element), download (download file from URL or by clicking),",
+            "back/forward (navigation), close (close browser).",
+            "Use refs from snapshot (e.g., @e1, @e2) to interact with elements reliably.",
+        ].join(" "),
+        parameters: BrowserToolSchema,
+        execute: async (_toolCallId, args) => {
+            const params = args;
+            console.log(`[Browser Tool] Executing action: ${params.action}`);
+            try {
+                // Ensure browser is ready
+                const browser = await getBrowserManager();
+                console.log(`[Browser Tool] Browser manager ready`);
+                switch (params.action) {
+                    case "navigate": {
+                        if (!params.url) {
+                            throw new Error("URL is required for navigate action");
+                        }
+                        const page = browser.getPage();
+                        await page.goto(params.url, { waitUntil: "domcontentloaded" });
+                        const url = page.url();
+                        const title = await page.title();
+                        return {
+                            content: [{
+                                    type: "text",
+                                    text: `Navigated to: ${title}\nURL: ${url}`
+                                }],
+                            details: { url, title },
+                        };
+                    }
+                    case "snapshot": {
+                        const snapshot = await browser.getSnapshot({
+                            interactive: params.interactive ?? true,
+                            compact: true,
+                        });
+                        const page = browser.getPage();
+                        const url = page.url();
+                        const title = await page.title();
+                        return {
+                            content: [{
+                                    type: "text",
+                                    text: `Page: ${title}\nURL: ${url}\n\n${snapshot.tree}`
+                                }],
+                            details: {
+                                url,
+                                title,
+                                snapshot: snapshot.tree,
+                                refs: snapshot.refs
+                            },
+                        };
+                    }
+                    case "screenshot": {
+                        const page = browser.getPage();
+                        const screenshot = await page.screenshot({
+                            fullPage: params.fullPage ?? false,
+                            type: "png",
+                        });
+                        const base64 = screenshot.toString("base64");
+                        return {
+                            content: [
+                                { type: "text", text: "Screenshot captured" },
+                                {
+                                    type: "image",
+                                    data: base64,
+                                    mimeType: "image/png"
+                                },
+                            ],
+                            details: { fullPage: params.fullPage ?? false },
+                        };
+                    }
+                    case "click": {
+                        if (!params.selector) {
+                            throw new Error("Selector is required for click action");
+                        }
+                        const locator = browser.getLocator(params.selector);
+                        await locator.click();
+                        return {
+                            content: [{
+                                    type: "text",
+                                    text: `Clicked element: ${params.selector}`
+                                }],
+                            details: { selector: params.selector },
+                        };
+                    }
+                    case "type": {
+                        if (!params.selector || !params.text) {
+                            throw new Error("Selector and text are required for type action");
+                        }
+                        const locator = browser.getLocator(params.selector);
+                        await locator.pressSequentially(params.text);
+                        return {
+                            content: [{
+                                    type: "text",
+                                    text: `Typed text into: ${params.selector}`
+                                }],
+                            details: { selector: params.selector, text: params.text },
+                        };
+                    }
+                    case "fill": {
+                        if (!params.selector || !params.text) {
+                            throw new Error("Selector and text are required for fill action");
+                        }
+                        const locator = browser.getLocator(params.selector);
+                        await locator.fill(params.text);
+                        return {
+                            content: [{
+                                    type: "text",
+                                    text: `Filled text into: ${params.selector}`
+                                }],
+                            details: { selector: params.selector, text: params.text },
+                        };
+                    }
+                    case "scroll": {
+                        const page = browser.getPage();
+                        const direction = params.direction ?? "down";
+                        const pixels = params.pixels ?? 500;
+                        const scrollMap = {
+                            down: { x: 0, y: pixels },
+                            up: { x: 0, y: -pixels },
+                            right: { x: pixels, y: 0 },
+                            left: { x: -pixels, y: 0 },
+                        };
+                        const { x, y } = scrollMap[direction];
+                        await page.evaluate(({ x, y }) => {
+                            window.scrollBy(x, y);
+                        }, { x, y });
+                        return {
+                            content: [{
+                                    type: "text",
+                                    text: `Scrolled ${direction} by ${pixels}px`
+                                }],
+                            details: { direction, pixels },
+                        };
+                    }
+                    case "extract": {
+                        if (!params.selector) {
+                            throw new Error("Selector is required for extract action");
+                        }
+                        const locator = browser.getLocator(params.selector);
+                        const text = await locator.textContent();
+                        return {
+                            content: [{
+                                    type: "text",
+                                    text: `Extracted text: ${text || "(empty)"}`
+                                }],
+                            details: { selector: params.selector, text },
+                        };
+                    }
+                    case "wait": {
+                        if (!params.selector) {
+                            throw new Error("Selector is required for wait action");
+                        }
+                        const locator = browser.getLocator(params.selector);
+                        await locator.waitFor({
+                            state: "visible",
+                            timeout: params.timeout ?? 30000
+                        });
+                        return {
+                            content: [{
+                                    type: "text",
+                                    text: `Element is now visible: ${params.selector}`
+                                }],
+                            details: { selector: params.selector },
+                        };
+                    }
+                    case "back": {
+                        const page = browser.getPage();
+                        await page.goBack();
+                        const url = page.url();
+                        return {
+                            content: [{
+                                    type: "text",
+                                    text: `Navigated back to: ${url}`
+                                }],
+                            details: { url },
+                        };
+                    }
+                    case "forward": {
+                        const page = browser.getPage();
+                        await page.goForward();
+                        const url = page.url();
+                        return {
+                            content: [{
+                                    type: "text",
+                                    text: `Navigated forward to: ${url}`
+                                }],
+                            details: { url },
+                        };
+                    }
+                    case "download": {
+                        const fs = await import("fs/promises");
+                        const path = await import("path");
+                        // Create downloads directory if it doesn't exist
+                        const downloadsDir = workspaceDir ? path.join(workspaceDir, "downloads") : path.join(process.cwd(), "downloads");
+                        try {
+                            await fs.mkdir(downloadsDir, { recursive: true });
+                        }
+                        catch (err) {
+                            // Directory might already exist, ignore
+                        }
+                        // Hybrid approach: URL download or click-triggered download
+                        if (params.url) {
+                            // Direct URL download
+                            const response = await fetch(params.url);
+                            if (!response.ok) {
+                                throw new Error(`Download failed: ${response.statusText}`);
+                            }
+                            const buffer = await response.arrayBuffer();
+                            const filename = params.downloadPath || path.basename(params.url) || `download_${Date.now()}`;
+                            const fullPath = path.isAbsolute(filename)
+                                ? filename
+                                : path.join(downloadsDir, filename);
+                            await fs.writeFile(fullPath, Buffer.from(buffer));
+                            return {
+                                content: [{
+                                        type: "text",
+                                        text: `Downloaded file to: ${fullPath}\nSize: ${buffer.byteLength} bytes`
+                                    }],
+                                details: {
+                                    path: fullPath,
+                                    size: buffer.byteLength,
+                                    url: params.url
+                                },
+                            };
+                        }
+                        else if (params.selector) {
+                            // Click-triggered download using Playwright
+                            const page = browser.getPage();
+                            const downloadPromise = page.waitForEvent('download', { timeout: 30000 });
+                            const locator = browser.getLocator(params.selector);
+                            await locator.click();
+                            const download = await downloadPromise;
+                            const suggestedFilename = download.suggestedFilename();
+                            const filename = params.downloadPath || suggestedFilename || `download_${Date.now()}`;
+                            const fullPath = path.isAbsolute(filename)
+                                ? filename
+                                : path.join(downloadsDir, filename);
+                            await download.saveAs(fullPath);
+                            return {
+                                content: [{
+                                        type: "text",
+                                        text: `Downloaded file to: ${fullPath}\nOriginal filename: ${suggestedFilename}`
+                                    }],
+                                details: {
+                                    path: fullPath,
+                                    originalFilename: suggestedFilename,
+                                    selector: params.selector
+                                },
+                            };
+                        }
+                        else {
+                            throw new Error("Download action requires either url or selector parameter");
+                        }
+                    }
+                    case "close": {
+                        if (browserManager) {
+                            await browserManager.close();
+                            browserManager = null;
+                        }
+                        return {
+                            content: [{
+                                    type: "text",
+                                    text: "Browser closed"
+                                }],
+                            details: { closed: true },
+                        };
+                    }
+                    default:
+                        throw new Error(`Unknown action: ${params.action}`);
+                }
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Browser action failed: ${errorMessage}`
+                        }],
+                    details: { error: errorMessage },
+                };
+            }
+        },
+    };
+}
+/**
+ * Cleanup function to close browser on process exit
+ */
+export async function closeBrowser() {
+    if (browserManager) {
+        await browserManager.close();
+        browserManager = null;
+    }
+}

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

@@ -0,0 +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

@@ -0,0 +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/install-skill-tool.d.ts

@@ -0,0 +1,6 @@
+import type { ToolDefinition } from "@mariozechner/pi-coding-agent";
+/**
+ * 创建 install_skill 工具：通过核心 installer 安装技能，不依赖 Nest。
+ * @param targetAgentId 安装目标（具体 agentId / "global"|"all" / 未传则当前/default）
+ */
+export declare function createInstallSkillTool(targetAgentId: string | undefined): ToolDefinition;

package/dist/core/tools/install-skill-tool.js

@@ -0,0 +1,53 @@
+import { Type } from "@sinclair/typebox";
+import { resolveInstallTarget, installSkillByUrl } from "../installer/index.js";
+const InstallSkillSchema = Type.Object({
+    url: Type.String({
+        description: "Skill 安装地址，如 GitHub 简写 owner/repo、完整 URL 或 owner/repo@skillName",
+    }),
+});
+/**
+ * 创建 install_skill 工具：通过核心 installer 安装技能，不依赖 Nest。
+ * @param targetAgentId 安装目标（具体 agentId / "global"|"all" / 未传则当前/default）
+ */
+export function createInstallSkillTool(targetAgentId) {
+    return {
+        name: "install_skill",
+        label: "Install Skill",
+        description: "将指定地址的技能安装到当前智能体工作区目录。在 OpenBot 中为用户安装技能时，" +
+            "应使用本工具而非 npx skills add，以保证安装到当前智能体对应的技能目录。",
+        parameters: InstallSkillSchema,
+        execute: async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
+            const url = (params.url ?? "").trim();
+            if (!url) {
+                return {
+                    content: [{ type: "text", text: "请提供技能安装地址（如 owner/repo 或 owner/repo@skillName）。" }],
+                    details: undefined,
+                };
+            }
+            try {
+                const target = await resolveInstallTarget(targetAgentId);
+                const result = await installSkillByUrl(url, {
+                    scope: target.scope,
+                    workspace: target.workspace,
+                });
+                const out = result.stdout?.trim() ?? "";
+                const err = result.stderr?.trim() ?? "";
+                const installDir = result.installDir;
+                const dirLine = installDir ? `\n安装目录：${installDir}` : "";
+                const baseText = out || (err ? `安装完成。\n${err}` : "技能已安装完成。");
+                const text = dirLine ? `${baseText}${dirLine}` : baseText;
+                return {
+                    content: [{ type: "text", text }],
+                    details: { stdout: result.stdout, stderr: result.stderr, installDir: result.installDir },
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return {
+                    content: [{ type: "text", text: `安装失败: ${msg}` }],
+                    details: undefined,
+                };
+            }
+        },
+    };
+}

package/dist/core/tools/save-experience-tool.d.ts

@@ -0,0 +1,5 @@
+import type { ToolDefinition } from "@mariozechner/pi-coding-agent";
+/**
+ * 创建 save_experience 工具：对话结束时由 Agent 调用，将经验总结存入向量库（infotype: experience）
+ */
+export declare function createSaveExperienceTool(sessionId: string): ToolDefinition;

package/dist/core/tools/save-experience-tool.js

@@ -0,0 +1,54 @@
+import { Type } from "@sinclair/typebox";
+import { addMemory } from "../memory/index.js";
+const SaveExperienceSchema = Type.Object({
+    summary: Type.String({
+        description: "本轮对话中总结出的经验、要点或可复用的结论，用于存入长期记忆",
+    }),
+});
+/**
+ * 创建 save_experience 工具：对话结束时由 Agent 调用，将经验总结存入向量库（infotype: experience）
+ */
+export function createSaveExperienceTool(sessionId) {
+    return {
+        name: "save_experience",
+        label: "Save Experience",
+        description: "在对话结束时调用，将本轮对话中总结出的经验、要点或可复用的结论存入长期记忆，便于后续会话检索。",
+        parameters: SaveExperienceSchema,
+        execute: async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
+            const text = (params.summary ?? "").trim();
+            if (!text) {
+                return {
+                    content: [{ type: "text", text: "未提供总结内容，未写入记忆。" }],
+                    details: undefined,
+                };
+            }
+            try {
+                const id = await addMemory(text, {
+                    infotype: "experience",
+                    sessionId,
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `经验已存入长期记忆（id: ${id}）。`,
+                        },
+                    ],
+                    details: { id },
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `存入记忆失败: ${msg}`,
+                        },
+                    ],
+                    details: undefined,
+                };
+            }
+        },
+    };
+}

package/dist/gateway/auth-hooks.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Gateway 各通道入口的鉴权/安全钩子（占位模块）。
+ * 连接之初可在此做 token 校验、限流等，当前暂不加逻辑，仅透传。
+ */
+import type { Request, Response, NextFunction } from 'express';
+import type { IncomingMessage } from 'http';
+/** HTTP：/server-api 进入 Nest 前的鉴权钩子（占位，直接 next） */
+export declare function authHookServerApi(req: Request, res: Response, next: NextFunction): void;
+/** HTTP：/channel 进入通道模块前的鉴权钩子（占位，直接 next） */
+export declare function authHookChannel(req: Request, res: Response, next: NextFunction): void;
+/** HTTP：/sse 进入 SSE 前的鉴权钩子（占位，直接 next） */
+export declare function authHookSse(req: Request, res: Response, next: NextFunction): void;
+/**
+ * WebSocket upgrade：/ws 或 /ws/voice 连接前的鉴权钩子（占位）。
+ * 返回 true 表示放行，false 表示拒绝（调用方应关闭 socket）。
+ */
+export declare function authHookWs(_req: IncomingMessage, _path: string): boolean;