orbitx 0.0.1 → 0.0.2

package/src/core/mcp-ipc-connection.ts

@@ -0,0 +1,153 @@
+import * as net from "net";
+import * as fs from "fs";
+import MCPConnection from "./mcp-connection";
+
+type Role = "server" | "client" | "pending";
+
+export class MCPIPCConnection extends MCPConnection {
+    private readonly socketPath: string;
+    private socket: net.Socket | null = null;
+    private server: net.Server | null = null;
+    private role: Role = "pending";
+    private writeBuffer: Buffer[] = [];
+    private readBuffer = "";
+
+    constructor(socketPath: string) {
+        super(true);
+        this.socketPath = socketPath;
+
+        this.on("write", (data: unknown) => {
+            this._sendJSON(data);
+        });
+
+        setTimeout(() => {
+            this._tryConnect();
+        }, Math.random() * 200); // Pervent Race Condtion
+    }
+
+    close(): void {
+        this.socket?.destroy();
+        this.server?.close();
+        this._cleanSocketFile();
+    }
+
+    private _tryConnect(): void {
+        const sock = net.createConnection({ path: this.socketPath });
+
+        sock.once("connect", () => {
+            this.role = "client";
+            this.emit("role", "client");
+            this._attachSocket(sock);
+        });
+
+        sock.once("error", (err: NodeJS.ErrnoException) => {
+            if (err.code === "ENOENT" || err.code === "ECONNREFUSED") {
+                sock.destroy();
+                this._becomeServer();
+            } else {
+                this.emit("error", err);
+            }
+        });
+    }
+
+    private _becomeServer(): void {
+        this._cleanSocketFile();
+
+        const srv = net.createServer((peer) => {
+            this.role = "server";
+            this.emit("role", "server");
+
+            srv.close();
+
+            this._attachSocket(peer);
+        });
+
+        srv.on("error", (err) => this.emit("error", err));
+
+        srv.listen({ path: this.socketPath }, () => {
+            this.server = srv;
+            this.emit("listening", this.socketPath);
+        });
+    }
+
+    private _attachSocket(sock: net.Socket): void {
+        this.socket = sock;
+
+        for (const chunk of this.writeBuffer) {
+            sock.write(chunk);
+        }
+        this.writeBuffer = [];
+
+        sock.setEncoding("utf8");
+
+        sock.on("data", (chunk: string) => {
+            this._handleIncoming(chunk);
+        });
+
+        sock.on("end", () => {
+            this.emit("disconnected");
+            this._maybeReconnect();
+        });
+
+        sock.on("error", (err: NodeJS.ErrnoException) => {
+            this.emit("error", err);
+        });
+
+        this.emit("connected", this.role);
+    }
+
+    private _sendJSON(data: unknown): void {
+        let line: string;
+        try {
+            line = JSON.stringify(data) + "\n";
+        } catch (err) {
+            this.emit("error", new Error(`MCPIPCConnection: cannot serialise data – ${err}`));
+            return;
+        }
+
+        const chunk = Buffer.from(line, "utf8");
+
+        if (this.socket && !this.socket.destroyed) {
+            this.socket.write(chunk);
+        } else {
+            this.writeBuffer.push(chunk);
+        }
+    }
+
+    private _handleIncoming(chunk: string): void {
+        this.readBuffer += chunk;
+
+        const lines = this.readBuffer.split("\n");
+
+        this.readBuffer = lines.pop() ?? "";
+
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed) continue;
+
+            try {
+                const parsed = JSON.parse(trimmed);
+                this.emit("read", parsed);
+            } catch {
+                this.emit("error", new Error(`MCPIPCConnection: malformed JSON – ${trimmed}`));
+            }
+        }
+    }
+
+    private _cleanSocketFile(): void {
+        try {
+            fs.unlinkSync(this.socketPath);
+        } catch { }
+    }
+
+    private _maybeReconnect(): void {
+        if (this.role === "client") {
+            setTimeout(() => {
+                this.role = "pending";
+                this._tryConnect();
+            }, 500);
+        }
+    }
+}
+
+export default MCPIPCConnection;

package/src/core/mcp-server.ts

