@next-open-ai/openbot 0.1.1

package/dist/gateway/server.js

@@ -0,0 +1,268 @@
+/**
+ * Avoid MaxListenersExceededWarning when Browser Tool is used repeatedly.
+ * Playwright/agent-browser attach abort listeners to the same AbortSignal per action;
+ * Node's default EventTarget maxListeners is 10.
+ */
+const Et = globalThis.EventTarget;
+if (Et?.prototype?.addEventListener && Et.prototype.setMaxListeners) {
+    const add = Et.prototype.addEventListener;
+    Et.prototype.addEventListener = function (type, listener, options) {
+        if (type === "abort" && typeof this.setMaxListeners === "function") {
+            this.setMaxListeners(32);
+        }
+        return add.call(this, type, listener, options);
+    };
+}
+import { WebSocketServer } from "ws";
+import { createServer, request as httpRequest } from "http";
+import { handleConnection } from "./connection-handler.js";
+import { readFile, stat } from "fs/promises";
+import { join, extname } from "path";
+import { existsSync } from "fs";
+import { spawn } from "child_process";
+import { createServer as createNetServer } from "net";
+import { handleRunScheduledTask } from "./methods/run-scheduled-task.js";
+import { handleInstallSkillFromPath } from "./methods/install-skill-from-path.js";
+import { setBackendBaseUrl } from "./backend-url.js";
+/**
+ * Find an available port starting from startPort
+ */
+async function findAvailablePort(startPort) {
+    let port = startPort;
+    while (true) {
+        try {
+            await new Promise((resolve, reject) => {
+                const server = createNetServer();
+                server.once("error", (err) => {
+                    if (err.code === "EADDRINUSE") {
+                        resolve(); // Port taken, try next
+                    }
+                    else {
+                        reject(err);
+                    }
+                });
+                server.once("listening", () => {
+                    server.close(() => resolve()); // Port available
+                });
+                server.listen(port);
+            });
+            // If we get here and the server listened successfully (then closed), checking if it was actually available logic needs care.
+            // Actually the above logic is slightly flawed for "resolve on error".
+            // Let's refine:
+            // If listen succeeds -> port is free. return it.
+            // If EADDRINUSE -> port busy. loop continue.
+            const isAvailable = await new Promise((resolve) => {
+                const server = createNetServer();
+                server.once("error", () => resolve(false));
+                server.once("listening", () => {
+                    server.close(() => resolve(true));
+                });
+                server.listen(port);
+            });
+            if (isAvailable)
+                return port;
+            port++;
+        }
+        catch (e) {
+            port++;
+        }
+    }
+}
+/**
+ * MIME types for static files
+ */
+const MIME_TYPES = {
+    ".html": "text/html",
+    ".js": "text/javascript",
+    ".css": "text/css",
+    ".json": "application/json",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".gif": "image/gif",
+    ".svg": "image/svg+xml",
+    ".ico": "image/x-icon",
+    ".woff": "font/woff",
+    ".woff2": "font/woff2",
+    ".ttf": "font/ttf",
+    ".eot": "application/vnd.ms-fontobject",
+};
+/**
+ * Start WebSocket gateway server
+ */
+export async function startGatewayServer(port = 3000) {
+    console.log(`Starting gateway server on port ${port}...`);
+    // 1. Find available port for Desktop Server
+    const backendPort = await findAvailablePort(3001);
+    console.log(`Found available port for Desktop Server: ${backendPort}`);
+    setBackendBaseUrl(`http://localhost:${backendPort}`);
+    // 2. Start Desktop Server
+    let backendProcess = null;
+    const serverPath = join(process.cwd(), "dist/server/main.js");
+    if (existsSync(serverPath)) {
+        console.log(`Spawning Desktop Server at ${serverPath}...`);
+        backendProcess = spawn("node", [serverPath], {
+            cwd: process.cwd(),
+            env: { ...process.env, PORT: backendPort.toString() },
+            stdio: ["ignore", "pipe", "pipe"], // Pipe stdout/stderr to capture logs
+        });
+        backendProcess.stdout?.on("data", (data) => {
+            const str = data.toString().trim();
+            if (str)
+                console.log(`[Desktop Server] ${str}`);
+        });
+        backendProcess.stderr?.on("data", (data) => {
+            const str = data.toString().trim();
+            if (str)
+                console.error(`[Desktop Server Error] ${str}`);
+        });
+        backendProcess.on("exit", (code) => {
+            if (code !== 0 && code !== null) {
+                console.error(`Desktop Server exited with code ${code}`);
+            }
+        });
+    }
+    else {
+        console.warn("⚠️ Desktop Server build not found. Skipping auto-start.");
+        console.warn("   Run 'npm run desktop:build' to build the server.");
+    }
+    // Create HTTP server
+    const httpServer = createServer(async (req, res) => {
+        // Simple health check endpoint
+        if (req.url === "/health") {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ status: "ok", timestamp: Date.now() }));
+            return;
+        }
+        // Scheduled task: run agent and POST assistant message back to Nest
+        const pathname = req.url?.split("?")[0] || "";
+        if (req.method === "POST" && pathname === "/run-scheduled-task") {
+            await handleRunScheduledTask(req, res);
+            return;
+        }
+        // 本地技能目录安装：在 Gateway 层直接处理，不依赖 Nest，保证桌面端稳定可用
+        if (req.method === "POST" && pathname === "/server-api/skills/install-from-path") {
+            const body = await new Promise((resolve, reject) => {
+                const chunks = [];
+                req.on("data", (chunk) => chunks.push(chunk));
+                req.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+                req.on("error", reject);
+            });
+            try {
+                const parsed = JSON.parse(body || "{}");
+                const result = await handleInstallSkillFromPath({
+                    path: parsed.path ?? "",
+                    scope: parsed.scope === "workspace" ? "workspace" : "global",
+                    workspace: parsed.workspace,
+                });
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify(result));
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                const code = message.includes("required") || message.includes("不存在") || message.includes("SKILL.md") || message.includes("目录名") ? 400 : 500;
+                res.writeHead(code, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ success: false, message }));
+            }
+            return;
+        }
+        // Proxy API requests to Backend (prefixed with /server-api)
+        if (req.url && req.url.startsWith("/server-api")) {
+            const options = {
+                hostname: "localhost",
+                port: backendPort, // Use discovered port
+                path: req.url,
+                method: req.method,
+                headers: req.headers,
+            };
+            const proxyReq = httpRequest(options, (proxyRes) => {
+                res.writeHead(proxyRes.statusCode || 500, proxyRes.headers);
+                proxyRes.pipe(res, { end: true });
+            });
+            proxyReq.on("error", (err) => {
+                console.error(`Proxy error to :${backendPort}`, err);
+                if (!res.headersSent) {
+                    res.writeHead(502, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "Bad Gateway", message: "Failed to connect to backend server" }));
+                }
+            });
+            req.pipe(proxyReq, { end: true });
+            return;
+        }
+        // Serve static files
+        try {
+            const staticDir = join(process.cwd(), "desktop/renderer/dist");
+            // Normalize URL to remove query parameters and ensuring it starts with /
+            const urlPath = req.url?.split("?")[0] || "/";
+            // Determine file path
+            let filePath = join(staticDir, urlPath === "/" ? "index.html" : urlPath);
+            // Check if file exists
+            try {
+                const stats = await stat(filePath);
+                if (stats.isDirectory()) {
+                    filePath = join(filePath, "index.html");
+                    await stat(filePath); // Check if index.html exists
+                }
+            }
+            catch {
+                // File not found
+                // SPA Fallback: serve index.html for non-API requests accepting HTML
+                if (req.headers.accept?.includes("text/html") && req.method === "GET") {
+                    filePath = join(staticDir, "index.html");
+                }
+                else {
+                    res.writeHead(404, { "Content-Type": "text/plain" });
+                    res.end("Not Found");
+                    return;
+                }
+            }
+            // Read and serve file
+            const content = await readFile(filePath);
+            const ext = extname(filePath).toLowerCase();
+            const contentType = MIME_TYPES[ext] || "application/octet-stream";
+            res.writeHead(200, { "Content-Type": contentType });
+            res.end(content);
+        }
+        catch (error) {
+            console.error("Static file error:", error);
+            res.writeHead(500, { "Content-Type": "text/plain" });
+            res.end("Internal Server Error");
+        }
+    });
+    // Create WebSocket server
+    const wss = new WebSocketServer({ server: httpServer });
+    // Handle new connections
+    wss.on("connection", (ws, req) => {
+        handleConnection(ws, req);
+    });
+    // Start listening
+    await new Promise((resolve) => {
+        httpServer.listen(port, () => {
+            console.log(`✅ Gateway server listening on ws://localhost:${port}`);
+            console.log(`   Health check: http://localhost:${port}/health`);
+            resolve();
+        });
+    });
+    // Cleanup function
+    const close = async () => {
+        console.log("Closing gateway server...");
+        // Stop Desktop Server
+        if (backendProcess) {
+            console.log("Stopping Desktop Server...");
+            backendProcess.kill();
+        }
+        // Close all WebSocket connections
+        wss.clients.forEach((client) => {
+            client.close();
+        });
+        // Close WebSocket server
+        await new Promise((resolve) => {
+            wss.close(() => resolve());
+        });
+        // Close HTTP server
+        await new Promise((resolve) => {
+            httpServer.close(() => resolve());
+        });
+        console.log("Gateway server closed");
+    };
+    return { httpServer, wss, close };
+}

