@bruch/max-client 0.1.0

package/src/transport/tcp.ts

@@ -0,0 +1,296 @@
+import type { Socket } from "bun";
+
+import { ConnectionError } from "../errors.ts";
+import { AsyncQueue, type Transport } from "./base.ts";
+
+export type TcpConnector = (
+  options: Bun.TCPSocketConnectOptions<undefined>,
+) => Promise<Socket<undefined>>;
+
+const defaultConnector: TcpConnector = async (options) => await Bun.connect(options);
+
+export class TcpTransport implements Transport<Uint8Array> {
+  private socket: Socket<undefined> | null = null;
+  private readonly chunks = new AsyncQueue<Uint8Array>();
+  private buffered: Uint8Array<ArrayBufferLike> = new Uint8Array();
+
+  constructor(
+    readonly host: string,
+    readonly port: number,
+    readonly useTls = true,
+    readonly proxy: string | null = null,
+    private readonly connector: TcpConnector = defaultConnector,
+  ) {}
+
+  get connected(): boolean {
+    return this.socket !== null && this.socket.readyState === 1;
+  }
+
+  async connect(): Promise<void> {
+    if (this.socket) return;
+    this.chunks.reset();
+    const endpoint = this.proxy ? new URL(this.proxy) : null;
+    let resolveOpen: () => void = () => undefined;
+    let rejectOpen: (error: Error) => void = () => undefined;
+    let opened = false;
+    const open = new Promise<void>((resolve, reject) => {
+      resolveOpen = resolve;
+      rejectOpen = reject;
+    });
+    const handlers = this.handlers();
+    try {
+      this.socket = await this.connector({
+        hostname: endpoint?.hostname ?? this.host,
+        port: endpoint ? Number(endpoint.port || defaultProxyPort(endpoint.protocol)) : this.port,
+        tls:
+          endpoint?.protocol === "https:"
+            ? { serverName: endpoint.hostname }
+            : !endpoint && this.useTls
+              ? { serverName: this.host }
+              : false,
+        socket: {
+          ...handlers,
+          open: () => {
+            opened = true;
+            resolveOpen();
+          },
+          close: (socket, error) => {
+            void handlers.close?.(socket, error);
+            if (!opened)
+              rejectOpen(error ?? new ConnectionError("Connection closed while opening"));
+          },
+          error: (socket, error) => {
+            void handlers.error?.(socket, error);
+            if (!opened) rejectOpen(error);
+          },
+          connectError: (socket, error) => {
+            void handlers.connectError?.(socket, error);
+            if (!opened) rejectOpen(error);
+          },
+          timeout: (socket) => {
+            void handlers.timeout?.(socket);
+            if (!opened) rejectOpen(new ConnectionError("Connection timed out while opening"));
+          },
+        },
+      });
+      await open;
+    } catch (error) {
+      this.socket = null;
+      throw error;
+    }
+    if (endpoint) {
+      await this.openTunnel(endpoint);
+      if (this.useTls) await this.upgradeTls();
+    }
+  }
+
+  async close(): Promise<void> {
+    this.socket?.end();
+    this.socket = null;
+    this.buffered = new Uint8Array();
+    this.chunks.reset();
+  }
+
+  async send(data: Uint8Array): Promise<void> {
+    if (!this.socket || !this.connected) throw new ConnectionError("Transport is not connected");
+    await this.sendRaw(data);
+  }
+
+  async recv(length?: number): Promise<Uint8Array> {
+    if (!this.connected) throw new ConnectionError("Transport is not connected");
+    if (length === undefined) return await this.chunks.shift();
+    while (this.buffered.byteLength < length) {
+      this.buffered = concatBytes(this.buffered, await this.chunks.shift());
+    }
+    const result = this.buffered.slice(0, length);
+    this.buffered = this.buffered.slice(length);
+    return result;
+  }
+
+  private handlers(): Bun.SocketHandler<undefined> {
+    return {
+      data: (_socket, data) => this.chunks.push(Uint8Array.from(data)),
+      close: (_socket, error) => {
+        this.socket = null;
+        this.chunks.fail(error ?? new ConnectionError("Connection closed"));
+      },
+      end: () => this.chunks.fail(new ConnectionError("Connection closed by server")),
+      error: (_socket, error) => this.chunks.fail(error),
+      connectError: (_socket, error) => this.chunks.fail(error),
+      timeout: () => this.chunks.fail(new ConnectionError("Connection timed out")),
+    };
+  }
+
+  private async openTunnel(proxy: URL): Promise<void> {
+    if (proxy.protocol === "http:" || proxy.protocol === "https:") {
+      await this.httpConnect(proxy);
+      return;
+    }
+    if (proxy.protocol === "socks5:" || proxy.protocol === "socks5h:") {
+      await this.socks5Connect(proxy);
+      return;
+    }
+    if (proxy.protocol === "socks4:" || proxy.protocol === "socks4a:") {
+      await this.socks4Connect(proxy);
+      return;
+    }
+    throw new TypeError(`Unsupported proxy protocol: ${proxy.protocol}`);
+  }
+
+  private async httpConnect(proxy: URL): Promise<void> {
+    const headers = [
+      `CONNECT ${this.host}:${this.port} HTTP/1.1`,
+      `Host: ${this.host}:${this.port}`,
+    ];
+    if (proxy.username || proxy.password) {
+      headers.push(
+        `Proxy-Authorization: Basic ${Buffer.from(`${decodeURIComponent(proxy.username)}:${decodeURIComponent(proxy.password)}`).toString("base64")}`,
+      );
+    }
+    await this.sendRaw(new TextEncoder().encode(`${headers.join("\r\n")}\r\n\r\n`));
+    const response = new TextDecoder().decode(
+      await this.readUntil(Uint8Array.from([13, 10, 13, 10])),
+    );
+    const status = Number(/^HTTP\/\d(?:\.\d)?\s+(\d{3})/.exec(response)?.[1]);
+    if (status !== 200)
+      throw new ConnectionError(`HTTP proxy CONNECT failed with status ${status || "unknown"}`);
+  }
+
+  private async socks5Connect(proxy: URL): Promise<void> {
+    const authenticated = Boolean(proxy.username || proxy.password);
+    await this.sendRaw(Uint8Array.from(authenticated ? [5, 2, 0, 2] : [5, 1, 0]));
+    const greeting = await this.recv(2);
+    if (greeting[0] !== 5 || greeting[1] === 0xff)
+      throw new ConnectionError("SOCKS5 negotiation failed");
+    if (greeting[1] === 2) {
+      const username = new TextEncoder().encode(decodeURIComponent(proxy.username));
+      const password = new TextEncoder().encode(decodeURIComponent(proxy.password));
+      if (username.length > 255 || password.length > 255)
+        throw new TypeError("SOCKS5 credentials are too long");
+      await this.sendRaw(
+        Uint8Array.from([1, username.length, ...username, password.length, ...password]),
+      );
+      const auth = await this.recv(2);
+      if (auth[1] !== 0) throw new ConnectionError("SOCKS5 authentication failed");
+    } else if (greeting[1] !== 0) {
+      throw new ConnectionError(`Unsupported SOCKS5 auth method: ${greeting[1]}`);
+    }
+    const hostname = new TextEncoder().encode(this.host);
+    if (hostname.length > 255) throw new TypeError("SOCKS5 hostname is too long");
+    await this.sendRaw(
+      Uint8Array.from([
+        5,
+        1,
+        0,
+        3,
+        hostname.length,
+        ...hostname,
+        (this.port >>> 8) & 0xff,
+        this.port & 0xff,
+      ]),
+    );
+    const head = await this.recv(4);
+    if (head[0] !== 5 || head[1] !== 0)
+      throw new ConnectionError(`SOCKS5 CONNECT failed: ${head[1]}`);
+    const addressLength = head[3] === 1 ? 4 : head[3] === 4 ? 16 : (await this.recv(1))[0];
+    if (addressLength === undefined) throw new ConnectionError("Invalid SOCKS5 response");
+    await this.recv(addressLength + 2);
+  }
+
+  private async socks4Connect(proxy: URL): Promise<void> {
+    const user = new TextEncoder().encode(decodeURIComponent(proxy.username));
+    const host = new TextEncoder().encode(this.host);
+    const request = Uint8Array.from([
+      4,
+      1,
+      (this.port >>> 8) & 0xff,
+      this.port & 0xff,
+      0,
+      0,
+      0,
+      1,
+      ...user,
+      0,
+      ...host,
+      0,
+    ]);
+    await this.sendRaw(request);
+    const response = await this.recv(8);
+    if (response[1] !== 90) throw new ConnectionError(`SOCKS4 CONNECT failed: ${response[1]}`);
+  }
+
+  private async upgradeTls(): Promise<void> {
+    const socket = this.socket;
+    if (!socket) throw new ConnectionError("Proxy socket closed before TLS upgrade");
+    await new Promise<void>((resolve, reject) => {
+      const handlers = this.handlers();
+      const [, tls] = socket.upgradeTLS({
+        tls: { serverName: this.host },
+        socket: {
+          ...handlers,
+          open: () => resolve(),
+          error: (_socket, error) => {
+            void handlers.error?.(_socket, error);
+            reject(error);
+          },
+        },
+      });
+      this.socket = tls;
+    });
+  }
+
+  private async sendRaw(data: Uint8Array): Promise<void> {
+    const socket = this.socket;
+    if (!socket || socket.readyState <= 0) throw new ConnectionError("Socket is not connected");
+    let offset = 0;
+    while (offset < data.byteLength) {
+      const written = socket.write(data, offset, data.byteLength - offset);
+      if (written < 0) throw new ConnectionError("Socket closed while writing");
+      if (written === 0) {
+        await Bun.sleep(0);
+        continue;
+      }
+      offset += written;
+    }
+    socket.flush();
+  }
+
+  private async readUntil(delimiter: Uint8Array): Promise<Uint8Array> {
+    let data = this.buffered;
+    for (;;) {
+      const index = findBytes(data, delimiter);
+      if (index >= 0) {
+        const end = index + delimiter.length;
+        const result = data.slice(0, end);
+        this.buffered = data.slice(end);
+        return result;
+      }
+      if (data.byteLength > 64 * 1024)
+        throw new ConnectionError("Proxy response header is too large");
+      data = concatBytes(data, await this.chunks.shift());
+    }
+  }
+}
+
+function concatBytes(left: Uint8Array, right: Uint8Array): Uint8Array {
+  const result = new Uint8Array(left.byteLength + right.byteLength);
+  result.set(left);
+  result.set(right, left.byteLength);
+  return result;
+}
+
+function defaultProxyPort(protocol: string): number {
+  if (protocol === "https:") return 443;
+  if (protocol === "http:") return 8080;
+  return 1080;
+}
+
+function findBytes(source: Uint8Array, target: Uint8Array): number {
+  outer: for (let index = 0; index <= source.length - target.length; index += 1) {
+    for (let offset = 0; offset < target.length; offset += 1) {
+      if (source[index + offset] !== target[offset]) continue outer;
+    }
+    return index;
+  }
+  return -1;
+}

