@h-ai/serv 0.1.0-alpha.67 → 0.1.0-alpha.69

package/dist/index.js

@@ -1,26 +1,53 @@
-import { servM, WILDCARD_ROLE, WILDCARD_PERMISSION, implement, normalizeServLocale, buildHaiErrorBody } from './chunk-R354OMWL.js';
+import { validateInputOrFail, resolveRequestLocale, localizeZodError } from './chunk-BGWE4S6Z.js';
+import { servM, WILDCARD_ROLE, WILDCARD_PERMISSION, implement, buildHaiErrorBody } from './chunk-TWHCU6HT.js';
 import process from 'process';
 import { upgradeWebSocket, serve } from '@hono/node-server';
 import { apiContract, AUDIO_WS_PATH, AudioWsClientMessageSchema } from '@h-ai/api-contract';
-import { core, ok, err, HaiCommonError } from '@h-ai/core';
+import { core, HaiCommonError, err, ok } from '@h-ai/core';
 import { OpenAPIHandler } from '@orpc/openapi/fetch';
 import { RPCHandler } from '@orpc/server/fetch';
 import { Hono } from 'hono';
 import { WebSocketServer } from 'ws';
 import { Buffer } from 'buffer';
 import { BlockList, isIP } from 'net';
+import { TRANSPORT_PLAINTEXT_RANGE, TRANSPORT_BODY_LIMITS, TRANSPORT_PROTOCOL, authenticateTransportRequest, TransportTimeError, createTransportErrorResponse, TransportBodyTooLargeError, readTransportBody, isValidSM2PublicKey } from '@h-ai/crypto';
 import { z } from 'zod';
 import { getCookie } from 'hono/cookie';
 import { readFile } from 'fs/promises';
 import { OpenAPIGenerator } from '@orpc/openapi';
 import { ZodToJsonSchemaConverter } from '@orpc/zod/zod4';
-import { TRANSPORT_PROTOCOL } from '@h-ai/crypto';
 
 // src/adapters/serv-adapter-fetch.ts
 function toFetch(app) {
-  const handler = (input, init) => {
-    const request = input instanceof Request ? input : new Request(typeof input === "string" ? input : input.toString(), init);
-    return Promise.resolve(app.fetch(request));
+  const handler = async (input, init) => {
+    const request = new Request(input, init);
+    const { signal } = request;
+    signal.throwIfAborted();
+    let onAbort;
+    const cancelled = new Promise((_resolve, reject) => {
+      onAbort = () => reject(signal.reason);
+      signal.addEventListener("abort", onAbort, { once: true });
+    });
+    try {
+      return await Promise.race([
+        Promise.resolve().then(async () => {
+          signal.throwIfAborted();
+          const response = await app.fetch(request);
+          if (signal.aborted) {
+            try {
+              await response.body?.cancel(signal.reason);
+            } catch {
+            }
+            signal.throwIfAborted();
+          }
+          return response;
+        }),
+        cancelled
+      ]);
+    } finally {
+      if (onAbort)
+        signal.removeEventListener("abort", onAbort);
+    }
   };
   return handler;
 }
@@ -585,36 +612,6 @@ function createClientIpResolver(trustedProxies) {
     return current;
   };
 }
-var DEFAULT_LOCALE = "zh-CN";
-function resolveRequestLocale(headers) {
-  const get = (name) => {
-    if (headers instanceof Headers)
-      return headers.get(name) ?? void 0;
-    return headers[name] ?? headers[name.toLowerCase()];
-  };
-  const explicit = get("x-hai-locale");
-  if (explicit)
-    return normalizeServLocale(explicit);
-  return normalizeServLocale(get("accept-language") ?? get("Accept-Language") ?? DEFAULT_LOCALE);
-}
-function localizeZodError(zodError, locale) {
-  const resolvedLocale = normalizeServLocale(locale);
-  return core.zodValidation.mapZodErrorToFormErrors(
-    zodError,
-    core.zodValidation.createPrefixedZodMessageGetter(
-      "serv",
-      (messageKey, params) => servM(messageKey, { locale: resolvedLocale, params })
-    )
-  );
-}
-function validateInputOrFail(schema, input, locale = DEFAULT_LOCALE) {
-  const resolvedLocale = normalizeServLocale(locale);
-  const result = schema.safeParse(input);
-  if (result.success)
-    return ok(result.data);
-  const errors = localizeZodError(result.error, resolvedLocale);
-  return err(HaiCommonError.VALIDATION_ERROR, servM("serv_validationFailed", { locale: resolvedLocale }), errors);
-}
 
 // src/pipelines/serv-pipeline-require-internal-rpc.ts
 var pipelineLogger = core.logger.child({ module: "serv", scope: "pipeline" });
