nstantpage-agent 0.5.32 → 0.5.33

package/dist/localServer.js

@@ -180,10 +180,10 @@ export class LocalServer {
     }
     async start() {
         this.server = http.createServer(async (req, res) => {
-            // CORS
+            // CORS — match gateway's headers so direct-localhost works from nstantpage.com
             res.setHeader('Access-Control-Allow-Origin', '*');
             res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
-            res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+            res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-Requested-With, X-Project-Id');
             if (req.method === 'OPTIONS') {
                 res.statusCode = 204;
                 res.end();
@@ -201,6 +201,127 @@ export class LocalServer {
                 }
             }
         });
+        // Handle WebSocket upgrades for direct-localhost terminal connections
+        // (same path as gateway: /live/terminal/ws/{projectId}/{sessionId})
+        this.server.on('upgrade', (req, socket, head) => {
+            const url = req.url || '';
+            const match = url.match(/^\/live\/terminal\/ws\/([^/]+)\/([^/?]+)/);
+            if (!match) {
+                socket.destroy();
+                return;
+            }
+            const sessionId = match[2];
+            const session = getTerminalSession(sessionId);
+            if (!session) {
+                socket.write('HTTP/1.1 404 Not Found\r\n\r\n');
+                socket.destroy();
+                return;
+            }
+            // Complete WebSocket handshake (RFC 6455)
+            const key = req.headers['sec-websocket-key'];
+            if (!key) {
+                socket.destroy();
+                return;
+            }
+            const crypto = require('crypto');
+            const accept = crypto.createHash('sha1')
+                .update(key + '258EAFA5-E914-47DA-95CA-C5AB0DC85B11')
+                .digest('base64');
+            socket.write('HTTP/1.1 101 Switching Protocols\r\n' +
+                'Upgrade: websocket\r\n' +
+                'Connection: Upgrade\r\n' +
+                `Sec-WebSocket-Accept: ${accept}\r\n` +
+                'Access-Control-Allow-Origin: *\r\n' +
+                '\r\n');
+            // Wire PTY ↔ WebSocket (same JSON protocol as tunnel relay)
+            const sendFrame = (data) => {
+                const buf = Buffer.from(data, 'utf-8');
+                const frame = Buffer.alloc(buf.length < 126 ? 2 + buf.length : 4 + buf.length);
+                frame[0] = 0x81; // text frame, FIN
+                if (buf.length < 126) {
+                    frame[1] = buf.length;
+                    buf.copy(frame, 2);
+                }
+                else {
+                    frame[1] = 126;
+                    frame.writeUInt16BE(buf.length, 2);
+                    buf.copy(frame, 4);
+                }
+                if (!socket.destroyed)
+                    socket.write(frame);
+            };
+            // Send connection confirmation
+            sendFrame(JSON.stringify({ type: 'connected', sessionId, projectId: match[1] }));
+            const cleanup = attachTerminalClient(sessionId, {
+                onData: (data) => sendFrame(JSON.stringify({ type: 'output', data })),
+                onExit: (code) => {
+                    sendFrame(JSON.stringify({ type: 'exit', exitCode: code }));
+                    socket.end();
+                },
+            });
+            // Parse incoming WebSocket frames from browser
+            let pending = Buffer.alloc(0);
+            socket.on('data', (chunk) => {
+                pending = Buffer.concat([pending, chunk]);
+                while (pending.length >= 2) {
+                    const masked = (pending[1] & 0x80) !== 0;
+                    let payloadLen = pending[1] & 0x7f;
+                    let offset = 2;
+                    if (payloadLen === 126) {
+                        if (pending.length < 4)
+                            return;
+                        payloadLen = pending.readUInt16BE(2);
+                        offset = 4;
+                    }
+                    else if (payloadLen === 127) {
+                        if (pending.length < 10)
+                            return;
+                        payloadLen = Number(pending.readBigUInt64BE(2));
+                        offset = 10;
+                    }
+                    if (masked)
+                        offset += 4;
+                    if (pending.length < offset + payloadLen)
+                        return;
+                    const opcode = pending[0] & 0x0f;
+                    if (opcode === 0x08) { // close
+                        socket.end();
+                        break;
+                    }
+                    let payload = pending.subarray(offset, offset + payloadLen);
+                    if (masked) {
+                        const maskKey = pending.subarray(offset - 4, offset);
+                        payload = Buffer.from(payload);
+                        for (let i = 0; i < payload.length; i++) {
+                            payload[i] ^= maskKey[i % 4];
+                        }
+                    }
+                    if (opcode === 0x01) { // text — JSON messages from frontend
+                        try {
+                            const msg = JSON.parse(payload.toString('utf-8'));
+                            if (msg.type === 'input' && typeof msg.data === 'string') {
+                                writeToTerminalSession(session, msg.data);
+                                session.lastActivity = Date.now();
+                            }
+                            else if (msg.type === 'resize' && typeof msg.cols === 'number' && typeof msg.rows === 'number') {
+                                resizeTerminalSession(session, msg.cols, msg.rows);
+                            }
+                        }
+                        catch { /* invalid JSON — ignore */ }
+                    }
+                    else if (opcode === 0x09) { // ping
+                        const pong = Buffer.alloc(2 + payloadLen);
+                        pong[0] = 0x8a;
+                        pong[1] = payloadLen;
+                        payload.copy(pong, 2);
+                        socket.write(pong);
+                    }
+                    pending = pending.subarray(offset + payloadLen);
+                }
+            });
+            socket.on('close', () => cleanup?.());
+            socket.on('error', () => cleanup?.());
+        });
         await new Promise((resolve, reject) => {
             this.server.listen(this.options.apiPort, '127.0.0.1', () => {
                 console.log(`  [LocalServer] API server on port ${this.options.apiPort}`);
@@ -519,7 +640,14 @@ export class LocalServer {
         const rows = parsed.rows || 30;
         // Determine shell
         const shellCmd = process.platform === 'win32' ? 'cmd.exe' : (process.env.SHELL || '/bin/bash');
-        const shellEnv = { ...process.env, TERM: 'xterm-256color', COLUMNS: String(cols), LINES: String(rows) };
+        const shellEnv = {
+            ...process.env,
+            TERM: 'xterm-256color',
+            COLORTERM: 'truecolor',
+            FORCE_COLOR: '3',
+            COLUMNS: String(cols),
+            LINES: String(rows),
+        };
         sessionCounter++;
         const label = parsed.label || `Terminal ${sessionCounter}`;
         let shell = null;

package/dist/tunnel.js

@@ -475,6 +475,10 @@ export class TunnelClient {
             case 'start-project':
                 this.handleStartProject(msg.projectId, msg.clean);
                 break;
+            case 'force-disconnect':
+                console.log('  [Tunnel] Received force-disconnect — will not reconnect');
+                this.shouldReconnect = false;
+                break;
             default:
                 console.warn(`  [Tunnel] Unknown message type: ${msg.type}`);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nstantpage-agent",
-  "version": "0.5.32",
+  "version": "0.5.33",
   "description": "Local development agent for nstantpage.com — run your projects locally, preview in the cloud. Replaces cloud containers for faster builds.",
   "type": "module",
   "bin": {