local.dev Tunnel Service - Product Requirements & Implementation Guide

Month 1:   100 free,  10 paid = $440 MRR
Month 3:  1000 free, 100 paid = $4,400 MRR
Month 6:  5000 free, 500 paid = $22,000 MRR
Month 12: 20000 free, 2000 paid = $88,000 MRR

Targets:
- Conversion rate: 10% free-to-paid
- Average revenue per user: $44
- CAC: <$20
- LTV: >$500

┌──────────────────────────────────────────────────────────────┐
│                   Global Anycast (Fly Edge)                   │
│                    *.local.dev → Fly App                      │
└────────────┬─────────────────────────────────────────────────┘
             │
    ┌────────▼─────────────────────────────────┐
    │   Fly Gateway App (Multi-Region)          │
    │   - tunnel-gateway.fly.dev                │
    │   - Auto-scales based on connections      │
    └────────┬─────────────────────────────────┘
             │ Fly Private Network (6PN)
    ┌────────▼─────────────────────────────────┐
    │   Customer Workspace Machines             │
    │   (Dynamically Created via Machines API)  │
    │   - Isolated Docker containers            │
    │   - Per-customer DNS/Proxy                │
    │   - Auto-sleep when inactive               │
    └───────────────────────────────────────────┘

app = "localdev-gateway"
primary_region = "iad"

[build]
  dockerfile = "Dockerfile.gateway"

[env]
  NODE_ENV = "production"
  PORT = "3000"

[http_service]
  internal_port = 3000
  force_https = true
  auto_stop_machines = false
  auto_start_machines = true

[[services]]
  protocol = "tcp"
  internal_port = 3000
  
  [[services.ports]]
    port = 80
    handlers = ["http"]
    
  [[services.ports]]
    port = 443
    handlers = ["tls", "http"]

[services.concurrency]
  type = "connections"
  hard_limit = 1000
  soft_limit = 800

[[regions]]
  iad = 2
  lax = 1
  lhr = 1
  sin = 1
  syd = 1

const { MachinesClient } = require('@fly/machines');

class FlyWorkspaceManager {
  constructor() {
    this.client = new MachinesClient({
      apiToken: process.env.FLY_API_TOKEN
    });
    this.appName = 'localdev-workspaces';
  }

  async createCustomerWorkspace(customer, tier) {
    const machineConfig = this.getMachineConfig(tier);
    
    const machine = await this.client.create({
      app: this.appName,
      region: customer.preferredRegion || 'iad',
      name: `workspace-${customer.id}`,
      config: {
        image: 'localdev/workspace:latest',
        
        guest: {
          cpus: machineConfig.cpus,
          memory_mb: machineConfig.memory,
          cpu_kind: tier === 'enterprise' ? 'performance' : 'shared'
        },
        
        env: {
          CUSTOMER_ID: customer.id,
          TIER: tier,
          WORKSPACE_ID: generateWorkspaceId(),
          DNS_ENABLED: String(tier !== 'free'),
          SSL_ENABLED: String(tier !== 'free'),
          CF_API_TOKEN: encrypted(customer.cfToken)
        },
        
        services: [{
          protocol: 'tcp',
          internal_port: 8080,
          auto_stop_machines: tier === 'free',
          auto_start_machines: true
        }],
        
        mounts: tier !== 'free' ? [{
          name: `workspace_${customer.id}`,
          path: '/data',
          size_gb: this.getStorageSize(tier)
        }] : [],
        
        restart: {
          policy: tier === 'free' ? 'no' : 'always'
        },
        
        schedule: tier === 'free' ? 'stop_after_1h' : null
      }
    });
    
    await this.setupWireGuardTunnel(machine, customer);
    
    if (customer.customDomain) {
      await this.setupCustomDomain(machine, customer.customDomain);
    }
    
    return {
      machineId: machine.id,
      hostname: `${machine.id}.vm.${this.appName}.internal`,
      publicUrl: `${customer.subdomain}.local.dev`,
      status: 'running',
      region: machine.region,
      ipv6: machine.private_ip
    };
  }

  getMachineConfig(tier) {
    const configs = {
      free: { cpus: 1, memory: 256, storage: 0 },
      developer: { cpus: 1, memory: 512, storage: 1 },
      professional: { cpus: 2, memory: 2048, storage: 10 },
      team: { cpus: 4, memory: 4096, storage: 50 },
      enterprise: { cpus: 8, memory: 8192, storage: 100 }
    };
    return configs[tier];
  }
}

