gzcli 0.1.0__py3-none-any.whl

clihub/__init__.py

@@ -0,0 +1,3 @@
+"""CLIHub - 统一父指令网关，将团队 HTTP 接口注册为子指令。"""
+
+__version__ = "0.1.0"

clihub/cli.py

@@ -0,0 +1,148 @@
+"""gzcli 入口：内置 init/update 命令 + 按配置动态生成子指令树。"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Any, Dict
+
+import click
+import httpx
+import yaml
+
+from . import __version__
+from . import config as cfg_mod
+from .executor import EXIT_LOCAL_ERROR, EXIT_OK, execute_subcommand
+from .schema import ConfigError, validate_config
+
+_ARG_TYPE_MAP = {
+    "string": str,
+    "int": int,
+    "float": float,
+}
+
+
+def _make_callback(ns_cfg: Dict[str, Any], sub_cfg: Dict[str, Any]):
+    def callback(**kwargs):
+        code = execute_subcommand(ns_cfg, sub_cfg, kwargs)
+        if code:
+            raise SystemExit(code)
+
+    return callback
+
+
+def _build_subcommand(ns_cfg: Dict[str, Any], sub_name: str, sub_cfg: Dict[str, Any]) -> click.Command:
+    params = []
+    for flag, spec in (sub_cfg.get("args") or {}).items():
+        atype = spec.get("type", "string")
+        kwargs: Dict[str, Any] = {
+            "required": bool(spec.get("required", False)),
+            "default": spec.get("default"),
+            "help": spec.get("help", ""),
+        }
+        if atype == "file":
+            kwargs["type"] = click.Path(exists=True, dir_okay=False)
+        elif atype == "bool":
+            kwargs["is_flag"] = True
+            kwargs["default"] = bool(spec.get("default", False))
+            kwargs.pop("required")
+        else:
+            kwargs["type"] = _ARG_TYPE_MAP[atype]
+        # 同时接受 --img_url 与 --img-url，参数名统一为下划线形式
+        decls = [f"--{flag}"]
+        dashed = flag.replace("_", "-")
+        if dashed != flag:
+            decls.append(f"--{dashed}")
+        decls.append(flag.replace("-", "_"))
+        params.append(click.Option(decls, **kwargs))
+
+    return click.Command(
+        name=sub_name,
+        params=params,
+        callback=_make_callback(ns_cfg, sub_cfg),
+        help=sub_cfg.get("description", ""),
+    )
+
+
+def _attach_dynamic_commands(root: click.Group, conf: Dict[str, Any]) -> None:
+    for ns_name, ns_cfg in conf["commands"].items():
+        ns_group = click.Group(name=ns_name, help=ns_cfg.get("description", ""))
+        for sub_name, sub_cfg in ns_cfg["subcommands"].items():
+            ns_group.add_command(_build_subcommand(ns_cfg, sub_name, sub_cfg))
+        root.add_command(ns_group)
+
+
+@click.command("init")
+@click.option("--conf", "conf_path", required=True,
+              type=click.Path(exists=True, dir_okay=False),
+              help="子指令注册配置文件（YAML）")
+def init_cmd(conf_path: str) -> None:
+    """初始化：校验并注册子指令配置。"""
+    try:
+        dest = cfg_mod.save_config(Path(conf_path))
+    except ConfigError as e:
+        click.echo(f"gzcli: {e}", err=True)
+        raise SystemExit(EXIT_LOCAL_ERROR)
+    conf = cfg_mod.load_config()
+    ns_count = len(conf["commands"])
+    sub_count = sum(len(ns["subcommands"]) for ns in conf["commands"].values())
+    click.echo(f"配置已生效: {dest}")
+    click.echo(f"已注册 {ns_count} 个命名空间、{sub_count} 个子指令，执行 gzcli --help 查看")
+
+
+@click.command("update")
+def update_cmd() -> None:
+    """从管理站点拉取最新配置（需配置 registry.url）。"""
+    try:
+        conf = cfg_mod.load_config()
+    except ConfigError as e:
+        click.echo(f"gzcli: {e}", err=True)
+        raise SystemExit(EXIT_LOCAL_ERROR)
+
+    url = (conf.get("registry") or {}).get("url")
+    if not url:
+        click.echo("gzcli: 当前配置未声明 registry.url，无法从管理站点更新", err=True)
+        raise SystemExit(EXIT_LOCAL_ERROR)
+
+    try:
+        resp = httpx.get(url, timeout=30)
+        resp.raise_for_status()
+        data = yaml.safe_load(resp.text)
+        validate_config(data)
+    except (httpx.HTTPError, yaml.YAMLError, ConfigError) as e:
+        click.echo(f"gzcli: 拉取配置失败: {e}", err=True)
+        raise SystemExit(EXIT_LOCAL_ERROR)
+
+    dest = cfg_mod.config_path()
+    dest.write_text(resp.text, encoding="utf-8")
+    click.echo(f"配置已更新: {dest}")
+
+
+def _build_root() -> click.Group:
+    root = click.Group(
+        name="gzcli",
+        help="CLIHub 统一入口：团队 HTTP 接口以子指令形式对外提供",
+        context_settings={"help_option_names": ["-h", "--help"]},
+    )
+    root.add_command(init_cmd)
+    root.add_command(update_cmd)
+
+    try:
+        conf = cfg_mod.load_config()
+    except ConfigError:
+        return root  # 未初始化时仅暴露 init/update
+    _attach_dynamic_commands(root, conf)
+    return root
+
+
+def main() -> None:
+    root = _build_root()
+    try:
+        root(prog_name="gzcli")
+    except ConfigError as e:
+        click.echo(f"gzcli: {e}", err=True)
+        sys.exit(EXIT_LOCAL_ERROR)
+
+
+if __name__ == "__main__":
+    main()

clihub/config.py

@@ -0,0 +1,48 @@
+"""配置的存储与加载。
+
+配置默认存放在 ``~/.gzcli/config.yaml``，可用环境变量 ``GZCLI_HOME``
+覆盖配置目录（便于测试与多环境隔离）。
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+from pathlib import Path
+from typing import Any, Dict
+
+import yaml
+
+from .schema import ConfigError, validate_config
+
+
+def config_dir() -> Path:
+    return Path(os.environ.get("GZCLI_HOME", Path.home() / ".gzcli"))
+
+
+def config_path() -> Path:
+    return config_dir() / "config.yaml"
+
+
+def load_config() -> Dict[str, Any]:
+    """加载并校验当前生效配置。未初始化或配置损坏时抛 ConfigError。"""
+    path = config_path()
+    if not path.exists():
+        raise ConfigError(
+            f"尚未初始化，请先执行 gzcli init --conf <conf.yaml>（期望路径: {path}）"
+        )
+    with open(path, "r", encoding="utf-8") as f:
+        data = yaml.safe_load(f)
+    return validate_config(data)
+
+
+def save_config(src: Path) -> Path:
+    """将外部配置文件校验后存入配置目录，返回落盘路径。"""
+    with open(src, "r", encoding="utf-8") as f:
+        data = yaml.safe_load(f)
+    validate_config(data)
+    d = config_dir()
+    d.mkdir(parents=True, exist_ok=True)
+    dest = config_path()
+    shutil.copyfile(src, dest)
+    return dest

