@next-open-ai/openbot 0.1.8 → 0.2.1

package/dist/gateway/server.js

@@ -1,8 +1,13 @@
 /**
- * WebSocket Gateway 入口：提供 WS JSON-RPC（如 agent.chat），并代理 /server-api 到 Desktop 后端（src/server/）。
- * 与 Nest Desktop Backend 是不同进程；本进程可拉 Nest 子进程并转发请求。
+ * Gateway 单进程入口：内嵌 Nest，按 path 分流。
+ * - /server-api → Nest（业务 REST）
+ * - /ws → Agent 对话 WebSocket
+ * - /ws/voice → 语音通道（占位）
+ * - /sse → SSE（占位）
+ * - /channel → 通道模块（占位）
+ * - 其余 → 静态资源
  */
-/* Avoid MaxListenersExceededWarning: Browser Tool / Playwright attach abort listeners to same AbortSignal; Node default maxListeners is 10. */
+/* Avoid MaxListenersExceededWarning */
 const Et = globalThis.EventTarget;
 if (Et?.prototype?.addEventListener && Et.prototype.setMaxListeners) {
     const add = Et.prototype.addEventListener;
@@ -13,70 +18,26 @@ if (Et?.prototype?.addEventListener && Et.prototype.setMaxListeners) {
         return add.call(this, type, listener, options);
     };
 }
+import express from "express";
+import { createServer } from "http";
 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, dirname } from "path";
 import { fileURLToPath } from "node:url";
-import { existsSync } from "fs";
-import { spawn } from "child_process";
-import { createServer as createNetServer } from "net";
+import { PATHS } from "./paths.js";
+import { authHookServerApi, authHookChannel, authHookSse, authHookWs } from "./auth-hooks.js";
+import { handleChannel } from "./channel-handler.js";
+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 { handleInstallSkillFromPath } from "./methods/install-skill-from-path.js";
 import { setBackendBaseUrl } from "./backend-url.js";
-import { ensureDesktopConfigInitialized } from "../config/desktop-config.js";
+import { ensureDesktopConfigInitialized } from "../core/config/desktop-config.js";
+import { createNestAppEmbedded } from "../server/bootstrap.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
-/** 包根目录（dist/gateway 的上级的上级），npm 安装后静态资源在 desktop/renderer/dist */
 const PACKAGE_ROOT = join(__dirname, "..", "..");
-const STATIC_DIR = join(PACKAGE_ROOT, "desktop", "renderer", "dist");
-/**
- * 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 STATIC_DIR = join(PACKAGE_ROOT, "apps", "desktop", "renderer", "dist");
 const MIME_TYPES = {
     ".html": "text/html",
     ".js": "text/javascript",
@@ -92,137 +53,65 @@ const MIME_TYPES = {
     ".ttf": "font/ttf",
     ".eot": "application/vnd.ms-fontobject",
 };
-/**
- * Start WebSocket gateway server
- */
 export async function startGatewayServer(port = 38080) {
     await ensureDesktopConfigInitialized();
     console.log(`Starting gateway server on port ${port}...`);
-    // 1. Find available port for Desktop Server
-    const backendPort = await findAvailablePort(38081);
-    console.log(`Found available port for Desktop Server: ${backendPort}`);
-    setBackendBaseUrl(`http://localhost:${backendPort}`);
-    // 2. Start Desktop Server（从包根目录找 dist/server，npm 全局安装时也能启动）
-    let backendProcess = null;
-    const serverPath = join(PACKAGE_ROOT, "dist", "server", "main.js");
-    if (existsSync(serverPath)) {
-        console.log(`Spawning Desktop Server at ${serverPath}...`);
-        backendProcess = spawn("node", [serverPath], {
-            cwd: PACKAGE_ROOT,
-            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}`);
-            }
+    setBackendBaseUrl(`http://localhost:${port}`);
+    const { app: nestApp, express: nestExpress } = await createNestAppEmbedded();
+    const gatewayExpress = express();
+    gatewayExpress.get(PATHS.HEALTH, (_req, res) => {
+        res.status(200).json({ status: "ok", timestamp: Date.now() });
+    });
+    gatewayExpress.post(PATHS.RUN_SCHEDULED_TASK, async (req, res) => {
+        await handleRunScheduledTask(req, res);
+    });
+    gatewayExpress.post(`${PATHS.SERVER_API}/skills/install-from-path`, async (req, res) => {
+        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);
         });
-    }
-    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,
             });
