create-windy 0.9.1 → 0.10.1

package/template/packages/server-sdk/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@southwind-ai/server-sdk",
-  "version": "0.5.2",
+  "version": "0.5.3",
   "license": "UNLICENSED",
   "type": "module",
   "engines": {

package/template/packages/shared/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/template/packages/shared/package.json

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

package/template/packages/shared/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/template/packages/shared/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/template/packages/shared/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/template/packages/shared/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/template/packages/shared/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;

package/template/scripts/operations/collect-device-info.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python3
+"""Emit bounded, read-only host diagnostics JSON to stdout. Run ON THE HOST.
+
+No package installation, service restart, Docker inspect, environment dump or
+credential reads. Redirect stdout to a report and mount that file read-only in
+Server as WINDY_HOST_DIAGNOSTICS_FILE. Missing tools do not abort the report.
+"""
+from __future__ import annotations
+
+import argparse
+import datetime
+import json
+import os
+import platform
+import re
+import stat
+import selectors
+import shutil
+import signal
+import subprocess
+import time
+from pathlib import Path
+
+MAX_OUTPUT = 16384
+TIMEOUT_SECONDS = 5
+PROBE_KEYS = (
+    "cpu", "memory", "blockDevices", "disks", "mounts", "network", "systemd",
+    "docker", "compose", "containers", "gpu",
+)
+
+
+def result(status, output="", exit_code=None, truncated=False):
+    return {"status": status, "exitCode": exit_code,
+            "output": output, "truncated": truncated}
+
+
+def stop(child):
+    if child.poll() is None:
+        try:
+            os.killpg(child.pid, signal.SIGKILL)
+        except ProcessLookupError:
+            pass
+    child.wait()
+
+
+def probe(command):
+    """Fixed argv only; output and wall time are independently bounded."""
+    if not shutil.which(command[0]):
+        return result("missing")
+    environment = {"PATH": os.defpath + ":/usr/local/bin:/opt/homebrew/bin",
+                   "LANG": "C", "LC_ALL": "C"}
+    # Never inherit remote Docker contexts or credentials from the invoking shell.
+    child = None
+    try:
+        child = subprocess.Popen(command, stdout=subprocess.PIPE,
+                                 stderr=subprocess.STDOUT, env=environment,
+                                 start_new_session=True)
+        output = bytearray()
+        deadline = time.monotonic() + TIMEOUT_SECONDS
+        with selectors.DefaultSelector() as selector:
+            selector.register(child.stdout, selectors.EVENT_READ)
+            while selector.get_map():
+                remaining = deadline - time.monotonic()
+                if remaining <= 0:
+                    stop(child)
+                    return result("timeout", output.decode("utf-8", "replace"))
+                for key, _ in selector.select(min(remaining, 0.1)):
+                    chunk = os.read(key.fileobj.fileno(), 4096)
+                    if not chunk:
+                        selector.unregister(key.fileobj)
+                        continue
+                    available = MAX_OUTPUT - len(output)
+                    output.extend(chunk[:available])
+                    if len(chunk) > available:
+                        stop(child)
+                        return result("failed", output.decode("utf-8", "replace"),
+                                      child.returncode, True)
+        try:
+            code = child.wait(timeout=max(0.01, deadline - time.monotonic()))
+        except subprocess.TimeoutExpired:
+            stop(child)
+            return result("timeout", output.decode("utf-8", "replace"))
+        text = output.decode("utf-8", "replace")
+        denied = any(term in text.lower() for term in (
+            "permission denied", "operation not permitted", "access is denied"))
+        status = "ok" if code == 0 else "permission-denied" if denied else "failed"
+        return result(status, text, code)
+    except PermissionError:
+        return result("permission-denied")
+    except OSError:
+        return result("failed")
+    finally:
+        if child is not None:
+            stop(child)
+            if child.stdout:
+                child.stdout.close()
+
+
+def memory_bytes(system):
+    try:
+        if system == "Linux":
+            with Path("/proc/meminfo").open() as stream:
+                for line in stream.read(4096).splitlines():
+                    if line.startswith("MemTotal:"):
+                        return int(line.split()[1]) * 1024
+        if system == "Darwin":
+            value = probe(["sysctl", "-n", "hw.memsize"])
+            return int(value["output"].strip()) if value["status"] == "ok" else None
+    except (OSError, ValueError):
+        pass
+    return None
+
+
+def commands(system, systemd_unit=None):
+    common = {
+        "docker": ["docker", "--host", "unix:///var/run/docker.sock", "version", "--format", "{{json .}}"],
+        "compose": ["docker", "compose", "version", "--short"],
+        "containers": ["docker", "--host", "unix:///var/run/docker.sock", "ps", "-a", "--format",
+                       "{{.Names}}\t{{.Image}}\t{{.State}}\t{{.Status}}\t{{.Ports}}"],
+        "gpu": ["nvidia-smi", "--query-gpu=name,memory.total,driver_version",
+                "--format=csv,noheader,nounits"],
+    }
+    if system == "Linux":
+        return {**common,
+                "cpu": ["lscpu", "--json"],
+                "memory": ["free", "-b"],
+                "blockDevices": ["lsblk", "--json", "--bytes", "--output",
+                                 "NAME,TYPE,SIZE,FSTYPE,MOUNTPOINTS,ROTA"],
+                "disks": ["df", "-Pk"],
+                "mounts": ["findmnt", "--json", "--output", "TARGET,SOURCE,FSTYPE"],
+                "network": ["ip", "-brief", "address"],
+                "systemd": (["systemctl", "show", "--no-pager",
+                             "--property=Id,LoadState,ActiveState,SubState,UnitFileState,Result,ExecMainStatus,ActiveEnterTimestamp",
+                             "--", unit_name(systemd_unit)] if systemd_unit else
+                            ["systemctl", "is-system-running"])}
+    if system == "Darwin":
+        return {**common,
+                "cpu": ["sysctl", "machdep.cpu.brand_string", "hw.logicalcpu"],
+                "memory": ["sysctl", "hw.memsize"],
+                "blockDevices": ["diskutil", "list"],
+                "disks": ["df", "-Pk"],
+                "mounts": ["mount"],
+                "network": ["ifconfig", "-a"]}
+    return {}
+
+
+def distribution(system):
+    if system == "Linux":
+        try:
+            with Path("/etc/os-release").open() as stream:
+                for line in stream.read(16384).splitlines():
+                    if line.startswith("PRETTY_NAME="):
+                        return line.split("=", 1)[1].strip().strip("\"")[:256]
+        except OSError:
+            pass
+    return platform.platform()[:256]
+
+
+def unit_name(value):
+    if not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9_.@-]{0,239}\.(service|target|socket|timer|mount)", value):
+        raise argparse.ArgumentTypeError("systemd unit must be a literal unit name")
+    return value
+
+
+def deployment_manifest(path):
+    """Read a small regular file; only release identity fields reach the report."""
+    descriptor = None
+    try:
+        descriptor = os.open(path, os.O_RDONLY | getattr(os, "O_NOFOLLOW", 0) |
+                             getattr(os, "O_NONBLOCK", 0))
+        metadata = os.fstat(descriptor)
+        if not stat.S_ISREG(metadata.st_mode) or metadata.st_size > 65536:
+            return {"status": "invalid"}
+        with os.fdopen(descriptor, "rb") as stream:
+            descriptor = None
+            content = stream.read(65537)
+        if len(content) > 65536:
+            return {"status": "invalid"}
+        data = json.loads(content)
+        if not isinstance(data, dict):
+            return {"status": "invalid"}
+        selected = {}
+        patterns = {"releaseId": r"[A-Za-z0-9._-]{1,128}",
+                    "gitSha": r"[a-fA-F0-9]{7,64}",
+                    "platform": r"[A-Za-z0-9._/-]{1,64}"}
+        for key, pattern in patterns.items():
+            if key in data:
+                if not isinstance(data[key], str) or not re.fullmatch(pattern, data[key]):
+                    return {"status": "invalid"}
+                selected[key] = data[key]
+        return {"status": "available", **selected} if selected else {"status": "invalid"}
+    except (ValueError, UnicodeError):
+        return {"status": "invalid"}
+    except OSError:
+        return {"status": "unreadable"}
+    finally:
+        if descriptor is not None:
+            os.close(descriptor)
+
+
+def collect(systemd_unit=None, manifest=None):
+    system = platform.system()
+    fixed_commands = commands(system, systemd_unit)
+    probes = {key: probe(fixed_commands[key]) if key in fixed_commands
+              else result("unsupported") for key in PROBE_KEYS}
+    gpu = probes["gpu"]
+    gpu_fact = {"gpuCount": len(gpu["output"].strip().splitlines())} if (
+        gpu["status"] == "ok" and not gpu["truncated"]) else {}
+    return {
+        "schemaVersion": 1, "scope": "host",
+        "collector": "windy-host-diagnostics-v1",
+        "collectedAt": datetime.datetime.now(datetime.timezone.utc).isoformat(),
+        "facts": {"os": {"Linux": "linux", "Darwin": "darwin", "Windows": "win32"}.get(system, system.lower()),
+                  "distribution": distribution(system), "kernel": platform.release(),
+                  "architecture": platform.machine(),
+                  "cpuLogicalCount": os.cpu_count() or 0,
+                  "memoryTotalBytes": memory_bytes(system), **gpu_fact},
+        "probes": probes,
+        **({"deployment": deployment_manifest(manifest)} if manifest else {}),
+    }
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--systemd-unit", type=unit_name,
+                        help="Inspect one installation unit using fixed read-only properties")
+    parser.add_argument("--manifest", type=Path,
+                        help="Read releaseId/gitSha/platform from a <=64 KiB release manifest")
+    args = parser.parse_args()
+    print(json.dumps(collect(args.systemd_unit, args.manifest), ensure_ascii=False, indent=2))