package/src/transport/websocket.ts

@@ -0,0 +1,63 @@
+import { AsyncQueue, type Transport } from "./base.ts";
+import { ConnectionError } from "../errors.ts";
+
+export class WebSocketTransport implements Transport<string> {
+  private socket: WebSocket | null = null;
+  private readonly messages = new AsyncQueue<string>();
+
+  constructor(
+    readonly url: string,
+    readonly proxy: string | null = null,
+  ) {}
+
+  get connected(): boolean {
+    return this.socket?.readyState === WebSocket.OPEN;
+  }
+
+  async connect(): Promise<void> {
+    if (this.socket) return;
+    const socket = new WebSocket(this.url, {
+      headers: { Origin: "https://web.max.ru" },
+      ...(this.proxy ? { proxy: this.proxy } : {}),
+    });
+    this.socket = socket;
+    await new Promise<void>((resolve, reject) => {
+      socket.addEventListener("open", () => resolve(), { once: true });
+      socket.addEventListener(
+        "error",
+        () => reject(new ConnectionError("WebSocket connection failed")),
+        {
+          once: true,
+        },
+      );
+    });
+    socket.addEventListener("message", (event) => {
+      if (typeof event.data === "string") this.messages.push(event.data);
+      else this.messages.fail(new TypeError("Expected a text WebSocket frame"));
+    });
+    socket.addEventListener("close", () => {
+      this.socket = null;
+      this.messages.fail(new ConnectionError("WebSocket closed"));
+    });
+    socket.addEventListener("error", () =>
+      this.messages.fail(new ConnectionError("WebSocket failed")),
+    );
+  }
+
+  async close(): Promise<void> {
+    const socket = this.socket;
+    this.socket = null;
+    if (socket && socket.readyState < WebSocket.CLOSING) socket.close();
+    this.messages.clear();
+  }
+
+  async send(data: string): Promise<void> {
+    if (!this.socket || !this.connected) throw new ConnectionError("Transport is not connected");
+    this.socket.send(data);
+  }
+
+  async recv(): Promise<string> {
+    if (!this.connected) throw new ConnectionError("Transport is not connected");
+    return await this.messages.shift();
+  }
+}

package/src/types/attachments.ts

@@ -0,0 +1,24 @@
+import { asRecord, asString } from "./utils.ts";
+
+export const AttachmentType = {
+  PHOTO: "PHOTO",
+  VIDEO: "VIDEO",
+  FILE: "FILE",
+  CONTACT: "CONTACT",
+  STICKER: "STICKER",
+  AUDIO: "AUDIO",
+  CONTROL: "CONTROL",
+  INLINE_KEYBOARD: "INLINE_KEYBOARD",
+  SHARE: "SHARE",
+  CALL: "CALL",
+} as const;
+
+export interface Attachment {
+  readonly type: string;
+  readonly raw: Readonly<Record<string, unknown>>;
+}
+
+export function parseAttachment(value: unknown): Attachment {
+  const raw = asRecord(value, "attachment");
+  return { type: asString(raw.type ?? raw._type, "UNKNOWN"), raw };
+}

package/src/types/index.ts

@@ -0,0 +1,3 @@
+export * from "./attachments.ts";
+export * from "./models.ts";
+export * from "./utils.ts";