dsh-cloud 0.2.0__py3-none-any.whl

dsh_cloud_cli/cli.py

@@ -0,0 +1,367 @@
+from __future__ import annotations
+
+import json
+import os
+import re
+import secrets
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+
+HELP = """Usage: dsh-cloud COMMAND [DIRECTORY] [OPTIONS]
+
+Commands:
+  start    safely initialize when needed, validate, and start the stack
+  init     write a managed deployment without starting Docker
+  doctor   validate Docker Compose and the managed configuration
+  up       start an initialized deployment
+  down     stop it without deleting data
+  status   show Compose service status
+  logs     show service logs
+
+Global options:
+  --help              show this help
+  --version           show the product release version
+  --mode trial|selfhost (default: trial)
+  --dir PATH          deployment directory (default: ./dsh-cloud)
+  --dry-run           print the exact plan without writing or running Docker
+  --json              stable machine-readable output
+"""
+COMMANDS = {"init", "start", "doctor", "up", "down", "status", "logs"}
+VALUE_OPTIONS = {"--mode": "mode", "--dir": "dir", "--domain": "domain", "--admin-email": "adminEmail", "--project-name": "projectName"}
+BOOLEAN_OPTIONS = {"--yes": "yes", "--json": "json", "--dry-run": "dryRun", "--wait": "wait", "--follow": "follow"}
+TRIAL_PUBLIC_BASE = "http://localhost:8787"
+TRIAL_CADDY_SITE = "http://localhost"
+PROJECT_NAME_PATTERN = re.compile(r"^[a-z0-9][a-z0-9_-]*$")
+
+
+class CliError(RuntimeError):
+    def __init__(self, message: str, exit_code: int = 2):
+        super().__init__(message)
+        self.exit_code = exit_code
+
+
+def parse_args(argv: list[str]) -> dict:
+    if not argv or "--help" in argv or argv[0] == "-h":
+        return {"special": "help"}
+    if "--version" in argv:
+        return {"special": "version"}
+    command = argv[0]
+    if command not in COMMANDS:
+        raise CliError(f"unknown command: {command}")
+    options: dict[str, str | bool] = {}
+    positionals: list[str] = []
+    index = 1
+    while index < len(argv):
+        token = argv[index]
+        if token == "--upstream-key" or token.startswith("--upstream-key="):
+            raise CliError("secret values are not accepted as command arguments")
+        if token in BOOLEAN_OPTIONS:
+            options[BOOLEAN_OPTIONS[token]] = True
+        elif token in VALUE_OPTIONS:
+            index += 1
+            if index >= len(argv) or argv[index].startswith("--"):
+                raise CliError(f"{token} requires a value")
+            options[VALUE_OPTIONS[token]] = argv[index]
+        elif token.startswith("-"):
+            raise CliError(f"unknown option: {token}")
+        else:
+            positionals.append(token)
+        index += 1
+    return {"command": command, "options": options, "positionals": positionals}
+
+
+def repository_root() -> Path:
+    return Path(__file__).resolve().parents[4]
+
+
+def load_manifest() -> dict:
+    packaged = Path(__file__).with_name("release-manifest.json")
+    if packaged.is_file():
+        return json.loads(packaged.read_text(encoding="utf-8"))
+    source = json.loads((repository_root() / "release/release.json").read_text(encoding="utf-8"))
+    return {
+        "schemaVersion": 1,
+        "version": source["version"],
+        "license": source["license"],
+        "stackSchema": source["stackSchema"],
+        "databaseSchema": source["databaseSchema"],
+        "minCliVersion": source["minCliVersion"],
+        "minUpgradeFrom": source["minUpgradeFrom"],
+        "harnessRuntime": source["harnessRuntime"],
+        "images": source["productImages"],
+        "baseImages": source["baseImages"],
+    }
+
+
+def target_of(parsed: dict) -> Path:
+    options, positionals = parsed["options"], parsed["positionals"]
+    return Path(str(options.get("dir") or (positionals[0] if positionals else "dsh-cloud"))).resolve()
+
+
+def docker_argv(target: Path, project: str, action: list[str] | None = None) -> list[str]:
+    return ["docker", "compose", "--project-directory", str(target), "--project-name", project,
+            "--env-file", str(target / ".env"), "-f", str(target / "docker-compose.yml"),
+            *(action or ["up", "-d", "--wait"])]
+
+
+def valid_domain(value: object) -> bool:
+    if not isinstance(value, str) or len(value) > 253 or "." not in value:
+        return False
+    return all(re.fullmatch(r"[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?", label) for label in value.split("."))
+
+
+def validate_options(options: dict, mode: str, project: str) -> None:
+    if not PROJECT_NAME_PATTERN.fullmatch(project):
+        raise CliError("invalid project name")
+    if mode != "selfhost":
+        return
+    if not valid_domain(options.get("domain")):
+        raise CliError("--domain must be a hostname without a scheme or port")
+    email = options.get("adminEmail")
+    if not isinstance(email, str) or len(email) > 254 or not re.fullmatch(r"[^@\s]+@[^@\s]+\.[^@\s]+", email):
+        raise CliError("--admin-email must be a valid email address")
+
+
+def plan(parsed: dict, manifest: dict) -> dict:
+    target = target_of(parsed)
+    options = parsed["options"]
+    mode = str(options.get("mode", "trial"))
+    if mode not in {"trial", "selfhost"}:
+        raise CliError(f"invalid mode: {mode}")
+    project = str(options.get("projectName", "dsh-selfhost"))
+    validate_options(options, mode, project)
+    trial = mode == "trial"
+    return {
+        "ok": True,
+        "dryRun": bool(options.get("dryRun")),
+        "command": parsed["command"],
+        "mode": mode,
+        "directory": str(target),
+        "projectName": project,
+        "bindAddress": "127.0.0.1" if trial else "0.0.0.0",
+        "url": TRIAL_PUBLIC_BASE if trial else f"https://{options.get('domain', '')}",
+        "publicBaseUrl": TRIAL_PUBLIC_BASE if trial else f"https://{options.get('domain', '')}",
+        "version": manifest["version"],
+        "dockerArgv": docker_argv(target, project, action_for(parsed["command"], options)),
+    }
+
+
+def atomic_write(path: Path, value: str, mode: int = 0o644) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+    temporary = path.with_name(f"{path.name}.tmp-{os.getpid()}-{secrets.token_hex(4)}")
+    descriptor = os.open(temporary, os.O_WRONLY | os.O_CREAT | os.O_EXCL, mode)
+    try:
+        with os.fdopen(descriptor, "w", encoding="utf-8") as handle:
+            handle.write(value)
+            handle.flush()
+            os.fsync(handle.fileno())
+        os.chmod(temporary, mode)
+        os.replace(temporary, path)
+    finally:
+        if temporary.exists():
+            temporary.unlink()
+
+
+def template_roots() -> tuple[Path, Path]:
+    packaged = Path(__file__).with_name("templates")
+    if (packaged / "docker-compose.yml").is_file():
+        return packaged, packaged / "config"
+    root = repository_root()
+    return root / "deploy/selfhost", root / "server/config"
+
+
+def generated_env(parsed: dict, manifest: dict) -> str:
+    options = parsed["options"]
+    mode = str(options.get("mode", "trial"))
+    trial = mode == "trial"
+    if not trial and (not options.get("domain") or not options.get("adminEmail")):
+        raise CliError("--domain and --admin-email are required in selfhost mode")
+    domain = "localhost" if trial else str(options["domain"])
+    public_base = TRIAL_PUBLIC_BASE if trial else f"https://{domain}"
+    values = [
+        ("COMPOSE_PROJECT_NAME", str(options.get("projectName", "dsh-selfhost"))),
+        ("DOMAIN", domain), ("SITE_SCHEME", "http" if trial else "https"),
+        ("PUBLIC_BASE", public_base), ("BIND_ADDRESS", "127.0.0.1" if trial else "0.0.0.0"),
+        ("DSH_SITE", TRIAL_CADDY_SITE if trial else f"https://{domain}"),
+        ("HTTP_PORT", "8787" if trial else "80"), ("HTTPS_PORT", "8443" if trial else "443"),
+        ("DHC_DEV", "1" if trial else "0"), ("DHC_CONFIG_DIR", "./config"),
+        ("PRICING_FILE", "pricing.cny.json"), ("AUTH_SECRET_FILE", "/run/secrets/auth_secret"),
+        ("UPSTREAM_BASE_URL", "https://api.deepseek.com/v1"), ("UPSTREAM_API_KEY", ""),
+        ("ADMIN_EMAILS", str(options.get("adminEmail", ""))),
+        ("MAIL_SMTP_HOST", ""), ("MAIL_SMTP_USER", ""), ("MAIL_SMTP_PASS", ""), ("MAIL_FROM", ""),
+        ("GOOGLE_LOGIN_CLIENT_ID", ""), ("GOOGLE_LOGIN_CLIENT_SECRET", ""),
+        ("GITHUB_LOGIN_CLIENT_ID", ""), ("GITHUB_LOGIN_CLIENT_SECRET", ""),
+        ("DHC_SERVER_IMAGE", manifest["images"]["server"]),
+        ("CADDY_IMAGE", manifest["baseImages"]["caddy"]),
+        ("POSTGRES_IMAGE", manifest["baseImages"]["postgres"]),
+        ("SOCKET_PROXY_IMAGE", manifest["baseImages"]["socketProxy"]),
+        ("WORK_IMAGE", manifest["images"]["workspace"]),
+    ]
+    return "".join(f"{key}={value}\n" for key, value in values)
+
+
+def initialize(parsed: dict, manifest: dict, deployment_plan: dict | None = None) -> Path:
+    deployment_plan = deployment_plan or plan(parsed, manifest)
+    target = target_of(parsed)
+    if target.exists():
+        entries = list(target.iterdir())
+        if (target / ".dsh-cloud").exists():
+            raise CliError(f"deployment is already initialized: {target}")
+        if entries:
+            raise CliError(f"refusing to overwrite non-empty directory: {target}")
+    target.mkdir(parents=True, exist_ok=True, mode=0o700)
+    templates, config = template_roots()
+    for name in ("docker-compose.yml", "Caddyfile", "compose.build.yml", "compose.postgres.yml"):
+        if (templates / name).is_file():
+            shutil.copy2(templates / name, target / name)
+    compose_path = target / "docker-compose.yml"
+    compose = compose_path.read_text(encoding="utf-8").replace(
+        "      - dhc-data:/app/data\n",
+        "      - dhc-data:/app/data\n      - ./secrets/auth_secret:/run/secrets/auth_secret:ro\n",
+    )
+    atomic_write(compose_path, compose)
+    shutil.copytree(config, target / "config")
+    secret = os.environ.get("DSH_CLOUD_TEST_RANDOM_HEX", secrets.token_hex(32))
+    atomic_write(target / "secrets/auth_secret", f"{secret}\n", 0o600)
+    atomic_write(target / ".env", generated_env(parsed, manifest), 0o600)
+    atomic_write(target / ".gitignore", ".env\nsecrets/\n.dsh-cloud/lock\n")
+    state = {
+        "schemaVersion": 1, "version": manifest["version"], "stackSchema": manifest["stackSchema"],
+        "mode": parsed["options"].get("mode", "trial"),
+        "projectName": parsed["options"].get("projectName", "dsh-selfhost"),
+        "publicBaseUrl": deployment_plan["publicBaseUrl"],
+        "composeFiles": ["docker-compose.yml"],
+    }
+    atomic_write(target / ".dsh-cloud/state.json", json.dumps(state, indent=2) + "\n", 0o600)
+    return target
+
+
+def action_for(command: str, options: dict) -> list[str]:
+    if command in {"up", "start"}:
+        return ["up", "-d", "--wait"]
+    if command == "down":
+        return ["down"]
+    if command == "status":
+        return ["ps", "--format", "json"]
+    if command == "logs":
+        return ["logs", *(["--follow"] if options.get("follow") else [])]
+    return ["config", "--quiet"]
+
+
+def restore_deployment(value: dict, state_path: Path, parsed: dict) -> None:
+    try:
+        persisted = json.loads(state_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as error:
+        raise CliError(f"invalid deployment state: {state_path}") from error
+    project_name = persisted.get("projectName")
+    if not isinstance(project_name, str) or not project_name:
+        raise CliError(f"invalid deployment project name: {state_path}")
+    environment: dict[str, str] = {}
+    try:
+        for line in (state_path.parent.parent / ".env").read_text(encoding="utf-8").splitlines():
+            if line and not line.startswith("#") and "=" in line:
+                key, setting = line.split("=", 1)
+                environment[key] = setting
+    except OSError:
+        pass
+    value["projectName"] = project_name
+    value["mode"] = persisted.get("mode", value["mode"])
+    value["publicBaseUrl"] = environment.get("PUBLIC_BASE") or persisted.get("publicBaseUrl") or value["publicBaseUrl"]
+    value["url"] = value["publicBaseUrl"]
+    value["bindAddress"] = environment.get("BIND_ADDRESS") or ("127.0.0.1" if value["mode"] == "trial" else "0.0.0.0")
+    value["dockerArgv"] = docker_argv(
+        Path(value["directory"]), value["projectName"], action_for(parsed["command"], parsed["options"])
+    )
+
+
+def parse_compose_output(stdout: str) -> object | None:
+    output = stdout.strip()
+    if not output:
+        return None
+    try:
+        return json.loads(output)
+    except json.JSONDecodeError:
+        return output
+
+
+def public_identity_configured(target: Path) -> bool:
+    environment: dict[str, str] = {}
+    for line in (target / ".env").read_text(encoding="utf-8").splitlines():
+        if line and not line.startswith("#") and "=" in line:
+            key, value = line.split("=", 1)
+            environment[key] = value.strip()
+    return bool(
+        (environment.get("MAIL_SMTP_HOST") and (environment.get("MAIL_FROM") or environment.get("MAIL_SMTP_USER")))
+        or (environment.get("GOOGLE_LOGIN_CLIENT_ID") and environment.get("GOOGLE_LOGIN_CLIENT_SECRET"))
+        or (environment.get("GITHUB_LOGIN_CLIENT_ID") and environment.get("GITHUB_LOGIN_CLIENT_SECRET"))
+    )
+
+
+def execute(parsed: dict) -> dict:
+    manifest = load_manifest()
+    if parsed.get("special") == "help":
+        return {"text": HELP}
+    if parsed.get("special") == "version":
+        return {"text": manifest["version"] + "\n"}
+    value = plan(parsed, manifest)
+    if parsed["command"] == "init":
+        if parsed["options"].get("dryRun"):
+            return {"json": value}
+        initialize(parsed, manifest, value)
+        return {"json": {**value, "initialized": True}}
+    state = Path(value["directory"]) / ".dsh-cloud/state.json"
+    if parsed["command"] == "start" and not state.is_file() and not parsed["options"].get("dryRun"):
+        initialize(parsed, manifest, value)
+    if state.is_file():
+        restore_deployment(value, state, parsed)
+    if parsed["options"].get("dryRun"):
+        return {"json": value}
+    if not state.is_file():
+        raise CliError(f"not an initialized deployment: {value['directory']}")
+    if (
+        value["mode"] == "selfhost"
+        and parsed["command"] in {"start", "up", "doctor"}
+        and not public_identity_configured(Path(value["directory"]))
+    ):
+        raise CliError(
+            f"public self-host requires SMTP or OAuth for the first verified account; "
+            f"edit {Path(value['directory']) / '.env'} and run dsh-cloud up"
+        )
+    argv = docker_argv(Path(value["directory"]), value["projectName"], action_for(parsed["command"], parsed["options"]))
+    prefix = json.loads(os.environ["DSH_CLOUD_TEST_COMMAND_JSON"]) if os.environ.get("DSH_CLOUD_TEST_COMMAND_JSON") else []
+    capture = bool(parsed["options"].get("json"))
+    result = subprocess.run(
+        [*prefix, *argv] if prefix else argv,
+        cwd=value["directory"], check=False, capture_output=capture, text=capture,
+    )
+    if result.returncode:
+        raise CliError(f"Docker Compose exited with status {result.returncode}", result.returncode)
+    if capture:
+        response = {**value, "dockerArgv": argv}
+        output = parse_compose_output(result.stdout)
+        if output is not None:
+            response["composeOutput"] = output
+        if result.stderr.strip():
+            response["composeError"] = result.stderr.strip()
+        return {"json": response}
+    return {"text": value["url"] + "\n" if parsed["command"] in {"start", "up"} else ""}
+
+
+def main(argv: list[str] | None = None) -> int:
+    values = list(sys.argv[1:] if argv is None else argv)
+    try:
+        result = execute(parse_args(values))
+        if result.get("text"):
+            print(result["text"], end="")
+        if result.get("json") is not None:
+            print(json.dumps(result["json"], separators=(",", ":")))
+        return 0
+    except CliError as error:
+        if "--json" in values:
+            print(json.dumps({"ok": False, "error": str(error)}, separators=(",", ":")))
+        else:
+            print(f"error: {error}", file=sys.stderr)
+        return error.exit_code

dsh_cloud_cli/release-manifest.json

@@ -0,0 +1,22 @@
+{
+  "schemaVersion": 1,
+  "version": "0.2.0",
+  "license": "LicenseRef-DSH-Cloud-Community-1.0",
+  "stackSchema": 1,
+  "databaseSchema": 1,
+  "minCliVersion": "0.2.0",
+  "minUpgradeFrom": "0.1.0",
+  "harnessRuntime": "0.1.0-rc.8",
+  "images": {
+    "server": "ghcr.io/agentsdanceai/dsh-cloud-server:0.2.0",
+    "workspace": "ghcr.io/agentsdanceai/dsh-cloud-workspace:0.2.0"
+  },
+  "baseImages": {
+    "python": "python:3.11-slim-bookworm@sha256:2e32f7d302adc1c37428355c1e646897c0c53f4fd60b6a551245fb90ee129f91",
+    "uv": "ghcr.io/astral-sh/uv:0.8.11@sha256:8101ad825250a114e7bef89eefaa73c31e34e10ffbe5aff01562740bac97553c",
+    "node": "node:24-bookworm-slim@sha256:3638d9a6fe4030bd716be989438248074489337ba3275657f93595428be4fc03",
+    "caddy": "caddy:2@sha256:df7f1c2fb114453b951de51a98efc010db1655a92c2e86be6706714e2417a78d",
+    "postgres": "postgres:18-alpine@sha256:d3e1620b530c944afa6e887d22eb899824da68e19c52024bf98f5220c88a65b2",
+    "socketProxy": "tecnativa/docker-socket-proxy@sha256:1f5038b54f06c3e18422902cf00ba21803d1c97805aae032e5e6673d532d3459"
+  }
+}

dsh_cloud_cli/templates/Caddyfile

@@ -0,0 +1,67 @@
+# =============================================================================
+#  DSH Cloud self-host — Caddy configuration
+#
+#  Both site addresses come from docker-compose.yml (which derives them from
+#  .env), so nothing in this file needs editing for a normal deployment:
+#
+#    DSH_SITE       https://dsh.example.com   -> automatic Let's Encrypt cert
+#                   http://localhost          -> local mode, no TLS
+#    DSH_WORK_SITE  https://work.example.com  -> cloud workspaces
+#                   https://work.localhost    -> workspaces off (internal CA,
+#                                                no public certificate request)
+#
+#  Optional: to receive certificate-expiry notices from the CA, add a global
+#  options block as the FIRST thing in this file:
+#      {
+#          email you@example.com
+#      }
+# =============================================================================
+
+# --- main site: console, LLM gateway, payments, /releases, /preview ----------
+{$DSH_SITE:http://localhost} {
+	# flush_interval -1 disables response buffering: the gateway streams SSE
+	# (every dsh request is stream:true) and buffering would stall replies.
+	reverse_proxy dhc-server:8100 {
+		flush_interval -1
+	}
+}
+
+# --- cloud workspaces: per-user dsh containers + PWA shell -------------------
+# The following request-header transformations are required by the workspace
+# protocol:
+#   header_up -Upgrade      on the AUTH subrequest only — dsh's chat uses
+#     WebSocket upgrades (/api/events.mux, /api/events.host). With Upgrade
+#     present, uvicorn treats the HTTP-only authorization subrequest as a
+#     WebSocket handshake and rejects it.
+#   header_up Host 127.0.0.1:3080
+#   header_up Origin http://127.0.0.1:3080
+#     dsh only trusts requests that look like they came from its own loopback
+#     (reachability fence + CSRF origin check). Drop either line and the
+#     workspace answers 403 to everything.
+{$DSH_WORK_SITE:https://work.localhost} {
+	# "/" and the PWA assets are served by the app: it fetches the container's
+	# index document and injects the manifest/service-worker/mobile CSS layers.
+	@pwa path / /index.html /manifest.webmanifest /sw.js /pwa/*
+	handle @pwa {
+		@rootdoc path / /index.html
+		rewrite @rootdoc /api/work/shell
+		reverse_proxy dhc-server:8100
+	}
+
+	# Everything else: the session cookie decides which container answers.
+	# /api/work/route ensures the user's container is running and replies
+	# 200 + "X-Work-Upstream: dshwork-<uid>:3081" (or a redirect to login /
+	# pricing / the starting page).
+	handle {
+		forward_auth dhc-server:8100 {
+			uri /api/work/route
+			copy_headers X-Work-Upstream
+			header_up -Upgrade
+		}
+		reverse_proxy {http.request.header.X-Work-Upstream} {
+			header_up Host 127.0.0.1:3080
+			header_up Origin http://127.0.0.1:3080
+			flush_interval -1
+		}
+	}
+}

dsh_cloud_cli/templates/compose.build.yml

@@ -0,0 +1,10 @@
+services:
+  dhc-server:
+    pull_policy: build
+    build:
+      context: ../..
+      dockerfile: server/Dockerfile
+      args:
+        VERSION: "0.2.0"
+        PYTHON_IMAGE: python:3.11-slim-bookworm@sha256:2e32f7d302adc1c37428355c1e646897c0c53f4fd60b6a551245fb90ee129f91
+        UV_IMAGE: ghcr.io/astral-sh/uv:0.8.11@sha256:8101ad825250a114e7bef89eefaa73c31e34e10ffbe5aff01562740bac97553c

dsh_cloud_cli/templates/compose.postgres.yml

@@ -0,0 +1,36 @@
+services:
+  dhc-server:
+    depends_on:
+      postgres:
+        condition: service_healthy
+    environment:
+      DB_BACKEND: postgres
+      POSTGRES_DSN: ${POSTGRES_DSN:-postgresql://dhc:${POSTGRES_PASSWORD:-dsh-cloud-local}@postgres:5432/dhc}
+
+  postgres:
+    image: ${POSTGRES_IMAGE:-postgres:18-alpine@sha256:d3e1620b530c944afa6e887d22eb899824da68e19c52024bf98f5220c88a65b2}
+    restart: unless-stopped
+    environment:
+      POSTGRES_DB: dhc
+      POSTGRES_USER: dhc
+      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-dsh-cloud-local}
+    volumes:
+      # postgres:18 stores versioned data below /var/lib/postgresql/18/docker.
+      # Mount the parent or Docker creates an anonymous volume for the real DB.
+      - dhc-pgdata:/var/lib/postgresql
+    networks: [dhc-net]
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U dhc -d dhc"]
+      interval: 10s
+      timeout: 5s
+      retries: 10
+    security_opt: ["no-new-privileges:true"]
+    logging:
+      driver: json-file
+      options:
+        max-size: "10m"
+        max-file: "3"
+
+volumes:
+  dhc-pgdata:
+    name: ${COMPOSE_PROJECT_NAME:-dsh-selfhost}_dhc-pgdata