package/dist/gateway/types.d.ts

@@ -0,0 +1,76 @@
+import type { WebSocket } from "ws";
+/**
+ * Gateway client connection
+ */
+export interface GatewayClient {
+    id: string;
+    ws: WebSocket;
+    authenticated: boolean;
+    sessionId?: string;
+    connectedAt: number;
+}
+/**
+ * Gateway message types
+ */
+export type GatewayMessageType = "request" | "response" | "event";
+/**
+ * Base gateway message
+ */
+export interface GatewayMessage {
+    type: GatewayMessageType;
+    id?: string;
+    method?: string;
+    params?: any;
+    result?: any;
+    error?: {
+        message: string;
+        code?: string;
+    };
+    event?: string;
+    payload?: any;
+}
+/**
+ * Request message
+ */
+export interface GatewayRequest extends GatewayMessage {
+    type: "request";
+    id: string;
+    method: string;
+    params?: any;
+}
+/**
+ * Response message
+ */
+export interface GatewayResponse extends GatewayMessage {
+    type: "response";
+    id: string;
+    result?: any;
+    error?: {
+        message: string;
+        code?: string;
+    };
+}
+/**
+ * Event message
+ */
+export interface GatewayEvent extends GatewayMessage {
+    type: "event";
+    event: string;
+    payload?: any;
+}
+/**
+ * Connect params
+ */
+export interface ConnectParams {
+    sessionId?: string;
+    nonce?: string;
+}
+/**
+ * Agent chat params
+ */
+export interface AgentChatParams {
+    message: string;
+    sessionId?: string;
+    /** 对话/安装目标：具体 agentId，或 "global"|"all" 表示全局；用于 install_skill 等隔离 */
+    targetAgentId?: string;
+}

