symmetry-cli 1.0.6 → 1.0.7

package/__test__/cli.test.ts

@@ -45,7 +45,7 @@ describe("Symmetry", () => {
     apiProvider: "test-provider",
     modelName: "test-model",
     name: "test",
-    public: true,
+    public: false,
     serverKey: "test-server-key",
     systemMessage: "test-system-message",
   };

package/dist/constants.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.apiProviders = exports.serverMessageKeys = exports.NORMALIZE_REGEX = void 0;
+exports.apiProviders = exports.serverMessageKeys = exports.PROVIDER_HELLO_TIMEOUT = exports.NORMALIZE_REGEX = void 0;
 exports.NORMALIZE_REGEX = /\s*\r?\n|\r/g;
+exports.PROVIDER_HELLO_TIMEOUT = 15000;
 exports.serverMessageKeys = {
     challenge: "challenge",
     conectionSize: "conectionSize",

package/dist/provider.js

@@ -22,6 +22,7 @@ class SymmetryProvider {
         this._isPublic = false;
         this._providerConnections = 0;
         this._providerSwarm = null;
+        this._serverSwarm = null;
         this._serverPeer = null;
         logger_1.logger.info(`🔗 Initializing client using config file: ${configPath}`);
         this._config = new config_1.ConfigManager(configPath);
@@ -50,7 +51,7 @@ class SymmetryProvider {
         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."));
-            this.testProviderCall();
+            this.joinServer();
         }
         process.on("SIGINT", async () => {
             var _a;
@@ -63,62 +64,74 @@ class SymmetryProvider {
             }
         });
     }
+    async destroySwarms() {
+        var _a, _b;
+        await ((_a = this._providerSwarm) === null || _a === void 0 ? void 0 : _a.destroy());
+        await ((_b = this._serverSwarm) === null || _b === void 0 ? void 0 : _b.destroy());
+    }
     async testProviderCall() {
-        logger_1.logger.info(chalk_1.default.white(`👋 Saying hello to your provider...`));
-        const testMessages = [
-            { role: "user", content: "Hello, this is a test message." },
-        ];
-        const req = this.buildStreamRequest(testMessages);
-        if (!req) {
-            logger_1.logger.error(chalk_1.default.red("❌ Failed to build test request"));
-            throw new Error("Failed to build test request");
-        }
-        const { requestOptions, requestBody } = req;
-        const { protocol, hostname, port, path, method, headers } = requestOptions;
-        const url = `${protocol}://${hostname}:${port}${path}`;
-        logger_1.logger.info(chalk_1.default.white(`🚀 Sending test request to ${url}`));
-        try {
-            const response = await fetch(url, {
-                method,
-                headers,
-                body: JSON.stringify(requestBody),
-            });
-            if (!response.ok) {
-                logger_1.logger.error(chalk_1.default.red(`❌ Server responded with status code: ${response.status}`));
-                throw new Error(`Server responded with status code: ${response.status}`);
+        const testCall = async () => {
+            logger_1.logger.info(chalk_1.default.white(`👋 Saying hello to your provider...`));
+            const testMessages = [
+                { role: "user", content: "Hello, this is a test message." },
+            ];
+            const req = this.buildStreamRequest(testMessages);
+            if (!req) {
+                logger_1.logger.error(chalk_1.default.red("❌ Failed to build test request"));
+                throw new Error("Failed to build test request");
             }
-            if (!response.body) {
-                logger_1.logger.error(chalk_1.default.red("❌ Failed to get a ReadableStream from the response"));
-                throw new Error("Failed to get a ReadableStream from the response");
+            const { requestOptions, requestBody } = req;
+            const { protocol, hostname, port, path, method, headers } = requestOptions;
+            const url = `${protocol}://${hostname}:${port}${path}`;
+            logger_1.logger.info(chalk_1.default.white(`🚀 Sending test request to ${url}`));
+            try {
+                const response = await fetch(url, {
+                    method,
+                    headers,
+                    body: JSON.stringify(requestBody),
+                });
+                if (!response.ok) {
+                    logger_1.logger.error(chalk_1.default.red(`❌ Server responded with status code: ${response.status}`));
+                    this.destroySwarms();
+                    throw new Error(`Server responded with status code: ${response.status}`);
+                }
+                if (!response.body) {
+                    logger_1.logger.error(chalk_1.default.red("❌ Failed to get a ReadableStream from the response"));
+                    this.destroySwarms();
+                    throw new Error("Failed to get a ReadableStream from the response");
+                }
+                logger_1.logger.info(chalk_1.default.white(`📡 Got response, checking stream...`));
+                const reader = response.body.getReader();
+                const { done } = await reader.read();
+                if (done) {
+                    logger_1.logger.error(chalk_1.default.red("❌ Stream ended without data"));
+                    this.destroySwarms();
+                    throw new Error("Stream ended without data");
+                }
+                logger_1.logger.info(chalk_1.default.green(`✅ Test inference call successful!`));
             }
-            logger_1.logger.info(chalk_1.default.white(`📡 Got response, checking stream...`));
-            const reader = response.body.getReader();
-            const { done } = await reader.read();
-            if (done) {
-                logger_1.logger.error(chalk_1.default.red("❌ Stream ended without data"));
-                throw new Error("Stream ended without data");
+            catch (error) {
+                this.destroySwarms();
+                logger_1.logger.error(chalk_1.default.red(`❌ Error during test inference call: ${error}`));
+                throw error;
             }
-            logger_1.logger.info(chalk_1.default.green(`✅ Test inference call successful!`));
-        }
-        catch (error) {
-            logger_1.logger.error(chalk_1.default.red(`❌ Error during test inference call: ${error}`));
-            throw error;
-        }
-        logger_1.logger.info(chalk_1.default.white(`🔗 Proceeding to join server...`));
-        await this.joinServer();
+            logger_1.logger.info(chalk_1.default.white(`🔗 Test call successful!`));
+        };
+        setTimeout(() => testCall(), constants_1.PROVIDER_HELLO_TIMEOUT);
     }
     async joinServer() {
-        const serverSwarm = new hyperswarm_1.default();
+        this._serverSwarm = new hyperswarm_1.default();
         const serverKey = Buffer.from(this._config.get("serverKey"));
-        serverSwarm.join(hypercore_crypto_1.default.discoveryKey(serverKey), {
+        this._serverSwarm.join(hypercore_crypto_1.default.discoveryKey(serverKey), {
             client: true,
             server: false,
         });
-        serverSwarm.flush();
-        serverSwarm.on("connection", (peer) => {
+        this._serverSwarm.flush();
+        this._serverSwarm.on("connection", (peer) => {
             var _a;
             this._serverPeer = peer;
             logger_1.logger.info(chalk_1.default.green("🔗 Connected to server."));
+            this.testProviderCall();
             this._challenge = hypercore_crypto_1.default.randomBytes(32);
             this._serverPeer.write((0, utils_1.createMessage)(constants_1.serverMessageKeys.challenge, {
                 challenge: this._challenge,

package/install.ps1

@@ -16,7 +16,7 @@ if (!(Get-Command npm -ErrorAction SilentlyContinue)) {
 }
 
 Print-Color $YELLOW "Installing symmetry-cli globally..."
-if (npm install -g .) {
+if (npm install -g symmetry-cli) {
     Print-Color $GREEN "symmetry-cli installed successfully!"
 } else {
     Print-Color $RED "Failed to install symmetry-cli. Please check your npm configuration and try again."
@@ -56,4 +56,4 @@ Print-Color $GREEN "Installation complete! You can now run 'symmetry-cli' to sta
 Print-Color $YELLOW "Please edit $provider_yaml to customize your provider settings, especially:"
 Print-Color $YELLOW "  - apiKey: Add your API key if required"
 Print-Color $YELLOW "  - name: Currently set to your system username, change if needed"
-Print-Color $YELLOW "  - public: Set to true by default, change to false if you don't want to be publicly accessible"
+Print-Color $YELLOW "  - public: Set to true by default, change to false if you don't want to be publicly accessible"

package/install.sh

@@ -18,7 +18,7 @@ if ! command -v npm >/dev/null 2>&1; then
 fi
 
 print_color "$YELLOW" "Installing symmetry-cli globally..."
-if npm install -g .; then
+if npm install -g symmetry-cli; then
     print_color "$GREEN" "symmetry-cli installed successfully!"
 else
     print_color "$RED" "Failed to install symmetry-cli. Please check your npm configuration and try again."

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "symmetry-cli",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "",
   "main": "dist/symmetry.js",
   "bin": "dist/symmetry.js",

package/readme.md

@@ -18,12 +18,12 @@ To install Symmetry, use the following commands:
 
 For Linux and macOS:
 ```bash
-curl -fsSL https://raw.githubusercontent.com/twinnydotdev/symmetry/master/install.sh | sh
+curl -fsSL https://www.twinny.dev/symmetry-unix.sh | sh
 ```
 
 For Windows:
 ```powershell
-iwr -useb https://raw.githubusercontent.com/twinnydotdev/symmetry/master/install.ps1 | iex
+iwr -useb https://www.twinny.dev/symmetry-windows.ps1 | iex
 ```
 
 ## Usage

package/src/constants.ts

@@ -1,5 +1,7 @@
 export const NORMALIZE_REGEX = /\s*\r?\n|\r/g;
 
+export const PROVIDER_HELLO_TIMEOUT = 30000
+
 export const serverMessageKeys = {
   challenge: "challenge",
   conectionSize: "conectionSize",

package/src/provider.ts

@@ -14,7 +14,7 @@ import {
 } from "./utils";
 import { logger } from "./logger";
 import { Peer, ProviderMessage, InferenceRequest, Message } from "./types";
-import { serverMessageKeys } from "./constants";
+import { PROVIDER_HELLO_TIMEOUT, serverMessageKeys } from "./constants";
 
 export class SymmetryProvider {
   private _challenge: Buffer | null = null;
@@ -24,6 +24,7 @@ export class SymmetryProvider {
   private _isPublic = false;
   private _providerConnections: number = 0;
   private _providerSwarm: Hyperswarm | null = null;
+  private _serverSwarm: Hyperswarm | null = null;
   private _serverPeer: Peer | null = null;
 
   constructor(configPath: string) {
@@ -63,7 +64,7 @@ export class SymmetryProvider {
         chalk.white(`🔑 Server key: ${this._config.get("serverKey")}`)
       );
       logger.info(chalk.white("🔗 Joining server, please wait."));
-      this.testProviderCall();
+      this.joinServer();
     }
 
     process.on("SIGINT", async () => {
@@ -78,78 +79,97 @@ export class SymmetryProvider {
     });
   }
 
+  async destroySwarms() {
+    await this._providerSwarm?.destroy();
+    await this._serverSwarm?.destroy();
+  }
+
   private async testProviderCall(): Promise<void> {
-    logger.info(chalk.white(`👋 Saying hello to your provider...`));
-    const testMessages: Message[] = [
-      { role: "user", content: "Hello, this is a test message." },
-    ];
-    const req = this.buildStreamRequest(testMessages);
-
-    if (!req) {
-      logger.error(chalk.red("❌ Failed to build test request"));
-      throw new Error("Failed to build test request");
-    }
+    const testCall = async () => {
+      logger.info(chalk.white(`👋 Saying hello to your provider...`));
+      const testMessages: Message[] = [
+        { role: "user", content: "Hello, this is a test message." },
+      ];
+      const req = this.buildStreamRequest(testMessages);
+
+      if (!req) {
+        logger.error(chalk.red("❌ Failed to build test request"));
+        throw new Error("Failed to build test request");
+      }
 
-    const { requestOptions, requestBody } = req;
-    const { protocol, hostname, port, path, method, headers } = requestOptions;
-    const url = `${protocol}://${hostname}:${port}${path}`;
+      const { requestOptions, requestBody } = req;
+      const { protocol, hostname, port, path, method, headers } =
+        requestOptions;
+      const url = `${protocol}://${hostname}:${port}${path}`;
+
+      logger.info(chalk.white(`🚀 Sending test request to ${url}`));
+
+      try {
+        const response = await fetch(url, {
+          method,
+          headers,
+          body: JSON.stringify(requestBody),
+        });
+
+        if (!response.ok) {
+          logger.error(
+            chalk.red(
+              `❌ Server responded with status code: ${response.status}`
+            )
+          );
+          this.destroySwarms();
+          throw new Error(
+            `Server responded with status code: ${response.status}`
+          );
+        }
 
-    logger.info(chalk.white(`🚀 Sending test request to ${url}`));
+        if (!response.body) {
+          logger.error(
+            chalk.red("❌ Failed to get a ReadableStream from the response")
+          );
+          this.destroySwarms();
+          throw new Error("Failed to get a ReadableStream from the response");
+        }
 
-    try {
-      const response = await fetch(url, {
-        method,
-        headers,
-        body: JSON.stringify(requestBody),
-      });
+        logger.info(chalk.white(`📡 Got response, checking stream...`));
 
-      if (!response.ok) {
-        logger.error(
-          chalk.red(`❌ Server responded with status code: ${response.status}`)
-        );
-        throw new Error(
-          `Server responded with status code: ${response.status}`
-        );
-      }
+        const reader = response.body.getReader();
+        const { done } = await reader.read();
+        if (done) {
+          logger.error(chalk.red("❌ Stream ended without data"));
+          this.destroySwarms();
+          throw new Error("Stream ended without data");
+        }
 
-      if (!response.body) {
+        logger.info(chalk.green(`✅ Test inference call successful!`));
+      } catch (error) {
+        this.destroySwarms();
         logger.error(
-          chalk.red("❌ Failed to get a ReadableStream from the response")
+          chalk.red(`❌ Error during test inference call: ${error}`)
         );
-        throw new Error("Failed to get a ReadableStream from the response");
+        throw error;
       }
 
-      logger.info(chalk.white(`📡 Got response, checking stream...`));
-
-      const reader = response.body.getReader();
-      const { done } = await reader.read();
-      if (done) {
-        logger.error(chalk.red("❌ Stream ended without data"));
-        throw new Error("Stream ended without data");
-      }
-
-      logger.info(chalk.green(`✅ Test inference call successful!`));
-    } catch (error) {
-      logger.error(chalk.red(`❌ Error during test inference call: ${error}`));
-      throw error;
-    }
+      logger.info(chalk.white(`🔗 Test call successful!`));
+    };
 
-    logger.info(chalk.white(`🔗 Proceeding to join server...`));
-    await this.joinServer();
+    setTimeout(() => testCall(), PROVIDER_HELLO_TIMEOUT)
   }
 
   async joinServer(): Promise<void> {
-    const serverSwarm = new Hyperswarm();
+    this._serverSwarm = new Hyperswarm();
     const serverKey = Buffer.from(this._config.get("serverKey"));
-    serverSwarm.join(crypto.discoveryKey(serverKey), {
+    this._serverSwarm.join(crypto.discoveryKey(serverKey), {
       client: true,
       server: false,
     });
-    serverSwarm.flush();
-    serverSwarm.on("connection", (peer: Peer) => {
+    this._serverSwarm.flush();
+    this._serverSwarm.on("connection", (peer: Peer) => {
       this._serverPeer = peer;
       logger.info(chalk.green("🔗 Connected to server."));
 
+      this.testProviderCall();
+
       this._challenge = crypto.randomBytes(32);
 
       this._serverPeer.write(