nstantpage-agent 0.2.0

package/dist/packageInstaller.js

@@ -0,0 +1,111 @@
+/**
+ * Package Installer — handles npm/pnpm package installation locally.
+ * Replaces the container-based /live/install endpoint.
+ */
+import { spawn } from 'child_process';
+import path from 'path';
+import { existsSync } from 'fs';
+export class PackageInstaller {
+    projectDir;
+    constructor(options) {
+        this.projectDir = options.projectDir;
+    }
+    /**
+     * Install packages into the project.
+     */
+    async install(packages, dev = false) {
+        const pm = this.detectPackageManager();
+        const args = this.buildInstallArgs(pm, packages, dev);
+        console.log(`  [Installer] ${pm} ${args.join(' ')}`);
+        try {
+            const output = await this.runCommand(pm, args, 60_000);
+            return {
+                success: true,
+                output,
+                installedPackages: packages,
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                output: err.message || 'Installation failed',
+                installedPackages: [],
+            };
+        }
+    }
+    /**
+     * Ensure all project dependencies are installed.
+     */
+    async ensureDependencies() {
+        const nodeModules = path.join(this.projectDir, 'node_modules');
+        if (existsSync(nodeModules))
+            return;
+        console.log(`  [Installer] Installing project dependencies...`);
+        const pm = this.detectPackageManager();
+        const args = pm === 'pnpm' ? ['install'] : ['install'];
+        await this.runCommand(pm, args, 120_000);
+        console.log(`  [Installer] Dependencies installed`);
+    }
+    /**
+     * Detect which package manager is used (pnpm, yarn, npm).
+     */
+    detectPackageManager() {
+        if (existsSync(path.join(this.projectDir, 'pnpm-lock.yaml')))
+            return 'pnpm';
+        if (existsSync(path.join(this.projectDir, 'yarn.lock')))
+            return 'yarn';
+        return 'npm';
+    }
+    buildInstallArgs(pm, packages, dev) {
+        const devFlag = dev
+            ? (pm === 'npm' ? '--save-dev' : '-D')
+            : '';
+        switch (pm) {
+            case 'pnpm':
+                return ['add', ...packages, ...(devFlag ? [devFlag] : [])];
+            case 'yarn':
+                return ['add', ...packages, ...(devFlag ? [devFlag] : [])];
+            default:
+                return ['install', ...packages, ...(devFlag ? [devFlag] : [])];
+        }
+    }
+    runCommand(cmd, args, timeoutMs) {
+        return new Promise((resolve, reject) => {
+            const proc = spawn(cmd, args, {
+                cwd: this.projectDir,
+                env: process.env,
+                shell: true,
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            let stdout = '';
+            let stderr = '';
+            proc.stdout?.on('data', (d) => {
+                stdout += d.toString();
+                process.stdout.write(`  ${d.toString().trimEnd()}\n`);
+            });
+            proc.stderr?.on('data', (d) => {
+                stderr += d.toString();
+                // Only show actual errors, not progress bars
+                const line = d.toString().trim();
+                if (line && !line.includes('progress') && !line.startsWith('⸩')) {
+                    process.stderr.write(`  ${line}\n`);
+                }
+            });
+            proc.on('close', (code) => {
+                if (code === 0)
+                    resolve(stdout);
+                else
+                    reject(new Error(stderr || stdout || `${cmd} exited with code ${code}`));
+            });
+            proc.on('error', reject);
+            setTimeout(() => {
+                try {
+                    proc.kill();
+                }
+                catch { }
+                reject(new Error(`${cmd} timed out after ${timeoutMs / 1000}s`));
+            }, timeoutMs);
+        });
+    }
+}
+//# sourceMappingURL=packageInstaller.js.map

package/dist/tunnel.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Tunnel Client v2 — WebSocket connection to gateway
+ *
+ * Enhanced to route requests to the correct local handler:
+ * - /live/* API requests → Local API server (handles file sync, checks, etc.)
+ * - Everything else → Local dev server (Vite, Next.js, etc.)
+ *
+ * Protocol (JSON messages over WebSocket):
+ *   Gateway → Agent:
+ *     { type: "http-request", id, method, url, headers, body? }
+ *     { type: "ping" }
+ *   Agent → Gateway:
+ *     { type: "http-response", id, statusCode, headers, body? }
+ *     { type: "pong" }
+ *     { type: "agent-info", version, hostname, platform, capabilities }
+ *     { type: "error-update", errors }
+ */
+interface TunnelClientOptions {
+    gatewayUrl: string;
+    token: string;
+    projectId: string;
+    /** Port where the local API server (/live/* handlers) runs */
+    apiPort: number;
+    /** Port where the dev server (Vite/Next.js) runs */
+    devPort: number;
+}
+export declare class TunnelClient {
+    private ws;
+    private options;
+    private reconnectTimer;
+    private shouldReconnect;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private pingInterval;
+    private requestsForwarded;
+    private connectedAt;
+    constructor(options: TunnelClientOptions);
+    get isConnected(): boolean;
+    get stats(): {
+        requestsForwarded: number;
+        connectedAt: number;
+        uptime: number;
+    };
+    connect(): Promise<void>;
+    disconnect(): void;
+    /**
+     * Push an error update to the gateway (for WebSocket error notifications).
+     */
+    pushErrorUpdate(errors: {
+        buildErrors: string[];
+        typeErrors: string[];
+        lintErrors: string[];
+        runtimeErrors: string[];
+    }): void;
+    private send;
+    private handleMessage;
+    /**
+     * Route incoming HTTP requests to the correct local server:
+     * - /live/* paths → Local API server (file sync, checks, etc.)
+     * - /health → Local API server
+     * - Everything else → Dev server (Vite HMR, page loads, etc.)
+     */
+    private handleHttpRequest;
+    /**
+     * Forward an HTTP request to a local server port and return the response.
+     */
+    private forwardToLocal;
+    private cleanup;
+    private scheduleReconnect;
+}
+export {};

package/dist/tunnel.js

@@ -0,0 +1,247 @@
+/**
+ * Tunnel Client v2 — WebSocket connection to gateway
+ *
+ * Enhanced to route requests to the correct local handler:
+ * - /live/* API requests → Local API server (handles file sync, checks, etc.)
+ * - Everything else → Local dev server (Vite, Next.js, etc.)
+ *
+ * Protocol (JSON messages over WebSocket):
+ *   Gateway → Agent:
+ *     { type: "http-request", id, method, url, headers, body? }
+ *     { type: "ping" }
+ *   Agent → Gateway:
+ *     { type: "http-response", id, statusCode, headers, body? }
+ *     { type: "pong" }
+ *     { type: "agent-info", version, hostname, platform, capabilities }
+ *     { type: "error-update", errors }
+ */
+import WebSocket from 'ws';
+import http from 'http';
+import os from 'os';
+export class TunnelClient {
+    ws = null;
+    options;
+    reconnectTimer = null;
+    shouldReconnect = true;
+    reconnectAttempts = 0;
+    maxReconnectAttempts = 50;
+    pingInterval = null;
+    requestsForwarded = 0;
+    connectedAt = 0;
+    constructor(options) {
+        this.options = options;
+    }
+    get isConnected() {
+        return this.ws?.readyState === WebSocket.OPEN;
+    }
+    get stats() {
+        return {
+            requestsForwarded: this.requestsForwarded,
+            connectedAt: this.connectedAt,
+            uptime: this.connectedAt ? Date.now() - this.connectedAt : 0,
+        };
+    }
+    async connect() {
+        return new Promise((resolve, reject) => {
+            const url = `${this.options.gatewayUrl}/tunnel/connect?token=${encodeURIComponent(this.options.token)}&projectId=${encodeURIComponent(this.options.projectId)}`;
+            this.ws = new WebSocket(url);
+            const connectTimeout = setTimeout(() => {
+                if (this.ws?.readyState !== WebSocket.OPEN) {
+                    this.ws?.terminate();
+                    reject(new Error('Connection timed out'));
+                }
+            }, 15_000);
+            this.ws.on('open', () => {
+                clearTimeout(connectTimeout);
+                this.reconnectAttempts = 0;
+                this.connectedAt = Date.now();
+                // Send enhanced agent info with capabilities
+                this.send({
+                    type: 'agent-info',
+                    version: '0.2.0',
+                    hostname: os.hostname(),
+                    platform: `${os.platform()} ${os.arch()}`,
+                    capabilities: [
+                        'file-sync',
+                        'type-check',
+                        'install',
+                        'terminal',
+                        'dev-server',
+                        'hard-patterns',
+                        'normalize',
+                        'full-api',
+                    ],
+                    apiPort: this.options.apiPort,
+                    devPort: this.options.devPort,
+                });
+                // Start keepalive ping
+                this.pingInterval = setInterval(() => {
+                    this.send({ type: 'pong' });
+                }, 30_000);
+                resolve();
+            });
+            this.ws.on('message', (data) => {
+                try {
+                    const msg = JSON.parse(data.toString());
+                    this.handleMessage(msg);
+                }
+                catch (err) {
+                    console.error('  [Tunnel] Invalid message:', err);
+                }
+            });
+            this.ws.on('close', (code, reason) => {
+                console.log(`  [Tunnel] Disconnected (${code}: ${reason || 'no reason'})`);
+                this.cleanup();
+                this.scheduleReconnect();
+            });
+            this.ws.on('error', (err) => {
+                clearTimeout(connectTimeout);
+                if (this.reconnectAttempts === 0) {
+                    reject(err);
+                }
+                console.error(`  [Tunnel] Error: ${err.message}`);
+            });
+        });
+    }
+    disconnect() {
+        this.shouldReconnect = false;
+        this.cleanup();
+        if (this.ws) {
+            this.ws.close(1000, 'Agent shutting down');
+            this.ws = null;
+        }
+    }
+    /**
+     * Push an error update to the gateway (for WebSocket error notifications).
+     */
+    pushErrorUpdate(errors) {
+        this.send({
+            type: 'error-update',
+            projectId: this.options.projectId,
+            errors,
+        });
+    }
+    send(msg) {
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify(msg));
+        }
+    }
+    handleMessage(msg) {
+        switch (msg.type) {
+            case 'ping':
+                this.send({ type: 'pong' });
+                break;
+            case 'http-request':
+                this.handleHttpRequest(msg);
+                break;
+            default:
+                console.warn(`  [Tunnel] Unknown message type: ${msg.type}`);
+        }
+    }
+    /**
+     * Route incoming HTTP requests to the correct local server:
+     * - /live/* paths → Local API server (file sync, checks, etc.)
+     * - /health → Local API server
+     * - Everything else → Dev server (Vite HMR, page loads, etc.)
+     */
+    handleHttpRequest(request) {
+        const { url } = request;
+        const isApiRequest = url.startsWith('/live/') || url === '/health';
+        const targetPort = isApiRequest ? this.options.apiPort : this.options.devPort;
+        this.forwardToLocal(request, targetPort);
+        this.requestsForwarded++;
+    }
+    /**
+     * Forward an HTTP request to a local server port and return the response.
+     */
+    forwardToLocal(request, port) {
+        const { id, method, url, headers, body } = request;
+        const reqOptions = {
+            hostname: '127.0.0.1',
+            port,
+            path: url,
+            method,
+            headers: {
+                ...headers,
+                host: `127.0.0.1:${port}`,
+                'x-forwarded-host': headers.host || '',
+                'x-tunnel-request-id': id,
+            },
+        };
+        const proxyReq = http.request(reqOptions, (proxyRes) => {
+            const chunks = [];
+            proxyRes.on('data', (chunk) => chunks.push(chunk));
+            proxyRes.on('end', () => {
+                const responseBody = Buffer.concat(chunks);
+                this.send({
+                    type: 'http-response',
+                    id,
+                    statusCode: proxyRes.statusCode || 200,
+                    headers: proxyRes.headers,
+                    body: responseBody.length > 0 ? responseBody.toString('base64') : undefined,
+                });
+            });
+        });
+        proxyReq.on('error', (err) => {
+            console.error(`  [Tunnel] Local proxy error for ${method} ${url} (port ${port}): ${err.message}`);
+            this.send({
+                type: 'http-response',
+                id,
+                statusCode: 502,
+                headers: { 'content-type': 'application/json' },
+                body: Buffer.from(JSON.stringify({
+                    error: `Local server error: ${err.message}`,
+                    agentMode: true,
+                })).toString('base64'),
+            });
+        });
+        proxyReq.setTimeout(60_000, () => {
+            proxyReq.destroy();
+            this.send({
+                type: 'http-response',
+                id,
+                statusCode: 504,
+                headers: { 'content-type': 'application/json' },
+                body: Buffer.from(JSON.stringify({
+                    error: 'Local server timeout',
+                    agentMode: true,
+                })).toString('base64'),
+            });
+        });
+        if (body) {
+            proxyReq.write(Buffer.from(body, 'base64'));
+        }
+        proxyReq.end();
+    }
+    cleanup() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.pingInterval) {
+            clearInterval(this.pingInterval);
+            this.pingInterval = null;
+        }
+    }
+    scheduleReconnect() {
+        if (!this.shouldReconnect)
+            return;
+        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+            console.error('  [Tunnel] Max reconnect attempts reached. Giving up.');
+            return;
+        }
+        const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), 30_000);
+        this.reconnectAttempts++;
+        console.log(`  [Tunnel] Reconnecting in ${delay / 1000}s (attempt ${this.reconnectAttempts})...`);
+        this.reconnectTimer = setTimeout(async () => {
+            try {
+                await this.connect();
+                console.log('  [Tunnel] Reconnected!');
+            }
+            catch {
+                // Will retry via close handler
+            }
+        }, delay);
+    }
+}
+//# sourceMappingURL=tunnel.js.map

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "nstantpage-agent",
+  "version": "0.2.0",
+  "description": "Local development agent for nstantpage.com — run your projects locally, preview in the cloud. Replaces cloud containers for faster builds.",
+  "type": "module",
+  "bin": {
+    "nstantpage": "./dist/cli.js",
+    "nstantpage-agent": "./dist/cli.js"
+  },
+  "main": "./dist/index.js",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/cli.ts",
+    "start": "node dist/cli.js",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nstantpage/nstantpage-agent"
+  },
+  "homepage": "https://nstantpage.com",
+  "bugs": {
+    "url": "https://github.com/nstantpage/nstantpage-agent/issues"
+  },
+  "keywords": [
+    "nstantpage",
+    "preview",
+    "development",
+    "agent",
+    "tunnel",
+    "local-dev",
+    "dev-server",
+    "vite",
+    "nextjs"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "conf": "^13.0.1",
+    "express": "^4.21.0",
+    "http-proxy": "^1.18.1",
+    "open": "^10.1.0",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.21",
+    "@types/http-proxy": "^1.17.14",
+    "@types/node": "^20.14.0",
+    "@types/ws": "^8.5.10",
+    "tsx": "^4.19.0",
+    "typescript": "^5.5.0"
+  }
+}