const proxy = require('http-proxy').createProxyServer();

class FlyGatewayRouter {
  constructor() {
    this.routes = new Map();
    this.flyResolver = new FlyPrivateResolver();
  }

  async handleRequest(req, res) {
    const subdomain = this.extractSubdomain(req.hostname);
    const route = await this.getRoute(subdomain);
    
    if (!route) {
      return res.status(404).send('Tunnel not found');
    }
    
    const machine = await this.getMachine(route.machineId);
    
    if (machine.state === 'stopped') {
      await this.startMachine(route.machineId);
      return res.send(this.getStartupPage(route));
    }
    
    // Free tier: inject marketing
    if (route.tier === 'free') {
      this.injectMarketingBanner(req, res);
    }
    
    // Route to workspace via Fly's private network
    const target = `http://${route.internalHost}`;
    
    proxy.web(req, res, {
      target,
      ws: true,
      headers: {
        'X-Forwarded-Host': req.hostname,
        'X-Customer-Id': route.customerId,
        'X-Tier': route.tier
      }
    });
  }

  injectMarketingBanner(req, res) {
    const originalWrite = res.write;
    res.write = function(chunk) {
      if (res.getHeader('content-type')?.includes('text/html')) {
        const banner = `
          <div style="position:fixed;top:0;width:100%;background:#ff6b35;
                      color:white;text-align:center;padding:10px;z-index:99999">
            🚀 Powered by local.dev | Upgrade for custom domains!
            <a href="https://local.dev/upgrade" 
               style="color:white;margin-left:10px">Upgrade Now →</a>
          </div>
        `;
        chunk = chunk.toString().replace('<body>', `<body>${banner}`);
      }
      originalWrite.call(this, chunk);
    };
  }
}

#!/usr/bin/env node
const WebSocket = require('ws');
const http = require('http');
const { program } = require('commander');

class LocalDevClient {
  constructor(options) {
    this.localPort = options.port;
    this.serverUrl = options.server || 'wss://tunnel.local.dev';
    this.apiKey = options.apiKey;
  }

  async connect() {
    console.log(`Connecting to ${this.serverUrl}...`);
    
    this.ws = new WebSocket(this.serverUrl, {
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'X-Local-Port': this.localPort
      }
    });
    
    this.ws.on('open', () => {
      console.log('Connected! Waiting for tunnel URL...');
    });
    
    this.ws.on('message', async (data) => {
      const message = JSON.parse(data);
      
      switch(message.type) {
        case 'tunnel-ready':
          console.log(`\n🚀 Tunnel ready at: ${message.url}\n`);
          break;
          
        case 'request':
          const response = await this.forwardToLocal(message);
          this.ws.send(JSON.stringify({
            type: 'response',
            id: message.id,
            ...response
          }));
          break;
          
        case 'error':
          console.error(`Error: ${message.message}`);
          if (message.code === 'LIMIT_EXCEEDED') {
            console.log('\n💡 Upgrade your plan at https://local.dev/pricing\n');
          }
          break;
      }
    });
    
    this.ws.on('close', () => {
      console.log('Tunnel closed');
      process.exit(0);
    });
  }

  async forwardToLocal(request) {
    return new Promise((resolve) => {
      const req = http.request({
        hostname: 'localhost',
        port: this.localPort,
        method: request.method,
        path: request.url,
        headers: request.headers
      }, (res) => {
        let body = '';
        res.on('data', chunk => body += chunk);
        res.on('end', () => {
          resolve({
            status: res.statusCode,
            headers: res.headers,
            body
          });
        });
      });
      
      if (request.body) req.write(request.body);
      req.end();
    });
  }
}

program
  .option('-p, --port <port>', 'Local port to tunnel', '3000')
  .option('-k, --api-key <key>', 'API key for authentication')
  .option('-s, --server <url>', 'Tunnel server URL')
  .parse(process.argv);

const client = new LocalDevClient(program.opts());
client.connect();

FROM node:20-alpine

# Install required tools
RUN apk add --no-cache caddy wget

