@linzumi/cli 0.0.20-beta → 0.0.22-beta

package/src/forwardTunnelProtocol.ts

@@ -1,324 +0,0 @@
-/*
-- Date: 2026-04-29
-  Spec: plans/2026-04-29-local-runner-streaming-forwarding-rca-plan.md
-  Relationship: Defines the runner-side binary local-forwarding tunnel frames
-  so editor/preview bytes avoid JSON/base64 Phoenix events.
-*/
-import { type JsonObject, isJsonObject } from "./protocol";
-
-const textEncoder = new TextEncoder();
-const textDecoder = new TextDecoder();
-const maxJsonPayloadBytes = 64 * 1024;
-const maxChunkBytes = 16 * 1024 * 1024;
-
-export const forwardTunnelChunkBytes = maxChunkBytes;
-
-export type ForwardTunnelWebSocketOpcode = "text" | "binary" | "ping" | "pong";
-
-export type ForwardTunnelFrame =
-  | {
-      readonly type: "open_http";
-      readonly streamId: number;
-      readonly payload: JsonObject;
-    }
-  | {
-      readonly type: "request_body_chunk";
-      readonly streamId: number;
-      readonly payload: Uint8Array;
-    }
-  | { readonly type: "request_body_end"; readonly streamId: number }
-  | {
-      readonly type: "response_headers";
-      readonly streamId: number;
-      readonly payload: JsonObject;
-    }
-  | {
-      readonly type: "response_body_chunk";
-      readonly streamId: number;
-      readonly payload: Uint8Array;
-    }
-  | { readonly type: "response_end"; readonly streamId: number }
-  | {
-      readonly type: "cancel";
-      readonly streamId: number;
-      readonly payload: JsonObject;
-    }
-  | {
-      readonly type: "stream_error";
-      readonly streamId: number;
-      readonly payload: JsonObject;
-    }
-  | {
-      readonly type: "open_websocket";
-      readonly streamId: number;
-      readonly payload: JsonObject;
-    }
-  | {
-      readonly type: "websocket_message";
-      readonly streamId: number;
-      readonly opcode: ForwardTunnelWebSocketOpcode;
-      readonly payload: Uint8Array;
-    }
-  | {
-      readonly type: "websocket_close";
-      readonly streamId: number;
-      readonly payload: JsonObject;
-    };
-
-export type DecodeForwardTunnelFrameResult =
-  | { readonly ok: true; readonly frame: ForwardTunnelFrame }
-  | { readonly ok: false; readonly error: string };
-
-export function encodeForwardTunnelFrame(
-  frame: ForwardTunnelFrame,
-): Uint8Array {
-  const type = frameTypeId(frame.type);
-  const body = framePayload(frame);
-  if (body.byteLength > maxChunkBytes) {
-    throw new Error("streaming_forward_payload_too_large");
-  }
-
-  const output = new Uint8Array(10 + body.byteLength);
-  output[0] = 75;
-  output[1] = 70;
-  output[2] = 84;
-  output[3] = 49;
-  output[4] = type;
-  output[5] = 0;
-  const view = new DataView(
-    output.buffer,
-    output.byteOffset,
-    output.byteLength,
-  );
-  view.setUint32(6, frame.streamId);
-  output.set(body, 10);
-  return output;
-}
-
-export function decodeForwardTunnelFrame(
-  input: Blob | ArrayBuffer | Uint8Array,
-): Promise<DecodeForwardTunnelFrameResult> {
-  return bytesFromMessage(input).then((bytes) =>
-    decodeForwardTunnelBytes(bytes),
-  );
-}
-
-export function decodeForwardTunnelBytes(
-  bytes: Uint8Array,
-): DecodeForwardTunnelFrameResult {
-  if (
-    bytes.byteLength < 10 ||
-    bytes[0] !== 75 ||
-    bytes[1] !== 70 ||
-    bytes[2] !== 84 ||
-    bytes[3] !== 49 ||
-    bytes[5] !== 0
-  ) {
-    return { ok: false, error: "invalid_streaming_forward_frame" };
-  }
-
-  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-  const type = frameTypeName(bytes[4]);
-  const streamId = view.getUint32(6);
-  const payload = bytes.subarray(10);
-
-  if (
-    type === undefined ||
-    streamId < 1 ||
-    payload.byteLength > maxChunkBytes
-  ) {
-    return { ok: false, error: "invalid_streaming_forward_frame" };
-  }
-
-  switch (type) {
-    case "open_http":
-    case "response_headers":
-    case "cancel":
-    case "stream_error":
-    case "open_websocket":
-    case "websocket_close":
-      return decodeJsonPayload(type, streamId, payload);
-    case "request_body_chunk":
-    case "response_body_chunk":
-      return { ok: true, frame: { type, streamId, payload } };
-    case "request_body_end":
-    case "response_end":
-      return payload.byteLength === 0
-        ? { ok: true, frame: { type, streamId } }
-        : { ok: false, error: "invalid_streaming_forward_frame" };
-    case "websocket_message":
-      return decodeWebSocketMessage(streamId, payload);
-  }
-}
-
-function framePayload(frame: ForwardTunnelFrame): Uint8Array {
-  switch (frame.type) {
-    case "open_http":
-    case "response_headers":
-    case "cancel":
-    case "stream_error":
-    case "open_websocket":
-    case "websocket_close": {
-      const encoded = textEncoder.encode(JSON.stringify(frame.payload));
-      if (encoded.byteLength > maxJsonPayloadBytes) {
-        throw new Error("streaming_forward_payload_too_large");
-      }
-      return encoded;
-    }
-    case "request_body_chunk":
-    case "response_body_chunk":
-      return frame.payload;
-    case "request_body_end":
-    case "response_end":
-      return new Uint8Array();
-    case "websocket_message": {
-      const output = new Uint8Array(1 + frame.payload.byteLength);
-      output[0] = websocketOpcodeId(frame.opcode);
-      output.set(frame.payload, 1);
-      return output;
-    }
-  }
-}
-
-function decodeJsonPayload(
-  type:
-    | "open_http"
-    | "response_headers"
-    | "cancel"
-    | "stream_error"
-    | "open_websocket"
-    | "websocket_close",
-  streamId: number,
-  payload: Uint8Array,
-): DecodeForwardTunnelFrameResult {
-  if (payload.byteLength > maxJsonPayloadBytes) {
-    return { ok: false, error: "streaming_forward_payload_too_large" };
-  }
-
-  try {
-    const parsed = JSON.parse(textDecoder.decode(payload));
-    return isJsonObject(parsed)
-      ? { ok: true, frame: { type, streamId, payload: parsed } }
-      : { ok: false, error: "invalid_streaming_forward_frame" };
-  } catch (_error) {
-    return { ok: false, error: "invalid_streaming_forward_frame" };
-  }
-}
-
-function decodeWebSocketMessage(
-  streamId: number,
-  payload: Uint8Array,
-): DecodeForwardTunnelFrameResult {
-  const opcode = websocketOpcodeName(payload[0]);
-  return opcode === undefined
-    ? { ok: false, error: "invalid_streaming_forward_frame" }
-    : {
-        ok: true,
-        frame: {
-          type: "websocket_message",
-          streamId,
-          opcode,
-          payload: payload.subarray(1),
-        },
-      };
-}
-
-function bytesFromMessage(
-  input: Blob | ArrayBuffer | Uint8Array,
-): Promise<Uint8Array> {
-  if (input instanceof Uint8Array) {
-    return Promise.resolve(input);
-  }
-
-  if (input instanceof ArrayBuffer) {
-    return Promise.resolve(new Uint8Array(input));
-  }
-
-  return input.arrayBuffer().then((buffer) => new Uint8Array(buffer));
-}
-
-function frameTypeId(type: ForwardTunnelFrame["type"]): number {
-  switch (type) {
-    case "open_http":
-      return 1;
-    case "request_body_chunk":
-      return 2;
-    case "request_body_end":
-      return 3;
-    case "response_headers":
-      return 4;
-    case "response_body_chunk":
-      return 5;
-    case "response_end":
-      return 6;
-    case "cancel":
-      return 7;
-    case "stream_error":
-      return 8;
-    case "open_websocket":
-      return 9;
-    case "websocket_message":
-      return 10;
-    case "websocket_close":
-      return 11;
-  }
-}
-
-function frameTypeName(typeId: number): ForwardTunnelFrame["type"] | undefined {
-  switch (typeId) {
-    case 1:
-      return "open_http";
-    case 2:
-      return "request_body_chunk";
-    case 3:
-      return "request_body_end";
-    case 4:
-      return "response_headers";
-    case 5:
-      return "response_body_chunk";
-    case 6:
-      return "response_end";
-    case 7:
-      return "cancel";
-    case 8:
-      return "stream_error";
-    case 9:
-      return "open_websocket";
-    case 10:
-      return "websocket_message";
-    case 11:
-      return "websocket_close";
-    default:
-      return undefined;
-  }
-}
-
-function websocketOpcodeId(opcode: ForwardTunnelWebSocketOpcode): number {
-  switch (opcode) {
-    case "text":
-      return 1;
-    case "binary":
-      return 2;
-    case "ping":
-      return 9;
-    case "pong":
-      return 10;
-  }
-}
-
-function websocketOpcodeName(
-  opcodeId: number,
-): ForwardTunnelWebSocketOpcode | undefined {
-  switch (opcodeId) {
-    case 1:
-      return "text";
-    case 2:
-      return "binary";
-    case 9:
-      return "ping";
-    case 10:
-      return "pong";
-    default:
-      return undefined;
-  }
-}