1import net from "node:net";
2import tls from "node:tls";
3import { URL } from "node:url";
4import { SocksClient } from "socks";
5 
6import type {
7  WechatClient,
8  WechatHttpInit,
9  WechatHttpResponse,
10} from "./wechat-http.ts";
11 
12export interface SocksProxyEndpoint {
13  host: string;
14  port: number;
15}
16 
17export function createSocksClient(proxy: SocksProxyEndpoint): WechatClient {
18  if (!proxy.host) throw new Error("SOCKS proxy host required");
19  if (!Number.isInteger(proxy.port) || proxy.port < 1 || proxy.port > 65535) {
20    throw new Error(`Invalid SOCKS proxy port: ${proxy.port}`);
21  }
22 
23  return async (url, init = {}) => {
24    return wechatHttpViaSocks(url, init, proxy);
25  };
26}
27 
28async function wechatHttpViaSocks(
29  rawUrl: string,
30  init: WechatHttpInit,
31  proxy: SocksProxyEndpoint,
32): Promise<WechatHttpResponse> {
33  const url = new URL(rawUrl);
34  const isHttps = url.protocol === "https:";
35  if (url.protocol !== "https:" && url.protocol !== "http:") {
36    throw new Error(`Unsupported protocol for SOCKS client: ${url.protocol}`);
37  }
38  const targetPort = url.port ? Number(url.port) : isHttps ? 443 : 80;
39 
40  const { socket: tcpSocket } = await SocksClient.createConnection({
41    proxy: { host: proxy.host, port: proxy.port, type: 5 },
42    command: "connect",
43    destination: { host: url.hostname, port: targetPort },
44  });
45 
46  let stream: net.Socket | tls.TLSSocket;
47  if (isHttps) {
48    const tlsSocket = tls.connect({ socket: tcpSocket, servername: url.hostname });
49    await new Promise<void>((resolve, reject) => {
50      const onSecure = () => {
51        tlsSocket.removeListener("error", onError);
52        resolve();
53      };
54      const onError = (err: Error) => {
55        tlsSocket.removeListener("secureConnect", onSecure);
56        try {
57          tlsSocket.destroy();
58        } catch {
59          /* noop */
60        }
61        try {
62          tcpSocket.destroy();
63        } catch {
64          /* noop */
65        }
66        reject(err);
67      };
68      tlsSocket.once("secureConnect", onSecure);
69      tlsSocket.once("error", onError);
70    });
71    stream = tlsSocket;
72  } else {
73    stream = tcpSocket;
74  }
75 
76  try {
77    return await sendRequestAndReadResponse(stream, url, init);
78  } finally {
79    try {
80      stream.destroy();
81    } catch {
82      /* noop */
83    }
84  }
85}
86 
87async function sendRequestAndReadResponse(
88  stream: net.Socket | tls.TLSSocket,
89  url: URL,
90  init: WechatHttpInit,
91): Promise<WechatHttpResponse> {
92  const method = init.method ?? (init.body !== undefined ? "POST" : "GET");
93  const body =
94    init.body === undefined
95      ? undefined
96      : Buffer.isBuffer(init.body)
97        ? init.body
98        : Buffer.from(init.body, "utf-8");
99 
100  const userHeaders = init.headers ?? {};
101  const headerMap = new Map<string, string>();
102  for (const [k, v] of Object.entries(userHeaders)) {
103    headerMap.set(k.toLowerCase(), `${k}: ${v}`);
104  }
105  if (!headerMap.has("host")) headerMap.set("host", `Host: ${url.host}`);
106  if (!headerMap.has("user-agent")) {
107    headerMap.set("user-agent", "User-Agent: baoyu-skills-wechat-api");
108  }
109  headerMap.set("connection", "Connection: close");
110  if (body && !headerMap.has("content-length")) {
111    headerMap.set("content-length", `Content-Length: ${body.length}`);
112  }
113 
114  const path = `${url.pathname || "/"}${url.search}`;
115  const requestHeader = Buffer.from(
116    `${method} ${path} HTTP/1.1\r\n` +
117      Array.from(headerMap.values()).join("\r\n") +
118      "\r\n\r\n",
119    "utf-8",
120  );
121 
122  await writeAll(stream, requestHeader);
123  if (body) await writeAll(stream, body);
124 
125  const raw = await readToEnd(stream);
126  return parseHttpResponse(raw);
127}
128 
129function writeAll(stream: net.Socket | tls.TLSSocket, data: Buffer): Promise<void> {
130  return new Promise((resolve, reject) => {
131    stream.write(data, (err) => {
132      if (err) reject(err);
133      else resolve();
134    });
135  });
136}
137 
138function readToEnd(stream: net.Socket | tls.TLSSocket): Promise<Buffer> {
139  return new Promise((resolve, reject) => {
140    const chunks: Buffer[] = [];
141    stream.on("data", (chunk: Buffer) => chunks.push(chunk));
142    stream.once("end", () => resolve(Buffer.concat(chunks)));
143    stream.once("error", reject);
144  });
145}
146 
147function parseHttpResponse(raw: Buffer): WechatHttpResponse {
148  const headerEnd = raw.indexOf("\r\n\r\n");
149  if (headerEnd < 0) {
150    throw new Error("Malformed HTTP response: missing header terminator");
151  }
152  const headerText = raw.subarray(0, headerEnd).toString("utf-8");
153  let bodyBytes = raw.subarray(headerEnd + 4);
154 
155  const lines = headerText.split("\r\n");
156  const statusLine = lines.shift() ?? "";
157  const statusMatch = statusLine.match(/^HTTP\/[\d.]+\s+(\d+)(?:\s+(.*))?$/);
158  if (!statusMatch) {
159    throw new Error(`Malformed HTTP status line: ${statusLine}`);
160  }
161  const status = Number.parseInt(statusMatch[1]!, 10);
162  const statusText = statusMatch[2] ?? "";
163 
164  const headers: Record<string, string | string[] | undefined> = {};
165  const lowercaseHeaders: Record<string, string> = {};
166  for (const line of lines) {
167    const colon = line.indexOf(":");
168    if (colon < 0) continue;
169    const key = line.slice(0, colon).trim();
170    const value = line.slice(colon + 1).trim();
171    const lower = key.toLowerCase();
172    const existing = headers[lower];
173    if (existing === undefined) {
174      headers[lower] = value;
175    } else if (Array.isArray(existing)) {
176      existing.push(value);
177    } else {
178      headers[lower] = [existing, value];
179    }
180    lowercaseHeaders[lower] = value;
181  }
182 
183  const transferEncoding = (lowercaseHeaders["transfer-encoding"] ?? "").toLowerCase();
184  if (transferEncoding.split(",").map((s) => s.trim()).includes("chunked")) {
185    bodyBytes = dechunk(bodyBytes);
186  } else if (lowercaseHeaders["content-length"] !== undefined) {
187    const length = Number.parseInt(lowercaseHeaders["content-length"]!, 10);
188    if (Number.isFinite(length) && length >= 0) {
189      bodyBytes = bodyBytes.subarray(0, length);
190    }
191  }
192 
193  return {
194    status,
195    statusText,
196    headers,
197    async buffer() {
198      return bodyBytes;
199    },
200    async text() {
201      return bodyBytes.toString("utf-8");
202    },
203    async json<T = unknown>() {
204      return JSON.parse(bodyBytes.toString("utf-8")) as T;
205    },
206  };
207}
208 
209function dechunk(raw: Buffer): Buffer {
210  const parts: Buffer[] = [];
211  let offset = 0;
212  while (offset < raw.length) {
213    const lineEnd = raw.indexOf("\r\n", offset);
214    if (lineEnd < 0) break;
215    const sizeText = raw.subarray(offset, lineEnd).toString("ascii").split(";")[0]!.trim();
216    const size = Number.parseInt(sizeText, 16);
217    if (!Number.isFinite(size) || size < 0) {
218      throw new Error(`Invalid chunked-encoding size: ${sizeText}`);
219    }
220    offset = lineEnd + 2;
221    if (size === 0) break;
222    if (offset + size > raw.length) {
223      throw new Error("Chunked-encoding body truncated");
224    }
225    parts.push(raw.subarray(offset, offset + size));
226    offset += size + 2;
227  }
228  return Buffer.concat(parts);
229}
230