package/dist/gateway/types.js

@@ -0,0 +1 @@
+export {};

package/dist/gateway/utils.d.ts

@@ -0,0 +1,22 @@
+import type { WebSocket } from "ws";
+import type { GatewayMessage } from "./types.js";
+/**
+ * Send JSON message to WebSocket client
+ */
+export declare function send(ws: WebSocket, message: GatewayMessage): void;
+/**
+ * Parse incoming WebSocket message
+ */
+export declare function parseMessage(data: Buffer | string): GatewayMessage | null;
+/**
+ * Create error response
+ */
+export declare function createErrorResponse(id: string, message: string, code?: string): GatewayMessage;
+/**
+ * Create success response
+ */
+export declare function createSuccessResponse(id: string, result: any): GatewayMessage;
+/**
+ * Create event message
+ */
+export declare function createEvent(event: string, payload: any): GatewayMessage;

package/dist/gateway/utils.js

@@ -0,0 +1,67 @@
+/**
+ * Send JSON message to WebSocket client
+ */
+export function send(ws, message) {
+    try {
+        ws.send(JSON.stringify(message));
+    }
+    catch (error) {
+        console.error("Failed to send message:", error);
+    }
+}
+/**
+ * Parse incoming WebSocket message
+ */
+export function parseMessage(data) {
+    try {
+        const text = typeof data === "string" ? data : data.toString();
+        const obj = JSON.parse(text);
+        // If type is missing, try to infer it
+        if (!obj.type) {
+            if (obj.method) {
+                obj.type = "request";
+            }
+            else if (obj.event) {
+                obj.type = "event";
+            }
+            else if (obj.result !== undefined || obj.error !== undefined) {
+                obj.type = "response";
+            }
+        }
+        return obj;
+    }
+    catch (error) {
+        console.error("Failed to parse message:", error);
+        return null;
+    }
+}
+/**
+ * Create error response
+ */
+export function createErrorResponse(id, message, code) {
+    return {
+        type: "response",
+        id,
+        error: { message, code },
+    };
+}
+/**
+ * Create success response
+ */
+export function createSuccessResponse(id, result) {
+    return {
+        type: "response",
+        id,
+        result,
+    };
+}
+/**
+ * Create event message
+ */
+export function createEvent(event, payload) {
+    return {
+        type: "event",
+        event,
+        payload,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { loadSkillsFromDir, loadSkillsFromPaths, formatSkillsForPrompt, type Skill, type LoadSkillsFromDirOptions, } from "./agent/skills.js";
+export { run, type RunOptions, type RunResult } from "./agent/run.js";
+export { getOpenbotAgentDir, ensureDefaultAgentDir } from "./agent/agent-dir.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export { loadSkillsFromDir, loadSkillsFromPaths, formatSkillsForPrompt, } from "./agent/skills.js";
+export { run } from "./agent/run.js";
+export { getOpenbotAgentDir, ensureDefaultAgentDir } from "./agent/agent-dir.js";

package/dist/memory/build-summary.d.ts

@@ -0,0 +1,6 @@
+import { type SessionEntry } from "@mariozechner/pi-coding-agent";
+/**
+ * 从 session entries 中提取可用于存入向量库的摘要文本：
+ * 优先使用最新 compaction 的 summary，否则用最近若干条消息拼成短文。
+ */
+export declare function buildSessionSummaryFromEntries(entries: SessionEntry[]): string | null;

package/dist/memory/build-summary.js

@@ -0,0 +1,27 @@
+import { getLatestCompactionEntry, } from "@mariozechner/pi-coding-agent";
+import { convertToLlm } from "@mariozechner/pi-coding-agent";
+/**
+ * 从 session entries 中提取可用于存入向量库的摘要文本：
+ * 优先使用最新 compaction 的 summary，否则用最近若干条消息拼成短文。
+ */
+export function buildSessionSummaryFromEntries(entries) {
+    const compaction = getLatestCompactionEntry(entries);
+    if (compaction?.summary) {
+        return compaction.summary;
+    }
+    const messageEntries = entries.filter((e) => e.type === "message");
+    if (messageEntries.length === 0)
+        return null;
+    const recent = messageEntries.slice(-20);
+    const messages = recent.map((e) => e.message);
+    const parts = [];
+    for (const msg of convertToLlm(messages)) {
+        const role = msg.role === "user" ? "User" : "Assistant";
+        const content = typeof msg.content === "string"
+            ? msg.content
+            : msg.content?.map((c) => c.text ?? "").join(" ") ?? "";
+        if (content.trim())
+            parts.push(`${role}: ${content.trim()}`);
+    }
+    return parts.length > 0 ? parts.join("\n") : null;
+}

package/dist/memory/compaction-extension.d.ts

@@ -0,0 +1,6 @@
+import type { ExtensionFactory } from "@mariozechner/pi-coding-agent";
+/**
+ * 创建用于在 session_compact 事件时把 compaction summary 写入向量库的 extension factory。
+ * 在 AgentSession 发生 compaction（自动或手动）后触发，无需等到关闭会话。
+ */
+export declare function createCompactionMemoryExtensionFactory(sessionId: string): ExtensionFactory;

package/dist/memory/compaction-extension.js

@@ -0,0 +1,23 @@
+import { addMemory } from "./index.js";
+/**
+ * 创建用于在 session_compact 事件时把 compaction summary 写入向量库的 extension factory。
+ * 在 AgentSession 发生 compaction（自动或手动）后触发，无需等到关闭会话。
+ */
+export function createCompactionMemoryExtensionFactory(sessionId) {
+    return (pi) => {
+        pi.on("session_compact", async (event) => {
+            const summary = event.compactionEntry?.summary?.trim();
+            if (!summary)
+                return;
+            try {
+                await addMemory(summary, {
+                    infotype: "compaction",
+                    sessionId,
+                });
+            }
+            catch (_) {
+                // 写入失败不打断会话
+            }
+        });
+    };
+}

package/dist/memory/embedding.d.ts

@@ -0,0 +1,10 @@
+export declare function getEmbedder(): Promise<(input: string, opts?: {
+    pooling?: string;
+    normalize?: boolean;
+}) => Promise<{
+    data: Float32Array;
+}>>;
+/**
+ * 对单条文本做 embedding，mean pooling + L2 归一化
+ */
+export declare function embed(text: string): Promise<number[]>;

package/dist/memory/embedding.js

@@ -0,0 +1,22 @@
+/// <reference path="./vendor.d.ts" />
+import { pipeline } from "@xenova/transformers";
+/** 多语言小模型，中英文表现较好，适合语义检索 */
+const MODEL = "Xenova/paraphrase-multilingual-MiniLM-L12-v2";
+let embedder = null;
+export async function getEmbedder() {
+    if (!embedder) {
+        embedder = await pipeline("feature-extraction", MODEL, { quantized: true });
+    }
+    return embedder;
+}
+/**
+ * 对单条文本做 embedding，mean pooling + L2 归一化
+ */
+export async function embed(text) {
+    const ext = await getEmbedder();
+    const out = await ext(text, {
+        pooling: "mean",
+        normalize: true,
+    });
+    return Array.from(out.data);
+}

package/dist/memory/index.d.ts

@@ -0,0 +1,29 @@
+import type { InfoType, MemorySearchResult } from "./types.js";
+export { buildSessionSummaryFromEntries } from "./build-summary.js";
+export type { InfoType, MemoryMetadata, MemorySearchResult } from "./types.js";
+export declare function initMemory(): Promise<void>;
+/**
+ * 将一条文本写入向量库
+ * @param text 内容
+ * @param metadata.infotype 经验总结(experience) 或 compaction 摘要(compaction)
+ * @param metadata.sessionId 会话 id
+ */
+export declare function addMemory(text: string, metadata: {
+    infotype: InfoType;
+    sessionId: string;
+}): Promise<string>;
+export interface SearchMemoryOptions {
+    topK?: number;
+    infotype?: import("./types.js").InfoType;
+    sessionId?: string;
+}
+/**
+ * 按语义搜索记忆，可按 infotype、sessionId 过滤
+ */
+export declare function searchMemory(query: string, topK?: number, options?: SearchMemoryOptions): Promise<MemorySearchResult[]>;
+/** 拉取 3 条经验，格式化为「经验内容」文本（用于拼入用户消息） */
+export declare function getExperienceContextForUserMessage(): Promise<string>;
+/**
+ * 拉取 1 条 compaction 摘要，用于拼入 system prompt（新建 AgentSession 时调用，可选 sessionId）
+ */
+export declare function getCompactionContextForSystemPrompt(sessionId?: string): Promise<string>;

package/dist/memory/index.js

@@ -0,0 +1,66 @@
+import { randomUUID } from "node:crypto";
+import { embed } from "./embedding.js";
+import { addToStore, queryStore } from "./vector-store.js";
+export { buildSessionSummaryFromEntries } from "./build-summary.js";
+let initialized = false;
+export async function initMemory() {
+    if (initialized)
+        return;
+    const { getChroma } = await import("./vector-store.js");
+    await getChroma();
+    initialized = true;
+}
+/**
+ * 将一条文本写入向量库
+ * @param text 内容
+ * @param metadata.infotype 经验总结(experience) 或 compaction 摘要(compaction)
+ * @param metadata.sessionId 会话 id
+ */
+export async function addMemory(text, metadata) {
+    const id = randomUUID();
+    const vec = await embed(text);
+    const meta = {
+        ...metadata,
+        createdAt: new Date().toISOString(),
+    };
+    await addToStore(id, vec, text, meta);
+    return id;
+}
+/**
+ * 按语义搜索记忆，可按 infotype、sessionId 过滤
+ */
+export async function searchMemory(query, topK = 10, options) {
+    const opts = typeof options === "object" && options != null ? options : {};
+    const k = opts.topK ?? topK;
+    const filter = opts.infotype != null || opts.sessionId != null
+        ? { infotype: opts.infotype, sessionId: opts.sessionId }
+        : undefined;
+    const vec = await embed(query);
+    const rows = await queryStore(vec, k, filter);
+    return rows.map((r) => ({
+        document: r.document,
+        metadata: r.metadata,
+        distance: r.distance,
+    }));
+}
+/** 拉取 3 条经验，格式化为「经验内容」文本（用于拼入用户消息） */
+export async function getExperienceContextForUserMessage() {
+    const results = await searchMemory("经验 总结 技巧 方法", 3, { infotype: "experience" });
+    if (results.length === 0)
+        return "";
+    const lines = results.map((r, i) => `${i + 1}. ${(r.document || "").trim()}`).filter(Boolean);
+    if (lines.length === 0)
+        return "";
+    return "以下为相关经验：\n\n" + lines.join("\n\n");
+}
+/**
+ * 拉取 1 条 compaction 摘要，用于拼入 system prompt（新建 AgentSession 时调用，可选 sessionId）
+ */
+export async function getCompactionContextForSystemPrompt(sessionId) {
+    const filter = sessionId != null ? { infotype: "compaction", sessionId } : { infotype: "compaction" };
+    const results = await searchMemory("对话 摘要 历史 上下文", 1, { ...filter, topK: 1 });
+    const doc = results[0]?.document?.trim();
+    if (!doc)
+        return "";
+    return "## 历史对话摘要\n\n" + doc;
+}

package/dist/memory/types.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 长记忆 metadata 中的信息类型
+ * - experience: 对话结束时 Agent 调用 save_experience 工具存入的经验总结
+ * - compaction: 关闭 session 时从 compaction 取出的会话摘要
+ */
+export type InfoType = "experience" | "compaction";
+export interface MemoryMetadata {
+    infotype: InfoType;
+    sessionId: string;
+    createdAt: string;
+}
+export interface MemorySearchResult {
+    document: string;
+    metadata: MemoryMetadata;
+    distance?: number;
+}

package/dist/memory/types.js

@@ -0,0 +1 @@
+export {};