@@ -0,0 +1,49 @@
+import type MCPTool from "./mcp";
+import type MCPConnection from "./mcp-connection";
+
+export class MCPServer {
+    #connection;
+    #tools: MCPTool[] = [];
+    constructor(connection: MCPConnection) {
+        this.#connection = connection;
+        this.#connection.on("read", (data: any) => {
+            const topic = data.topic;
+            const pid = data.pid;
+            if (topic == "getTools") {
+                this.#connection.emit("write", {
+                    pid,
+                    topic: "getToolsCallback",
+                    tools: this.#tools.map(tool => ({
+                        name: tool.getOptions().name,
+                        description: tool.getOptions().description,
+                        inputs: tool.getOptions().inputs
+                    }))
+                });
+            }
+            if (topic == "toolCall") {
+                const tool = this.#tools.find(t => t.getOptions().name == data.tool);
+                if (tool) {
+                    tool.getOptions().execute(data.envID, data.inputs).then((response) => {
+                        this.#connection.emit("write", {
+                            pid,
+                            topic: "toolCallCallback",
+                            output: response
+                        });
+                    }).catch(error => {
+                        this.#connection.emit("write", {
+                            pid,
+                            topic: "toolCallCallback",
+                            output: { error: error.message }
+                        });
+                    });
+                }
+            }
+        });
+    }
+
+    registerTool(tool: MCPTool) {
+        this.#tools.push(tool);
+    }
+}
+
+export default MCPServer;

package/src/core/mcp.ts

@@ -0,0 +1,23 @@
+export class MCPTool {
+    #options;
+    constructor(options: {
+        name: string;
+        description: string;
+        inputs: {
+            name: string;
+            type: "number" | "string" | "boolean" | "object" | "array";
+            description: string;
+            required?: boolean;
+            default?: any;
+        }[];
+        execute: (envID: string, inputs: Record<string, any>) => Promise<any>;
+    }) {
+        this.#options = options;
+    }
+
+    getOptions() {
+        return this.#options;
+    }
+}
+
+export default MCPTool;

package/src/core/ollama-provider.ts

@@ -0,0 +1,70 @@
+import { Ollama } from "ollama";
+import AIProvider, { type Message, type ChatResponse, type StreamCallback } from "./ai-provider";
+
+export class OllamaProvider extends AIProvider {
+    private client: Ollama;
+    private model: string;
+
+    constructor(model: string, host: string = "http://localhost:11434") {
+        super();
+        this.client = new Ollama({ host });
+        this.model = model;
+    }
+
+    async chat(
+        messages: Message[],
+        streamCallback?: StreamCallback
+    ): Promise<ChatResponse> {
+        const formattedMessages = messages.map(msg => ({
+            role: msg.role,
+            content: msg.content || ""
+        }));
+
+        if (streamCallback) {
+            const stream = await this.client.chat({
+                model: this.model,
+                messages: formattedMessages as any,
+                stream: true
+            });
+
+            let fullContent = "";
+            let promptEvalCount = 0;
+            let evalCount = 0;
+
+            for await (const chunk of stream) {
+                const content = chunk.message?.content || "";
+                if (content) {
+                    fullContent += content;
+                    streamCallback({ role: "assistant", content, done: false });
+                }
+
+                if (chunk.prompt_eval_count !== undefined) {
+                    promptEvalCount = chunk.prompt_eval_count;
+                }
+                if (chunk.eval_count !== undefined) {
+                    evalCount = chunk.eval_count;
+                }
+            }
+
+            streamCallback({ role: "assistant", content: "", done: true });
+            return {
+                content: fullContent,
+                inputTokens: promptEvalCount,
+                outputTokens: evalCount
+            };
+        } else {
+            const response = await this.client.chat({
+                model: this.model,
+                messages: formattedMessages as any
+            });
+
+            return {
+                content: response.message?.content || "",
+                inputTokens: response.prompt_eval_count || 0,
+                outputTokens: response.eval_count || 0
+            };
+        }
+    }
+}
+
+export default OllamaProvider;

package/src/core/skill.ts

@@ -0,0 +1,16 @@
+export class Skill {
+    #skill;
+    constructor(skill: {
+        name: string;
+        description: string;
+        instructions: string;
+    }) {
+        this.#skill = skill;
+    }
+
+    getSkill() {
+        return this.#skill;
+    }
+}
+
+export default Skill;

package/src/index.ts

