@assetsart/nylon-mesh 1.0.1

package/Cargo.toml

@@ -0,0 +1,33 @@
+[package]
+name = "nylon-mesh"
+version = "1.0.1"
+edition = "2024"
+
+[dependencies]
+mimalloc = { version = "0.1", default-features = false, features = ["secure"] }
+async-trait = "0.1"
+bytes = "1.11.1"
+http = "1.4.0"
+moka = { version = "0.12.13", features = ["future", "sync"] }
+once_cell = "1.19"
+pingora = { version = "0.7.0", features = ["openssl"] }
+pingora-core = { version = "0.7.0", features = ["openssl"] }
+pingora-proxy = "0.7.0"
+pingora-cache = "0.7.0"
+pingora-load-balancing = "0.7.0"
+redis = { version = "1.0.4", features = ["tokio-comp"] }
+serde = { version = "1.0", features = ["derive"] }
+serde_yaml = "0.9"
+tokio = { version = "1.40", features = ["full"] }
+tracing = "0.1"
+tracing-subscriber = "0.3"
+openssl = { version = "0.10", default-features = false }
+serde_json = "1.0.149"
+
+[profile.release]
+overflow-checks = true
+strip = true
+opt-level = "z"
+lto = true
+codegen-units = 1
+panic = "abort"

package/README.md

