symmetry-cli 1.0.0

package/.eslintrc.js

@@ -0,0 +1,15 @@
+module.exports = {
+  parser: '@typescript-eslint/parser',
+  plugins: ['@typescript-eslint'],
+  extends: [
+    'eslint:recommended',
+    'plugin:@typescript-eslint/recommended',
+  ],
+  env: {
+    node: true,
+    jest: true,
+  },
+  rules: {
+    // You can add custom rules here
+  },
+};

package/LICENCE

@@ -0,0 +1,20 @@
+Copyright (c) 2024 Richard Macarthy (rjmacarthy)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/__test__/cli.test.ts

@@ -0,0 +1,61 @@
+import { SymmetryClient } from "../src/client";
+import yaml from "js-yaml";
+
+jest.mock("hyperswarm", () => {
+  return jest.fn().mockImplementation(() => ({
+    join: jest
+      .fn()
+      .mockReturnValue({ flushed: jest.fn().mockResolvedValue(undefined) }),
+    on: jest.fn(),
+    destroy: jest.fn().mockResolvedValue(undefined),
+    flush: jest.fn().mockResolvedValue(undefined),
+  }));
+});
+
+jest.mock("hypercore-crypto", () => ({
+  discoveryKey: jest.fn().mockReturnValue("test"),
+  keyPair: jest.fn().mockReturnValue({
+    publicKey: "test-public-key",
+    secretKey: "test-secret-key",
+  }),
+  sign: jest.fn(),
+}));
+
+jest.mock("fs", () => ({
+  readFileSync: jest.fn(),
+  writeFileSync: jest.fn(),
+  existsSync: jest.fn(),
+}));
+
+jest.mock("js-yaml", () => ({
+  load: jest.fn(),
+}));
+
+
+describe("Symmetry", () => {
+  let writer: SymmetryClient;
+  const mockConfig = {
+    path: "/test/path",
+    temperature: 1,
+    apiHostname: "test.api.com",
+    apiPort: 443,
+    apiPath: "/v1/chat",
+    apiProtocol: "https",
+    apiKey: "test-api-key",
+    apiProvider: "test-provider",
+    modelName: "test-model",
+    name: "test",
+    public: true,
+    serverKey: "test-server-key",
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    (yaml.load as jest.Mock).mockReturnValue(mockConfig);
+    writer = new SymmetryClient("mock-config.yaml");
+  });
+
+  test("init method sets up the writer correctly", async () => {
+    await writer.init();
+  });
+});

package/dist/client.js

