@southwind-ai/config 0.1.1 → 0.1.3

package/index.ts

@@ -1,4 +1,5 @@
 export * from "./src/definition.js";
 export * from "./src/environment-loader.js";
+export * from "./src/ai-openai-compatible.js";
 export * from "./src/platform.js";
 export * from "./src/secrets.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@southwind-ai/config",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "license": "UNLICENSED",
   "type": "module",
   "engines": {
@@ -8,11 +8,12 @@
   },
   "files": [
     "index.ts",
+    "src/ai-openai-compatible.ts",
     "src/**/*.ts",
     "!src/**/*.test.ts"
   ],
   "dependencies": {
-    "@southwind-ai/shared": "0.1.1",
+    "@southwind-ai/shared": "0.1.2",
     "zod": "^4.4.3"
   },
   "exports": {

package/src/ai-openai-compatible.ts

@@ -0,0 +1,131 @@
+import { isIP } from "node:net";
+import { z } from "zod";
+import { defineModuleConfig } from "./definition.js";
+import {
+  loadModuleConfigSync,
+  strictInteger,
+  type ConfigEnvironment,
+} from "./environment-loader.js";
+import { EnvironmentSecretResolver } from "./secrets.js";
+
+export interface OpenAiCompatibleDeploymentConfig {
+  baseUrl: string;
+  model: string;
+  apiKey?: string;
+  connectTimeoutMs: number;
+  requestTimeoutMs: number;
+  maxResponseBytes: number;
+}
+
+const deploymentSchema: z.ZodType<OpenAiCompatibleDeploymentConfig> =
+  z.strictObject({
+    baseUrl: z.string().transform(normalizeOpenAiCompatibleBaseUrl),
+    model: z.string().trim().min(1).max(200),
+    apiKey: z.string().trim().min(1).optional(),
+    connectTimeoutMs: z.number().int().min(100).max(30_000),
+    requestTimeoutMs: z.number().int().min(1_000).max(300_000),
+    maxResponseBytes: z
+      .number()
+      .int()
+      .min(1_024)
+      .max(16 * 1_024 * 1_024),
+  });
+
+export const openAiCompatibleDeploymentConfigDefinition =
+  defineModuleConfig<OpenAiCompatibleDeploymentConfig>({
+    key: "ai.openai-compatible",
+    label: "OpenAI-compatible 模型部署",
+    ownedEnvironmentPrefixes: ["QWEN_", "AI_PROVIDER_"],
+    schema: deploymentSchema,
+    environment: [
+      { key: "QWEN_API_URL", path: "baseUrl" },
+      { key: "QWEN_MODEL", path: "model" },
+      {
+        key: "QWEN_API_KEY",
+        path: "apiKey",
+        secret: { provider: "env" },
+      },
+      integer("AI_PROVIDER_CONNECT_TIMEOUT_MS", "connectTimeoutMs", 5_000),
+      integer("AI_PROVIDER_REQUEST_TIMEOUT_MS", "requestTimeoutMs", 60_000),
+      integer(
+        "AI_PROVIDER_MAX_RESPONSE_BYTES",
+        "maxResponseBytes",
+        2 * 1_024 * 1_024,
+      ),
+    ],
+  });
+
+export function loadOpenAiCompatibleDeploymentConfig(
+  environment: ConfigEnvironment = process.env,
+): OpenAiCompatibleDeploymentConfig {
+  return loadModuleConfigSync(
+    openAiCompatibleDeploymentConfigDefinition,
+    environment,
+    new EnvironmentSecretResolver(environment),
+  );
+}
+
+export function normalizeOpenAiCompatibleBaseUrl(raw: string): string {
+  let url: URL;
+  try {
+    url = new URL(raw.trim());
+  } catch {
+    throw new Error("OpenAI-compatible Endpoint 无效");
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error("OpenAI-compatible Endpoint 只允许 HTTP 或 HTTPS");
+  }
+  if (url.username || url.password || url.search || url.hash) {
+    throw new Error("OpenAI-compatible Endpoint 不允许凭据、查询串或片段");
+  }
+  const hostname = url.hostname.toLowerCase();
+  if (isCloudMetadataHost(hostname)) {
+    throw new Error("OpenAI-compatible Endpoint 禁止访问云 metadata");
+  }
+  if (url.protocol === "http:" && !isPrivateHost(hostname)) {
+    throw new Error("公网 OpenAI-compatible Endpoint 必须使用 HTTPS");
+  }
+  url.pathname = url.pathname.replace(/\/+$/, "");
+  return url.toString().replace(/\/$/, "");
+}
+
+function integer(key: string, path: string, defaultValue: number) {
+  return { key, path, defaultValue, decode: strictInteger };
+}
+
+function isPrivateHost(hostname: string): boolean {
+  if (
+    hostname === "localhost" ||
+    hostname.endsWith(".localhost") ||
+    hostname.endsWith(".internal") ||
+    hostname.endsWith(".local") ||
+    (!hostname.includes(".") && isIP(hostname) === 0)
+  ) {
+    return true;
+  }
+  if (isIP(hostname) === 4) {
+    const [first = 0, second = 0] = hostname.split(".").map(Number);
+    return (
+      first === 10 ||
+      first === 127 ||
+      (first === 172 && second >= 16 && second <= 31) ||
+      (first === 192 && second === 168)
+    );
+  }
+  if (isIP(hostname) === 6) {
+    return (
+      hostname === "::1" ||
+      hostname.startsWith("fc") ||
+      hostname.startsWith("fd")
+    );
+  }
+  return false;
+}
+
+function isCloudMetadataHost(hostname: string): boolean {
+  return (
+    hostname === "169.254.169.254" ||
+    hostname === "metadata.google.internal" ||
+    hostname === "metadata.azure.internal"
+  );
+}

package/src/platform.ts

@@ -1,4 +1,11 @@
-import type { DatabaseDialect } from "@southwind-ai/shared";
+import type {
+  DatabaseDialect,
+  LicenseCatalogDefinition,
+} from "@southwind-ai/shared";
+import {
+  parseLicenseCatalog,
+  parseLicenseCatalogJson,
+} from "@southwind-ai/shared";
 import { z } from "zod";
 import { defineModuleConfig, ModuleConfigRegistry } from "./definition.js";
 import {
@@ -33,6 +40,8 @@ export interface PlatformConfig {
     publicKeyId?: string;
     publicKey?: string;
     machineCode?: string;
+    /** 宿主自定义 License 版本目录；未配置时回退 shared 默认三级目录。 */
+    versions?: LicenseCatalogDefinition[];
   };
   audit: { enabled: boolean; redactFields: string[] };
   compatibility: {
@@ -75,6 +84,20 @@ const platformSchema: z.ZodType<PlatformConfig> = z.strictObject({
     publicKeyId: z.string().trim().min(1).optional(),
     publicKey: z.string().trim().min(1).optional(),
     machineCode: z.string().trim().min(1).optional(),
+    versions: z
+      .unknown()
+      .transform((value, context) => {
+        try {
+          return parseLicenseCatalog(value);
+        } catch (error) {
+          context.addIssue({
+            code: "custom",
+            message: error instanceof Error ? error.message : "版本目录无效",
+          });
+          return z.NEVER;
+        }
+      })
+      .optional(),
   }),
   audit: z.strictObject({
     enabled: z.boolean(),
@@ -105,6 +128,7 @@ export const platformConfigDefinition = defineModuleConfig<PlatformConfig>({
     "LICENSE_PUBLIC_KEY_ID",
     "LICENSE_PUBLIC_KEY",
     "LICENSE_MACHINE_CODE",
+    "WINDY_LICENSE_VERSIONS",
   ],
   environment: [
     value("PLATFORM_NAME", "name", "Windy Platform"),
@@ -133,6 +157,9 @@ export const platformConfigDefinition = defineModuleConfig<PlatformConfig>({
     value("LICENSE_PUBLIC_KEY_ID", "license.publicKeyId"),
     value("LICENSE_PUBLIC_KEY", "license.publicKey"),
     secret("LICENSE_MACHINE_CODE", "license.machineCode"),
+    value("WINDY_LICENSE_VERSIONS", "license.versions", undefined, (raw) =>
+      parseLicenseCatalogJson(raw, "WINDY_LICENSE_VERSIONS"),
+    ),
     value("AUDIT_ENABLED", "audit.enabled", true, strictBoolean),
     value(
       "AUDIT_REDACT_FIELDS",