@@ -0,0 +1,17 @@
+export { AIProvider } from "./core/ai-provider";
+export { BaseAgent } from "./core/base-agent";
+export { DeepSeekProvider } from "./core/deepseek-provider";
+export { MCPClient } from "./core/mcp-client";
+export { MCPConnection } from "./core/mcp-connection";
+export { MCPIPCConnection } from "./core/mcp-ipc-connection";
+export { MCPServer } from "./core/mcp-server";
+export { MCPTool } from "./core/mcp";
+export { OllamaProvider } from "./core/ollama-provider";
+export { Skill } from "./core/skill";
+
+export { ResearcherAgent } from "./templates/researcher";
+export { SimpleAgent } from "./templates/simple";
+
+export { ReadFileTool, WriteFileTool } from "./tools/fs";
+export { GetCurrentTimeTool } from "./tools/utils";
+export { FetchTool, ReadWebPageTool, WebSearchTool } from "./tools/www";

package/src/templates/researcher.ts

@@ -0,0 +1,73 @@
+import type { Message } from "../core/ai-provider";
+import type AIProvider from "../core/ai-provider";
+import BaseAgent from "../core/base-agent";
+import type MCPTool from "../core/mcp";
+import MCPClient from "../core/mcp-client";
+import MCPConnection from "../core/mcp-connection";
+import MCPServer from "../core/mcp-server";
+import type Skill from "../core/skill";
+import { ReadWebPageTool, WebSearchTool } from "../tools/www";
+
+export class ResearcherAgent extends BaseAgent {
+    constructor({
+        aiProvider,
+        instruction = `you are research agent you have some rules you don't know about any true otherwise first search about it
+your each topic search iteration contain two step
+1. use web-search tool to get some urls from search engine
+2. read 4 url with best topic near to out search query in this step you execute 4 read-web-page tool call at once
+if result is resolve needs we stop otherwise do above operation more
+YOU MUST DO two step before decide to response don't do web-search alone!! at less do search and read page operation 3 times to to get as much information as possible`,
+        tools = [
+            WebSearchTool,
+            ReadWebPageTool
+        ],
+        skills = [],
+        maxMemorizeToken = 30000,
+        initData = {
+            memory: "",
+            messagesFull: [],
+            fullInputMissTokens: 0,
+            fullInputHitTokens: 0,
+            fullOutputTokens: 0,
+            messagesCompact: [],
+            currentInputMissTokens: 0,
+            currentInputHitTokens: 0,
+            currentOutputTokens: 0,
+        }
+    }: {
+        instruction?: string;
+        tools?: MCPTool[];
+        aiProvider: AIProvider;
+        skills?: Skill[];
+        maxMemorizeToken?: number;
+        initData?: {
+            memory: string;
+            messagesFull: Message[];
+            fullInputMissTokens: number;
+            fullInputHitTokens: number;
+            fullOutputTokens: number;
+            messagesCompact: Message[];
+            currentInputMissTokens: number;
+            currentInputHitTokens: number;
+            currentOutputTokens: number;
+        }
+    }) {
+        const conn = new MCPConnection();
+        const mcpServer = new MCPServer(conn);
+        tools.forEach(tool => {
+            mcpServer.registerTool(tool);
+        });
+        const mcpClient = new MCPClient("DEFAULT_ENV", conn);
+        super({
+            aiProvider,
+            instruction,
+            mcpClient,
+            allowedTools: tools,
+            skills,
+            maxMemorizeToken,
+            initData,
+        });
+    }
+}
+
+export default ResearcherAgent;

package/src/templates/simple.ts

