create-windy 0.8.3 → 0.10.0

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/agent-server/install-python-dependencies.sh

@@ -1,92 +0,0 @@
-#!/bin/sh
-set -eu
-
-index_url="${WINDY_PYPI_INDEX_URL:-}"
-total_timeout_seconds="${WINDY_PYPI_TOTAL_TIMEOUT_SECONDS:-}"
-
-case "$index_url" in
-  http://* | https://*) ;;
-  *)
-    echo "Agent Server Python index 必须是 credential-free HTTP(S) URL" >&2
-    exit 64
-    ;;
-esac
-case "$index_url" in
-  *"@"* | *"?"* | *"#"*)
-    echo "Agent Server Python index 不得内嵌 credential、query 或 fragment" >&2
-    exit 64
-    ;;
-esac
-
-index_address="${index_url#*://}"
-index_host="${index_address%%/*}"
-case "$index_address" in
-  "" | *[!A-Za-z0-9._~:/%-]*)
-    echo "Agent Server Python index 含有不安全字符" >&2
-    exit 64
-    ;;
-esac
-case "$index_host" in
-  "" | *[!A-Za-z0-9.:-]*)
-    echo "Agent Server Python index host 无效" >&2
-    exit 64
-    ;;
-esac
-case "$total_timeout_seconds" in
-  "" | *[!0-9]*)
-    echo "WINDY_PYPI_TOTAL_TIMEOUT_SECONDS 必须是 1 到 600 的整数" >&2
-    exit 64
-    ;;
-esac
-if [ "$total_timeout_seconds" -lt 1 ] || [ "$total_timeout_seconds" -gt 600 ]; then
-  echo "WINDY_PYPI_TOTAL_TIMEOUT_SECONDS 必须是 1 到 600 的整数" >&2
-  exit 64
-fi
-
-trusted_host=""
-insecure_host=""
-case "$index_url" in
-  http://*)
-    trusted_host="$index_host"
-    insecure_host="$index_host"
-    ;;
-esac
-
-run_uv_network() {
-  operation="$1"
-  shift
-  if ! timeout --kill-after=5s "${total_timeout_seconds}s" env \
-    UV_DEFAULT_INDEX="$index_url" \
-    UV_INSECURE_HOST="$insecure_host" \
-    UV_CONCURRENT_DOWNLOADS=1 \
-    UV_HTTP_TIMEOUT=30 \
-    UV_HTTP_RETRIES=2 \
-    UV_NO_PROGRESS=1 \
-    sh -c 'attempt=1; while [ "$attempt" -le 3 ]; do "$@" && exit 0; if [ "$attempt" -lt 3 ]; then echo "[windy] Python 网络操作失败，2 秒后重试" >&2; sleep 2; fi; attempt=$((attempt + 1)); done; exit 1' windy-python "$@"; then
-    echo "Agent Server Python index 不可用或总时限已到：${operation}失败" >&2
-    exit 70
-  fi
-}
-
-case "${1:-}" in
-  install-uv)
-    if ! timeout --kill-after=5s "${total_timeout_seconds}s" env \
-      PIP_INDEX_URL="$index_url" \
-      PIP_TRUSTED_HOST="$trusted_host" \
-      pip install --no-cache-dir --timeout 30 --retries 2 uv==0.9.27; then
-      echo "Agent Server Python index 不可用或总时限已到：无法安装 uv" >&2
-      exit 70
-    fi
-    ;;
-  lock)
-    run_uv_network "lock index 刷新" uv lock
-    ;;
-  sync)
-    shift
-    run_uv_network "依赖同步" uv sync "$@"
-    ;;
-  *)
-    echo "未知的 Agent Server Python 安装阶段" >&2
-    exit 64
-    ;;
-esac

package/template/apps/agent-server/pyproject.toml

@@ -1,51 +0,0 @@
-[project]
-name = "southwind-agent-server"
-version = "0.1.0"
-description = "Southwind AI canonical Agent Runtime server"
-requires-python = ">=3.12,<3.13"
-dependencies = [
-  "cryptography==49.0.0",
-  "fastapi==0.139.2",
-  "httpx==0.28.1",
-  "jsonschema==4.26.0",
-  "opentelemetry-api==1.42.1",
-  "opentelemetry-exporter-otlp-proto-http==1.42.1",
-  "opentelemetry-sdk==1.42.1",
-  "pillow==12.3.0",
-  "psycopg[binary,pool]==3.3.4",
-  "pydantic==2.13.4",
-  "uvicorn==0.51.0",
-]
-
-[dependency-groups]
-dev = [
-  "mypy==2.3.0",
-  "pytest==9.1.1",
-  "pytest-asyncio==1.4.0",
-  "ruff==0.15.22",
-  "types-jsonschema==4.26.0.20260518",
-]
-
-[tool.pytest.ini_options]
-asyncio_mode = "auto"
-pythonpath = [".", "src"]
-testpaths = ["tests"]
-
-[tool.ruff]
-line-length = 88
-target-version = "py312"
-
-[tool.ruff.lint]
-select = ["E", "F", "I", "UP", "B", "ASYNC"]
-
-[tool.mypy]
-python_version = "3.12"
-strict = true
-files = ["src", "tests"]
-
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[tool.hatch.build.targets.wheel]
-packages = ["src/southwind_agent_server"]

package/template/apps/agent-server/src/southwind_agent_server/__init__.py

@@ -1,5 +0,0 @@
-"""Southwind AI Agent Server."""
-
-from .app import create_app
-
-__all__ = ["create_app"]