@southwind-ai/shared 0.3.2 → 0.3.3

package/index.ts

@@ -47,3 +47,6 @@ export * from "./src/diagnostics.js";
 // @windy-module system.agent begin
 export * from "./src/agent-workflow-presets.js";
 // @windy-module system.agent end
+
+export * from "./src/environment-assessment.js";
+export * from "./src/environment-policy.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@southwind-ai/shared",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "license": "UNLICENSED",
   "type": "module",
   "engines": {

package/src/environment-assessment.ts

@@ -0,0 +1,68 @@
+/** Host evidence is supplied by an explicitly mounted collector report, never inferred from a container. */
+export const HOST_PROBE_KEYS = [
+  "cpu",
+  "memory",
+  "blockDevices",
+  "disks",
+  "mounts",
+  "network",
+  "systemd",
+  "docker",
+  "compose",
+  "containers",
+  "gpu",
+] as const;
+export type HostProbeKey = (typeof HOST_PROBE_KEYS)[number];
+export interface HostDiagnosticProbe {
+  status:
+    | "ok"
+    | "missing"
+    | "permission-denied"
+    | "timeout"
+    | "failed"
+    | "unsupported";
+  exitCode: number | null;
+  output: string;
+  truncated: boolean;
+}
+export interface HostDiagnosticsReport {
+  schemaVersion: 1;
+  scope: "host";
+  collector: "windy-host-diagnostics-v1";
+  collectedAt: string;
+  facts: {
+    os: string;
+    distribution?: string;
+    kernel: string;
+    architecture: string;
+    cpuLogicalCount: number;
+    memoryTotalBytes: number | null;
+    /** Present only when a successful GPU query establishes the count. */
+    gpuCount?: number;
+  };
+  probes: Record<HostProbeKey, HostDiagnosticProbe>;
+  deployment?: {
+    status: "available" | "invalid" | "unreadable";
+    releaseId?: string;
+    gitSha?: string;
+    platform?: string;
+  };
+}
+export interface EnvironmentSnapshot {
+  generatedAt: string;
+  process: {
+    scope: "process";
+    platform: string;
+    architecture: string;
+    nodeVersion: string;
+    bunVersion?: string;
+    containerized: boolean;
+    logicalCpuCount: number;
+    memoryTotalBytes: number;
+  };
+  host: {
+    status: "available" | "not-configured" | "invalid" | "stale" | "unreadable";
+    message: string;
+    report?: HostDiagnosticsReport;
+  };
+}

package/src/environment-policy.ts

@@ -0,0 +1,205 @@
+/** Deployment requirements are recommendations, not authorization or probe results. */
+export interface FeatureEnvironmentPolicy {
+  key: string;
+  title: string;
+  execution: "none" | "cpu" | "local-gpu" | "remote";
+  recommendedEnabled?: boolean;
+  supportedPlatforms?: string[];
+  supportedArchitectures?: string[];
+  minMemoryGiB?: number;
+  requiredEnvironmentKeys?: string[];
+}
+export const AI_RUNTIME_KINDS = [
+  "agent",
+  "document",
+  "speech",
+  "embedding",
+] as const;
+export type AiRuntimeKind = (typeof AI_RUNTIME_KINDS)[number];
+export type AiRuntimeSwitches = Partial<Record<AiRuntimeKind, boolean>>;
+
+export interface AntivirusEnvironmentPolicy {
+  packaged: boolean;
+  enabled: boolean;
+}
+
+export interface EnvironmentPolicy {
+  schemaVersion: 1;
+  build: { modules: string[]; runtimes?: AiRuntimeSwitches };
+  runtime?: AiRuntimeSwitches;
+  antivirus?: AntivirusEnvironmentPolicy;
+  features: FeatureEnvironmentPolicy[];
+}
+export interface FeatureEnvironmentAssessment {
+  key: string;
+  title: string;
+  status:
+    | "hardware"
+    | "software"
+    | "not-packaged"
+    | "configuration"
+    | "unknown"
+    | "available"
+    | "disabled";
+  message: string;
+  evidence: string[];
+  recommendedEnabled?: boolean;
+}
+export interface EnvironmentAssessmentSnapshot {
+  status: "available" | "not-configured" | "invalid";
+  message: string;
+  features: FeatureEnvironmentAssessment[];
+}
+
+function object(
+  value: unknown,
+  required: string[],
+  optional: string[] = [],
+): Record<string, unknown> {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("环境预设必须为对象");
+  const record = value as Record<string, unknown>;
+  if (
+    required.some((key) => !Object.hasOwn(record, key)) ||
+    Object.keys(record).some((key) => ![...required, ...optional].includes(key))
+  )
+    throw new Error("环境预设缺少必需字段或包含未知字段");
+  return record;
+}
+function strings(value: unknown, pattern: RegExp, max = 128): string[] {
+  if (
+    !Array.isArray(value) ||
+    value.length > max ||
+    value.some(
+      (item) =>
+        typeof item !== "string" || item.length > 128 || !pattern.test(item),
+    ) ||
+    new Set(value).size !== value.length
+  )
+    throw new Error("环境预设列表无效或重复");
+  return value as string[];
+}
+export function parseEnvironmentPolicy(value: unknown): EnvironmentPolicy {
+  const root = object(
+    value,
+    ["schemaVersion", "build", "features"],
+    ["runtime", "antivirus"],
+  );
+  if (root.schemaVersion !== 1) throw new Error("不支持的环境预设版本");
+  const build = object(root.build, ["modules"], ["runtimes"]);
+  const modules = strings(build.modules, /^[a-z][a-z0-9.-]*$/);
+  if (!Array.isArray(root.features) || root.features.length > 128)
+    throw new Error("功能评估配置超出上限");
+  const features = root.features.map((value): FeatureEnvironmentPolicy => {
+    const row = object(
+      value,
+      ["key", "title", "execution"],
+      [
+        "recommendedEnabled",
+        "supportedPlatforms",
+        "supportedArchitectures",
+        "minMemoryGiB",
+        "requiredEnvironmentKeys",
+      ],
+    );
+    const [key] = strings([row.key], /^[a-z][a-z0-9.-]*$/);
+    if (
+      typeof row.title !== "string" ||
+      !row.title.trim() ||
+      row.title.length > 120
+    )
+      throw new Error("功能评估标题无效");
+    if (!["none", "cpu", "local-gpu", "remote"].includes(String(row.execution)))
+      throw new Error("功能执行方式无效");
+    if (
+      row.recommendedEnabled !== undefined &&
+      typeof row.recommendedEnabled !== "boolean"
+    )
+      throw new Error("推荐开关必须为布尔值");
+    if (
+      row.minMemoryGiB !== undefined &&
+      (typeof row.minMemoryGiB !== "number" ||
+        !Number.isFinite(row.minMemoryGiB) ||
+        row.minMemoryGiB <= 0 ||
+        row.minMemoryGiB > 65536)
+    )
+      throw new Error("最低内存要求无效");
+    return {
+      key: key!,
+      title: row.title,
+      execution: row.execution as FeatureEnvironmentPolicy["execution"],
+      ...(row.recommendedEnabled === undefined
+        ? {}
+        : { recommendedEnabled: row.recommendedEnabled as boolean }),
+      ...(row.minMemoryGiB === undefined
+        ? {}
+        : { minMemoryGiB: row.minMemoryGiB as number }),
+      ...(row.supportedPlatforms === undefined
+        ? {}
+        : {
+            supportedPlatforms: strings(
+              row.supportedPlatforms,
+              /^(linux|darwin|win32)$/,
+            ),
+          }),
+      ...(row.supportedArchitectures === undefined
+        ? {}
+        : {
+            supportedArchitectures: strings(
+              row.supportedArchitectures,
+              /^(x64|arm64|arm|ia32|ppc64|s390x|riscv64|loong64)$/,
+            ),
+          }),
+      ...(row.requiredEnvironmentKeys === undefined
+        ? {}
+        : {
+            requiredEnvironmentKeys: strings(
+              row.requiredEnvironmentKeys,
+              /^[A-Z][A-Z0-9_]*$/,
+            ),
+          }),
+    };
+  });
+  if (new Set(features.map(({ key }) => key)).size !== features.length)
+    throw new Error("功能评估 Key 重复");
+  const runtime = Object.hasOwn(root, "runtime")
+    ? parseRuntimeSwitches(root.runtime)
+    : undefined;
+  const runtimes = Object.hasOwn(build, "runtimes")
+    ? parseRuntimeSwitches(build.runtimes)
+    : undefined;
+  for (const kind of AI_RUNTIME_KINDS) {
+    if (runtimes?.[kind] === false && runtime?.[kind] === true)
+      throw new Error(`运行时未随包交付：${kind}`);
+  }
+  const antivirus = Object.hasOwn(root, "antivirus")
+    ? parseAntivirusPolicy(root.antivirus)
+    : undefined;
+  return {
+    schemaVersion: 1,
+    build: { modules, ...(runtimes ? { runtimes } : {}) },
+    features,
+    ...(runtime ? { runtime } : {}),
+    ...(antivirus ? { antivirus } : {}),
+  };
+}
+
+function parseRuntimeSwitches(value: unknown): AiRuntimeSwitches {
+  const switches = object(value, [], [...AI_RUNTIME_KINDS]);
+  const runtime: AiRuntimeSwitches = {};
+  for (const kind of AI_RUNTIME_KINDS) {
+    if (!Object.hasOwn(switches, kind)) continue;
+    const enabled = switches[kind];
+    if (typeof enabled !== "boolean") throw new Error("运行时开关必须为布尔值");
+    runtime[kind] = enabled;
+  }
+  return runtime;
+}
+
+function parseAntivirusPolicy(value: unknown): AntivirusEnvironmentPolicy {
+  const { packaged, enabled } = object(value, ["packaged", "enabled"]);
+  if (typeof packaged !== "boolean" || typeof enabled !== "boolean")
+    throw new Error("病毒扫描交付和启用设置必须为布尔值");
+  if (enabled && !packaged) throw new Error("病毒扫描未随项目交付，不能启用");
+  return { packaged, enabled };
+}

package/src/license-console-capabilities.ts

@@ -101,6 +101,13 @@ export const LICENSE_CONSOLE_CAPABILITIES = {
     apis: ["POST /api/auth/sessions/:id/revoke"],
     auditActions: ["auth.session.revoke"],
   },
+  profile: {
+    feature: "license.profile",
+    permission: "license.profile.update",
+    entry: "profile",
+    apis: ["PATCH /api/auth/me"],
+    auditActions: ["license.operator.updated"],
+  },
   audit: {
     feature: "license.audit",
     permission: "license.audit.read",

package/src/license.ts

@@ -205,6 +205,7 @@ export type LicenseOperatorRole =
 export type LicenseOperatorPermission =
   | "license.record.read"
   | "license.audit.read"
+  | "license.profile.update"
   | "license.issue"
   | "license.project.manage"
   | "license.key.rotate"

package/src/module-configuration.ts

@@ -20,7 +20,8 @@ export interface ModuleConfigFieldDescriptor {
   path: string;
   label: string;
   description: string;
-  input: "boolean" | "integer" | "text";
+  input: "boolean" | "integer" | "text" | "time-zone";
+  unit?: "bytes";
   applyMode?: ModuleConfigApplyMode;
   minimum?: number;
   maximum?: number;