easytyga 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Joe Wee (jyswee)
+
+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/README.md

@@ -0,0 +1,107 @@
+# easytyga
+
+**Tunnel your local AI to the internet. Secure. One command.**
+
+Expose your local Ollama, vLLM, or any HTTP service to the internet with API key authentication. No port forwarding, no static IP, no nginx configs.
+
+```bash
+npx easytyga
+```
+
+```
+  ┌─────────────────────────────────────┐
+  │          easytyga v1.0.0             │
+  │  Tunnel your local AI to the web     │
+  └─────────────────────────────────────┘
+
+  GPU:     NVIDIA GeForce RTX 4090
+  Target:  http://localhost:11434
+  Relay:   wss://relay.easytyga.com/ws
+
+  ┌─────────────────────────────────────┐
+  │  Tunnel active                      │
+  └─────────────────────────────────────┘
+
+  Public URL:  https://abc123.easytyga.com
+  API Key:     et_a1b2c3d4e5f6...
+```
+
+That's it. Your local AI is now accessible from anywhere, secured with an API key.
+
+## Why?
+
+Ollama has **no built-in authentication** and **no remote access**. If you want to use your GPU from your phone, office, or a cloud app, you need to cobble together nginx + Cloudflare tunnels + basic auth.
+
+easytyga solves this in one command:
+- **Secure tunnel** -- no port forwarding, works behind any NAT/firewall
+- **API key auth** -- auto-generated, every request authenticated
+- **Auto-detects your GPU** -- knows what hardware you're running
+- **Works with anything** -- Ollama, vLLM, LocalAI, ComfyUI, or any HTTP service
+
+## Usage
+
+```bash
+# Tunnel local Ollama (default port 11434)
+npx easytyga
+
+# Tunnel a different service
+npx easytyga --target http://localhost:8080
+
+# Use a specific key
+npx easytyga --key et_abc123...
+```
+
+## Options
+
+| Flag | Description |
+|------|-------------|
+| `--target <url>` | Local endpoint (default: `http://localhost:11434`) |
+| `--server <url>` | Relay server URL |
+| `--key <key>` | Connection key |
+| `--help` | Show help |
+
+## How it works
+
+1. easytyga connects to the relay server via WebSocket
+2. The relay assigns you a public URL with API key auth
+3. Incoming requests are forwarded through the tunnel to your local service
+4. Responses stream back to the caller
+
+Your IP stays private. No ports to open. Works from any network.
+
+## Features
+
+- **One command** -- `npx easytyga`, no install, no config files
+- **API key auth** -- every tunnel gets a unique key, no anonymous access
+- **GPU detection** -- auto-detects NVIDIA, AMD, and Apple Silicon
+- **Model detection** -- discovers installed Ollama models automatically
+- **Auto-reconnect** -- exponential backoff, set and forget
+- **Streaming** -- full support for streaming responses (chat, generate)
+- **Any HTTP service** -- not locked to Ollama, tunnel anything
+
+## Integrations
+
+easytyga supports plugins for third-party services:
+
+- **[gpusmarket.com](https://gpusmarket.com)** -- List your GPU on the peer-to-peer rental marketplace and earn money (`--list`)
+- **[agenticmemory.ai](https://agenticmemory.ai)** -- Add persistent conversation memory to your AI (`--memory`)
+
+See [easytyga.com](https://easytyga.com) for documentation on integrations and self-hosted relay servers.
+
+## License
+
+MIT
+
+---
+
+## Trademarks
+
+"easytyga" and the easytyga logo are trademarks of Joe Wee. The name and branding may not be used in derivative works without written permission.
+
+This software is provided under the MIT license -- you are free to use, modify, and distribute the code, but the easytyga name, branding, and relay infrastructure remain the property of the author.
+
+Ollama is a trademark of Ollama, Inc. vLLM is a trademark of vLLM contributors. NVIDIA, GeForce, and RTX are trademarks of NVIDIA Corporation. AMD and Radeon are trademarks of AMD. Apple and Apple Silicon are trademarks of Apple Inc. All other trademarks are the property of their respective owners. This project is not affiliated with or endorsed by any of these companies.
+
+---
+
+Built by [Joe Wee](https://github.com/jyswee)

package/bin/cli.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+/**
+ * easytyga - Tunnel your local AI to the internet. Secure. One command.
+ *
+ * Usage:
+ *   npx easytyga                              # Free tunnel with auto-generated auth
+ *   npx easytyga --target http://...:11434     # Custom local endpoint
+ *   npx easytyga --list                        # List your GPU on the marketplace
+ *   npx easytyga --memory                      # Add persistent memory
+ *   npx easytyga --key et_abc123...            # Use existing key
+ */
+
+const { createTunnel } = require('../src/tunnel');
+const { detectGpu } = require('../src/detect');
+
+// -- CLI args --
+const args = process.argv.slice(2);
+
+function getArg(name, fallback) {
+  const idx = args.indexOf('--' + name);
+  return idx >= 0 && args[idx + 1] ? args[idx + 1] : fallback;
+}
+function hasFlag(name) {
+  return args.includes('--' + name);
+}
+
+if (hasFlag('help') || hasFlag('h')) {
+  console.log(`
+  easytyga - Tunnel your local AI to the internet
+
+  Usage:
+    npx easytyga                           Free tunnel with API key auth
+    npx easytyga --list                    List your GPU on the marketplace
+    npx easytyga --memory                  Add persistent conversation memory
+    npx easytyga --key et_...              Use existing key
+
+  Options:
+    --target <url>    Local endpoint (default: http://localhost:11434)
+    --server <url>    Relay server (default: wss://relay.easytyga.com/ws)
+    --key <key>       Connection key
+    --list            Register on the GPU marketplace
+    --memory          Enable persistent memory
+    --help            Show this help
+
+  Examples:
+    npx easytyga                           Tunnel local Ollama
+    npx easytyga --target http://...:8080  Tunnel any HTTP service
+    npx easytyga --list --memory           Marketplace + persistent memory
+
+  https://easytyga.com
+  `);
+  process.exit(0);
+}
+
+const targetUrl = (getArg('target', '') || getArg('ollama', '') || 'http://localhost:11434').replace(/\/$/, '');
+const serverUrl = getArg('server', 'wss://relay.easytyga.com/ws');
+const key = getArg('key', '') || process.env.EASYTYGA_KEY || '';
+const listMode = hasFlag('list');
+const memoryMode = hasFlag('memory');
+
+// -- Main --
+(async () => {
+  console.log('');
+  console.log('  easytyga v1.0.0');
+  console.log('  Tunnel your local AI to the web');
+  console.log('');
+
+  const gpu = await detectGpu();
+  if (gpu) console.log(`  GPU:     ${gpu}`);
+  console.log(`  Target:  ${targetUrl}`);
+  console.log(`  Relay:   ${serverUrl}`);
+  if (listMode) console.log('  Mode:    Marketplace');
+  if (memoryMode) console.log('  Memory:  Enabled');
+  console.log('');
+
+  try {
+    await createTunnel({
+      ollamaUrl: targetUrl,
+      serverUrl,
+      key,
+      listMode,
+      memoryMode,
+      gpu,
+    });
+  } catch (err) {
+    console.error(`  Error: ${err.message}`);
+    process.exit(1);
+  }
+})();

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "easytyga",
+  "version": "1.0.0",
+  "description": "Tunnel your local AI to the internet. Secure. One command. Works with Ollama, vLLM, and any HTTP service.",
+  "bin": {
+    "easytyga": "bin/cli.js"
+  },
+  "keywords": [
+    "tunnel",
+    "ollama",
+    "ngrok",
+    "reverse-proxy",
+    "llm",
+    "gpu",
+    "ai",
+    "inference",
+    "remote-access",
+    "api-gateway",
+    "vllm",
+    "local-ai"
+  ],
+  "author": "Joe Wee <jyswee@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jyswee/easytyga"
+  },
+  "homepage": "https://easytyga.com",
+  "dependencies": {
+    "ws": "^8.16.0"
+  }
+}

package/src/detect.js

@@ -0,0 +1,42 @@
+/**
+ * GPU detection - tries to identify the local GPU model.
+ */
+
+const { execSync } = require('child_process');
+
+async function detectGpu() {
+  try {
+    // Try nvidia-smi first
+    const output = execSync('nvidia-smi --query-gpu=name --format=csv,noheader', {
+      timeout: 5000,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).toString().trim();
+    if (output) return output.split('\n')[0].trim();
+  } catch {}
+
+  try {
+    // macOS: system_profiler
+    const output = execSync('system_profiler SPDisplaysDataType 2>/dev/null | grep "Chip\\|Chipset"', {
+      timeout: 5000,
+      shell: true,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).toString().trim();
+    const match = output.match(/Apple (M\d[\w\s]*)/i);
+    if (match) return match[1].trim();
+  } catch {}
+
+  try {
+    // Linux: lspci
+    const output = execSync("lspci | grep -i 'vga\\|3d\\|display' | head -1", {
+      timeout: 5000,
+      shell: true,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).toString().trim();
+    const match = output.match(/NVIDIA.*\[(.*?)\]/i) || output.match(/AMD.*\[(.*?)\]/i);
+    if (match) return match[1].trim();
+  } catch {}
+
+  return null;
+}
+
+module.exports = { detectGpu };

package/src/tunnel.js

@@ -0,0 +1,239 @@
+/**
+ * Core tunnel client - connects to a WebSocket relay server and forwards requests.
+ * Handles auth, request forwarding, streaming, and auto-reconnect.
+ */
+
+const http = require('http');
+const https = require('https');
+const WebSocket = require('ws');
+const crypto = require('crypto');
+
+// ── Protocol helpers ──
+
+function decodeBody(b64) {
+  return b64 ? Buffer.from(b64, 'base64') : Buffer.alloc(0);
+}
+
+function encodeBody(buf) {
+  return buf && buf.length > 0 ? Buffer.from(buf).toString('base64') : '';
+}
+
+function wsSend(ws, obj) {
+  try { ws.send(JSON.stringify(obj)); } catch {}
+}
+
+// ── Verify Ollama is reachable ──
+
+async function checkOllama(ollamaUrl) {
+  return new Promise((resolve) => {
+    const url = new URL('/api/version', ollamaUrl);
+    const transport = url.protocol === 'https:' ? https : http;
+    const req = transport.get(url, { timeout: 5000 }, (res) => {
+      let body = '';
+      res.on('data', (c) => body += c);
+      res.on('end', () => {
+        try {
+          const data = JSON.parse(body);
+          resolve(data.version || true);
+        } catch {
+          resolve(true);
+        }
+      });
+    });
+    req.on('error', () => resolve(false));
+    req.on('timeout', () => { req.destroy(); resolve(false); });
+  });
+}
+
+// ── Get available models ──
+
+async function getModels(ollamaUrl) {
+  return new Promise((resolve) => {
+    const url = new URL('/api/tags', ollamaUrl);
+    const transport = url.protocol === 'https:' ? https : http;
+    const req = transport.get(url, { timeout: 5000 }, (res) => {
+      let body = '';
+      res.on('data', (c) => body += c);
+      res.on('end', () => {
+        try {
+          const data = JSON.parse(body);
+          resolve((data.models || []).map(m => m.name));
+        } catch {
+          resolve([]);
+        }
+      });
+    });
+    req.on('error', () => resolve([]));
+    req.on('timeout', () => { req.destroy(); resolve([]); });
+  });
+}
+
+// ── Forward a request to local Ollama ──
+
+function forwardToOllama(ws, msg, ollamaUrl) {
+  const url = new URL(msg.path, ollamaUrl);
+  const transport = url.protocol === 'https:' ? https : http;
+  const body = decodeBody(msg.body);
+
+  const reqOpts = {
+    method: msg.method || 'POST',
+    hostname: url.hostname,
+    port: url.port,
+    path: url.pathname + url.search,
+    headers: {
+      'Content-Type': 'application/json',
+      ...(body.length > 0 ? { 'Content-Length': body.length } : {}),
+    },
+    timeout: 120000,
+  };
+
+  const req = transport.request(reqOpts, (res) => {
+    const headers = {};
+    for (const [k, v] of Object.entries(res.headers)) {
+      if (k.toLowerCase() !== 'transfer-encoding') headers[k] = v;
+    }
+    wsSend(ws, { id: msg.id, type: 'response-start', status: res.statusCode, headers });
+
+    res.on('data', (chunk) => {
+      wsSend(ws, { id: msg.id, type: 'response-data', chunk: encodeBody(chunk) });
+    });
+
+    res.on('end', () => {
+      wsSend(ws, { id: msg.id, type: 'response-end' });
+    });
+  });
+
+  req.on('error', (err) => {
+    wsSend(ws, { id: msg.id, type: 'response-error', error: err.message });
+  });
+
+  req.on('timeout', () => {
+    req.destroy();
+    wsSend(ws, { id: msg.id, type: 'response-error', error: 'Request timed out' });
+  });
+
+  if (body.length > 0) req.write(body);
+  req.end();
+}
+
+// ── Main tunnel function ──
+
+async function createTunnel(opts) {
+  const { ollamaUrl, serverUrl, key, listMode, memoryMode, gpu } = opts;
+
+  // Check Ollama
+  const version = await checkOllama(ollamaUrl);
+  if (!version) {
+    throw new Error(`Cannot reach Ollama at ${ollamaUrl}\nMake sure Ollama is running: ollama serve`);
+  }
+  console.log(`  Ollama ${typeof version === 'string' ? `v${version}` : ''} reachable`);
+
+  // Get models
+  const models = await getModels(ollamaUrl);
+  if (models.length > 0) {
+    console.log(`  Models: ${models.slice(0, 5).join(', ')}${models.length > 5 ? ` (+${models.length - 5} more)` : ''}`);
+  }
+
+  // Generate a tunnel key if none provided
+  const tunnelKey = key || `ot_${crypto.randomBytes(16).toString('hex')}`;
+  const isAnonymous = !key;
+
+  console.log('');
+
+  // Connect with auto-reconnect
+  let reconnectDelay = 2000;
+  const MAX_RECONNECT = 30000;
+  let requestCount = 0;
+
+  function connect() {
+    const ws = new WebSocket(serverUrl);
+
+    ws.on('open', () => {
+      wsSend(ws, {
+        type: 'auth',
+        key: tunnelKey,
+        anonymous: isAnonymous,
+        gpu: gpu || undefined,
+        models: models,
+        list: listMode || false,
+        memory: memoryMode || false,
+      });
+    });
+
+    ws.on('message', (data) => {
+      let msg;
+      try { msg = JSON.parse(data); } catch { return; }
+
+      if (msg.type === 'auth-ok') {
+        reconnectDelay = 2000;
+        console.log('  ┌─────────────────────────────────────┐');
+        console.log('  │  Tunnel active                      │');
+        console.log('  └─────────────────────────────────────┘');
+        if (msg.publicUrl) {
+          console.log('');
+          console.log(`  Public URL:  ${msg.publicUrl}`);
+        }
+        if (msg.apiKey) {
+          console.log(`  API Key:     ${msg.apiKey}`);
+        }
+        if (msg.listingTitle) {
+          console.log(`  Listing:     ${msg.listingTitle}`);
+        }
+        if (listMode) {
+          console.log('');
+          console.log('  Your GPU is listed on the marketplace.');
+          console.log('  Renters can find and use your GPU now.');
+        }
+        if (memoryMode) {
+          console.log('');
+          console.log('  Persistent memory enabled.');
+          console.log('  Conversations persist across sessions.');
+        }
+        console.log('');
+        console.log('  Press Ctrl+C to disconnect.');
+        console.log('');
+        return;
+      }
+
+      if (msg.type === 'auth-fail') {
+        console.error(`  Authentication failed: ${msg.error}`);
+        if (isAnonymous) {
+          console.error('  The relay server may not support anonymous tunnels.');
+          console.error('  Get a key at https://easytyga.com');
+        }
+        process.exit(1);
+      }
+
+      if (msg.type === 'request' && msg.id) {
+        requestCount++;
+        process.stdout.write(`\r  Requests forwarded: ${requestCount}`);
+        forwardToOllama(ws, msg, ollamaUrl);
+        return;
+      }
+    });
+
+    ws.on('close', () => {
+      console.log(`\n  Disconnected. Reconnecting in ${reconnectDelay / 1000}s...`);
+      setTimeout(connect, reconnectDelay);
+      reconnectDelay = Math.min(reconnectDelay * 2, MAX_RECONNECT);
+    });
+
+    ws.on('error', (err) => {
+      if (err.code !== 'ECONNREFUSED') {
+        console.error(`  WebSocket error: ${err.message}`);
+      }
+    });
+  }
+
+  connect();
+
+  // Graceful shutdown
+  process.on('SIGINT', () => {
+    console.log('\n\n  Tunnel closed. Goodbye!');
+    if (listMode) console.log('  Your listing has been set to offline.');
+    process.exit(0);
+  });
+  process.on('SIGTERM', () => { process.exit(0); });
+}
+
+module.exports = { createTunnel, checkOllama, getModels };