-            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;
+            res.status(200).json(result);
         }
-        // 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;
+        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.status(code).json({ success: false, message });
         }
-        // Serve static files (from package root so npm install works)
+    });
+    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));
+    gatewayExpress.use(async (req, res) => {
+        const staticDir = STATIC_DIR;
+        const urlPath = req.url?.split("?")[0] || "/";
+        let filePath = join(staticDir, urlPath === "/" ? "index.html" : urlPath);
         try {
-            const staticDir = STATIC_DIR;
-            // 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
-                }
+            const stats = await stat(filePath);
+            if (stats.isDirectory()) {
+                filePath = join(filePath, "index.html");
+                await stat(filePath);
+            }
+        }
+        catch {
+            if (req.headers.accept?.includes("text/html") && req.method === "GET") {
+                filePath = join(staticDir, "index.html");
             }
-            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;
-                }
+            else {
+                res.writeHead(404, { "Content-Type": "text/plain" });
+                res.end("Not Found");
+                return;
             }
-            // Read and serve file
+        }
+        try {
             const content = await readFile(filePath);
             const ext = extname(filePath).toLowerCase();
             const contentType = MIME_TYPES[ext] || "application/octet-stream";
@@ -235,41 +124,42 @@ export async function startGatewayServer(port = 38080) {
             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);
+    const httpServer = createServer(gatewayExpress);
+    const wss = new WebSocketServer({ noServer: true });
+    wss.on("connection", (ws, req) => handleConnection(ws, req));
+    httpServer.on("upgrade", (req, socket, head) => {
+        const path = req.url?.split("?")[0] || "";
+        if (handleVoiceUpgrade(req, socket, head)) {
+            return;
+        }
+        const isAgentWs = path === PATHS.WS || path === "/";
+        if (isAgentWs && authHookWs(req, path)) {
+            wss.handleUpgrade(req, socket, head, (ws) => {
+                wss.emit("connection", ws, req);
+            });
+        }
+        else {
+            socket.destroy();
+        }
     });
-    // Start listening
-    await new Promise((resolve) => {
+    const actualPort = 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();
+            const addr = httpServer.address();
+            const p = typeof addr === "object" && addr && "port" in addr ? addr.port : port;
+            console.log(`✅ Gateway server listening on ws://localhost:${p}`);
+            console.log(`   Health: http://localhost:${p}${PATHS.HEALTH}`);
+            console.log(`   API:    http://localhost:${p}${PATHS.SERVER_API}`);
+            console.log(`   WS:     ws://localhost:${p}${PATHS.WS}`);
+            resolve(p);
         });
     });
-    // 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());
-        });
+        await nestApp.close();
+        wss.clients.forEach((c) => c.close());
+        await new Promise((r) => wss.close(() => r()));
+        await new Promise((r) => httpServer.close(() => r()));
         console.log("Gateway server closed");
     };
-    return { httpServer, wss, close };
+    return { httpServer, wss, port: actualPort, close };
 }

package/dist/gateway/sse-handler.d.ts

@@ -0,0 +1,6 @@
+/**
+ * SSE 端点（占位）。
+ * 后续：Agent 流式输出；当前返回 501 或简单说明。
+ */
+import type { Request, Response } from 'express';
+export declare function handleSse(_req: Request, res: Response): void;

package/dist/gateway/sse-handler.js

@@ -0,0 +1,3 @@
+export function handleSse(_req, res) {
+    res.status(501).setHeader('Content-Type', 'application/json').end(JSON.stringify({ ok: false, message: 'SSE endpoint not implemented yet' }));
+}

package/dist/gateway/voice-handler.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 语音通道 WebSocket（占位）。
+ * 后续：/ws/voice 建连、二进制/信令、与语音服务对接；当前仅关闭连接并返回 400 或不做 upgrade。
+ */
+import type { IncomingMessage } from 'http';
+import type { Duplex } from 'stream';
+/**
+ * 处理 /ws/voice 的 upgrade 请求（占位）。
+ * 返回 true 表示已处理（例如拒绝并关闭），调用方不必再交给 agent /ws；
+ * 返回 false 表示未处理。
+ */
+export declare function handleVoiceUpgrade(req: IncomingMessage, socket: Duplex, _head: Buffer): boolean;