@@ -0,0 +1,64 @@
+import type { Message } from "../core/ai-provider";
+import type AIProvider from "../core/ai-provider";
+import BaseAgent from "../core/base-agent";
+import type MCPTool from "../core/mcp";
+import MCPClient from "../core/mcp-client";
+import MCPConnection from "../core/mcp-connection";
+import MCPServer from "../core/mcp-server";
+import type Skill from "../core/skill";
+
+export class SimpleAgent extends BaseAgent {
+    constructor({
+        aiProvider,
+        instruction = "",
+        tools = [],
+        skills = [],
+        maxMemorizeToken = 16000,
+        initData = {
+            memory: "",
+            messagesFull: [],
+            fullInputMissTokens: 0,
+            fullInputHitTokens: 0,
+            fullOutputTokens: 0,
+            messagesCompact: [],
+            currentInputMissTokens: 0,
+            currentInputHitTokens: 0,
+            currentOutputTokens: 0,
+        }
+    }: {
+        instruction: string;
+        tools: MCPTool[];
+        aiProvider: AIProvider;
+        skills?: Skill[];
+        maxMemorizeToken?: number;
+        initData?: {
+            memory: string;
+            messagesFull: Message[];
+            fullInputMissTokens: number;
+            fullInputHitTokens: number;
+            fullOutputTokens: number;
+            messagesCompact: Message[];
+            currentInputMissTokens: number;
+            currentInputHitTokens: number;
+            currentOutputTokens: number;
+        }
+    }) {
+        const conn = new MCPConnection();
+        const mcpServer = new MCPServer(conn);
+        tools.forEach(tool => {
+            mcpServer.registerTool(tool);
+        });
+        const mcpClient = new MCPClient("DEFAULT_ENV", conn);
+        super({
+            aiProvider,
+            instruction,
+            mcpClient,
+            allowedTools: tools,
+            skills,
+            maxMemorizeToken,
+            initData,
+        });
+    }
+}
+
+export default SimpleAgent;

package/src/tests/mcp.test.ts

@@ -0,0 +1,73 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import os from "os";
+import MCPIPCConnection from "../core/mcp-ipc-connection";
+import MCPServer from "../core/mcp-server";
+import MCPClient from "../core/mcp-client";
+import { GetCurrentTimeTool } from "../tools/utils";
+import { FetchTool, WebSearchTool } from "../tools/www";
+
+describe("MCP Client and Server", async () => {
+    const path1 = os.platform() == "win32" ? `\\\\.\\pipe\\test${Math.random() * 1000}` : `/tmp/mcp_test${Math.random() * 1000}.sock`;
+    const path2 = os.platform() == "win32" ? `\\\\.\\pipe\\test${Math.random() * 1000}` : `/tmp/mcp_test${Math.random() * 1000}.sock`;
+
+    const ipcConnection11 = new MCPIPCConnection(path1);
+    const ipcConnection21 = new MCPIPCConnection(path2);
+
+    const ipcConnection12 = new MCPIPCConnection(path1);
+    const ipcConnection22 = new MCPIPCConnection(path2);
+
+    let mcpServer1: MCPServer;
+    let mcpServer2: MCPServer;
+    let mcpClient: MCPClient;
+
+    await test("should connect MCP Client to Servers and get empty tools", async () => {
+        mcpServer1 = new MCPServer(ipcConnection11);
+        mcpServer2 = new MCPServer(ipcConnection21);
+        mcpClient = new MCPClient("DEFAULT_ENV", [ipcConnection12, ipcConnection22]);
+        const result = await mcpClient.getTools();
+        assert.equal(result.length, 0);
+    });
+
+    await test("should register tool on client side", async () => {
+        mcpClient.registerTool(GetCurrentTimeTool);
+        const result = await mcpClient.getTools();
+
+        assert.equal(result.length, 1);
+    });
+
+    await test("should register tool on server1 side", async () => {
+        mcpServer1.registerTool(FetchTool);
+        const result = await mcpClient.getTools();
+
+        assert.equal(result.length, 2);
+    });
+
+    await test("should register tool on server2 side", async () => {
+        mcpServer2.registerTool(WebSearchTool);
+        const result = await mcpClient.getTools();
+
+        assert.equal(result.length, 3);
+    });
+
+    await test("should call tool on client side", async () => {
+        const result = await mcpClient.callTool(GetCurrentTimeTool.getOptions().name, {});
+
+        assert.ok(typeof result == "string");
+    });
+
+    await test("should call tool on server1 side", async () => {
+        const result = await mcpClient.callTool(FetchTool.getOptions().name, { url: "https://google.com" });
+
+        assert.ok(typeof result == "string");
+    });
+
+    await test("should call tool on server2 side", async () => {
+        const result = await mcpClient.callTool(WebSearchTool.getOptions().name, { query: "test" });
+
+        assert.ok(typeof result == "string");
+    });
+
+
+    // Need Close Connections
+});

package/src/tools/fs/index.ts

@@ -0,0 +1,2 @@
+export { ReadFileTool } from "./read-file";
+export { WriteFileTool } from "./write-file";

package/src/tools/fs/read-file.ts