@@ -727,9 +724,9 @@ var RpcHttpConfigInputSchema = z.union([
 var TransportRuntimeConfigInputSchema = z.union([
   z.literal(false),
   z.object({
+    maxPlaintextBytes: z.number().int().min(TRANSPORT_PLAINTEXT_RANGE.min).max(TRANSPORT_PLAINTEXT_RANGE.max).optional().describe("\u53CC\u5411\u4E1A\u52A1\u660E\u6587 UTF-8 \u5B57\u8282\u4E0A\u9650\uFF1B\u9ED8\u8BA4 1 MiB\uFF0C\u5BC6\u6587\u4E0E\u4EE3\u7406\u9884\u7B97\u81EA\u52A8\u63A8\u5BFC").meta({ default: TRANSPORT_BODY_LIMITS.plaintextBytes }),
     keyExchangePath: AbsolutePathSchema.default("/_hai/key-exchange"),
-    excludePaths: z.array(AbsolutePathSchema).default([]),
-    maxClients: z.number().int().positive().default(1e4)
+    excludePaths: z.array(AbsolutePathSchema).default([])
   })
 ]);
 var ServerConfigInputSchema = z.object({
@@ -790,6 +787,9 @@ function resolveServTransportRuntimeConfig(input = false) {
 var HEADER_REQUEST_ID = "x-request-id";
 var HEADER_AUTHORIZATION = "authorization";
 var HEADER_USER_AGENT = "user-agent";
+function resolveRequestId(value) {
+  return value && /^[\w.:-]{1,128}$/.test(value) ? value : core.id.uuid();
+}
 function extractBearerToken(value) {
   if (!value)
     return void 0;
@@ -800,7 +800,7 @@ function extractBearerToken(value) {
 }
 function parseRequestContext(input) {
   const headers = input.request.headers;
-  const requestId = headers.get(HEADER_REQUEST_ID) ?? core.id.uuid();
+  const requestId = core.context.get().requestId ?? resolveRequestId(headers.get(HEADER_REQUEST_ID));
   const ip = normalizeClientIp(Object.hasOwn(input, "ip") ? input.ip : input.remoteAddress);
   const locale = resolveRequestLocale(headers);
   const accessToken = extractBearerToken(headers.get(HEADER_AUTHORIZATION));
@@ -848,7 +848,7 @@ function resolveRefreshCookieConfig(apiPrefix, config, iam) {
   return {
     cookieName: config.cookieName ?? "hai_refresh_token",
     maxAge: config.maxAge ?? 30 * 24 * 3600,
-    isSecure: config.secure ?? process.env.NODE_ENV === "production",
+    isSecure: config.secure ?? (process.env.NODE_ENV === "production" || process.env.HAI_CORE_ENV === "production"),
     refreshCookiePath: `${apiPrefix}${IAM_AUTH_PATHS.refresh}`,
     onRefresh,
     nativeTokenTransport: config.nativeTokenTransport
@@ -1058,7 +1058,6 @@ function readScalarBrowserEntry(packageInfo) {
   return typeof browser === "string" ? browser : void 0;
 }
 var logger2 = core.logger.child({ module: "serv", scope: "transport" });
-var MAX_ENCRYPTED_BODY = 1048576;
 var ENCRYPTABLE_RESPONSE_CONTENT_TYPES = ["application/json"];
 function createTransportMiddleware(manager, keyExchangePath, excludePaths = []) {
   return async (c, next) => {
@@ -1070,55 +1069,72 @@ function createTransportMiddleware(manager, keyExchangePath, excludePaths = [])
     const clientId = c.req.header(TRANSPORT_PROTOCOL.CLIENT_ID_HEADER);
     if (!clientId)
       return jsonError(servM("serv_transportClientIdRequired"), 400);
-    const clientPublicKey = await manager.getClientPublicKey(clientId);
-    if (!clientPublicKey)
-      return jsonError(servM("serv_transportClientKeyNotFound"), 400);
-    if (hasBody(c.req.method) && !isEmptyBody(c.req.raw)) {
-      const decErr = await decryptRequestInPlace(c, manager);
-      if (decErr)
-        return decErr;
+    let requestContext;
+    try {
+      const verified = await authenticateTransportRequest(manager, c.req.raw);
+      if (!verified.success) {
+        if (verified.error.cause instanceof TransportTimeError && verified.error.cause.context)
+          return createTransportErrorResponse(verified.error.cause, { manager, context: verified.error.cause.context });
+        return jsonError(servM("serv_transportDecryptFailed"), 400);
+      }
+      requestContext = verified.data.context;
+      if (c.req.method !== "GET" && c.req.method !== "HEAD")
+        replaceRequestBody(c, verified.data.plaintext);
+    } catch (error) {
+      if (error instanceof TransportBodyTooLargeError)
+        return createTransportErrorResponse(error);
+      return jsonError(servM("serv_transportInvalidPayload"), error instanceof RangeError ? 413 : 400);
     }
     await next();
     const response = c.res;
     if (!response)
       return;
     const contentType = response.headers.get("Content-Type") ?? "";
-    if (isEmptyResponse(response))
-      return;
-    if (!canEncryptResponseContentType(contentType)) {
-      c.res = jsonError(servM("serv_transportEncryptFailed"), 500);
-      return;
-    }
-    const contentLength = response.headers.get("Content-Length");
-    if (contentLength && Number.parseInt(contentLength, 10) > MAX_ENCRYPTED_BODY) {
+    const bodyless = c.req.method === "HEAD" || isEmptyResponse(response);
+    if (bodyless)
+      void response.body?.cancel().catch(() => {
+      });
+    c.header("Content-Length", void 0);
+    c.header("Content-Encoding", void 0);
+    c.header(TRANSPORT_PROTOCOL.ENCRYPTED_HEADER, void 0);
+    c.header(TRANSPORT_PROTOCOL.ENVELOPE_HEADER, void 0);
+    if (!bodyless && !canEncryptResponseContentType(contentType)) {
+      void response.body?.cancel().catch(() => {
+      });
       c.res = jsonError(servM("serv_transportEncryptFailed"), 500);
       return;
     }
     let bodyText;
     try {
-      bodyText = await response.clone().text();
+      bodyText = bodyless ? "" : await readTransportBody(response.body, {
+        maxBytes: manager.bodyLimits.plaintextBytes,
+        direction: "response",
+        signal: c.req.raw.signal
+      });
     } catch (cause) {
+      if (cause instanceof TransportBodyTooLargeError) {
+        c.res = await createTransportErrorResponse(cause, { manager, context: requestContext });
+        return;
+      }
       logger2.warn("Failed to read response body for encryption", { error: cause });
       c.res = jsonError(servM("serv_transportEncryptFailed"), 500);
       return;
     }
-    if (!bodyText)
-      return;
-    if (bodyText.length > MAX_ENCRYPTED_BODY) {
-      c.res = jsonError(servM("serv_transportEncryptFailed"), 500);
-      return;
-    }
-    const encResult = await manager.encryptResponse(clientId, bodyText);
+    const headers = new Headers(response.headers);
+    headers.delete(TRANSPORT_PROTOCOL.ENCRYPTED_HEADER);
+    headers.delete("Content-Length");
+    headers.delete("Content-Encoding");
+    const encResult = await manager.encryptResponse(requestContext, bodyText, response.status);
     if (!encResult.success) {
       logger2.warn("Failed to encrypt response", { error: encResult.error });
       c.res = jsonError(servM("serv_transportEncryptFailed"), 500);
       return;
     }
-    const headers = new Headers(response.headers);
     headers.set("Content-Type", "application/json; charset=utf-8");
     headers.set(TRANSPORT_PROTOCOL.ENCRYPTED_HEADER, TRANSPORT_PROTOCOL.ENCRYPTED_HEADER_VALUE);
-    headers.delete("Content-Length");
-    c.res = new Response(JSON.stringify(encResult.data), {
+    if (bodyless)
+      headers.set(TRANSPORT_PROTOCOL.ENVELOPE_HEADER, JSON.stringify(encResult.data));
+    c.res = new Response(bodyless ? null : JSON.stringify(encResult.data), {
       status: response.status,
       statusText: response.statusText,
       headers
@@ -1128,16 +1144,22 @@ function createTransportMiddleware(manager, keyExchangePath, excludePaths = [])
 async function handleKeyExchange(request, manager) {
   let body;
   try {
-    body = await request.json();
-  } catch {
-    return jsonError(servM("serv_transportInvalidPayload"), 400);
+    body = JSON.parse(await readTransportBody(request.body, {
+      maxBytes: TRANSPORT_BODY_LIMITS.keyExchangeBytes,
+      signal: request.signal
+    }));
+  } catch (error) {
+    return jsonError(servM("serv_transportInvalidPayload"), error instanceof RangeError ? 413 : 400);
   }
-  if (typeof body.clientPublicKey !== "string" || body.clientPublicKey.length === 0)
+  if (!body || typeof body !== "object" || !("clientPublicKey" in body) || !isValidSM2PublicKey(body.clientPublicKey) || new TextEncoder().encode(body.clientPublicKey).byteLength > TRANSPORT_BODY_LIMITS.publicKeyBytes) {
     return jsonError(servM("serv_transportInvalidPayload"), 400);
+  }
   try {
-    const clientId = await manager.registerClientKey(body.clientPublicKey);
     const serverPublicKey = manager.getServerPublicKey();
-    return new Response(JSON.stringify({ serverPublicKey, clientId }), {
+    if (new TextEncoder().encode(serverPublicKey).byteLength > TRANSPORT_BODY_LIMITS.publicKeyBytes)
+      return jsonError(servM("serv_transportKeyExchangeFailed"), 500);
+    const clientId = await manager.registerClientKey(body.clientPublicKey);
+    return new Response(JSON.stringify({ serverKeyId: manager.getServerKeyId(), serverPublicKey, clientId, maxPlaintextBytes: manager.bodyLimits.plaintextBytes }), {
       status: 200,
       headers: { "Content-Type": "application/json; charset=utf-8" }
     });
@@ -1146,37 +1168,23 @@ async function handleKeyExchange(request, manager) {
     return jsonError(servM("serv_transportKeyExchangeFailed"), 500);
   }
 }
-async function decryptRequestInPlace(c, manager) {
-  const isEncrypted = c.req.header(TRANSPORT_PROTOCOL.ENCRYPTED_HEADER) === TRANSPORT_PROTOCOL.ENCRYPTED_HEADER_VALUE;
-  if (!isEncrypted)
-    return jsonError(servM("serv_transportInvalidPayload"), 400);
-  let payload;
-  try {
-    payload = await c.req.raw.clone().json();
-  } catch {
-    return jsonError(servM("serv_transportInvalidPayload"), 400);
-  }
-  if (!isEncryptedPayloadShape(payload))
-    return jsonError(servM("serv_transportInvalidPayload"), 400);
-  const decResult = manager.decryptRequest(payload);
-  if (!decResult.success) {
-    logger2.warn("Failed to decrypt request", { error: decResult.error });
-    return jsonError(servM("serv_transportDecryptFailed"), 400);
-  }
+function replaceRequestBody(c, body) {
   const original = c.req.raw;
   const newHeaders = new Headers(original.headers);
   newHeaders.delete(TRANSPORT_PROTOCOL.ENCRYPTED_HEADER);
   newHeaders.delete("Content-Length");
+  newHeaders.delete("Content-Encoding");
   newHeaders.set("Content-Type", "application/json; charset=utf-8");
   const newRequest = new Request(original.url, {
     method: original.method,
     headers: newHeaders,
-    body: decResult.data,
+    body,
+    signal: original.signal,
     // @ts-expect-error Node fetch 需要 duplex 才能携带流式 body。
     duplex: "half"
   });
   c.req.raw = newRequest;
-  return void 0;
+  c.req.bodyCache = {};
 }
 function shouldExclude(pathname, excludePaths, keyExchangePath) {
   if (pathname === keyExchangePath)
@@ -1189,18 +1197,7 @@ function canEncryptResponseContentType(contentType) {
 function isEmptyResponse(response) {
   if ([204, 304].includes(response.status))
     return true;
-  return response.headers.get("Content-Length") === "0";
-}
-function hasBody(method) {
-  return ["POST", "PUT", "PATCH", "DELETE"].includes(method.toUpperCase());
-}
-function isEmptyBody(req) {
-  if (req.body === null)
-    return true;
-  const cl = req.headers.get("Content-Length");
-  if (cl !== null)
-    return Number.parseInt(cl, 10) === 0;
-  return !req.headers.get("Content-Type");
+  return response.body === null;
 }
 function jsonError(message, status) {
   return new Response(JSON.stringify({ error: message }), {
@@ -1208,12 +1205,6 @@ function jsonError(message, status) {
     headers: { "Content-Type": "application/json; charset=utf-8" }
   });
 }
-function isEncryptedPayloadShape(value) {
-  if (!value || typeof value !== "object")
-    return false;
-  const p = value;
-  return typeof p.encryptedKey === "string" && typeof p.ciphertext === "string" && typeof p.iv === "string";
-}
 
 // src/serv-app.ts
 var API_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"];
@@ -1221,6 +1212,11 @@ var audioWsServers = /* @__PURE__ */ new WeakMap();
 function createApp(options) {
   const http = resolveServHttpConfig(options.http);
   const app = new Hono();
+  app.use("*", async (c, next) => {
+    const requestId = resolveRequestId(c.req.header("x-request-id") ?? null);
+    await core.context.run({ requestId, userId: void 0, scopeId: void 0, jobId: void 0 }, () => core.i18n.runWithLocale(resolveRequestLocale(c.req.raw.headers), next));
+    c.header("x-request-id", requestId);
+  });
   app.notFound((c) => c.json(buildHaiErrorBody(
     HaiCommonError.NOT_FOUND,
     core.i18n.coreM("core_errorNotFound", { locale: resolveRequestLocale(c.req.raw.headers) })
@@ -1240,8 +1236,9 @@ function createApp(options) {
     mountCustomMiddlewares(app, options.middlewares);
   if (options.transport) {
     const mgr = options.transport.crypto.transport.createServer({
+      serverKeyRing: options.transport.serverKeyRing,
       keyStore: options.transport.keyStore,
-      maxClients: options.transport.maxClients
+      maxPlaintextBytes: options.transport.maxPlaintextBytes
     });
     if (!mgr.success) {
       throw core.error.buildHaiErrorInst(
@@ -1323,7 +1320,7 @@ function mountRPCRoutes(app, procedures, rpcConfig, createContext) {
 }
 async function handleORPC(c, next, prefix, handler, createContext) {
   const context = await createContext({ request: c.req.raw, remoteAddress: readRemoteAddress(c.env) });
-  const { matched, response } = await handler.handle(c.req.raw, { prefix, context });
+  const { matched, response } = await core.context.run({ requestId: context.requestId, userId: context.session?.userId, scopeId: context.scopeId }, () => handler.handle(c.req.raw, { prefix, context }));
   if (!matched) {
     await next();
     return;