# Install CoreDNS
RUN wget https://github.com/coredns/coredns/releases/download/v1.11.1/coredns_1.11.1_linux_amd64.tgz && \
    tar xzf coredns_1.11.1_linux_amd64.tgz && \
    mv coredns /usr/local/bin/ && \
    rm coredns_1.11.1_linux_amd64.tgz

# Install workspace manager
COPY workspace-manager.js /app/
COPY package.json /app/
WORKDIR /app
RUN npm install

# Ports
EXPOSE 8080 53 443

CMD ["node", "workspace-manager.js"]

-- Customers
CREATE TABLE customers (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  email VARCHAR(255) UNIQUE NOT NULL,
  tier VARCHAR(50) NOT NULL DEFAULT 'free',
  stripe_customer_id VARCHAR(255),
  api_key VARCHAR(255) UNIQUE NOT NULL,
  created_at TIMESTAMP DEFAULT NOW(),
  updated_at TIMESTAMP DEFAULT NOW()
);

-- Workspaces
CREATE TABLE workspaces (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  customer_id UUID REFERENCES customers(id),
  machine_id VARCHAR(255) UNIQUE,
  subdomain VARCHAR(255) UNIQUE,
  region VARCHAR(50),
  status VARCHAR(50),
  created_at TIMESTAMP DEFAULT NOW()
);

-- Tunnels
CREATE TABLE tunnels (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  workspace_id UUID REFERENCES workspaces(id),
  subdomain VARCHAR(255),
  target_port INTEGER,
  created_at TIMESTAMP DEFAULT NOW(),
  closed_at TIMESTAMP
);

-- Usage tracking
CREATE TABLE usage_metrics (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  customer_id UUID REFERENCES customers(id),
  metric_type VARCHAR(50), -- bandwidth, requests, tunnels
  value BIGINT,
  timestamp TIMESTAMP DEFAULT NOW()
);

-- Custom domains
CREATE TABLE custom_domains (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  customer_id UUID REFERENCES customers(id),
  domain VARCHAR(255) UNIQUE NOT NULL,
  verified BOOLEAN DEFAULT FALSE,
  ssl_cert_id VARCHAR(255),
  created_at TIMESTAMP DEFAULT NOW()
);

-- Indexes for performance
CREATE INDEX idx_usage_customer_time ON usage_metrics(customer_id, timestamp);
CREATE INDEX idx_tunnels_workspace ON tunnels(workspace_id);
CREATE INDEX idx_workspaces_customer ON workspaces(customer_id);

# Install Fly CLI
curl -L https://fly.io/install.sh | sh

# Login to Fly
fly auth login

# Create applications
fly apps create localdev-gateway
fly apps create localdev-workspaces

# Create PostgreSQL cluster
fly postgres create --name localdev-db --region iad
fly postgres attach --app localdev-gateway localdev-db

# Create Redis instance
fly redis create --name localdev-cache --region iad
fly redis attach --app localdev-gateway localdev-cache

# Set environment variables
fly secrets set \
  STRIPE_SECRET_KEY=sk_live_... \
  STRIPE_WEBHOOK_SECRET=whsec_... \
  FLY_API_TOKEN=... \
  CLOUDFLARE_API_TOKEN=... \
  JWT_SECRET=... \
  --app localdev-gateway

# Build and deploy gateway
cd gateway
fly deploy --app localdev-gateway

# Scale globally
fly scale count 6 \
  --region iad=2,lax=1,lhr=1,sin=1,syd=1 \
  --app localdev-gateway

# Configure autoscaling
fly autoscale set min=2 max=20 --app localdev-gateway

# Add wildcard certificate
fly certs add "*.local.dev" --app localdev-gateway

# Configure DNS records at your provider
# A record: local.dev -> Fly.io IP
# CNAME: *.local.dev -> localdev-gateway.fly.dev

# Build workspace Docker image
cd workspace
docker build -t localdev/workspace:latest .

# Push to Fly registry
fly registry push localdev/workspace:latest

# Connect to database
fly postgres connect -a localdev-db

# Run schema
psql < schema.sql

# Create initial admin user
psql -c "INSERT INTO customers (email, tier, api_key) 
         VALUES ('admin@local.dev', 'enterprise', 'admin_key');"

# Deploy Grafana for monitoring
fly apps create localdev-monitoring
fly deploy --app localdev-monitoring -i grafana/grafana

# Set up alerts
fly scale count 1 --app localdev-monitoring