@skyramp/skyramp 0.5.9 → 0.5.16

package/package.json

@@ -1,14 +1,16 @@
 {
   "name": "@skyramp/skyramp",
-  "version": "0.5.9",
+  "version": "0.5.16",
   "description": "module for leveraging skyramp cli functionality",
   "scripts": {
     "lint": "eslint 'src/**/*.js' 'src/**/*.ts' --fix",
     "pack": "npm pack",
-    "reference-docs": "documentation build src/**/*.js src/classes/**/*.js -f md -o reference.md"
+    "reference-docs": "documentation build src/**/*.js src/classes/**/*.js -f md -o reference.md",
+    "postinstall": "node scripts/download-binary.js",
+    "clean": "rimraf node_modules && rimraf package-lock.json && rimraf skyramp && rimraf lib/*"
   },
   "files": [
-    "lib/**",
+    "scripts/*.js",
     "src/*.js",
     "src/*.ts",
     "src/classes/*.js",
@@ -18,6 +20,7 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
+    "@aws-sdk/client-s3": "^3.812.0",
     "fs": "^0.0.1-security",
     "js-yaml": "^4.1.0",
     "koffi": "2.5.12"

package/scripts/download-binary.js

@@ -0,0 +1,189 @@
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { S3Client, GetObjectCommand } = require("@aws-sdk/client-s3");
+
+function log(level, message) {
+    const timestamp = new Date().toISOString();
+    console.log(`[${timestamp}] [${level.toUpperCase()}] ${message}`);
+}
+
+let S3_PRIVATE = process.env.S3_PRIVATE || false;  // Set to true if libraries are in a private S3 bucket
+const AWS_REGION = process.env.AWS_REGION || 'us-west-2';  // Set your AWS region
+const SKIP_DOWNLOAD = process.env.SKIP_DOWNLOAD || false;  // Set to true to skip the download process
+const PUBLIC_BUCKET_NAME = process.env.INT_LIBRARY_BUCKET || 'skyramp-public';  // Set to your S3 public bucket name
+const PUBLIC_LIBRARY_PATH = process.env.INT_LIBRARY_PATH || `release/v${require('../package.json').version}/lib`;  // Set to your S3 public library root path
+const PRIVATE_BUCKET_NAME = process.env.INT_LIBRARY_BUCKET || undefined;  // Set to your S3 private bucket name
+const PRIVATE_LIBRARY_PATH = process.env.INT_LIBRARY_PATH || '';  // Set to your S3 private library root path
+
+if (SKIP_DOWNLOAD) {
+    log('info', "Skipping download as requested by SKIP_DOWNLOAD=true.");
+    process.exit(0);
+}
+
+if (process.env.CI) {
+    log('info', "Running in CI environment. Defaulting to private S3 download.");
+    S3_PRIVATE = true;
+}
+
+const archMap = {
+    x64: 'amd64',
+    ia32: '386',
+    arm: 'arm',
+    arm64: 'arm64',
+};
+
+const platformMap = {
+    win32: 'windows',
+    darwin: 'darwin',
+    linux: 'linux',
+};
+
+const extMap = {
+    windows: 'dll',
+    darwin: 'dylib',
+    linux: 'so',
+};
+
+const rawPlatform = process.platform;
+const rawArch = process.arch;
+const platform = platformMap[rawPlatform];
+const arch = archMap[rawArch];
+const ext = extMap[platform];
+
+if (!platform || !arch || !ext) {
+    log('error', `Unsupported platform or architecture: ${rawPlatform} / ${rawArch}`);
+    process.exit(1);
+}
+
+const prefix = 'skyramp';
+const binaryFilename = `${prefix}-${platform}-${arch}.${ext}`;
+const headerFilename = `${prefix}-${platform}-${arch}.h`;
+
+const baseUrl = `https://${PUBLIC_BUCKET_NAME}.s3.${AWS_REGION}.amazonaws.com/${PUBLIC_LIBRARY_PATH}/`;
+const localDir = path.join(__dirname, '..', 'lib');
+
+const files = [
+    { name: binaryFilename, dest: path.join(localDir, binaryFilename) },
+    { name: headerFilename, dest: path.join(localDir, headerFilename) },
+];
+
+async function calculateMD5(filePath) {
+    return new Promise((resolve, reject) => {
+        const hash = crypto.createHash('md5');
+        const stream = fs.createReadStream(filePath);
+        stream.on('data', data => hash.update(data));
+        stream.on('end', () => resolve(hash.digest('hex')));
+        stream.on('error', (err) => {
+            log('error', `Failed to calculate MD5 for ${filePath}: ${err.message}`);
+            reject(err);
+        });
+    });
+}
+
+async function getETag(url) {
+    return new Promise((resolve, reject) => {
+        https.get(url, { method: 'HEAD' }, res => {
+            if (res.statusCode !== 200) {
+                reject(new Error(`HTTP ${res.statusCode}: ${url}`));
+                return;
+            }
+            resolve(res.headers['etag']?.replace(/"/g, '')); // Remove quotes from ETag
+        }).on('error', (err) => {
+            log('error', `Error during HEAD request to ${url}: ${err.message}`);
+            reject(err);
+        });
+    });
+}
+
+async function download(url, dest, options = {}) {
+    await fs.promises.mkdir(path.dirname(dest), { recursive: true });
+
+    const { session, bucket, s3Key } = options;
+
+    return new Promise((resolve, reject) => {
+        if (session && bucket && s3Key) {
+            // Private S3 download using AWS SDK
+            const command = new GetObjectCommand({ Bucket: bucket, Key: s3Key });
+            session.send(command).then(response => {
+                const stream = response.Body;
+                const file = fs.createWriteStream(dest);
+                stream.pipe(file);
+                stream.on('error', (err) => {
+                    log('error', `Error streaming file from S3: ${err.message}`);
+                    reject(err);
+                });
+                file.on('finish', () => {
+                    log('info', `Successfully downloaded ${s3Key} to ${dest}`);
+                    file.close(resolve);
+                });
+            }).catch(err => {
+                log('error', `Failed to download ${s3Key} from S3: ${err.message}`);
+                reject(err);
+            });
+        } else {
+            // Public URL download using https
+            https.get(url, res => {
+                if (res.statusCode !== 200) {
+                    const error = new Error(`HTTP ${res.statusCode}: ${url}`);
+                    log('error', `Failed to download ${url}: ${error.message}`);
+                    reject(error);
+                    return;
+                }
+                const file = fs.createWriteStream(dest);
+                res.pipe(file);
+                file.on('finish', () => {
+                    log('info', `Successfully downloaded ${url} to ${dest}`);
+                    file.close(resolve);
+                });
+            }).on('error', (err) => {
+                log('error', `Error during download from ${url}: ${err.message}`);
+                reject(err);
+            });
+        }
+    });
+}
+
+(async () => {
+    for (const file of files) {
+        let options = {};
+        let url = baseUrl + file.name;
+        const localFile = file.dest;
+        log('info', `Processing ${file.name}...`);
+
+        try {
+            if (S3_PRIVATE) {
+                log("Pulling libraries from Private S3.");
+                const s3 = new S3Client({region: AWS_REGION});
+
+                url = null; // No URL needed for S3 private download client
+                options = {
+                    session: s3,
+                    bucket: PRIVATE_BUCKET_NAME,
+                    s3Key: `${PRIVATE_LIBRARY_PATH}/${file.name}`
+                };
+            } else if (fs.existsSync(localFile)) {
+                log('info', `Checking ${file.name} for changes...`);
+                const remoteETag = await getETag(url);
+                const localHash = await calculateMD5(localFile);
+                log('debug', `Remote ETag: ${remoteETag}, Local Hash: ${localHash}`);
+
+                if (remoteETag === localHash) {
+                    log('info', `✅ ${file.name} is up-to-date.`);
+                    continue;
+                } else {
+                    log('info', `🔄 ${file.name} differs, downloading...`);
+                }
+            } else {
+                log('info', `⬇️ ${file.name} not found locally, downloading...`);
+            }
+
+            await download(url, file.dest, options);
+            log('info', `✅ Saved ${file.name} to ${file.dest}`);
+        } catch (e) {
+            log('error', `❌ Failed to process ${file.name}: ${e.message}`);
+            process.exit(1);
+        }
+    }
+})();

package/src/classes/RequestV2.d.ts

@@ -15,6 +15,7 @@ interface RequestV2Options {
   expectedCode?: string;
   funcHandler?: string;
   funcHandlerType?: string;
+  insecure?: boolean;
 }
 export declare class RequestV2 {
   /**

package/src/classes/RequestV2.js

@@ -20,6 +20,7 @@ class RequestV2 {
    * @param {string} [options.expectedCode=''] - The expected HTTP status code of the response.
    * @param {string} [options.funcHandler=''] - The dynamic handler function for the request.
    * @param {string} [options.funcHandlerType=''] - The type of the dynamic handler (e.g., 'python', 'javascript').
+   * @param {boolean} [options.insecure=false] - Skip cert verification if set.
    */
   constructor(options = {}) {
     this.url = options.url || '';
@@ -35,6 +36,7 @@ class RequestV2 {
     this.expectedCode = options.expectedCode || '';
     this.funcHandler = options.funcHandler || '';
     this.funcHandlerType = options.funcHandlerType || '';
+    this.insecure = options.insecure || false;
   }
 
   toYaml() {
@@ -52,7 +54,8 @@ class RequestV2 {
       formParams: 'form_params',
       expectedCode: 'expected_code',
       funcHandler: 'func_handler',
-      funcHandlerType: 'func_handler_type'
+      funcHandlerType: 'func_handler_type',
+      insecure: 'insecure'
     };
 
     const { body, ...rest } = this;
@@ -90,7 +93,8 @@ class RequestV2 {
       formParams: 'form_params',
       expectedCode: 'expected_code',
       funcHandler: 'func_handler',
-      funcHandlerType: 'func_handler_type'
+      funcHandlerType: 'func_handler_type',
+      insecure: 'insecure'
     };
 
     const { ...rest } = this;

package/src/classes/SkyrampClient.d.ts

@@ -3,7 +3,6 @@ import { Endpoint } from './Endpoint';
 import { Scenario } from './Scenario';
 import {TrafficConfig} from './TrafficConfig';
 import { Protocol } from './Protocol';
-import {oauthResponseType} from './SkyrampClient';
 
 export enum Language {
   PYTHON = 'python'
@@ -61,9 +60,16 @@ interface SkyrampClientOptions {
   local_image?: boolean;
 }
 
+interface AnalyzeOpenAPIOptions {
+  apiSchema: string;
+  uri: string;
+}
+
 interface TraceCollectOptions {
   output?: string;
   workerContainerName?: string;
+  playwright?: boolean;
+  playwrightOutput?: string;
 }
 
 interface GenerateRestTestOptions {
@@ -87,21 +93,24 @@ interface GenerateRestTestOptions {
   responseStatusCode?: string;
   force?: boolean;
   deployDashboard?: boolean;
-  formParams?: {[formParamName: string]: string | number | boolean | object};
-  pathParams?: {[pathName: string]: string | number | boolean | object};
-  queryParams?: {[queryName: string]: string | number | boolean | object};
+  formParams?: string;
+  pathParams?: string;
+  queryParams?: string;
   apiSchema?: string[];
   traceFilePath?: string;
   generateInclude?: string[];
   generateExclude?: string[];
   generateInsecure?: boolean;
   assertOption?: string;
-  loadCount?: number;
-  loadDuration?: number;
-  loadNumThreads?: number;
-  loadRampupDuration?: number;
-  loadRampupInterval?: number;
-  loadTargetRPS?: number;
+  playwright?: boolean;
+  playwrightOutput?: string;
+  playwrightInput?: string;
+  loadCount?: string;
+  loadDuration?: string;
+  loadNumThreads?: string;
+  loadRampupDuration?: string;
+  loadRampupInterval?: string;
+  loadTargetRPS?: string;
   unblock?: boolean;
 }
 
@@ -134,11 +143,6 @@ export declare class SkyrampClient {
     isDockerenv: boolean): Promise<void>;
   
   testerStartV1(options: testerStartV1Options): Promise<void>;
-  testerStartvalidateToken(userToken: string): Promise<void>;
-  readCredential(): Promise<credResponseType>;
-  getOAuthURL(provider: string, port: number): string;
-  runOAuthLoopback(provider: string, port: number): Promise<oauthResponseType>;
-  registerUser(provider: string, email: string, oauthToken: string): Promise<string>;
 
   testerGenerate(
     protocol: Protocol,
@@ -158,4 +162,5 @@ export declare class SkyrampClient {
 
   generateRestTest(options: GenerateRestTestOptions): Promise<string>;
   traceCollect(options: TraceCollectOptions): Promise<string>;
+  analyzeOpenapi(options: AnalyzeOpenAPIOptions): Promise<string>;
 }

package/src/classes/SkyrampClient.js

@@ -3,19 +3,6 @@ const koffi = require('koffi');
 const TrafficConfig = require('./TrafficConfig');
 const RequestV2 = require('./RequestV2');
 const ResponseV2 = require('./ResponseV2');
-const oauthResponseType = koffi.struct({
-  emails: koffi.array('char*', 10),
-  num_emails: 'int',
-  token: 'char*',
-  error: 'char*'
-});
-
-const credResponseType = koffi.struct({
-  email: 'char*',
-  user_token: 'char*',
-  provider: 'char*',
-  error: 'char*',
-});
 
 const workerInfoType = koffi.struct({
   container_name: 'char*',
@@ -64,19 +51,13 @@ const deployTargetWrapper = lib.func('deployTargetWrapper', 'string', ['string',
 const deleteTargetWrapper = lib.func('deleteTargetWrapper', 'string', ['string', 'string', 'string', 'string', 'string']);
 const runTesterGenerateRestWrapper = lib.func('runTesterGenerateRestWrapper', testerGenerateType, ['string', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'int', 'bool', 'bool', 'bool']);
 
-const generateRestTestWrapper = lib.func('generateRestTestWrapper', 'string', ['string', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'int', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'bool', 'bool', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'bool', 'string', 'int', 'int', 'int', 'int', 'int', 'int', 'bool']);
-const traceCollectWrapper = lib.func('traceCollectWrapper', 'string', ['string', 'string']);
-
-// credential / oauth related
-const readCredentialWrapper = lib.func('readCredentialWrapper', credResponseType, []);
-const validateTokenWrapper = lib.func('validateTokenWrapper', 'string', ['string']);
-const registerUserWrapper = lib.func('registerUserWrapper', 'string', ['string', 'string', 'string']);
-const getOAuthURL = lib.func('getOAuthURLWrapper', 'string', ['string', 'int']);
-const runOAuthLoopback = lib.func('runOAuthLoopback', oauthResponseType, ['string', 'int']);
+const generateRestTestWrapper = lib.func('generateRestTestWrapper', 'string', ['string', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'int', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'bool', 'bool', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'bool', 'string', 'bool', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'bool']);
+const traceCollectWrapper = lib.func('traceCollectWrapper', 'string', ['string', 'string', 'bool', 'string']);
+const analyzeOpenapiWrapper = lib.func('analyzeOpenapiWrapper', 'string', ['string', 'string']);
 
 // contract test
 // func sendRequestWrapper(address, namespace, kubePath, kubeContext, clusterName, request, dockerNetwork, workerImage *C.char, localImage bool) *C.char {
-const sendRequestWrapper = lib.func('sendRequestWrapper', contractResponseType, ['string', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'bool']);
+const sendRequestWrapper = lib.func('sendRequestWrapper', contractResponseType, ['string', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'string', 'bool']);
 
 // dashboard
 const deployDockerDashboardWrapper = lib.func('deployDockerDashboardWrapper', 'string', ['string']);
@@ -138,7 +119,7 @@ class SkyrampClient {
         if (options.k8SConfigPath) {
           this.kubeconfigPath = options.k8SConfigPath;
         }
-      } 
+      }
 
       if (this.kubeconfigPath || this.clusterName || this.context) {
         this.addKubeConfig(this.context, this.clusterName, this.kubeconfigPath);
@@ -146,10 +127,10 @@ class SkyrampClient {
       // set default worker image
       if (options.workerImage) {
         this.workerImage = options.workerImage;
-      } 
+      }
       if (options.local_image) {
         this.local_image = options.local_image;
-      } 
+      }
     } else {
       if (kubeconfigPathOrOptions || clusterName || context) {
         this.addKubeConfig(context, clusterName, kubeconfigPathOrOptions);
@@ -160,89 +141,6 @@ class SkyrampClient {
     }
   }
 
-  setUserToken(userToken) {
-    this.userToken = userToken;
-  }
-
-  getOAuthURL(provider, port) {
-    return getOAuthURL(provider, port);
-  }
-
-  getUserEmail() {
-    return this.userEmail;
-  }
-
-  getUserToken() {
-    return this.userToken;
-  }
-
-  getUserProvider() {
-    return this.userProvider;
-  }
-
-  async readCredential() {
-    return new Promise((resolve, reject) => {
-      readCredentialWrapper.async((err, res) => {
-        if (err) {
-          reject(err);
-        } else if (res) {
-          if (res.error != null) {
-            reject(res.error);
-          } else {
-            this.userToken = res.user_token;
-            this.userEmail = res.email;
-            this.userProvider = res.provider;
-            resolve(res);
-          }
-        } else {
-          reject(new Error('failed to read credential'));
-        }
-      });
-    });
-  }
-
-  async runOAuthLoopback(provider, port) {
-    return new Promise((resolve, reject) => {
-      runOAuthLoopback.async(provider, port, (err, res) => {
-        if (err) {
-          reject(err);
-        } else if (res) {
-          resolve(res);
-        } else {
-          reject(new Error("failed to get oauth token"));
-        }
-      });
-    });
-  }
-
-  async validateToken(userToken) {
-    return new Promise((resolve, reject) => {
-      validateTokenWrapper.async(userToken, (err, res) => {
-        if (err) {
-          reject(err);
-        } else if (res) {
-          resolve(new Error(res));
-        } else {
-          resolve();
-        }
-      });
-    });
-  }
-
-  async registerUser(provider, email, oauthToken) {
-    return new Promise((resolve, reject) => {
-      registerUserWrapper.async(provider, email, oauthToken, (err, res) => {
-        if (err) {
-          reject(err);
-        } else if (res) {
-          reject(new Error(res));
-        } else {
-          resolve();
-        }
-      });
-    });
-  }
-
   /**
    * Applies local changes to the Kubernetes cluster configuration.
    *
@@ -338,7 +236,7 @@ class SkyrampClient {
    * @returns {Promise} - A Promise that resolves if deployment is successful, and rejects with an error if any error occurs during deployment.
    * @throws {Error} - If there is no cluster to deploy the worker to.
    */
-  async deploySkyrampWorker(namespace, workerImage = '', localImage = false, kubePath='', kubeContext='', clusterName='') {
+  async deploySkyrampWorker(namespace, workerImage = '', localImage = false, kubePath = '', kubeContext = '', clusterName = '') {
     return new Promise((resolve, reject) => {
       deploySkyrampWorkerWrapper.async(namespace, kubePath, kubeContext, clusterName, workerImage, localImage, (err, res) => {
         if (err) {
@@ -360,7 +258,7 @@ class SkyrampClient {
    * @returns {Promise} - A promise that resolves with no value upon successful deletion.
    * @throws {Error} - If there is no cluster to delete the worker from or if there is no worker to delete from the specified namespace.
    */
-  async deleteSkyrampWorker(namespace, kubePath='', kubeContext='', clusterName='') {
+  async deleteSkyrampWorker(namespace, kubePath = '', kubeContext = '', clusterName = '') {
     if (this.kubeConfigPath === null) {
       throw new Error('No cluster to delete worker from.');
     }
@@ -538,7 +436,7 @@ class SkyrampClient {
     const testYamlContent = getYamlBytes(testDescription);
     const stringifiedHeaders = JSON.stringify(globalHeaders);
 
-    return this.runTesterStartv1( namespace,
+    return this.runTesterStartv1(namespace,
       kubePath,
       kubeContext,
       clusterName,
@@ -673,7 +571,7 @@ class SkyrampClient {
 
     return mockDescription;
   }
-  
+
   /**
    * Generates test scenarios based on the provided parameters.
    * 
@@ -726,7 +624,7 @@ class SkyrampClient {
     const req = new RequestV2(options);
     return new Promise((resolve, reject) => {
       const jsonRequest = req.toJson();
-      sendRequestWrapper.async(this.address, this.namespace, this.kubeconfigPath, this.context, this.clusterName, jsonRequest, this.dockerNetwork, this.workerImage, this.local_image, (err, res) => {
+      sendRequestWrapper.async(this.address, this.namespace, this.kubeconfigPath, this.context, this.clusterName, jsonRequest, this.dockerNetwork, this.workerImage, this.clientID, this.local_image, (err, res) => {
         if (err) {
           reject(err);
         } else if (res) {
@@ -776,11 +674,39 @@ class SkyrampClient {
     });
   }
 
+  /**
+ * Analyzes an OpenAPI schema and URI.
+ *
+ * @param {Object} options - The options for analysis.
+ * @param {string} options.apiSchema - The OpenAPI schema to analyze.
+ * @param {string} options.uri - The URI to analyze.
+ * @returns {Promise<string>} A promise that resolves with the analysis result.
+ */
+  async analyzeOpenapi(options) {
+    return new Promise((resolve, reject) => {
+      analyzeOpenapiWrapper.async(
+        options.apiSchema || "",
+        options.uri || "",
+        (err, res) => {
+          if (err) {
+            reject(err);
+          } else if (res.error) {
+            reject(new Error(res));
+          } else {
+            resolve(res);
+          }
+        }
+      );
+    });
+  }
+
   async traceCollect(options) {
     return new Promise((resolve, reject) => {
       traceCollectWrapper.async(
         options.output || "",
         options.workerContainerName || "",
+        options.playwright || false,
+        options.playwrightOutput || "",
         (err, res) => {
           if (err) {
             reject(err);
@@ -795,7 +721,6 @@ class SkyrampClient {
   }
 
   async generateRestTest(options) {
-    // TODO: Fix the k8sConfig default value
     return new Promise((resolve, reject) => {
       generateRestTestWrapper.async(
         options.testType || "",
@@ -818,29 +743,30 @@ class SkyrampClient {
         options.responseStatusCode || "",
         options.force || false,
         options.deployDashboard || false,
-        JSON.stringify(options.formParams || {}),
-        JSON.stringify(options.pathParams || {}),
-        JSON.stringify(options.queryParams || {}),
+        options.formParams || "",
+        options.pathParams || "",
+        options.queryParams || "",
         JSON.stringify(options.apiSchema || []),
         options.traceFilePath || "",
         JSON.stringify(options.generateInclude || []),
         JSON.stringify(options.generateExclude || []),
         options.generateInsecure || false,
         options.assertOption || "",
-        options.loadCount || 0,
-        options.loadDuration || 0,
-        options.loadNumThreads || 0,
-        options.loadRampupDuration || 0,
-        options.loadRampupInterval || 0,
-        options.loadTargetRPS || 0,
+        options.playwright || false,
+        options.playwrightOutput || "",
+        options.playwrightInput || "",
+        options.loadCount || "0",
+        options.loadDuration || "0",
+        options.loadNumThreads || "0",
+        options.loadRampupDuration || "0",
+        options.loadRampupInterval || "0",
+        options.loadTargetRPS || "0",
         options.unblock || false,
         (err, res) => {
           if (err) {
             reject(err);
-          } else if (res) {
-            reject(new Error(res));
           } else {
-            resolve();
+            resolve(res);
           }
         }
       );

package/src/lib.js

@@ -7,18 +7,18 @@ let libPath = '';
 
 if (platform === 'linux') {
   if (arch === 'x64') {
-    libPath = 'dev-linux-amd64.so';
+    libPath = 'skyramp-linux-amd64.so';
   } else if (arch === 'ia32') {
-    libPath = 'dev-linux-386.so';
+    libPath = 'skyramp-linux-386.so';
   }
 } else if (platform === 'darwin') {
   if (arch === 'x64') {
-    libPath = 'dev-darwin-amd64.dylib';
+    libPath = 'skyramp-darwin-amd64.dylib';
   } else if (arch === 'arm64') {
-    libPath = 'dev-darwin-arm64.dylib';
+    libPath = 'skyramp-darwin-arm64.dylib';
   }
 } else if (platform === 'win32') {
-  libPath = 'dev-windows-amd64.dll';
+  libPath = 'skyramp-windows-amd64.dll';
 }
 
 if (!libPath) {