package/template/apps/server/src/agent/module-ai-port-factory.ts

@@ -1,41 +0,0 @@
-import type { ModuleManifest } from "@southwind-ai/modules";
-import { createModuleAiOperationReadinessPort } from "../ai-runtime-readiness/operation-port.js";
-import type { AiRuntimeReadinessTrustStoreV1 } from "../ai-runtime-readiness/trust-store.js";
-import { createModuleAiOperationPort } from "../module-host/ai-operation-port.js";
-import type { createServerRuntime } from "../runtime.js";
-
-type OperationRuntime = Parameters<typeof createModuleAiOperationPort>[3];
-type ReadinessInput = Parameters<typeof createModuleAiOperationReadinessPort>[0];
-
-export function createModuleAiPorts(input: {
-  readonly modules: readonly ModuleManifest[];
-  readonly runtime: ReturnType<typeof createServerRuntime>;
-  readonly sources: ReadinessInput["sources"];
-  readonly trustStore: AiRuntimeReadinessTrustStoreV1;
-  readonly operations: OperationRuntime;
-}) {
-  const operations = (
-    moduleName: string,
-    guardContext: Parameters<typeof createModuleAiOperationPort>[1],
-    signal: AbortSignal,
-  ) => createModuleAiOperationPort(
-    moduleName,
-    guardContext,
-    signal,
-    input.operations,
-  );
-  const readiness = (
-    moduleName: string,
-    guardContext: Parameters<typeof createModuleAiOperationPort>[1],
-    signal: AbortSignal,
-  ) => createModuleAiOperationReadinessPort({
-    moduleName,
-    guardContext,
-    signal,
-    modules: input.modules,
-    sources: input.sources,
-    trustStore: input.trustStore,
-    runtime: input.runtime,
-  });
-  return { operations, readiness };
-}