package/dist/gateway/voice-handler.js

@@ -0,0 +1,18 @@
+import { PATHS } from './paths.js';
+/**
+ * 处理 /ws/voice 的 upgrade 请求（占位）。
+ * 返回 true 表示已处理（例如拒绝并关闭），调用方不必再交给 agent /ws；
+ * 返回 false 表示未处理。
+ */
+export function handleVoiceUpgrade(req, socket, _head) {
+    const path = req.url?.split('?')[0] || '';
+    if (path !== PATHS.WS_VOICE) {
+        return false;
+    }
+    socket.write('HTTP/1.1 501 Not Implemented\r\n' +
+        'Content-Type: application/json\r\n' +
+        'Connection: close\r\n\r\n' +
+        JSON.stringify({ ok: false, message: 'Voice WebSocket not implemented yet' }));
+    socket.destroy();
+    return true;
+}

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-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";
-export { resolveInstallTarget, installSkillByUrl, installSkillFromPath, type InstallByUrlOptions, type InstallByUrlResult, type InstallFromPathOptions, type InstallFromPathResult, } from "./installer/index.js";
-export { getProviderSupport, ensureProviderSupportFile, syncDesktopConfigToModelsJson, type ProviderSupport, type ProviderSupportEntry, type ProviderSupportModel, type ModelSupportType, } from "./config/desktop-config.js";
+export { loadSkillsFromDir, loadSkillsFromPaths, formatSkillsForPrompt, type Skill, type LoadSkillsFromDirOptions, } from "./core/agent/skills.js";
+export { run, type RunOptions, type RunResult } from "./core/agent/run.js";
+export { getOpenbotAgentDir, ensureDefaultAgentDir } from "./core/agent/agent-dir.js";
+export { resolveInstallTarget, installSkillByUrl, installSkillFromPath, type InstallByUrlOptions, type InstallByUrlResult, type InstallFromPathOptions, type InstallFromPathResult, } from "./core/installer/index.js";
+export { getProviderSupport, ensureProviderSupportFile, syncDesktopConfigToModelsJson, type ProviderSupport, type ProviderSupportEntry, type ProviderSupportModel, type ModelSupportType, } from "./core/config/desktop-config.js";

package/dist/index.js

@@ -1,5 +1,5 @@
-export { loadSkillsFromDir, loadSkillsFromPaths, formatSkillsForPrompt, } from "./agent/skills.js";
-export { run } from "./agent/run.js";
-export { getOpenbotAgentDir, ensureDefaultAgentDir } from "./agent/agent-dir.js";
-export { resolveInstallTarget, installSkillByUrl, installSkillFromPath, } from "./installer/index.js";
-export { getProviderSupport, ensureProviderSupportFile, syncDesktopConfigToModelsJson, } from "./config/desktop-config.js";
+export { loadSkillsFromDir, loadSkillsFromPaths, formatSkillsForPrompt, } from "./core/agent/skills.js";
+export { run } from "./core/agent/run.js";
+export { getOpenbotAgentDir, ensureDefaultAgentDir } from "./core/agent/agent-dir.js";
+export { resolveInstallTarget, installSkillByUrl, installSkillFromPath, } from "./core/installer/index.js";
+export { getProviderSupport, ensureProviderSupportFile, syncDesktopConfigToModelsJson, } from "./core/config/desktop-config.js";

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

@@ -9,7 +9,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 import { Injectable } from '@nestjs/common';
 import { randomUUID } from 'crypto';