@@ -0,0 +1,104 @@
+<div align="center">
+
+# 🕸️ Nylon Mesh
+
+**Cache Everything. Scale Instantly.**
+
+[![Rust](https://img.shields.io/badge/Rust-000000?style=flat-square&logo=rust&logoColor=white)](https://www.rust-lang.org/)
+[![License](https://img.shields.io/badge/License-MIT-green)](#)
+
+*A blazing-fast edge proxy built to solve the headaches of caching for modern SSR frameworks.*
+
+[Why Nylon Mesh?](#why-nylon-mesh) • [Features](#key-features) • [Quick Start](#installation) • [Configuration](#configuration-example-nylon-meshyaml)
+
+</div>
+
+
+
+## Why Nylon Mesh?
+
+Frameworks like **Next.js, Nuxt, React (SSR), Angular, and Vue** are powerful—but server-side rendering is computationally expensive. Running Node.js under heavy traffic without a dedicated caching layer leads to:
+
+- High CPU usage and slow Time to First Byte (TTFB)
+- Potential crashes under traffic spikes
+- Complex custom caching logic inside your app
+
+**Nylon Mesh sits in front of your app.** It intercepts HTTP requests, caches the expensive SSR-generated HTML in RAM (Tier 1) and Redis (Tier 2), and serves subsequent users instantly—dropping your backend load to near zero.
+
+## Key Features
+
+- ⚡️ **Blazing Fast**: Built in Rust on top of Pingora.
+- 🚀 **Two-Tier Caching**: Uses a lightning-fast in-memory RAM cache (Tier-1) and falls back to Redis (Tier-2).
+- ⚖️ **Load Balancing**: Built-in support for Round Robin and Weighted routing to multiple upstream servers.
+- 🛠 **Zero-Code Integration**: Works with any backend by just placing it in front of your existing app. No SDKs needed.
+- ⚙️ **Simple Configuration**: Easy to set up using a single YAML file.
+
+## Installation
+
+Nylon Mesh is written in **Rust** for maximum performance. You can compile and run it directly:
+
+```bash
+cargo build --release
+```
+
+Or install it via Bun into your Node.js project:
+
+```bash
+bun add nylon-mesh
+```
+
+## Initialization
+
+Generate a ready-to-use configuration file in your project:
+
+```bash
+bunx nylon-mesh init
+```
+
+This creates a `nylon-mesh.yaml` in your project folder. **No code changes are required in your application.**
+
+## Running the Proxy
+
+Start by pointing the proxy at your generated config file:
+
+```bash
+cargo run --release -- nylon-mesh.yaml
+```
+
+Or via the CLI wrapper if installed via package manager:
+
+```bash
+bunx nylon-mesh start nylon-mesh.yaml
+```
+
+Traffic hitting port `3000` (default) is now being cached and routed to your backend efficiently!
+
+## Configuration Example (`nylon-mesh.yaml`)
+
+```yaml
+listen: "0.0.0.0:3000"
+upstreams:
+  - "127.0.0.1:3001"
+load_balancer_algo: "round_robin"
+redis_url: "redis://localhost:6379"
+
+cache:
+  tier1_capacity: 10000
+  tier1_ttl_seconds: 3
+  tier2_ttl_seconds: 60
+  status: [200, 404]
+  content_types:
+    - "text/html"
+
+bypass:
+  paths:
+    - "/_next/"
+    - "/api/"
+  extensions:
+    - ".ico"
+    - ".png"
+```
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

package/bin/nylon-mesh.js

@@ -0,0 +1,213 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const https = require('https');
+
+const args = process.argv.slice(2);
+const command = args[0] || 'start';
+
+const REPO = 'AssetsArt/nylon-mesh';
+const BINARY_NAME = 'nylon-mesh';
+
+const DEFAULT_YAML = `# threads: 10
+# liveness_path: "/_health/live"
+# readiness_path: "/_health/ready"
+# grace_period_seconds: 0
+# graceful_shutdown_timeout_seconds: 0
+listen: "0.0.0.0:3000"
+# tls:
+#   listen: "0.0.0.0:443"
+#   certs:
+#     - host: "default"
+#       cert_path: "cert.pem"
+#       key_path: "key.pem"
+upstreams:
+  - "127.0.0.1:3001"
+  # - address: "127.0.0.1:3002"
+    # weight: 5
+load_balancer_algo: "round_robin"
+redis_url: "redis://localhost:6379"
+cache:
+  tier1_capacity: 10000
+  tier1_ttl_seconds: 3
+  tier2_ttl_seconds: 60
+  status:
+    - 200
+  content_types:
+    - "text/html"
+bypass:
+  paths:
+    - "/_next/"
+    - "/api/"
+  extensions:
+    - ".ico"
+    - ".png"
+# cache_control:
+#   - value: "public, max-age=31536000, immutable"
+#     paths:
+#       - "/_next/static/"
+#     extensions:
+#       - ".ico"
+#       - ".png"
+#       - ".jpg"
+`;
+
+function getPlatformString() {
+  const platform = process.platform;
+  const arch = process.arch;
+
+  let osStr = '';
+  switch (platform) {
+    case 'win32': osStr = 'windows'; break;
+    case 'darwin': osStr = 'macos'; break;
+    case 'linux': osStr = 'linux-gnu'; break; // Default to gnu, musl support can be added if statically linked or specify manually
+    default: throw new Error(`Unsupported platform: ${platform}`);
+  }
+
+  let archStr = '';
+  switch (arch) {
+    case 'x64': archStr = 'x86_64'; break;
+    case 'arm64': archStr = 'aarch64'; break;
+    default: throw new Error(`Unsupported architecture: ${arch}`);
+  }
+
+  // Windows suffix
+  const ext = platform === 'win32' ? '.exe' : '';
+
+  // Format: nylon-mesh-{platform}-{arch}{ext}
+  return `nylon-mesh-${osStr}-${archStr}${ext}`;
+}
+
+function httpsGet(url, options = {}) {
+  return new Promise((resolve, reject) => {
+    https.get(url, { headers: { 'User-Agent': 'nylon-mesh-cli' }, ...options }, (res) => {
+      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        resolve(httpsGet(res.headers.location, options));
+      } else if (res.statusCode === 200) {
+        resolve(res);
+      } else {
+        reject(new Error(`Failed with status code: ${res.statusCode}`));
+      }
+    }).on('error', reject);
+  });
+}
+
+async function getLatestReleaseVersion() {
+  try {
+    const res = await httpsGet(`https://api.github.com/repos/${REPO}/releases/latest`);
+    let data = '';
+    for await (const chunk of res) { data += chunk; }
+    const release = JSON.parse(data);
+    return release.tag_name;
+  } catch (err) {
+    console.error('Failed to fetch latest release from GitHub API.', err.message);
+    return null;
+  }
+}
+
+async function downloadBinary(targetPath) {
+  const version = await getLatestReleaseVersion();
+  if (!version) {
+    console.error('Could not determine latest version. Please build from source using `cargo build --release`.');
+    process.exit(1);
+  }
+
+  let platformName;
+  try {
+    platformName = getPlatformString();
+  } catch (e) {
+    console.error(e.message);
+    process.exit(1);
+  }
+
+  const downloadUrl = `https://github.com/${REPO}/releases/download/${version}/${platformName}`;
+  console.log(`Downloading ${platformName} (${version})...`);
+  console.log(`From: ${downloadUrl}`);
+
+  try {
+    const res = await httpsGet(downloadUrl);
+    const fileStream = fs.createWriteStream(targetPath);
+    await new Promise((resolve, reject) => {
+      res.pipe(fileStream);
+      res.on('error', reject);
+      fileStream.on('finish', () => {
+        fileStream.close();
+        resolve();
+      });
+    });
+    fs.chmodSync(targetPath, 0o755); // Make it executable
+    console.log('Download complete.');
+  } catch (err) {
+    console.error('Download failed:', err.message);
+    process.exit(1);
+  }
+}
+
+async function main() {
+  const localBinDir = path.join(__dirname, '..', 'bin');
+  const exeExt = process.platform === 'win32' ? '.exe' : '';
+  const downloadedBinaryPath = path.join(localBinDir, `${BINARY_NAME}-bin${exeExt}`);
+
+  if (command === 'init') {
+    const targetPath = path.join(process.cwd(), 'nylon-mesh.yaml');
+    if (fs.existsSync(targetPath)) {
+      console.error('nylon-mesh.yaml already exists.');
+    } else {
+      fs.writeFileSync(targetPath, DEFAULT_YAML);
+      console.log('Created nylon-mesh.yaml!');
+    }
+
+    if (!fs.existsSync(downloadedBinaryPath)) {
+      await downloadBinary(downloadedBinaryPath);
+    } else {
+      console.log('Binary already downloaded.');
+    }
+
+    console.log('Run `npx nylon-mesh start` to start the proxy.');
+    process.exit(0);
+  }
+
+  if (command === 'start') {
+    const targetReleasePath = path.join(__dirname, '..', 'target', 'release', `${BINARY_NAME}${exeExt}`);
+    const targetDebugPath = path.join(__dirname, '..', 'target', 'debug', `${BINARY_NAME}${exeExt}`);
+
+    let exeToRun = null;
+    if (fs.existsSync(downloadedBinaryPath)) {
+      exeToRun = downloadedBinaryPath;
+    } else if (fs.existsSync(targetReleasePath)) {
+      exeToRun = targetReleasePath;
+    } else if (fs.existsSync(targetDebugPath)) {
+      exeToRun = targetDebugPath;
+    } else {
+      console.log('Nylon Mesh binary not found. Downloading...');
+      await downloadBinary(downloadedBinaryPath);
+      exeToRun = downloadedBinaryPath;
+    }
+
+    let yamlPath = path.join(process.cwd(), 'nylon-mesh.yaml');
+    if (args[1]) {
+      yamlPath = path.resolve(process.cwd(), args[1]);
+    }
+
+    if (!fs.existsSync(yamlPath)) {
+      console.error(`Config file not found at ${yamlPath}. Run \`npx nylon-mesh init\` first.`);
+      process.exit(1);
+    }
+
+    console.log(`Starting Nylon Mesh with config: ${yamlPath}`);
+    const child = spawnSync(exeToRun, [yamlPath], { stdio: 'inherit' });
+    process.exit(child.status || 0);
+  }
+
+  console.error(`Unknown command: ${command}`);
+  console.error(`Usage:`);
+  console.error(`  npx nylon-mesh init   - Create a default config file and download binary`);
+  console.error(`  npx nylon-mesh start  - Start the proxy server`);
+  process.exit(1);
+}
+
+main().catch(err => {
+  console.error(err);
+  process.exit(1);
+});