clihub/executor.py

@@ -0,0 +1,174 @@
+"""HTTP 调用执行层：把命令行参数按配置映射为一次内部 HTTP 调用。
+
+约定：
+- 正常结果（JSON/文本/流）写 stdout，诊断与错误写 stderr；
+- 非 JSON/文本 的二进制响应落盘，stdout 打印文件路径；
+- 退出码：0 成功；1 接口返回错误或网络错误；2 本地配置/凭证问题。
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+import time
+from pathlib import Path
+from typing import Any, Dict, Optional, Tuple
+
+import httpx
+
+EXIT_OK = 0
+EXIT_REMOTE_ERROR = 1
+EXIT_LOCAL_ERROR = 2
+
+
+def _err(msg: str) -> None:
+    print(f"gzcli: {msg}", file=sys.stderr)
+
+
+def _build_auth(auth_cfg: Dict[str, Any]) -> Tuple[Dict[str, str], Optional[httpx.Auth], Optional[str]]:
+    """返回 (headers, httpx_auth, error_msg)。凭证缺失时不抛异常，返回错误信息。"""
+    atype = (auth_cfg or {}).get("type", "none")
+    if atype == "none":
+        return {}, None, None
+
+    if atype in ("header_token", "bearer"):
+        env_name = auth_cfg.get("token_env", "")
+        token = os.environ.get(env_name, "")
+        if not token:
+            return {}, None, f"缺少凭证：请设置环境变量 {env_name}"
+        if atype == "header_token":
+            return {auth_cfg.get("header", "X-API-Token"): token}, None, None
+        return {"Authorization": f"Bearer {token}"}, None, None
+
+    if atype == "basic":
+        user = os.environ.get(auth_cfg.get("user_env", ""), "")
+        password = os.environ.get(auth_cfg.get("pass_env", ""), "")
+        if not user or not password:
+            return {}, None, (
+                f"缺少凭证：请设置环境变量 {auth_cfg.get('user_env')} / {auth_cfg.get('pass_env')}"
+            )
+        return {}, httpx.BasicAuth(user, password), None
+
+    return {}, None, f"不支持的鉴权类型: {atype}"
+
+
+def _dump_json(data: Any) -> None:
+    print(json.dumps(data, ensure_ascii=False, indent=2))
+
+
+def _handle_response(resp: httpx.Response) -> int:
+    ct = resp.headers.get("content-type", "")
+    if "json" in ct:
+        try:
+            _dump_json(resp.json())
+            return EXIT_OK
+        except ValueError:
+            pass
+    if ct.startswith("text/") or ct == "":
+        sys.stdout.write(resp.text)
+        if resp.text and not resp.text.endswith("\n"):
+            sys.stdout.write("\n")
+        return EXIT_OK
+
+    # 二进制响应：落盘并打印路径
+    ext = ""
+    if "/" in ct:
+        ext = "." + ct.split("/", 1)[1].split(";")[0].replace("jpeg", "jpg")
+    out = Path.cwd() / f"gzcli_output_{int(time.time())}{ext}"
+    out.write_bytes(resp.content)
+    print(str(out))
+    return EXIT_OK
+
+
+def execute_subcommand(ns_cfg: Dict[str, Any], sub_cfg: Dict[str, Any], values: Dict[str, Any]) -> int:
+    """按后端类型分发执行，返回进程退出码。"""
+    if sub_cfg.get("type", "http") == "script":
+        from .script_backend import execute_script
+
+        return execute_script(sub_cfg, values)
+    return _execute_http(ns_cfg, sub_cfg, values)
+
+
+def _execute_http(ns_cfg: Dict[str, Any], sub_cfg: Dict[str, Any], values: Dict[str, Any]) -> int:
+    """执行 http 型子指令，返回进程退出码。"""
+    service = ns_cfg["service"]
+    url = service["base_url"].rstrip("/") + sub_cfg["path"]
+    method = sub_cfg["method"].upper()
+    timeout = float(service.get("timeout", 30))
+
+    headers, auth, auth_err = _build_auth(service.get("auth") or {})
+    if auth_err:
+        _err(auth_err)
+        return EXIT_LOCAL_ERROR
+
+    query: Dict[str, Any] = {}
+    json_body: Dict[str, Any] = {}
+    form: Dict[str, Any] = {}
+    files: Dict[str, Any] = {}
+    opened = []
+
+    for flag, spec in (sub_cfg.get("args") or {}).items():
+        name = flag.replace("-", "_")
+        val = values.get(name)
+        if val is None:
+            continue
+        target, _, field = spec["to"].partition(".")
+        atype = spec.get("type", "string")
+        try:
+            if atype == "file":
+                fh = open(val, "rb")
+                opened.append(fh)
+                files[field] = (Path(val).name, fh)
+            elif target == "query":
+                query[field] = val
+            elif target == "json":
+                json_body[field] = val
+            elif target == "form":
+                form[field] = val if isinstance(val, str) else str(val)
+            elif target == "header":
+                headers[field] = str(val)
+        except OSError as e:
+            _err(f"无法读取文件 {val}: {e}")
+            for fh in opened:
+                fh.close()
+            return EXIT_LOCAL_ERROR
+
+    # 有文件或表单字段时用 multipart，否则 JSON body
+    request_kwargs: Dict[str, Any] = {"params": query, "headers": headers, "auth": auth}
+    if files or form:
+        request_kwargs["data"] = form
+        request_kwargs["files"] = files
+    elif json_body and method not in ("GET", "HEAD"):
+        request_kwargs["json"] = json_body
+    elif json_body:
+        query.update(json_body)
+
+    stream = bool(sub_cfg.get("stream"))
+    try:
+        with httpx.Client(timeout=timeout) as client:
+            if stream:
+                with client.stream(method, url, **request_kwargs) as resp:
+                    if resp.status_code >= 400:
+                        resp.read()
+                        _err(f"HTTP {resp.status_code}: {resp.text.strip()[:500]}")
+                        return EXIT_REMOTE_ERROR
+                    for chunk in resp.iter_bytes():
+                        sys.stdout.buffer.write(chunk)
+                        sys.stdout.buffer.flush()
+                    return EXIT_OK
+
+            resp = client.request(method, url, **request_kwargs)
+            if resp.status_code >= 400:
+                _err(f"HTTP {resp.status_code}: {resp.text.strip()[:500]}")
+                return EXIT_REMOTE_ERROR
+            return _handle_response(resp)
+    except httpx.TimeoutException:
+        _err(f"请求超时（{timeout}s）: {url}")
+        return EXIT_REMOTE_ERROR
+    except httpx.HTTPError as e:
+        _err(f"网络错误: {e}")
+        return EXIT_REMOTE_ERROR
+    finally:
+        for fh in opened:
+            fh.close()

clihub/schema.py

@@ -0,0 +1,161 @@
+"""conf.yaml 的 Schema 校验。
+
+配置结构::
+
+    version: 1
+    registry:                 # 可选，未来 Web 管理站点
+      url: https://clihub.example.com/api/config
+    commands:                 # 一级子指令（团队命名空间）
+      img_detect:
+        description: 图像检测能力集
+        service:                        # http 型子指令必填
+          base_url: http://img-detect.internal.api
+          timeout: 30
+          auth:
+            type: header_token          # header_token | bearer | basic | none
+            header: X-API-Token
+            token_env: GZCLI_IMG_TOKEN
+        subcommands:                    # 二级子指令
+          obj_detect:
+            description: 图像目标检测
+            method: POST                # http 型必填
+            path: /v1/detect            # http 型必填
+            stream: false
+            args:
+              img:
+                type: file              # string|int|float|bool|file
+                to: form.img            # http 目标: query|json|form|header.字段名
+                required: true
+
+      data_team:                        # script 型命名空间可以没有 service
+        description: 数据团队工具集
+        subcommands:
+          clean_csv:
+            type: script                # script 后端：执行团队提供的 Python 脚本
+            description: CSV 清洗工具
+            script:
+              source: git+https://git.internal.com/data-team/clean_csv.git@v1.2.0
+              # 也支持本地路径: ./tools/clean_csv.py（文件）或 ./tools/clean_csv/（目录）
+              entry: clean_csv.py       # source 为目录时必填；为 .py 文件时忽略
+              timeout: 300              # 可选，秒；缺省不限制
+            args:
+              input:
+                type: file
+                to: argv.input          # script 目标: argv.参数名 | env.环境变量名
+                required: true
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any, Dict
+
+SUPPORTED_ARG_TYPES = {"string", "int", "float", "bool", "file"}
+SUPPORTED_METHODS = {"GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"}
+SUPPORTED_AUTH = {"header_token", "bearer", "basic", "none"}
+SUPPORTED_BACKENDS = {"http", "script"}
+
+_HTTP_TO_RE = re.compile(r"^(query|json|form|header)\.[A-Za-z0-9_.\[\]-]+$")
+_SCRIPT_TO_RE = re.compile(r"^(argv|env)\.[A-Za-z_][A-Za-z0-9_]*$")
+
+
+class ConfigError(Exception):
+    """配置不合法或缺失。"""
+
+
+def _fail(path: str, msg: str) -> None:
+    raise ConfigError(f"配置错误 [{path}]: {msg}")
+
+
+def _validate_auth(auth: Any, p: str) -> None:
+    if auth.get("type") not in SUPPORTED_AUTH:
+        _fail(f"{p}.type", f"仅支持 {sorted(SUPPORTED_AUTH)}")
+    if auth.get("type") in ("header_token", "bearer") and not auth.get("token_env"):
+        _fail(f"{p}.token_env", "header_token/bearer 必须指定读取凭证的环境变量名")
+    if auth.get("type") == "basic" and not (auth.get("user_env") and auth.get("pass_env")):
+        _fail(f"{p}.user_env/pass_env", "basic 必须指定用户名/密码的环境变量名")
+
+
+def _validate_http_sub(sub: Dict[str, Any], sp: str) -> None:
+    method = str(sub.get("method", "")).upper()
+    if method not in SUPPORTED_METHODS:
+        _fail(f"{sp}.method", f"http 型子指令必填，仅支持 {sorted(SUPPORTED_METHODS)}")
+    path = sub.get("path")
+    if not isinstance(path, str) or not path.startswith("/"):
+        _fail(f"{sp}.path", "http 型子指令必填，且必须以 / 开头")
+
+
+def _validate_script_sub(sub: Dict[str, Any], sp: str) -> None:
+    script = sub.get("script")
+    if not isinstance(script, dict) or not script.get("source"):
+        _fail(f"{sp}.script.source", "script 型子指令必填（本地路径或 git+URL[@ref]）")
+    source = str(script["source"])
+    if not (source.startswith("git+") or source.endswith(".py") or script.get("entry")):
+        _fail(f"{sp}.script.entry", "source 为目录时必须指定 entry 入口文件")
+
+
+def _validate_args(sub: Dict[str, Any], sp: str, backend: str) -> None:
+    args = sub.get("args") or {}
+    if not isinstance(args, dict):
+        _fail(f"{sp}.args", "必须是 mapping")
+    to_re = _HTTP_TO_RE if backend == "http" else _SCRIPT_TO_RE
+    to_hint = "query|json|form|header.字段名" if backend == "http" else "argv.参数名 | env.环境变量名"
+    for flag, spec in args.items():
+        ap = f"{sp}.args.{flag}"
+        if not isinstance(spec, dict):
+            _fail(ap, "必须是 mapping")
+        atype = spec.get("type", "string")
+        if atype not in SUPPORTED_ARG_TYPES:
+            _fail(f"{ap}.type", f"仅支持 {sorted(SUPPORTED_ARG_TYPES)}")
+        to = spec.get("to")
+        if not isinstance(to, str) or not to_re.match(to):
+            _fail(f"{ap}.to", f"必填，格式为 {to_hint}")
+        if backend == "http" and atype == "file" and not to.startswith("form."):
+            _fail(f"{ap}.to", "http 后端中 file 类型只能映射到 form.字段（multipart 上传）")
+        if backend == "script" and atype == "file" and not to.startswith("argv."):
+            _fail(f"{ap}.to", "script 后端中 file 类型只能映射到 argv.参数（传文件路径）")
+
+
+def validate_config(data: Any) -> Dict[str, Any]:
+    """校验并返回配置 dict，不合法时抛 ConfigError。"""
+    if not isinstance(data, dict):
+        _fail("$", "顶层必须是 mapping")
+
+    commands = data.get("commands")
+    if not isinstance(commands, dict) or not commands:
+        _fail("commands", "至少需要一个一级子指令（团队命名空间）")
+
+    for ns_name, ns in commands.items():
+        p = f"commands.{ns_name}"
+        if not isinstance(ns, dict):
+            _fail(p, "必须是 mapping")
+
+        subs = ns.get("subcommands")
+        if not isinstance(subs, dict) or not subs:
+            _fail(f"{p}.subcommands", "至少需要一个二级子指令")
+
+        backends = set()
+        for sub_name, sub in subs.items():
+            sp = f"{p}.subcommands.{sub_name}"
+            if not isinstance(sub, dict):
+                _fail(sp, "必须是 mapping")
+            backend = sub.get("type", "http")
+            if backend not in SUPPORTED_BACKENDS:
+                _fail(f"{sp}.type", f"仅支持 {sorted(SUPPORTED_BACKENDS)}，缺省为 http")
+            backends.add(backend)
+            if backend == "http":
+                _validate_http_sub(sub, sp)
+            else:
+                _validate_script_sub(sub, sp)
+            _validate_args(sub, sp, backend)
+
+        # 含 http 子指令时必须有 service；纯 script 命名空间可以没有
+        service = ns.get("service")
+        if service is None and "http" in backends:
+            _fail(f"{p}.service.base_url", "命名空间包含 http 型子指令，必填")
+        if service is not None:
+            if not service.get("base_url"):
+                _fail(f"{p}.service.base_url", "必填，团队接口的 base url")
+            _validate_auth(service.get("auth") or {"type": "none"}, f"{p}.service.auth")
+
+    return data

