@adaas/a-frame 0.0.21 → 0.0.23

package/src/lib/A-FrameChannel/A-FrameChannel.component.env-node.ts

@@ -0,0 +1,586 @@
+import { A_Feature, A_Inject } from "@adaas/a-concept";
+import { A_FrameFeatures } from "./A-FrameChannel.constants";
+import { A_FrameChannelRequest } from "./A-FrameChannelRequest.context";
+import { A_FrameEnv } from "../A-FrameEnv/A-FrameEnv.fragment.env-node";
+import { A_FrameChannelError } from "./A-FrameChannel.error";
+import { A_FrameChannel } from "./A-FrameChannel.component";
+import * as http from "http";
+import * as https from "https";
+// import * as crypto from "crypto";
+// import * as net from "net";
+// import * as tls from "tls";
+import { A_FrameChannelStream } from "./A-FrameChannelStream.entity";
+import { A_FrameChannelEvent } from "./A-FrameChannelEvent.context";
+
+export class A_FrameNodeChannel extends A_FrameChannel {
+
+    @A_Feature.Extend({
+        name: A_FrameFeatures.Request,
+        scope: [A_FrameChannel],
+    })
+    async request(
+        @A_Inject(A_FrameChannelRequest) context: A_FrameChannelRequest,
+        @A_Inject(A_FrameEnv) env: A_FrameEnv,
+    ) {
+        const url = `${env.A_FRAME_SERVER_URL}${context.path}`;
+        const parsedUrl = new URL(url);
+        const client = parsedUrl.protocol === "https:" ? https : http;
+        const payload = context.body !== undefined ? JSON.stringify(context.body) : undefined;
+
+        const result = await new Promise<unknown>((resolve, reject) => {
+            const req = client.request(
+                {
+                    protocol: parsedUrl.protocol,
+                    hostname: parsedUrl.hostname,
+                    port: parsedUrl.port,
+                    path: `${parsedUrl.pathname}${parsedUrl.search}`,
+                    method: context.method,
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${env.A_FRAME_SERVER_API_KEY}`,
+                        ...(payload ? { "Content-Length": Buffer.byteLength(payload) } : {}),
+                    },
+                },
+                (res) => {
+                    const chunks: Buffer[] = [];
+
+                    res.on("data", (chunk) => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)));
+                    res.on("end", () => {
+                        const raw = Buffer.concat(chunks).toString("utf8");
+
+                        if ((res.statusCode ?? 500) >= 400) {
+                            console.error(`[A-FrameChannel] <-- ${res.statusCode} ${context.method} ${url}`);
+                            reject(
+                                new A_FrameChannelError({
+                                    title: A_FrameChannelError.RequestFailed,
+                                    description: `Request to ${context.path} failed with status ${res.statusCode}`,
+                                }),
+                            );
+                            return;
+                        }
+
+                        if (!raw) {
+                            console.log(`[A-FrameChannel] <-- ${res.statusCode} ${context.method} ${url} (empty)`);
+                            resolve(undefined);
+                            return;
+                        }
+
+                        try {
+                            const parsed = JSON.parse(raw);
+                            console.log(`[A-FrameChannel] <-- ${res.statusCode} ${context.method} ${url}`);
+                            resolve(parsed);
+                        } catch {
+                            console.error(`[A-FrameChannel] <-- ${res.statusCode} ${context.method} ${url} (invalid JSON)`);
+                            reject(
+                                new A_FrameChannelError({
+                                    title: A_FrameChannelError.RequestFailed,
+                                    description: `Invalid JSON response from ${context.path}`,
+                                }),
+                            );
+                        }
+                    });
+                },
+            );
+
+            req.setTimeout(15_000, () => {
+                console.error(`[A-FrameChannel] TIMEOUT ${context.method} ${url}`);
+                req.destroy(
+                    new A_FrameChannelError({
+                        title: A_FrameChannelError.Timeout,
+                        description: `Request to ${context.path} timed out after 15 seconds`,
+                    }),
+                );
+            });
+
+            req.on("error", (err) => reject(err));
+
+            if (payload) req.write(payload);
+            req.end();
+        });
+
+        context.complete(result);
+
+    }
+
+
+
+
+    async stream(
+        @A_Inject(A_FrameChannelStream) stream: A_FrameChannelStream,
+        @A_Inject(A_FrameEnv) env: A_FrameEnv,
+    ) {
+        const url = `${env.A_FRAME_SERVER_URL}${stream.path}`;
+        const parsedUrl = new URL(url);
+        const client = parsedUrl.protocol === "https:" ? https : http;
+        const payload = stream.body !== undefined ? JSON.stringify(stream.body) : undefined;
+
+        await new Promise<void>((resolve, reject) => {
+
+            const req = client.request(
+                {
+                    protocol: parsedUrl.protocol,
+                    hostname: parsedUrl.hostname,
+                    port: parsedUrl.port,
+                    path: `${parsedUrl.pathname}${parsedUrl.search}`,
+                    method: stream.method,
+                    headers: {
+                        "Content-Type": "application/json",
+                        Accept: "text/event-stream",
+                        Authorization: `Bearer ${env.A_FRAME_SERVER_API_KEY}`,
+                        ...(payload ? { "Content-Length": Buffer.byteLength(payload) } : {}),
+                    },
+                },
+                (res) => {
+                    if ((res.statusCode ?? 500) >= 400) {
+                        console.error(`[A-FrameChannel] <-- ${res.statusCode} ${stream.method} ${url}`);
+                        reject(
+                            new A_FrameChannelError({
+                                title: A_FrameChannelError.RequestFailed,
+                                description: `Stream request to ${stream.path} failed with status ${res.statusCode}`,
+                            }),
+                        );
+                        return;
+                    }
+
+                    let buffer = '';
+
+                    res.on("data", async (chunk) => {
+                        buffer += Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk);
+                        const lines = buffer.split('\n');
+                        // Keep the last incomplete line in the buffer for the next chunk
+                        buffer = lines.pop() || '';
+
+                        for (const line of lines) {
+                            // SSE spec: only lines prefixed with "data: " carry event payloads
+                            if (!line.startsWith('data: ')) continue;
+
+                            const data = line.slice(6).trim();
+
+                            // SSE end-of-stream sentinel — no payload to process
+                            if (data === '[DONE]') continue;
+
+                            // ──────────────────────────────────────────────────
+                            // SERVER ACTION DISPATCH
+                            // Each parsed event is expected to carry a `type`
+                            // field that identifies the action sent by the server.
+                            //
+                            // Add new cases here as the server-side action set
+                            // grows. The raw event is also pushed to `events` so
+                            // callers receive the full history via context.complete.
+                            //
+                            // Example shape: { type: 'some_action', data: { ... } }
+                            // ──────────────────────────────────────────────────
+                            try {
+                                const event = JSON.parse(data);
+
+                                await stream.propagate(event.type, event.data);
+                            } catch {
+                                console.error(`[A-FrameChannel] Invalid SSE payload from ${stream.path}: ${data}`);
+                            }
+                        }
+                    });
+
+                    res.on("end", () => {
+                        console.log(`[A-FrameChannel] <-- ${res.statusCode} ${stream.method} ${url} (stream complete)`);
+                        resolve();
+                    });
+
+                    res.on("error", (err) => reject(err));
+                },
+            );
+
+            req.setTimeout(60_000, () => {
+                console.error(`[A-FrameChannel] TIMEOUT ${stream.method} ${url}`);
+                req.destroy(
+                    new A_FrameChannelError({
+                        title: A_FrameChannelError.Timeout,
+                        description: `Stream request to ${stream.path} timed out after 60 seconds`,
+                    }),
+                );
+            });
+
+            req.on("error", (err) => reject(err));
+
+            if (payload) req.write(payload);
+            req.end();
+        });
+
+        stream.complete();
+    }
+
+
+    async send(
+        @A_Inject(A_FrameChannelStream) stream: A_FrameChannelStream,
+        @A_Inject(A_FrameChannelEvent) event: A_FrameChannelEvent,
+        @A_Inject(A_FrameEnv) env: A_FrameEnv,
+    ) {
+        // SSE is server-to-client only; to push data back to the server
+        // during an active stream session we make a separate HTTP POST to
+        // a companion endpoint.
+        //
+        // Convention: same base path as the stream with "/send" appended —
+        // adjust to match your server-side routing.
+        const url = `${env.A_FRAME_SERVER_URL}${stream.path}/send`;
+        const parsedUrl = new URL(url);
+        const client = parsedUrl.protocol === "https:" ? https : http;
+
+        // Always serialise as { type, data } so the server can dispatch
+        // the same way it dispatches events back to the client.
+        const payload = JSON.stringify({ type: event.name, data: event.data });
+
+        await new Promise<void>((resolve, reject) => {
+            const req = client.request(
+                {
+                    protocol: parsedUrl.protocol,
+                    hostname: parsedUrl.hostname,
+                    port: parsedUrl.port,
+                    path: `${parsedUrl.pathname}${parsedUrl.search}`,
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${env.A_FRAME_SERVER_API_KEY}`,
+                        "Content-Length": Buffer.byteLength(payload),
+                    },
+                },
+                (res) => {
+                    // Drain the response so the socket can be freed/reused.
+                    res.resume();
+
+                    res.on("end", () => {
+                        if ((res.statusCode ?? 500) >= 400) {
+                            console.error(`[A-FrameChannel] <-- ${res.statusCode} POST ${url}`);
+                            reject(
+                                new A_FrameChannelError({
+                                    title: A_FrameChannelError.RequestFailed,
+                                    description: `Send event "${event.name}" to ${stream.path} failed with status ${res.statusCode}`,
+                                }),
+                            );
+                            return;
+                        }
+
+                        console.log(`[A-FrameChannel] --> ${res.statusCode} POST ${url} (event: ${event.name})`);
+                        resolve();
+                    });
+                },
+            );
+
+            req.setTimeout(15_000, () => {
+                console.error(`[A-FrameChannel] TIMEOUT POST ${url}`);
+                req.destroy(
+                    new A_FrameChannelError({
+                        title: A_FrameChannelError.Timeout,
+                        description: `Send event "${event.name}" to ${stream.path} timed out after 15 seconds`,
+                    }),
+                );
+            });
+
+            req.on("error", (err) => reject(err));
+
+            req.write(payload);
+            req.end();
+        });
+    }
+}
+
+//     // ─── WebSocket feature ────────────────────────────────────────────────────
+
+//     @A_Feature.Extend({
+//         name: A_FrameFeatures.Socket,
+//         scope: [A_FrameChannel],
+//     })
+//     async socket(
+//         @A_Inject(A_FrameChannelSocket) socket: A_FrameChannelSocket,
+//         @A_Inject(A_FrameEnv) env: A_FrameEnv,
+//     ) {
+//         const url = `${env.A_FRAME_SERVER_URL}${socket.path}`;
+//         const parsedUrl = new URL(url);
+
+//         // Both http→ws and https→wss are TLS-detected the same way
+//         const isSecure =
+//             parsedUrl.protocol === "https:" || parsedUrl.protocol === "wss:";
+
+//         const hostname = parsedUrl.hostname;
+//         const port = parsedUrl.port
+//             ? parseInt(parsedUrl.port, 10)
+//             : isSecure ? 443 : 80;
+//         const wsPath = `${parsedUrl.pathname}${parsedUrl.search}`;
+//         const hostHeader = parsedUrl.port ? `${hostname}:${parsedUrl.port}` : hostname;
+
+//         // ── WebSocket opening handshake (RFC 6455 §4.1) ─────────────────────
+//         // Generate a fresh 16-byte random key.  The server must echo it back
+//         // as SHA-1("key" + magic) in Sec-WebSocket-Accept, which we verify to
+//         // guard against accidental plain-HTTP responses being accepted as WS.
+//         const wsKey = crypto.randomBytes(16).toString("base64");
+//         const expectedAccept = crypto
+//             .createHash("sha1")
+//             .update(wsKey + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11")
+//             .digest("base64");
+
+//         await new Promise<void>((resolve, reject) => {
+//             // Establish raw TCP (or TLS) transport without HTTP machinery
+//             const rawSocket: net.Socket = isSecure
+//                 ? tls.connect({ host: hostname, port, servername: hostname })
+//                 : net.connect({ host: hostname, port });
+
+//             let handshakeDone = false;
+//             let frameBuffer = Buffer.alloc(0);
+
+//             // ── Send the HTTP/1.1 Upgrade request once transport is ready ────
+//             function sendHandshake() {
+//                 // If the caller provided a body, encode it in a custom header so
+//                 // it survives the GET-only WebSocket upgrade request.
+//                 const initHeader = socket.body !== undefined
+//                     ? [`X-A-Frame-Init: ${Buffer.from(JSON.stringify(socket.body)).toString("base64")}`]
+//                     : [];
+
+//                 const lines = [
+//                     `GET ${wsPath} HTTP/1.1`,
+//                     `Host: ${hostHeader}`,
+//                     "Upgrade: websocket",
+//                     "Connection: Upgrade",
+//                     `Sec-WebSocket-Key: ${wsKey}`,
+//                     "Sec-WebSocket-Version: 13",
+//                     // Auth header — same Bearer token used by all other methods
+//                     `Authorization: Bearer ${env.A_FRAME_SERVER_API_KEY}`,
+//                     ...initHeader,
+//                     "",  // produces the mandatory blank CRLF line
+//                     "",
+//                 ];
+
+//                 rawSocket.write(lines.join("\r\n"));
+//             }
+
+//             // For TLS, wait until the TLS handshake finishes before writing
+//             if (isSecure) {
+//                 (rawSocket as tls.TLSSocket).once("secureConnect", sendHandshake);
+//             } else {
+//                 rawSocket.once("connect", sendHandshake);
+//             }
+
+//             rawSocket.on("data", async (chunk: Buffer) => {
+//                 frameBuffer = Buffer.concat([frameBuffer, chunk]);
+
+//                 // ── Phase 1: wait for the HTTP 101 response header block ─────
+//                 if (!handshakeDone) {
+//                     const headEnd = frameBuffer.indexOf("\r\n\r\n");
+//                     if (headEnd === -1) return; // headers still arriving
+
+//                     const statusBlock = frameBuffer.slice(0, headEnd).toString("utf8");
+//                     frameBuffer = frameBuffer.slice(headEnd + 4);
+
+//                     // Reject anything that isn't a 101 Switching Protocols
+//                     const statusLine = statusBlock.split("\r\n")[0];
+//                     if (!statusLine.includes("101")) {
+//                         rawSocket.destroy();
+//                         reject(
+//                             new A_FrameChannelError({
+//                                 title: A_FrameChannelError.RequestFailed,
+//                                 description: `WebSocket upgrade rejected: ${statusLine}`,
+//                             }),
+//                         );
+//                         return;
+//                     }
+
+//                     // ── Sec-WebSocket-Accept verification ────────────────────
+//                     // Confirms the server is a genuine WebSocket endpoint and not
+//                     // an HTTP proxy replaying our request unchanged.
+//                     const acceptMatch = statusBlock.match(/Sec-WebSocket-Accept:\s*([^\r\n]+)/i);
+//                     if (!acceptMatch || acceptMatch[1].trim() !== expectedAccept) {
+//                         rawSocket.destroy();
+//                         reject(
+//                             new A_FrameChannelError({
+//                                 title: A_FrameChannelError.RequestFailed,
+//                                 description:
+//                                     "WebSocket handshake failed: invalid Sec-WebSocket-Accept — possible MITM or non-WS endpoint",
+//                             }),
+//                         );
+//                         return;
+//                     }
+
+//                     handshakeDone = true;
+
+//                     // Attach the send capability now that the socket is open
+//                     socket.attachSendFn((data: string) => {
+//                         rawSocket.write(encodeWebSocketFrame(data));
+//                     });
+
+//                     console.log(`[A-FrameChannel] WS OPEN ${url}`);
+//                 }
+
+//                 // ── Phase 2: parse and dispatch complete WS frames ───────────
+//                 while (frameBuffer.length >= 2) {
+//                     const { frame, consumed } = tryParseWebSocketFrame(frameBuffer);
+//                     if (!frame || consumed === 0) break; // incomplete frame — wait for more data
+
+//                     frameBuffer = frameBuffer.slice(consumed);
+
+//                     switch (frame.opcode) {
+//                         case 0x8: {
+//                             // Close frame — echo it back and tear down gracefully
+//                             rawSocket.write(encodeWebSocketFrame("", 0x8));
+//                             rawSocket.end();
+//                             socket.complete();
+//                             console.log(`[A-FrameChannel] WS CLOSE ${url}`);
+//                             resolve();
+//                             return;
+//                         }
+
+//                         case 0x9: {
+//                             // Ping — must reply with Pong carrying the same payload (RFC 6455 §5.5.2)
+//                             rawSocket.write(encodeWebSocketFrame(frame.payload.toString("utf8"), 0xa));
+//                             break;
+//                         }
+
+//                         case 0x1:
+//                         case 0x2: {
+//                             // ──────────────────────────────────────────────────
+//                             // SERVER ACTION DISPATCH
+//                             // Each text/binary frame carries a JSON payload shaped
+//                             // as { type: string, data: any }.
+//                             //
+//                             // Add new cases in a subclass via:
+//                             //   @A_FrameChannelSocket.onEvent('type_name')
+//                             //   async onTypeName(@A_Inject(A_FrameChannelEvent) event) { ... }
+//                             // ──────────────────────────────────────────────────
+//                             const text = frame.payload.toString("utf8");
+//                             try {
+//                                 const event = JSON.parse(text);
+//                                 await socket.propagate(event.type, event.data);
+//                             } catch {
+//                                 console.error(
+//                                     `[A-FrameChannel] Invalid WS payload from ${socket.path}: ${text}`,
+//                                 );
+//                             }
+//                             break;
+//                         }
+//                     }
+//                 }
+//             });
+
+//             rawSocket.on("end", () => {
+//                 socket.complete();
+//                 resolve();
+//             });
+
+//             rawSocket.on("error", (err) => {
+//                 socket.fail(
+//                     new A_FrameChannelError({
+//                         title: A_FrameChannelError.RequestFailed,
+//                         description: `WebSocket error on ${socket.path}: ${err.message}`,
+//                     }),
+//                 );
+//                 reject(err);
+//             });
+
+//             // 60 s idle timeout — same as stream; adjust per use-case
+//             rawSocket.setTimeout(60_000, () => {
+//                 console.error(`[A-FrameChannel] WS TIMEOUT ${url}`);
+//                 rawSocket.destroy(
+//                     new A_FrameChannelError({
+//                         title: A_FrameChannelError.Timeout,
+//                         description: `WebSocket connection to ${socket.path} timed out after 60 seconds`,
+//                     }),
+//                 );
+//             });
+//         });
+//     }
+// }
+
+
+// // =============================================================================
+// // WebSocket frame helpers (RFC 6455)
+// // Module-level pure functions — no external dependencies required.
+// // =============================================================================
+
+// /**
+//  * Encode `data` as a masked WebSocket text frame (opcode 0x1).
+//  * Client → server frames MUST be masked per RFC 6455 §5.3.
+//  * Pass opcode 0x8 for a close frame, 0xa for pong, etc.
+//  */
+// function encodeWebSocketFrame(data: string, opcode: number = 0x1): Buffer {
+//     const payload = Buffer.from(data, "utf8");
+//     const len = payload.length;
+
+//     // 4-byte random masking key — new key per frame (RFC 6455 §10.3)
+//     const mask = crypto.randomBytes(4);
+
+//     // Header size: 2 base bytes + 0/2/8 extended length bytes + 4 mask bytes
+//     let headerLen = 6;
+//     if (len > 65535) headerLen += 8;
+//     else if (len > 125) headerLen += 2;
+
+//     const frame = Buffer.allocUnsafe(headerLen + len);
+//     frame[0] = 0x80 | (opcode & 0x0f); // FIN=1, opcode
+
+//     let offset = 1;
+//     if (len <= 125) {
+//         frame[offset++] = 0x80 | len;          // MASK=1, 7-bit length
+//     } else if (len <= 65535) {
+//         frame[offset++] = 0x80 | 126;          // MASK=1, 16-bit extended length
+//         frame.writeUInt16BE(len, offset);
+//         offset += 2;
+//     } else {
+//         frame[offset++] = 0x80 | 127;          // MASK=1, 64-bit extended length
+//         frame.writeBigUInt64BE(BigInt(len), offset);
+//         offset += 8;
+//     }
+
+//     mask.copy(frame, offset);
+//     offset += 4;
+
+//     for (let i = 0; i < len; i++) {
+//         frame[offset + i] = payload[i] ^ mask[i % 4];
+//     }
+
+//     return frame;
+// }
+
+// /**
+//  * Attempt to parse one complete WebSocket frame from `buf`.
+//  * Returns `{ frame: null, consumed: 0 }` if the buffer does not yet contain a
+//  * complete frame — the caller should buffer more data and retry.
+//  *
+//  * Server → client frames are never masked, so no unmasking is needed here.
+//  * If the server incorrectly sends a masked frame it is unmasked anyway.
+//  */
+// function tryParseWebSocketFrame(
+//     buf: Buffer,
+// ): { frame: { opcode: number; payload: Buffer; fin: boolean } | null; consumed: number } {
+//     if (buf.length < 2) return { frame: null, consumed: 0 };
+
+//     const fin = (buf[0] & 0x80) !== 0;
+//     const opcode = buf[0] & 0x0f;
+//     const masked = (buf[1] & 0x80) !== 0;
+//     let payloadLen = buf[1] & 0x7f;
+//     let offset = 2;
+
+//     if (payloadLen === 126) {
+//         if (buf.length < 4) return { frame: null, consumed: 0 };
+//         payloadLen = buf.readUInt16BE(2);
+//         offset = 4;
+//     } else if (payloadLen === 127) {
+//         if (buf.length < 10) return { frame: null, consumed: 0 };
+//         payloadLen = Number(buf.readBigUInt64BE(2));
+//         offset = 10;
+//     }
+
+//     const maskBytes = masked ? 4 : 0;
+//     if (buf.length < offset + maskBytes + payloadLen) {
+//         return { frame: null, consumed: 0 };
+//     }
+
+//     let maskKey: Buffer | null = null;
+//     if (masked) {
+//         maskKey = buf.slice(offset, offset + 4);
+//         offset += 4;
+//     }
+
+//     const payload = Buffer.from(buf.slice(offset, offset + payloadLen));
+//     if (masked && maskKey) {
+//         for (let i = 0; i < payload.length; i++) {
+//             payload[i] ^= maskKey[i % 4];
+//         }
+//     }
+
+//     return { frame: { opcode, payload, fin }, consumed: offset + payloadLen };
+// }