@@ -0,0 +1,230 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SymmetryClient = void 0;
+const node_stream_1 = require("node:stream");
+const promises_1 = require("stream/promises");
+const chalk_1 = __importDefault(require("chalk"));
+const hyperswarm_1 = __importDefault(require("hyperswarm"));
+const hypercore_crypto_1 = __importDefault(require("hypercore-crypto"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const config_1 = require("./config");
+const utils_1 = require("./utils");
+const logger_1 = require("./logger");
+const constants_1 = require("./constants");
+class SymmetryClient {
+    constructor(configPath) {
+        this._conversationIndex = 0;
+        this._discoveryKey = null;
+        this._isPublic = false;
+        this._providerSwarm = null;
+        this._serverPeer = null;
+        this._challenge = null;
+        logger_1.logger.info(`🔗 Initializing client using config file: ${configPath}`);
+        this._config = new config_1.ConfigManager(configPath);
+        this._isPublic = this._config.get("public");
+    }
+    async init() {
+        this._providerSwarm = new hyperswarm_1.default();
+        const keyPair = hypercore_crypto_1.default.keyPair();
+        this._discoveryKey = hypercore_crypto_1.default.discoveryKey(keyPair.publicKey);
+        const discovery = this._providerSwarm.join(this._discoveryKey, {
+            client: true,
+            server: false,
+        });
+        await discovery.flushed();
+        this._providerSwarm.on("error", (err) => {
+            logger_1.logger.error(chalk_1.default.red("🚨 Swarm Error:"), err);
+        });
+        this._providerSwarm.on("connection", (peer) => {
+            var _a, _b;
+            (_a = this._serverPeer) === null || _a === void 0 ? void 0 : _a.write((0, utils_1.createMessage)(constants_1.serverMessageKeys.conectionSize, {
+                connections: (_b = this._providerSwarm) === null || _b === void 0 ? void 0 : _b.connections.size,
+            }));
+            logger_1.logger.info(`⚡️ New connection from peer: ${peer.rawStream.remoteHost}`);
+            this.listeners(peer);
+        });
+        logger_1.logger.info(`📁 Symmetry client initialized.`);
+        logger_1.logger.info(`🔑 Discovery key: ${this._discoveryKey.toString("hex")}`);
+        if (this._isPublic) {
+            logger_1.logger.info(chalk_1.default.white(`🔑 Server key: ${this._config.get("serverKey")}`));
+            logger_1.logger.info(chalk_1.default.white("🔗 Joining server, please wait."));
+            await this.joinServer();
+        }
+    }
+    async joinServer() {
+        const serverSwarm = new hyperswarm_1.default();
+        const serverKey = Buffer.from(this._config.get("serverKey"));
+        serverSwarm.join(hypercore_crypto_1.default.discoveryKey(serverKey), {
+            client: true,
+            server: false,
+        });
+        serverSwarm.flush();
+        serverSwarm.on("connection", (peer) => {
+            this._serverPeer = peer;
+            logger_1.logger.info(chalk_1.default.green("🔗 Connected to server."));
+            this._challenge = hypercore_crypto_1.default.randomBytes(32);
+            this._serverPeer.write((0, utils_1.createMessage)(constants_1.serverMessageKeys.challenge, {
+                challenge: this._challenge,
+            }));
+            this._serverPeer.write((0, utils_1.createMessage)(constants_1.serverMessageKeys.join, {
+                ...this._config.getAll(),
+                discoveryKey: this._discoveryKey,
+            }));
+            this._serverPeer.on("data", async (buffer) => {
+                if (!buffer)
+                    return;
+                const data = (0, utils_1.safeParseJson)(buffer.toString());
+                if (data && data.key) {
+                    switch (data.key) {
+                        case constants_1.serverMessageKeys.challenge:
+                            this.handleServerHandshake(data.data);
+                            break;
+                    }
+                }
+            });
+        });
+    }
+    getServerPublicKey(serverKeyHex) {
+        const publicKey = Buffer.from(serverKeyHex, "hex");
+        if (publicKey.length !== 32) {
+            throw new Error(`Expected a 32-byte public key, but got ${publicKey.length} bytes`);
+        }
+        return publicKey;
+    }
+    handleServerHandshake(data) {
+        if (!this._challenge) {
+            console.log("No challenge set. Cannot verify.");
+            return;
+        }
+        const serverKeyHex = this._config.get("serverKey");
+        try {
+            const publicKey = this.getServerPublicKey(serverKeyHex);
+            const signatureBuffer = Buffer.from(data.signature.data, "base64");
+            const verified = hypercore_crypto_1.default.verify(this._challenge, signatureBuffer, publicKey);
+            if (verified) {
+                logger_1.logger.info(chalk_1.default.greenBright(`✅ Verification handshake successful.`));
+            }
+            else {
+                logger_1.logger.error(`❌ Verification failed!`);
+            }
+        }
+        catch (error) {
+            console.error("Error during verification:", error);
+        }
+    }
+    heartbeat(peer) {
+        peer.write((0, utils_1.createMessage)(constants_1.serverMessageKeys.heartbeat, {
+            discoveryKey: this._discoveryKey,
+        }));
+    }
+    listeners(peer) {
+        peer.on("close", () => {
+            logger_1.logger.info(`🔌 Peer ${peer.rawStream.remoteHost} disconnected.`);
+        });
+        peer.on("data", async (buffer) => {
+            if (!buffer)
+                return;
+            const data = (0, utils_1.safeParseJson)(buffer.toString());
+            if (data && data.key) {
+                switch (data.key) {
+                    case constants_1.serverMessageKeys.newConversation:
+                        this._conversationIndex = this._conversationIndex + 1;
+                        break;
+                    case constants_1.serverMessageKeys.inference:
+                        logger_1.logger.info(`📦 Inference message received from ${peer.rawStream.remoteHost}`);
+                        await this.handleInference(data, peer);
+                        break;
+                }
+            }
+        });
+    }
+    async handleInference(data, peer) {
+        const messages = data === null || data === void 0 ? void 0 : data.data;
+        if (!messages || !messages.length)
+            return;
+        const req = this.buildStreamRequest(messages);
+        if (!req)
+            return;
+        const { requestOptions, requestBody } = req;
+        const { protocol, hostname, port, path, method, headers } = requestOptions;
+        const url = `${protocol}://${hostname}:${port}${path}`;
+        try {
+            const response = await fetch(url, {
+                method,
+                headers,
+                body: JSON.stringify(requestBody),
+            });
+            if (!response.ok) {
+                throw new Error(`Server responded with status code: ${response.status}`);
+            }
+            if (!response.body) {
+                throw new Error("Failed to get a ReadableStream from the response");
+            }
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const responseStream = node_stream_1.Readable.fromWeb(response.body);
+            const peerStream = new node_stream_1.PassThrough();
+            responseStream.pipe(peerStream);
+            let completion = "";
+            const provider = this._config.get("apiProvider");
+            const peerPipeline = (0, promises_1.pipeline)(peerStream, async function (source) {
+                for await (const chunk of source) {
+                    if (peer.writable) {
+                        completion += (0, utils_1.getChatDataFromProvider)(provider, (0, utils_1.safeParseStreamResponse)(chunk.toString()));
+                        if (!peer.write(chunk)) {
+                            await new Promise((resolve) => peer.once("drain", resolve));
+                        }
+                    }
+                    else {
+                        break;
+                    }
+                }
+            });
+            await Promise.resolve(peerPipeline);
+            if (this._config.get("dataCollectionEnabled")) {
+                this.saveCompletion(completion, peer, messages);
+            }
+        }
+        catch (error) {
+            let errorMessage = "An error occurred during inference";
+            if (error instanceof Error)
+                errorMessage = error.message;
+            logger_1.logger.error(`🚨 ${errorMessage}`);
+        }
+    }
+    async saveCompletion(completion, peer, messages) {
+        node_fs_1.default.writeFile(`${this._config.get("path")}/${peer.publicKey.toString("hex")}-${this._conversationIndex}.json`, JSON.stringify([
+            ...messages,
+            {
+                role: "assistant",
+                content: completion,
+            },
+        ]), () => {
+            logger_1.logger.info(`📝 Completion saved to file`);
+        });
+    }
+    buildStreamRequest(messages) {
+        const requestOptions = {
+            hostname: this._config.get("apiHostname"),
+            port: Number(this._config.get("apiPort")),
+            path: this._config.get("apiPath"),
+            protocol: this._config.get("apiProtocol"),
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${this._config.get("apiKey")}`,
+            },
+        };
+        const requestBody = {
+            model: this._config.get("modelName"),
+            messages: messages || undefined,
+            temperature: 1, // TODO: Make this configurable
+            stream: true,
+        };
+        return { requestOptions, requestBody };
+    }
+}
+exports.SymmetryClient = SymmetryClient;
+exports.default = SymmetryClient;

package/dist/config-manager.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigManager = void 0;
+exports.createConfigManager = createConfigManager;
+exports.createConfigManagerClient = createConfigManagerClient;
+const fs_1 = __importDefault(require("fs"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+class ConfigManager {
+    constructor(configPath) {
+        const configFile = fs_1.default.readFileSync(configPath, "utf8");
+        const loadedConfig = js_yaml_1.default.load(configFile);
+        this.config = {
+            ...loadedConfig,
+            type: "client"
+        };
+        this.validate();
+    }
+    validate() {
+        this.validateClientConfig(this.config);
+    }
+    validateClientConfig(config) {
+        const requiredFields = [
+            "apiHostname",
+            "apiPath",
+            "apiPort",
+            "apiProtocol",
+            "apiProvider",
+            "modelName",
+            "path",
+            "public",
+            "serverKey",
+        ];
+        for (const field of requiredFields) {
+            if (!(field in config)) {
+                throw new Error(`Missing required field in client configuration: ${field}`);
+            }
+        }
+        if (typeof config.public !== "boolean") {
+            throw new Error('The "public" field in client configuration must be a boolean');
+        }
+    }
+    get(key) {
+        return this.config[key];
+    }
+    isClientConfig() {
+        return this.config.type === "client";
+    }
+}
+exports.ConfigManager = ConfigManager;
+function createConfigManager(configPath) {
+    return new ConfigManager(configPath);
+}
+function createConfigManagerClient(configPath) {
+    return new ConfigManager(configPath);
+}

package/dist/config.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigManager = void 0;
+const fs_1 = __importDefault(require("fs"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+class ConfigManager {
+    constructor(configPath) {
+        const configFile = fs_1.default.readFileSync(configPath, "utf8");
+        const config = js_yaml_1.default.load(configFile);
+        this.config = config;
+        this.validate();
+    }
+    getAll() {
+        return this.config;
+    }
+    validate() {
+        const requiredFields = [
+            "apiHostname",
+            "apiPath",
+            "apiPort",
+            "apiProtocol",
+            "apiProvider",
+            "modelName",
+            "path",
+            "public",
+            "serverKey",
+        ];
+        for (const field of requiredFields) {
+            if (!(field in this.config)) {
+                throw new Error(`Missing required field in client configuration: ${field}`);
+            }
+        }
+        if (typeof this.config.public !== "boolean") {
+            throw new Error('The "public" field in client configuration must be a boolean');
+        }
+    }
+    get(key) {
+        return this.config[key];
+    }
+}
+exports.ConfigManager = ConfigManager;

package/dist/constants.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiProviders = exports.serverMessageKeys = exports.NORMALIZE_REGEX = void 0;
+exports.NORMALIZE_REGEX = /\s*\r?\n|\r/g;
+exports.serverMessageKeys = {
+    challenge: "challenge",
+    conectionSize: "conectionSize",
+    heartbeat: "heartbeat",
+    inference: "inference",
+    inferenceEnded: "inferenceEnded",
+    join: "join",
+    joinAck: "joinAck",
+    leave: "leave",
+    newConversation: "newConversation",
+    ping: "ping",
+    pong: "pong",
+    providerDetails: "providerDetails",
+    reportCompletion: "reportCompletion",
+    requestProvider: "requestProvider",
+    sessionValid: "sessionValid",
+    verifySession: "verifySession",
+};
+exports.apiProviders = {
+    LiteLLM: 'litellm',
+    LlamaCpp: 'llamacpp',
+    LMStudio: 'lmstudio',
+    Ollama: 'ollama',
+    Oobabooga: 'oobabooga',
+    OpenWebUI: 'openwebui',
+};

package/dist/database.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.database = void 0;
+const path_1 = __importDefault(require("path"));
+const sqlite3_1 = __importDefault(require("sqlite3"));
+exports.database = new sqlite3_1.default.Database(path_1.default.join(__dirname, "../sqlite.db"));

package/dist/logger.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = exports.Logger = exports.LogLevel = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const chalk_1 = __importDefault(require("chalk"));
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+    LogLevel[LogLevel["ERROR"] = 1] = "ERROR";
+    LogLevel[LogLevel["INFO"] = 2] = "INFO";
+    LogLevel[LogLevel["WARNING"] = 3] = "WARNING";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+class Logger {
+    constructor() {
+        this.logLevel = LogLevel.INFO;
+    }
+    static getInstance() {
+        if (!Logger.instance) {
+            Logger.instance = new Logger();
+        }
+        return Logger.instance;
+    }
+    setLogLevel(level) {
+        this.logLevel = level;
+    }
+    info(message, ...args) {
+        if (this.logLevel <= LogLevel.INFO) {
+            console.log(chalk_1.default.blue("ℹ️ INFO:"), message, ...args);
+        }
+    }
+    warning(message, ...args) {
+        console.log(chalk_1.default.yellow("⚠️ WARNING:"), message, ...args);
+    }
+    error(message, ...args) {
+        console.error(chalk_1.default.red("❌ ERROR:"), message, ...args);
+    }
+    debug(message, ...args) {
+        console.log(chalk_1.default.gray("🐛 DEBUG:"), message, ...args);
+    }
+}
+exports.Logger = Logger;
+exports.logger = Logger.getInstance();

package/dist/peer-repository.js

@@ -0,0 +1,114 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PeerRepository = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const database_1 = require("./database");
+const logger_1 = require("./logger");
+class PeerRepository {
+    constructor() {
+        this.db = database_1.database;
+    }
+    upsert(message) {
+        return new Promise((resolve, reject) => {
+            this.db.run(`
+        INSERT OR REPLACE INTO peers (
+          key, discovery_key, gpu_memory, model_name, public, server_key, last_seen, online
+        ) VALUES (?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP, TRUE)
+      `, [
+                message.key,
+                message.discoveryKey,
+                message.config.gpuMemory,
+                message.config.modelName,
+                message.config.public,
+                message.config.serverKey,
+            ], function (err) {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(this.lastID);
+                }
+            });
+        });
+    }
+    getByDiscoveryKey(discoveryKey) {
+        return new Promise((resolve, reject) => {
+            this.db.get("SELECT * FROM peers WHERE discovery_key = ?", [discoveryKey], (err, row) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(row);
+                }
+            });
+        });
+    }
+    getPeer(randomPeerRequest) {
+        return new Promise((resolve, reject) => {
+            const { modelName } = randomPeerRequest;
+            this.db.get(`SELECT * FROM peers WHERE model_name = ? ORDER BY RANDOM() LIMIT 1`, [modelName], (err, row) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(row);
+                }
+            });
+        });
+    }
+    updateLastSeen(peerKey) {
+        return new Promise((resolve, reject) => {
+            this.db.run("UPDATE peers SET last_seen = ?, online = FALSE WHERE key = ?", [new Date().toISOString(), peerKey], function (err) {
+                if (err) {
+                    console.error(chalk_1.default.red("❌ Error updating peer last seen in database:"), err);
+                    reject(err);
+                }
+                else {
+                    if (this.changes > 0) {
+                        logger_1.logger.info(chalk_1.default.yellow("🕒 Peer disconnected"));
+                    }
+                    else {
+                        logger_1.logger.info(chalk_1.default.yellow("⚠️ Peer not found in database"));
+                    }
+                    resolve(this.changes);
+                }
+            });
+        });
+    }
+    async getActivePeerCount() {
+        return new Promise((resolve, reject) => {
+            this.db.get("SELECT COUNT(*) as count FROM peers WHERE online = TRUE", (err, row) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(row.count);
+                }
+            });
+        });
+    }
+    async getActiveModelCount() {
+        return new Promise((resolve, reject) => {
+            this.db.get("SELECT COUNT(DISTINCT model_name) as count FROM peers WHERE online = TRUE", (err, row) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(row.count);
+                }
+            });
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    updateStats(peerKey, data) {
+        // TODO: Update stats in database
+        logger_1.logger.info(peerKey, data);
+    }
+}
+exports.PeerRepository = PeerRepository;
+module.exports = {
+    PeerRepository,
+};