chatup 0.2.20__tar.gz → 0.2.22__tar.gz

{chatup-0.2.20/src/chatup.egg-info → chatup-0.2.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chatup
-Version: 0.2.20
+Version: 0.2.22
 Summary: ChatArch setup CLI extracted from ChatTool
 Author-email: rexwzh <1073853456@qq.com>
 License-Expression: MIT
@@ -16,6 +16,7 @@ License-File: LICENSE
 Requires-Dist: click<9.0,>=8.0
 Requires-Dist: chatstyle[tui]<0.3.0,>=0.2.0
 Requires-Dist: chatenv<0.3.0,>=0.2.11
+Requires-Dist: ChatGlance<0.4.0,>=0.3.0
 Requires-Dist: python-dotenv<2.0,>=1.0
 Requires-Dist: colorama
 Provides-Extra: dev
@@ -59,7 +60,7 @@ chatup doctor
 chatup uv
 chatup chrome-for-testing install --channel stable -I
 chatup playwright install 1.61.1 -I
-chatup workspace default ~/Playground
+chatup workspace ~/Playground
 ```
 
 `chatup uv` 默认更新已有 `~/.bashrc`、`~/.zshrc` 的自动激活块；使用 `chatup uv --no-activate` 可保持启动配置不变。不会创建缺失的 rc 文件，Windows 跳过此项。
@@ -68,6 +69,8 @@ chatup workspace default ~/Playground
 
 ```bash
 chatup gitea --force
+chatup glance --dry-run
+chatup glance
 chatup discourse -e discourse-prod --hostname discourse.public.wzhecnu.cn
 chatup zulip -e zulip-prod --external-host zulip.public.wzhecnu.cn --port 3095
 chatup mysql
@@ -99,16 +102,17 @@ npm run studio
 
 需要已有 Node.js >=18.12 和 npm >=9。创建带锁文件的 Remotion 4.0.530 项目，检测本机 Chrome 并输出渲染命令；不覆盖已有无关目录，也不替换 Node 或下载浏览器。项目放在指定目录，已有 Blender/Chrome 可通过 `chatup macos --app blender --app chrome` 验证或安装。详见[Remotion 安装约定](https://arch.gh.wzhecnu.cn/ChatUp/commands/#remotion)。
 
-## Chrome 与 iTerm2
+## Chrome、Snipaste 与 iTerm2
 
 ```bash
 chatup chrome --dry-run
 chatup chrome             # 按系统安装普通 Google Chrome
+chatup snipaste           # 在 macOS 或 Windows 安装 Snipaste
 chatup iterm              # 安装 iTerm2，仅限 macOS
 chatup chrome --sudo --yes # Linux：允许提权并确认包安装
 ```
 
-macOS 直接下载官方 DMG/ZIP 并校验开发者签名，无需 Homebrew；默认装到 `/Applications`，不可写时使用 `~/Applications`。Windows 使用 WinGet `Google.Chrome`；Linux x86_64 使用官方 DEB/RPM 与 apt/dnf/yum/zypper。已安装时验证并复用，不改默认浏览器、终端或用户配置。自动化浏览器仍使用 `chatup chrome-for-testing`。详见[安装约定](https://arch.gh.wzhecnu.cn/ChatUp/commands/#chrome-iterm)。
+macOS 直接下载官方 DMG/ZIP 并校验开发者签名，无需 Homebrew；默认装到 `/Applications`，不可写时使用 `~/Applications`。Windows 使用 WinGet 精确包 `Google.Chrome.EXE`（当前用户安装）和 `liule.Snipaste`，需以 `--yes` 接受首次协议，Chrome 还会验证已安装程序的 Google 签名、产品身份和版本；Linux x86_64 支持 Chrome 的官方 DEB/RPM 与 apt/dnf/yum/zypper。已安装时验证并复用，不改默认浏览器、终端或用户配置。自动化浏览器仍使用 `chatup chrome-for-testing`。详见[安装约定](https://arch.gh.wzhecnu.cn/ChatUp/commands/#chrome-iterm)。
 
 ## ChatGPT / Codex 桌面应用
 
@@ -128,9 +132,11 @@ chatup chatgpt --yes  # Windows 首次安装时接受 Store 协议
 | --- | --- |
 | 基础运行环境 | `doctor`、`uv`、`nodejs`、`docker`、`zsh`、`chrome-for-testing`、`chromedriver`、`playwright`、`frp` |
 | 工作区脚手架 | `workspace` |
-| 桌面应用 | `macos`（Snipaste/iTerm2/Chrome/Blender 多选）、`chrome`、`iterm`（仅 macOS）、`chatgpt`（含 Codex） |
+| 桌面应用 | `macos`（Snipaste/iTerm2/Chrome/Blender 多选）、`chrome`、`snipaste`（macOS/Windows）、`iterm`（仅 macOS）、`chatgpt`（含 Codex） |
 | 视频项目 | `remotion` |
-| 本地服务安装 | `gitea`、`discourse`、`zulip`、`mysql`、`nginx`、`crs` |
+| 本地服务安装 | `gitea`、`glance`、`discourse`、`zulip`、`mysql`、`nginx`、`crs` |
+
+`chatup glance` 裸命令安装 `ChatArch/glance` 最新稳定维护版到有效 ChatArch home 下的 `glance`。当前仅支持 Linux amd64；严格验证归档、`SHA256SUMS`、`BUILDINFO.txt`、source SHA 和原始二进制版本，复用 ChatGlance portable API 初始化 loopback 配置。它不启动服务、不建立公网入口、不写密码；重复运行保留配置和数据，版本变更请使用 `chatglance runtime update`。
 | Agent 工具链 | `cc-connect`、`claude`、`codex`、`cursor-agent`、`opencode`、`hermes`、`lark-cli` |
 
 桌面应用使用系统原生应用目录；ChatArch 自管安装项默认目录收敛到 `~/.chatarch/...`，例如 `~/.chatarch/chrome-for-testing`、`~/.chatarch/chromedriver`、`~/.chatarch/playwright`、`~/.chatarch/chattea`、`~/.chatarch/discourse`、`~/.chatarch/zulip`、`~/.chatarch/chatdata`、`~/.chatarch/nginx` 和 `~/.chatarch/crs/local`。`cursor-agent` 额外注册 ChatEnv `CursorAgent` profile，`discourse`/`zulip` 注册管理员凭据 profile，并支持 `-e/--env` 从 env 文件或 profile 快速配置；显式选择 profile 时不会混入进程环境中的其他账号凭据。CLI 树由 ChatStyle 的注册表渲染。更完整的能力边界见 `docs/capability-map.md`。

{chatup-0.2.20 → chatup-0.2.22}/README.md

@@ -28,7 +28,7 @@ chatup doctor
 chatup uv
 chatup chrome-for-testing install --channel stable -I
 chatup playwright install 1.61.1 -I
-chatup workspace default ~/Playground
+chatup workspace ~/Playground
 ```
 
 `chatup uv` 默认更新已有 `~/.bashrc`、`~/.zshrc` 的自动激活块；使用 `chatup uv --no-activate` 可保持启动配置不变。不会创建缺失的 rc 文件，Windows 跳过此项。
@@ -37,6 +37,8 @@ chatup workspace default ~/Playground
 
 ```bash
 chatup gitea --force
+chatup glance --dry-run
+chatup glance
 chatup discourse -e discourse-prod --hostname discourse.public.wzhecnu.cn
 chatup zulip -e zulip-prod --external-host zulip.public.wzhecnu.cn --port 3095
 chatup mysql
@@ -68,16 +70,17 @@ npm run studio
 
 需要已有 Node.js >=18.12 和 npm >=9。创建带锁文件的 Remotion 4.0.530 项目，检测本机 Chrome 并输出渲染命令；不覆盖已有无关目录，也不替换 Node 或下载浏览器。项目放在指定目录，已有 Blender/Chrome 可通过 `chatup macos --app blender --app chrome` 验证或安装。详见[Remotion 安装约定](https://arch.gh.wzhecnu.cn/ChatUp/commands/#remotion)。
 
-## Chrome 与 iTerm2
+## Chrome、Snipaste 与 iTerm2
 
 ```bash
 chatup chrome --dry-run
 chatup chrome             # 按系统安装普通 Google Chrome
+chatup snipaste           # 在 macOS 或 Windows 安装 Snipaste
 chatup iterm              # 安装 iTerm2，仅限 macOS
 chatup chrome --sudo --yes # Linux：允许提权并确认包安装
 ```
 
-macOS 直接下载官方 DMG/ZIP 并校验开发者签名，无需 Homebrew；默认装到 `/Applications`，不可写时使用 `~/Applications`。Windows 使用 WinGet `Google.Chrome`；Linux x86_64 使用官方 DEB/RPM 与 apt/dnf/yum/zypper。已安装时验证并复用，不改默认浏览器、终端或用户配置。自动化浏览器仍使用 `chatup chrome-for-testing`。详见[安装约定](https://arch.gh.wzhecnu.cn/ChatUp/commands/#chrome-iterm)。
+macOS 直接下载官方 DMG/ZIP 并校验开发者签名，无需 Homebrew；默认装到 `/Applications`，不可写时使用 `~/Applications`。Windows 使用 WinGet 精确包 `Google.Chrome.EXE`（当前用户安装）和 `liule.Snipaste`，需以 `--yes` 接受首次协议，Chrome 还会验证已安装程序的 Google 签名、产品身份和版本；Linux x86_64 支持 Chrome 的官方 DEB/RPM 与 apt/dnf/yum/zypper。已安装时验证并复用，不改默认浏览器、终端或用户配置。自动化浏览器仍使用 `chatup chrome-for-testing`。详见[安装约定](https://arch.gh.wzhecnu.cn/ChatUp/commands/#chrome-iterm)。
 
 ## ChatGPT / Codex 桌面应用
 
@@ -97,9 +100,11 @@ chatup chatgpt --yes  # Windows 首次安装时接受 Store 协议
 | --- | --- |
 | 基础运行环境 | `doctor`、`uv`、`nodejs`、`docker`、`zsh`、`chrome-for-testing`、`chromedriver`、`playwright`、`frp` |
 | 工作区脚手架 | `workspace` |
-| 桌面应用 | `macos`（Snipaste/iTerm2/Chrome/Blender 多选）、`chrome`、`iterm`（仅 macOS）、`chatgpt`（含 Codex） |
+| 桌面应用 | `macos`（Snipaste/iTerm2/Chrome/Blender 多选）、`chrome`、`snipaste`（macOS/Windows）、`iterm`（仅 macOS）、`chatgpt`（含 Codex） |
 | 视频项目 | `remotion` |
-| 本地服务安装 | `gitea`、`discourse`、`zulip`、`mysql`、`nginx`、`crs` |
+| 本地服务安装 | `gitea`、`glance`、`discourse`、`zulip`、`mysql`、`nginx`、`crs` |
+
+`chatup glance` 裸命令安装 `ChatArch/glance` 最新稳定维护版到有效 ChatArch home 下的 `glance`。当前仅支持 Linux amd64；严格验证归档、`SHA256SUMS`、`BUILDINFO.txt`、source SHA 和原始二进制版本，复用 ChatGlance portable API 初始化 loopback 配置。它不启动服务、不建立公网入口、不写密码；重复运行保留配置和数据，版本变更请使用 `chatglance runtime update`。
 | Agent 工具链 | `cc-connect`、`claude`、`codex`、`cursor-agent`、`opencode`、`hermes`、`lark-cli` |
 
 桌面应用使用系统原生应用目录；ChatArch 自管安装项默认目录收敛到 `~/.chatarch/...`，例如 `~/.chatarch/chrome-for-testing`、`~/.chatarch/chromedriver`、`~/.chatarch/playwright`、`~/.chatarch/chattea`、`~/.chatarch/discourse`、`~/.chatarch/zulip`、`~/.chatarch/chatdata`、`~/.chatarch/nginx` 和 `~/.chatarch/crs/local`。`cursor-agent` 额外注册 ChatEnv `CursorAgent` profile，`discourse`/`zulip` 注册管理员凭据 profile，并支持 `-e/--env` 从 env 文件或 profile 快速配置；显式选择 profile 时不会混入进程环境中的其他账号凭据。CLI 树由 ChatStyle 的注册表渲染。更完整的能力边界见 `docs/capability-map.md`。

{chatup-0.2.20 → chatup-0.2.22}/pyproject.toml

@@ -13,6 +13,7 @@ dependencies = [
     "click>=8.0,<9.0",
     "chatstyle[tui]>=0.2.0,<0.3.0",
     "chatenv>=0.2.11,<0.3.0",
+    "ChatGlance>=0.3.0,<0.4.0",
     "python-dotenv>=1.0,<2.0",
     "colorama",
 ]

{chatup-0.2.20 → chatup-0.2.22}/src/chatup/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.2.20"
+__version__ = "0.2.22"

{chatup-0.2.20 → chatup-0.2.22}/src/chatup/cli.py

@@ -6,7 +6,7 @@ from chatstyle import add_tree_option
 from chatup import __version__
 from chatup.commands.chrome_for_testing import cli as chrome_for_testing_cli
 from chatup.commands.chromedriver import cli as chromedriver_cli
-from chatup.commands.desktop import chrome_cli, iterm_cli
+from chatup.commands.desktop import chrome_cli, iterm_cli, snipaste_cli
 from chatup.commands.macos import macos_cli
 from chatup.commands.playwright import cli as playwright_cli
 from chatup.commands.remotion import remotion_cli
@@ -36,6 +36,7 @@ main.add_command(chrome_for_testing_cli)
 main.add_command(chromedriver_cli)
 main.add_command(playwright_cli)
 main.add_command(chrome_cli)
+main.add_command(snipaste_cli)
 main.add_command(iterm_cli)
 main.add_command(macos_cli)
 main.add_command(remotion_cli)

{chatup-0.2.20 → chatup-0.2.22}/src/chatup/commands/desktop.py

@@ -44,6 +44,15 @@ def chrome_cli(**kwargs) -> None:
     _install("chrome", **kwargs)
 
 
+@click.command(name="snipaste")
+@click.option("--dry-run", is_flag=True, help="Show the installation plan without downloading or installing.")
+@click.option("--yes", "-y", is_flag=True, help="Accept Windows agreements.")
+@click.option("--log-level", type=click.Choice(["DEBUG", "INFO", "WARNING", "ERROR"], case_sensitive=False), default="INFO")
+def snipaste_cli(**kwargs) -> None:
+    """Install Snipaste for macOS or Windows."""
+    _install("snipaste", **kwargs)
+
+
 @click.command(name="iterm")
 @click.option("--dry-run", is_flag=True, help="Show the installation plan without downloading or installing.")
 @click.option("--log-level", type=click.Choice(["DEBUG", "INFO", "WARNING", "ERROR"], case_sensitive=False), default="INFO")

{chatup-0.2.20 → chatup-0.2.22}/src/chatup/runtime/_managed_artifact.py

@@ -79,7 +79,7 @@ def safe_extract_zip(
                             f"Symlink escapes {label} archive root: {member.filename}"
                         )
                     target.parent.mkdir(parents=True, exist_ok=True)
-                    target.symlink_to(link_value)
+                    target.symlink_to(link_value, target_is_directory=resolved_link.is_dir())
                     continue
                 if member.is_dir() or stat.S_ISDIR(mode):
                     target.mkdir(parents=True, exist_ok=True)

{chatup-0.2.20 → chatup-0.2.22}/src/chatup/setup/desktop.py

@@ -1,8 +1,10 @@
-"""Native installers for Google Chrome and supported macOS desktop apps."""
+"""Native installers for Chrome, Snipaste and supported macOS desktop apps."""
 from __future__ import annotations
 
 import logging
 import hashlib
+import base64
+import json
 import os
 from pathlib import Path
 import platform
@@ -22,6 +24,8 @@ logger = logging.getLogger(__name__)
 MAC_APPS = {
     "chrome": {
         "app": "Google Chrome",
+        "winget_id": "Google.Chrome.EXE",
+        "winget_scope": "user",
         "bundle": "Google Chrome.app",
         "bundle_id": "com.google.Chrome",
         "team_id": "EQHXZ8M8AV",
@@ -38,6 +42,7 @@ MAC_APPS = {
     },
     "snipaste": {
         "app": "Snipaste",
+        "winget_id": "liule.Snipaste",
         "bundle": "Snipaste.app",
         "bundle_id": "com.Snipaste",
         "team_id": "NGTL73P583",
@@ -73,15 +78,15 @@ def _is_root() -> bool:
     return hasattr(os, "geteuid") and os.geteuid() == 0
 
 
-def plan_desktop_install(
-    app: str, *, sudo: bool = False, yes: bool = False,
-) -> dict[str, Any]:
+def plan_desktop_install(app: str, *, sudo: bool = False, yes: bool = False) -> dict[str, Any]:
     """Describe the current platform's installation without writes or processes."""
     spec = MAC_APPS[app]
     system = platform.system()
     plan = {"app": spec["app"], "platform": system}
-    if app != "chrome" and system != "Darwin":
+    if system != "Darwin" and app in {"iterm", "blender"}:
         raise RuntimeError(f"{spec['app']} is supported on macOS only; current platform: {system}.")
+    if system not in {"Darwin", "Windows"} and app == "snipaste":
+        raise RuntimeError(f"{spec['app']} is supported on macOS and Windows only; current platform: {system}.")
     if system == "Darwin":
         if platform.machine().lower() not in {"arm64", "aarch64", "x86_64", "amd64"}:
             raise RuntimeError(f"Unsupported macOS architecture: {platform.machine()}.")
@@ -92,13 +97,24 @@ def plan_desktop_install(
         directory = directories[0] if os.access(directories[0], os.W_OK) else directories[1]
         return {**plan, **spec, "method": "macos", "path": str(existing or directory / spec["bundle"])}
     if system == "Windows":
-        selector = ["--id", "Google.Chrome", "--exact", "--source", "winget", "--disable-interactivity"]
+        package_id = spec.get("winget_id")
+        if not package_id:
+            raise RuntimeError(f"{spec['app']} is supported on macOS only; current platform: {system}.")
+        selector = ["--id", package_id, "--exact", "--source", "winget", "--disable-interactivity"]
         command = ["winget", "install", *selector, "--silent", "--no-upgrade"]
+        if spec.get("winget_scope"):
+            command += ["--scope", spec["winget_scope"]]
         verify = ["winget", "list", *selector]
         if yes:
             command += ["--accept-package-agreements", "--accept-source-agreements"]
             verify += ["--accept-source-agreements"]
-        return {**plan, "method": "winget", "command": command, "verify_command": verify}
+        return {
+            **plan,
+            "method": "winget",
+            "winget_id": package_id,
+            "command": command,
+            "verify_command": verify,
+        }
     if system == "Linux":
         if platform.machine().lower() not in {"x86_64", "amd64"}:
             raise RuntimeError("Google Chrome for Linux requires x86_64; Google does not provide a Linux ARM package.")
@@ -274,22 +290,77 @@ def _install_linux(plan: dict[str, Any], *, sudo: bool) -> dict[str, Any]:
     return {**plan, **installed, "status": "installed", "verified": True}
 
 
+def _google_signed_file(path: Path) -> dict[str, str]:
+    powershell = shutil.which("powershell.exe") or shutil.which("pwsh.exe")
+    if not powershell:
+        raise RuntimeError("PowerShell is required to verify Google's Authenticode signature.")
+    # Encode the script and quote its sole path literal, including apostrophes.
+    literal = str(path).replace("'", "''")
+    script = (
+        "$ErrorActionPreference = 'Stop'; "
+        "$ProgressPreference = 'SilentlyContinue'; "
+        "$env:PSModulePath = Join-Path $PSHOME 'Modules'; "
+        "[Console]::OutputEncoding = [System.Text.UTF8Encoding]::new(); "
+        f"$file = Get-Item -LiteralPath '{literal}'; "
+        "$sig = Get-AuthenticodeSignature -LiteralPath $file.FullName; "
+        "$publisher = if ($sig.SignerCertificate) { "
+        "$sig.SignerCertificate.GetNameInfo([System.Security.Cryptography.X509Certificates.X509NameType]::SimpleName, $false) "
+        "} else { '' }; "
+        "@{status=[string]$sig.Status; publisher=$publisher; "
+        "product=$file.VersionInfo.ProductName; version=$file.VersionInfo.ProductVersion; "
+        "original=$file.VersionInfo.OriginalFilename} | ConvertTo-Json -Compress"
+    )
+    encoded = base64.b64encode(script.encode("utf-16-le")).decode("ascii")
+    result = _run([powershell, "-NoProfile", "-NonInteractive", "-OutputFormat", "Text",
+                   "-EncodedCommand", encoded], timeout=120)
+    details = json.loads(result.stdout.lstrip("\ufeff"))
+    if not isinstance(details, dict) or details.get("status") != "Valid" or details.get("publisher") != "Google LLC":
+        raise RuntimeError(f"Google Authenticode signature verification failed: {path}.")
+    version = details.get("version", "")
+    if (details.get("product") != "Google Chrome"
+            or str(details.get("original", "")).lower() != "chrome.exe"
+            or not isinstance(version, str) or not re.fullmatch(r"\d+(?:\.\d+){3}", version)):
+        raise RuntimeError(f"Cannot verify installed Google Chrome identity/version: {path}.")
+    return {"binary": str(path), "path": str(path), "version": version}
+
+
+def _windows_chrome() -> dict[str, str] | None:
+    for variable in ("LOCALAPPDATA", "PROGRAMW6432", "PROGRAMFILES", "PROGRAMFILES(X86)"):
+        root = os.environ.get(variable)
+        if root:
+            binary = Path(root) / "Google/Chrome/Application/chrome.exe"
+            if binary.exists():
+                return _google_signed_file(binary)
+    return None
+
+
 def _install_windows(plan: dict[str, Any]) -> dict[str, Any]:
+    is_chrome = plan["winget_id"] == "Google.Chrome.EXE"
+    existing = _windows_chrome() if is_chrome else None
+    if existing:
+        return {**plan, **existing, "status": "already_installed", "verified": True}
     executable = shutil.which("winget")
     if not executable:
-        raise RuntimeError("WinGet is required to install Google Chrome: https://aka.ms/getwinget")
+        raise RuntimeError(f"WinGet is required to install {plan['app']}: https://aka.ms/getwinget")
 
     def installed():
         result = _run([executable, *plan["verify_command"][1:]], timeout=120, check=False)
-        return result.returncode == 0 and re.search(r"\bGoogle\.Chrome\b", result.stdout) is not None
+        return result.returncode == 0 and re.search(
+            rf"(?<![\w.-]){re.escape(plan['winget_id'])}(?![\w.-])", result.stdout,
+        ) is not None
 
     if installed():
+        if is_chrome:
+            raise RuntimeError("Google Chrome package record exists, but signed chrome.exe was not found.")
         return {**plan, "status": "already_installed", "verified": True}
-    logger.info("Installing Google Chrome with WinGet; use --yes to accept source/package agreements")
+    logger.info("Installing %s with WinGet; use --yes to accept source/package agreements", plan["app"])
     _run([executable, *plan["command"][1:]], capture=False)
     if not installed():
-        raise RuntimeError("Google Chrome installation verification failed: no matching WinGet package record.")
-    return {**plan, "status": "installed", "verified": True}
+        raise RuntimeError(f"{plan['app']} installation verification failed: no matching WinGet package record.")
+    details = _windows_chrome() if is_chrome else {}
+    if is_chrome and not details:
+        raise RuntimeError("Google Chrome installation verification failed: signed chrome.exe not found.")
+    return {**plan, **details, "status": "installed", "verified": True}
 
 
 def setup_desktop_app(

{chatup-0.2.20 → chatup-0.2.22}/src/chatup/setup/elements.py

@@ -26,6 +26,7 @@ from chatup.setup.discourse import (
     setup_discourse,
 )
 from chatup.setup.frp import setup_frp
+from chatup.setup.glance import DEFAULT_GLANCE_VERSION, setup_glance
 from chatup.setup.gitea import (
     DEFAULT_BASE_URL as DEFAULT_GITEA_BASE_URL,
     DEFAULT_DATABASE_BACKEND as DEFAULT_GITEA_DATABASE_BACKEND,
@@ -231,6 +232,15 @@ def gitea_setup(
     )
 
 
+def glance_setup(version, runtime_home, dry_run, interactive):
+    return setup_glance(
+        version=version,
+        runtime_home=runtime_home,
+        dry_run=dry_run,
+        interactive=interactive,
+    )
+
+
 def discourse_setup(
     home,
     hostname,
@@ -612,6 +622,37 @@ SETUP_COMMAND_ELEMENTS = (
         ),
     ),
 
+    SetupCommandElement(
+        name="glance",
+        help="Install the verified maintained ChatArch Glance runtime without starting it.",
+        callback=glance_setup,
+        options=(
+            SetupOptionElement(
+                param_decls=("--version",),
+                kwargs={
+                    "default": DEFAULT_GLANCE_VERSION,
+                    "show_default": True,
+                    "help": "Maintained release: latest or exact chatarch-vMAJOR.MINOR.PATCH.",
+                },
+            ),
+            SetupOptionElement(
+                param_decls=("--runtime-home",),
+                kwargs={
+                    "default": None,
+                    "type": click.Path(path_type=Path),
+                    "help": "Runtime root; defaults to the active ChatArch home/glance.",
+                },
+            ),
+            SetupOptionElement(
+                param_decls=("--dry-run",),
+                kwargs={"is_flag": True, "help": "Show paths without network access or writes."},
+            ),
+            SetupOptionElement(
+                param_decls=("--interactive/--no-interactive", "-i/-I"),
+                kwargs={"default": None, "help": INTERACTIVE_OPTION_HELP},
+            ),
+        ),
+    ),
     SetupCommandElement(
         name="gitea",
         help="Install ChatArch Gitea and optionally write a local app.ini/user service.",

chatup-0.2.22/src/chatup/setup/glance.py

@@ -0,0 +1,240 @@
+"""Install the maintained ChatArch Glance release into a portable runtime."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import hashlib
+import json
+import os
+from pathlib import Path
+import platform
+import re
+import shlex
+import subprocess
+import tempfile
+import urllib.request
+
+import click
+from chatenv import get_paths
+from chatglance.portable import initialize, install_verified_binary, runtime_home
+
+
+DEFAULT_GLANCE_REPO = "ChatArch/glance"
+DEFAULT_GLANCE_VERSION = "latest"
+TAG_PATTERN = re.compile(r"chatarch-v(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)")
+SOURCE_SHA_PATTERN = re.compile(r"[0-9a-f]{40}")
+
+
+@dataclass(frozen=True)
+class GlanceInstallation:
+    status: str
+    tag: str
+    version: str | None
+    binary: Path
+    config: Path
+    start_command: tuple[str, ...]
+
+
+def normalize_release_tag(value: str) -> str:
+    tag = str(value).strip()
+    if not TAG_PATTERN.fullmatch(tag):
+        raise ValueError("Glance version must be an exact chatarch-vMAJOR.MINOR.PATCH tag")
+    return tag
+
+
+def _require_supported_platform() -> None:
+    system = platform.system().lower()
+    machine = platform.machine().lower()
+    if system != "linux" or machine not in {"x86_64", "amd64"}:
+        raise ValueError("Maintained ChatArch/glance releases currently support Linux amd64 only")
+
+
+def resolve_latest_release_tag(repo: str = DEFAULT_GLANCE_REPO) -> str:
+    url = f"https://api.github.com/repos/{repo}/releases/latest"
+    with urllib.request.urlopen(url, timeout=30) as response:
+        payload = json.loads(response.read().decode("utf-8"))
+    tag = payload.get("tag_name")
+    if not isinstance(tag, str):
+        raise ValueError(f"Latest {repo} release did not provide a tag")
+    return normalize_release_tag(tag)
+
+
+def resolve_requested_tag(version: str, repo: str = DEFAULT_GLANCE_REPO) -> str:
+    value = str(version or DEFAULT_GLANCE_VERSION).strip()
+    return resolve_latest_release_tag(repo) if value == DEFAULT_GLANCE_VERSION else normalize_release_tag(value)
+
+
+def release_asset_name(tag: str) -> str:
+    return f"glance-{normalize_release_tag(tag)}-linux-amd64.tar.gz"
+
+
+def release_asset_url(repo: str, tag: str, name: str) -> str:
+    return f"https://github.com/{repo}/releases/download/{tag}/{name}"
+
+
+def download_release_asset(url: str, destination: Path) -> None:
+    with urllib.request.urlopen(url, timeout=120) as response, destination.open("wb") as output:
+        status = getattr(response, "status", 200)
+        if status != 200:
+            raise ValueError(f"Glance release download failed with HTTP {status}")
+        while chunk := response.read(1024 * 1024):
+            output.write(chunk)
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for chunk in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _parse_checksums(path: Path, expected_names: set[str]) -> dict[str, str]:
+    checksums: dict[str, str] = {}
+    for line in path.read_text(encoding="utf-8").splitlines():
+        match = re.fullmatch(r"([0-9a-f]{64})  ([A-Za-z0-9._+-]+)", line)
+        if not match or match.group(2) in checksums:
+            raise ValueError("Invalid SHA256SUMS manifest")
+        checksums[match.group(2)] = match.group(1)
+    if set(checksums) != expected_names:
+        raise ValueError("SHA256SUMS does not describe the exact expected release files")
+    return checksums
+
+
+def _parse_buildinfo(path: Path) -> dict[str, str]:
+    result: dict[str, str] = {}
+    for line in path.read_text(encoding="utf-8").splitlines():
+        key, separator, value = line.partition("=")
+        if not separator or not key or key in result:
+            raise ValueError("Invalid BUILDINFO.txt manifest")
+        result[key] = value
+    expected = {"tag", "source_sha", "binary_version", "archive", "goos", "goarch", "cgo_enabled"}
+    if set(result) != expected:
+        raise ValueError("BUILDINFO.txt has unexpected or missing fields")
+    return result
+
+
+def _verify_release_files(archive: Path, checksums_path: Path, buildinfo_path: Path, tag: str) -> tuple[str, str]:
+    checksums = _parse_checksums(checksums_path, {archive.name, buildinfo_path.name})
+    for path in (archive, buildinfo_path):
+        if _sha256(path) != checksums[path.name]:
+            raise ValueError(f"SHA256 mismatch for {path.name}")
+    info = _parse_buildinfo(buildinfo_path)
+    if info["tag"] != tag:
+        raise ValueError("BUILDINFO tag does not match requested release")
+    if not SOURCE_SHA_PATTERN.fullmatch(info["source_sha"]):
+        raise ValueError("BUILDINFO source_sha must be exactly 40 lowercase hex characters")
+    version = f"{tag}+{info['source_sha']}"
+    expected = {
+        "binary_version": version,
+        "archive": archive.name,
+        "goos": "linux",
+        "goarch": "amd64",
+        "cgo_enabled": "0",
+    }
+    for key, value in expected.items():
+        if info[key] != value:
+            raise ValueError(f"BUILDINFO {key} does not match the requested release")
+    return checksums[archive.name], version
+
+
+def _read_observed_version(binary: Path) -> str:
+    try:
+        result = subprocess.run(
+            [str(binary), "--version"], capture_output=True, text=True, timeout=5,
+            check=True, env={"PATH": "/usr/bin:/bin"},
+        )
+    except (OSError, subprocess.SubprocessError, UnicodeError) as exc:
+        raise ValueError(f"Installed Glance version check failed ({type(exc).__name__})") from None
+    return result.stdout.strip()
+
+
+def _existing_binary_matches(home: Path, archive_sha256: str, version: str) -> bool:
+    binary = home / "bin/glance"
+    provenance_path = home / "bin/glance.provenance.json"
+    if not (binary.exists() or binary.is_symlink() or provenance_path.exists() or provenance_path.is_symlink()):
+        return False
+    refusal = "Existing Glance runtime is not this exact verified release; use native `chatglance runtime update` for explicit changes"
+    if binary.is_symlink() or provenance_path.is_symlink() or not binary.is_file() or not provenance_path.is_file():
+        raise ValueError(refusal)
+    try:
+        provenance = json.loads(provenance_path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeError, json.JSONDecodeError):
+        raise ValueError(refusal) from None
+    tag, source_sha = version.split("+", 1)
+    expected = {
+        "source": "verified local archive",
+        "source_tag": tag,
+        "source_revision": source_sha,
+        "version": version,
+        "archive_sha256": archive_sha256,
+        "binary_sha256": _sha256(binary),
+    }
+    if provenance != expected or _read_observed_version(binary) != version:
+        raise ValueError(refusal)
+    return True
+
+
+def install_glance(
+    *, version: str = DEFAULT_GLANCE_VERSION, home: str | Path | None = None,
+    repo: str = DEFAULT_GLANCE_REPO, dry_run: bool = False,
+) -> GlanceInstallation:
+    """Install or exactly reuse one verified maintained Go release, then initialize resources."""
+    _require_supported_platform()
+    root = runtime_home(home)
+    binary = root / "bin/glance"
+    config = root / "config/glance.yml"
+    requested = str(version or DEFAULT_GLANCE_VERSION).strip()
+    if dry_run:
+        tag = DEFAULT_GLANCE_VERSION if requested == DEFAULT_GLANCE_VERSION else normalize_release_tag(requested)
+        return GlanceInstallation("planned", tag, None, binary, config, ("chatglance", "runtime", "serve", "--runtime-home", str(root)))
+
+    tag = resolve_requested_tag(requested, repo)
+    archive_name = release_asset_name(tag)
+    names = (archive_name, "SHA256SUMS", "BUILDINFO.txt")
+    staging_parent = get_paths().home_dir / "chatup" / "staging"
+    staging_parent.mkdir(parents=True, mode=0o700, exist_ok=True)
+    if staging_parent.is_symlink() or not staging_parent.is_dir():
+        raise ValueError("Unsafe Glance download staging directory")
+    staging_parent.chmod(0o700)
+    with tempfile.TemporaryDirectory(prefix="glance-", dir=staging_parent) as temporary:
+        staging = Path(temporary)
+        for name in names:
+            download_release_asset(release_asset_url(repo, tag, name), staging / name)
+        archive = staging / archive_name
+        archive_sha256, raw_version = _verify_release_files(
+            archive, staging / "SHA256SUMS", staging / "BUILDINFO.txt", tag
+        )
+        reused = _existing_binary_matches(root, archive_sha256, raw_version)
+        if not reused:
+            install_verified_binary(archive, archive_sha256, root, version=raw_version)
+    initialize(root)
+    if not config.is_file() or config.is_symlink():
+        raise ValueError("ChatGlance initialization did not provide a safe runtime config")
+    return GlanceInstallation(
+        "reused" if reused else "installed", tag, raw_version, binary, config,
+        ("chatglance", "runtime", "serve", "--runtime-home", str(root)),
+    )
+
+
+def setup_glance(
+    version: str = DEFAULT_GLANCE_VERSION,
+    runtime_home: str | Path | None = None,
+    dry_run: bool = False,
+    interactive=None,
+) -> GlanceInstallation:
+    """Click-facing setup wrapper; setup never starts or enables the server."""
+    del interactive
+    try:
+        result = install_glance(version=version, home=runtime_home, dry_run=dry_run)
+    except (OSError, ValueError, json.JSONDecodeError) as exc:
+        raise click.ClickException(str(exc)) from exc
+    if result.status == "planned":
+        click.echo(f"Glance setup plan: {result.tag} -> {result.binary}")
+    else:
+        click.echo(f"Glance binary: {result.binary}")
+        click.echo(f"Glance config: {result.config}")
+        click.echo(f"Glance release: {result.version} ({result.status})")
+    click.echo("Native start command: " + shlex.join(result.start_command))
+    click.echo("The server was not started and no service or public endpoint was created.")
+    return result