clihub/script_backend.py

@@ -0,0 +1,132 @@
+"""script 后端：把子指令映射为对团队 Python 脚本的子进程调用。
+
+- source 支持本地路径（.py 文件或目录）与 git+URL[@ref]（缓存到
+  ``$GZCLI_HOME/tools/``，ref 建议锁定 tag，保证内容可追溯）；
+- 参数映射：``argv.xxx`` 拼为 ``--xxx 值``（bool 为开关、file 传绝对路径），
+  ``env.XXX`` 注入子进程环境变量；
+- 依赖隔离：脚本目录含 pyproject.toml / requirements.txt 且系统有 uv 时，
+  用 ``uv run`` 自动建隔离环境；否则回退到当前解释器直接执行；
+- stdout/stderr 原样透传，退出码透传。
+"""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+from . import config as cfg_mod
+
+EXIT_LOCAL_ERROR = 2
+
+
+def _err(msg: str) -> None:
+    print(f"gzcli: {msg}", file=sys.stderr)
+
+
+def _tools_dir() -> Path:
+    d = cfg_mod.config_dir() / "tools"
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+
+def _resolve_source(script_cfg: Dict[str, Any]) -> Tuple[Optional[Path], Optional[str]]:
+    """返回 (脚本文件绝对路径, 错误信息)。"""
+    source = str(script_cfg["source"])
+
+    if source.startswith("git+"):
+        url_ref = source[4:]
+        url, _, ref = url_ref.rpartition("@")
+        key = hashlib.sha256(url_ref.encode()).hexdigest()[:12]
+        dest = _tools_dir() / key
+        if not dest.exists():
+            cmd = ["git", "clone", "--depth", "1"]
+            if ref:
+                cmd += ["--branch", ref]
+            cmd += [url, str(dest)]
+            _err(f"首次使用，正在拉取脚本: {url_ref}")
+            proc = subprocess.run(cmd, capture_output=True, text=True)
+            if proc.returncode != 0:
+                return None, f"拉取脚本失败: {proc.stderr.strip()[:300]}"
+        base = dest
+    else:
+        base = Path(source).expanduser().resolve()
+        if not base.exists():
+            return None, f"脚本路径不存在: {base}"
+
+    if base.is_file():
+        return base, None
+    entry = script_cfg.get("entry")
+    if not entry:
+        return None, "source 为目录时必须在配置中指定 script.entry"
+    script_path = base / entry
+    if not script_path.is_file():
+        return None, f"入口文件不存在: {script_path}"
+    return script_path, None
+
+
+def _runner_for(script_path: Path) -> List[str]:
+    """优先用 uv 建隔离环境运行；否则回退当前解释器。"""
+    d = script_path.parent
+    uv = shutil.which("uv")
+    if uv:
+        if (d / "pyproject.toml").exists():
+            return [uv, "run", "--project", str(d), "python", str(script_path)]
+        if (d / "requirements.txt").exists():
+            return [uv, "run", "--with-requirements", str(d / "requirements.txt"),
+                    "python", str(script_path)]
+    return [sys.executable, str(script_path)]
+
+
+def _build_argv_and_env(
+    args_spec: Dict[str, Any], values: Dict[str, Any]
+) -> Tuple[List[str], Dict[str, str]]:
+    argv: List[str] = []
+    env = dict(os.environ)
+    for flag, spec in args_spec.items():
+        name = flag.replace("-", "_")
+        val = values.get(name)
+        if val is None:
+            continue
+        target, _, field = spec["to"].partition(".")
+        if target == "env":
+            env[field] = str(val)
+            continue
+        # argv 目标
+        dashed = field.replace("_", "-")
+        atype = spec.get("type", "string")
+        if atype == "bool":
+            if val:
+                argv.append(f"--{dashed}")
+        elif atype == "file":
+            argv += [f"--{dashed}", str(Path(val).resolve())]
+        else:
+            argv += [f"--{dashed}", str(val)]
+    return argv, env
+
+
+def execute_script(sub_cfg: Dict[str, Any], values: Dict[str, Any]) -> int:
+    """执行 script 型子指令，返回脚本退出码（本地问题返回 2）。"""
+    script_cfg = sub_cfg["script"]
+    script_path, err = _resolve_source(script_cfg)
+    if err:
+        _err(err)
+        return EXIT_LOCAL_ERROR
+
+    argv, env = _build_argv_and_env(sub_cfg.get("args") or {}, values)
+    cmd = _runner_for(script_path) + argv
+    timeout = script_cfg.get("timeout")  # 缺省不限制
+
+    try:
+        proc = subprocess.run(cmd, cwd=str(script_path.parent), env=env, timeout=timeout)
+        return proc.returncode
+    except subprocess.TimeoutExpired:
+        _err(f"脚本执行超时（{timeout}s）: {script_path.name}")
+        return EXIT_LOCAL_ERROR
+    except OSError as e:
+        _err(f"脚本启动失败: {e}")
+        return EXIT_LOCAL_ERROR