@@ -0,0 +1,54 @@
+import MCPTool from "../../core/mcp";
+import fs from "fs/promises";
+import path from "path";
+
+export const ReadFileTool = new MCPTool({
+    name: "read-file",
+    description: "Reads text content from a file at the specified path.",
+    inputs: [{
+        name: "filePath",
+        type: "string",
+        description: `Absolute or relative path to the file (e.g., "/home/user/doc.txt" or "./file.txt")`,
+        required: true,
+    }],
+    execute: async (_: string, inputs: Record<string, any>): Promise<any> => {
+        try {
+            const { filePath } = inputs;
+
+            if (!filePath || typeof filePath !== "string") {
+                throw new Error("filePath must be a non-empty string");
+            }
+
+            const normalizedPath = path.normalize(filePath);
+
+            const data = await fs.readFile(normalizedPath, "utf-8");
+
+            return {
+                message: `File read successfully: ${normalizedPath}`,
+                path: normalizedPath,
+                content: data,
+                size: data.length
+            };
+
+        } catch (error) {
+            let errorMessage = error instanceof Error ? error.message : String(error);
+
+            if (error instanceof Error && "code" in error) {
+                const err = error as NodeJS.ErrnoException;
+                if (err.code === "ENOENT") {
+                    errorMessage = `File not found: ${inputs.filePath}`;
+                } else if (err.code === "EACCES") {
+                    errorMessage = `Permission denied: ${inputs.filePath}`;
+                } else if (err.code === "EISDIR") {
+                    errorMessage = `Path is a directory, not a file: ${inputs.filePath}`;
+                }
+            }
+
+            return {
+                error: errorMessage
+            };
+        }
+    }
+});
+
+export default ReadFileTool;

package/src/tools/fs/write-file.ts

@@ -0,0 +1,73 @@
+import MCPTool from "../../core/mcp";
+import fs from "fs/promises";
+import path from "path";
+
+export const WriteFileTool = new MCPTool({
+    name: "write-file",
+    description: "Writes text content to a file at the specified path. Creates new file or overwrites existing.",
+    inputs: [{
+        name: "filePath",
+        type: "string",
+        description: `Absolute or relative path to the file (e.g., "/home/user/doc.txt" or "./file.txt")`,
+        required: true,
+    },
+    {
+        name: "data",
+        type: "string",
+        description: "Text content to write (supports multi-line)",
+        required: true,
+    }],
+    execute: async (_: string, inputs: Record<string, any>): Promise<any> => {
+        try {
+            const { filePath, data } = inputs;
+
+            if (!filePath || typeof filePath !== "string") {
+                throw new Error("filePath must be a non-empty string");
+            }
+
+            if (typeof data !== "string") {
+                throw new Error("data must be a string");
+            }
+
+            const normalizedPath = path.normalize(filePath);
+
+            const dir = path.dirname(normalizedPath);
+            await fs.mkdir(dir, { recursive: true });
+
+            await fs.writeFile(normalizedPath, data, "utf-8");
+
+            return {
+                message: `File written: ${normalizedPath}`,
+                path: normalizedPath,
+                size: data.length
+            };
+
+        } catch (error) {
+            let errorMessage = error instanceof Error ? error.message : String(error);
+
+            if (error instanceof Error && "code" in error) {
+                const err = error as NodeJS.ErrnoException;
+
+                if (err.code === "EACCES") {
+                    errorMessage = `Permission denied: Cannot write to ${inputs.filePath}`;
+                } else if (err.code === "ENOENT") {
+                    errorMessage = `Directory does not exist or cannot be created: ${path.dirname(inputs.filePath)}`;
+                } else if (err.code === "EISDIR") {
+                    errorMessage = `Path is a directory, cannot write file: ${inputs.filePath}`;
+                } else if (err.code === "ENOSPC") {
+                    errorMessage = `No space left on device: Cannot write to ${inputs.filePath}`;
+                } else if (err.code === "EROFS") {
+                    errorMessage = `Read-only file system: Cannot write to ${inputs.filePath}`;
+                } else if (err.code === "ENAMETOOLONG") {
+                    errorMessage = `File path is too long: ${inputs.filePath}`;
+                }
+            }
+
+            return {
+                error: errorMessage
+            };
+        }
+    }
+});
+
+export default WriteFileTool;