-import { agentManager } from '../../agent/agent-manager.js';
+import { agentManager } from '../../core/agent/agent-manager.js';
 import { DatabaseService } from '../database/database.service.js';
 /**
  * Agents service: session + history storage in SQLite.

package/dist/server/bootstrap.d.ts

@@ -0,0 +1,15 @@
+import type { INestApplication } from '@nestjs/common';
+import type { Express } from 'express';
+export interface NestAppResult {
+    app: INestApplication;
+    express: Express;
+}
+/**
+ * 创建 Nest 应用（内嵌模式）：不 listen，不设置 globalPrefix。
+ * Gateway 将返回的 express 挂到 /server-api，请求路径会剥掉前缀后进入 Nest。
+ */
+export declare function createNestAppEmbedded(): Promise<NestAppResult>;
+/**
+ * 独立启动时使用：设置 globalPrefix 并监听端口。
+ */
+export declare function createNestAppStandalone(port?: number): Promise<INestApplication>;

package/dist/server/bootstrap.js

@@ -0,0 +1,38 @@
+/**
+ * Nest 应用创建：支持「内嵌到 Gateway」与「独立监听」两种模式。
+ * - 内嵌：不设置 globalPrefix、不 listen，返回 { app, express } 供 Gateway 挂载到 /server-api。
+ * - 独立：设置 globalPrefix('server-api') 并 listen(port)，用于单独启动 Desktop Server。
+ */
+import { NestFactory } from '@nestjs/core';
+import { AppModule } from './app.module.js';
+/**
+ * 创建 Nest 应用（内嵌模式）：不 listen，不设置 globalPrefix。
+ * Gateway 将返回的 express 挂到 /server-api，请求路径会剥掉前缀后进入 Nest。
+ */
+export async function createNestAppEmbedded() {
+    const app = await NestFactory.create(AppModule, {
+        cors: true,
+    });
+    app.enableCors({
+        origin: ['http://localhost:5173', 'http://localhost:38080', 'http://localhost:38081'],
+        credentials: true,
+    });
+    await app.init();
+    const express = app.getHttpAdapter().getInstance();
+    return { app, express };
+}
+/**
+ * 独立启动时使用：设置 globalPrefix 并监听端口。
+ */
+export async function createNestAppStandalone(port = 38081) {
+    const app = await NestFactory.create(AppModule, {
+        cors: true,
+    });
+    app.setGlobalPrefix('server-api');
+    app.enableCors({
+        origin: ['http://localhost:5173', 'http://localhost:38080', 'http://localhost:38081'],
+        credentials: true,
+    });
+    await app.listen(port);
+    return app;
+}

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

@@ -78,5 +78,5 @@ export declare class ConfigService {
         types?: string[];
     }[]>;
     /** 完整 provider 目录（支持列表 + 各 provider 的模型），供前端一次拉取 */
-    getProviderSupport(): Promise<import("../../config/provider-support-default.js").ProviderSupport>;
+    getProviderSupport(): Promise<import("../../core/config/provider-support-default.js").ProviderSupport>;
 }

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

@@ -11,7 +11,7 @@ import { Injectable } from '@nestjs/common';
 import { readFile, writeFile, mkdir } from 'fs/promises';
 import { join } from 'path';
 import { existsSync } from 'fs';
-import { getProviderSupport, syncDesktopConfigToModelsJson } from '../../config/desktop-config.js';
+import { getProviderSupport, syncDesktopConfigToModelsJson } from '../../core/config/desktop-config.js';
 import { AgentConfigService } from '../agent-config/agent-config.service.js';
 let ConfigService = class ConfigService {
     agentConfigService;

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

@@ -1,10 +1,18 @@
-import { OnModuleDestroy } from '@nestjs/common';
-import Database from 'better-sqlite3';
-export declare class DatabaseService implements OnModuleDestroy {
-    private db;
-    getDb(): Database.Database;
+import { OnModuleDestroy, OnModuleInit } from '@nestjs/common';
+/** RunResult compatible with better-sqlite3 for callers that use .changes / .lastInsertRowid */
+export interface RunResult {
+    changes: number;
+    lastInsertRowid: number;
+}
+export declare class DatabaseService implements OnModuleInit, OnModuleDestroy {
+    private sqlDb;
+    private dbPath;
+    private initPromise;
+    onModuleInit(): Promise<void>;
+    private doInit;
+    private getDb;
     private runMigrations;
-    run(sql: string, params?: unknown[]): Database.RunResult;
+    run(sql: string, params?: unknown[]): RunResult;
     get<T>(sql: string, params?: unknown[]): T | undefined;
     all<T>(sql: string, params?: unknown[]): T[];
     onModuleDestroy(): void;