gzcli-0.1.0.dist-info/METADATA

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: gzcli
+Version: 0.1.0
+Summary: CLIHub: 一个父指令统一网关，将团队 HTTP 接口以子指令方式对外提供
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.1
+Requires-Dist: httpx>=0.27
+Requires-Dist: pyyaml>=6.0
+Dynamic: license-file
+
+# gzcli
+
+一个父指令统一网关：各团队将 HTTP 接口通过配置文件注册为 `gzcli` 的子指令，
+鉴权、调用、更新等横切逻辑由 `gzcli` 统一屏蔽。
+
+```bash
+gzcli init --conf conf.yaml          # 注册子指令配置
+gzcli img_detect detect --img a.jpg   # 调用团队接口
+```
+
+详细设计见项目内讨论，MVP 阶段配置 Schema 见 `examples/conf.yaml`。

gzcli-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+clihub/__init__.py,sha256=4TJJzwbeMEIoi6vZMpVVOGHOpdY7b0Jt1rlMdol0N7E,105
+clihub/cli.py,sha256=iVjQyewPUtp_0u-Fhi_1PQG9Yll92RlA980cccC-3A4,4795
+clihub/config.py,sha256=xsYsR-YDTjKCUvOr34OPE_wLYrJV77F7sE_MEg2qXaM,1323
+clihub/executor.py,sha256=Up-_ZPAKVBH-NIfu-ztuBx2tiT0nXAVROW0unvq-Ro4,6170
+clihub/schema.py,sha256=1E-NhL_xzfchG4A8wDjHKOafyft1H_ONibjGzIxuzL0,7107
+clihub/script_backend.py,sha256=E0PyWxU4sTYbJf5u1K9WG2_xhPw75VrM4zkTIxFhibo,4625
+gzcli-0.1.0.dist-info/licenses/LICENSE,sha256=kzoRrmT5XQUVc530O_UppnrVVMJ35bX3cFnleBqXKxc,1071
+gzcli-0.1.0.dist-info/METADATA,sha256=ZGn0zTwbGtbsshPcyh6fF_8mDQQhguukYLewSA_ASzA,750
+gzcli-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+gzcli-0.1.0.dist-info/entry_points.txt,sha256=BiTHtDw1Zyo9QO4ymkby2TJ41we2EEGlHihjlm32eaA,42
+gzcli-0.1.0.dist-info/top_level.txt,sha256=nP-CtByVbnzFe8b_po_GdbU3x3zeKMbAFTmL6hZ9BDs,7
+gzcli-0.1.0.dist-info/RECORD,,

gzcli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

gzcli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+gzcli = clihub.cli:main

gzcli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 CLIHub Authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

gzcli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+clihub