tinet-agent-cli 0.1.0.dev36__py3-none-any.whl

taco/commands/credential.py

@@ -0,0 +1,222 @@
+from __future__ import annotations
+
+import json
+import os
+import re
+import sys
+from json import JSONDecodeError
+
+import typer
+
+from taco.core.context import get_cli_context
+from taco.core.errors import TacoError
+from taco.core.output import emit_success, exit_with_error
+from taco.services.tool_service import ToolService, validate_credentials_payload
+
+
+credential_app = typer.Typer(help="内置工具 Provider 凭据管理")
+
+
+@credential_app.command("schema", help="读取 Provider 凭据字段定义，不读取值。")
+def credential_schema(
+    ctx: typer.Context,
+    provider: str = typer.Argument(..., help="完整 Provider ID。"),
+) -> None:
+    cli_context = get_cli_context(ctx)
+    try:
+        schema = ToolService().credential_schema(
+            provider,
+            profile=cli_context.profile,
+        )
+    except TacoError as error:
+        exit_with_error(ctx, error, json_default=True)
+    emit_success(
+        ctx,
+        {"provider": provider, "schema": schema},
+        json_default=True,
+    )
+
+
+@credential_app.command("status", help="读取凭据 schema 与服务端脱敏状态。")
+def credential_status(
+    ctx: typer.Context,
+    provider: str = typer.Argument(..., help="完整 Provider ID。"),
+) -> None:
+    cli_context = get_cli_context(ctx)
+    try:
+        result = ToolService().credential_status(
+            provider,
+            profile=cli_context.profile,
+        )
+    except TacoError as error:
+        exit_with_error(ctx, error, json_default=True)
+    emit_success(ctx, result, json_default=True)
+
+
+@credential_app.command("set", help="从 stdin 或环境变量设置 Provider 凭据。")
+def set_credentials(
+    ctx: typer.Context,
+    provider: str = typer.Argument(..., help="完整 Provider ID。"),
+    from_stdin: bool = typer.Option(
+        False,
+        "--from-stdin",
+        help="从 stdin 读取凭据 JSON 对象。",
+    ),
+    from_env: str | None = typer.Option(
+        None,
+        "--from-env",
+        help="从指定环境变量读取完整凭据 JSON 对象。",
+    ),
+    env_prefix: str | None = typer.Option(
+        None,
+        "--env-prefix",
+        help="按 schema 字段从指定环境变量前缀读取。",
+    ),
+    yes: bool = typer.Option(False, "--yes", help="确认写入租户共享凭据。"),
+) -> None:
+    if not yes:
+        exit_with_error(
+            ctx,
+            TacoError(
+                code="CREDENTIAL_CONFIRM_REQUIRED",
+                message="写入 Provider 凭据前必须显式传入 --yes。",
+                exit_code=2,
+            ),
+            json_default=True,
+        )
+    source_count = sum(
+        (
+            int(from_stdin),
+            int(from_env is not None),
+            int(env_prefix is not None),
+        )
+    )
+    if source_count != 1:
+        exit_with_error(
+            ctx,
+            TacoError(
+                code="CREDENTIAL_SOURCE_REQUIRED",
+                message=(
+                    "必须且只能选择 --from-stdin、--from-env 或 --env-prefix。"
+                ),
+                exit_code=2,
+            ),
+            json_default=True,
+        )
+
+    cli_context = get_cli_context(ctx)
+    try:
+        service = ToolService()
+        schema = service.credential_schema(
+            provider,
+            profile=cli_context.profile,
+        )
+        credentials = (
+            _read_credentials_from_stdin()
+            if from_stdin
+            else (
+                _read_credentials_from_named_env(from_env)
+                if from_env is not None
+                else _read_credentials_from_env(schema, env_prefix or "")
+            )
+        )
+        validate_credentials_payload(credentials, schema)
+        service.set_credentials(
+            provider,
+            credentials,
+            profile=cli_context.profile,
+        )
+    except TacoError as error:
+        exit_with_error(ctx, error, json_default=True)
+    emit_success(
+        ctx,
+        {
+            "provider": provider,
+            "updated": True,
+            "fields": sorted(credentials),
+        },
+        json_default=True,
+    )
+
+
+@credential_app.command("delete", help="删除租户共享的 Provider 凭据。")
+def delete_credentials(
+    ctx: typer.Context,
+    provider: str = typer.Argument(..., help="完整 Provider ID。"),
+    yes: bool = typer.Option(False, "--yes", help="确认删除共享凭据。"),
+) -> None:
+    if not yes:
+        exit_with_error(
+            ctx,
+            TacoError(
+                code="CREDENTIAL_DELETE_CONFIRM_REQUIRED",
+                message="删除 Provider 凭据前必须显式传入 --yes。",
+                exit_code=2,
+            ),
+            json_default=True,
+        )
+    cli_context = get_cli_context(ctx)
+    try:
+        ToolService().delete_credentials(
+            provider,
+            profile=cli_context.profile,
+        )
+    except TacoError as error:
+        exit_with_error(ctx, error, json_default=True)
+    emit_success(
+        ctx,
+        {"provider": provider, "deleted": True},
+        json_default=True,
+    )
+
+
+def _read_credentials_from_stdin() -> dict[str, object]:
+    return _parse_credentials_json(sys.stdin.read(), source="stdin")
+
+
+def _read_credentials_from_named_env(env_name: str) -> dict[str, object]:
+    value = os.getenv(env_name)
+    if value is None:
+        raise TacoError(
+            code="CREDENTIAL_INPUT_INVALID",
+            message=f"环境变量 {env_name} 不存在。",
+            exit_code=2,
+        )
+    return _parse_credentials_json(value, source=f"环境变量 {env_name}")
+
+
+def _parse_credentials_json(
+    value: str,
+    *,
+    source: str,
+) -> dict[str, object]:
+    try:
+        payload = json.loads(value)
+    except (JSONDecodeError, UnicodeError) as error:
+        raise TacoError(
+            code="CREDENTIAL_INPUT_INVALID",
+            message=f"{source} 必须是合法的凭据 JSON 对象。",
+            exit_code=2,
+        ) from error
+    if not isinstance(payload, dict):
+        raise TacoError(
+            code="CREDENTIAL_INPUT_INVALID",
+            message=f"{source} 凭据必须是 JSON 对象。",
+            exit_code=2,
+        )
+    return payload
+
+
+def _read_credentials_from_env(
+    schema: list[dict[str, object]],
+    prefix: str,
+) -> dict[str, object]:
+    credentials: dict[str, object] = {}
+    for field in schema:
+        name = field.get("name")
+        if not isinstance(name, str):
+            continue
+        env_name = prefix + re.sub(r"[^A-Za-z0-9]", "_", name).upper()
+        if env_name in os.environ:
+            credentials[name] = os.environ[env_name]
+    return credentials

taco/commands/discovery.py

@@ -0,0 +1,409 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import shutil
+import tempfile
+from pathlib import Path
+from typing import Any, Literal
+from uuid import uuid4
+
+import typer
+from typer.main import get_command
+
+from taco.core.assets import list_json_assets, load_json_asset, load_skill_files
+from taco.core.errors import TacoError
+from taco.core.output import emit_success, exit_with_error
+
+
+scenario_app = typer.Typer(help="场景 playbook 发现")
+example_app = typer.Typer(help="内置 DSL 示例发现")
+skills_app = typer.Typer(help="Agent Skill 安装与状态")
+schema_app = typer.Typer(help="读取当前 CLI 内置 DSL schema")
+
+_SKILL_TARGETS = {
+    "cursor": Path.home() / ".cursor" / "skills" / "taco",
+    "codex": Path.home() / ".agents" / "skills" / "taco",
+    "openclaw": Path.home() / ".openclaw" / "skills" / "taco",
+}
+OutputFormat = Literal["text", "json"]
+AgentTarget = Literal["cursor", "codex", "openclaw"]
+_INTERNAL_PARAMETER_NAMES = {"install_completion", "show_completion"}
+
+
+def machine_help(
+    ctx: typer.Context,
+    output: OutputFormat = typer.Option(
+        "text",
+        "-o",
+        "--output",
+        help="text 或 json。",
+    ),
+) -> None:
+    from taco.cli import app
+
+    tree = _serialize_command(get_command(app), name="taco")
+    tree["format_version"] = 1
+    if output == "json":
+        emit_success(ctx, tree, json_default=True)
+        return
+    if output != "text":
+        exit_with_error(ctx, _invalid_output_error(), json_default=True)
+    typer.echo("\n".join(_command_lines(tree)))
+
+
+@schema_app.command("show", help="读取指定的内置 DSL schema。")
+def schema_command(
+    ctx: typer.Context,
+    resource: str = typer.Argument(..., help="资源名称，例如 agent。"),
+    output: OutputFormat = typer.Option(
+        "text",
+        "-o",
+        "--output",
+        help="text 或 json。",
+    ),
+) -> None:
+    try:
+        schema = load_json_asset("schemas", resource)
+    except TacoError as error:
+        exit_with_error(ctx, error, json_default=True)
+    _emit_discovery_payload(ctx, schema, output)
+
+
+@schema_app.command("list", help="列出当前 CLI 内置 DSL schema。")
+def list_schemas(
+    ctx: typer.Context,
+    output: OutputFormat = typer.Option(
+        "text",
+        "-o",
+        "--output",
+        help="text 或 json。",
+    ),
+) -> None:
+    _emit_discovery_payload(
+        ctx,
+        {"items": list_json_assets("schemas")},
+        output,
+    )
+
+
+@example_app.command("describe", help="读取当前 CLI 内置的 DSL 示例。")
+def describe_example(
+    ctx: typer.Context,
+    example_id: str = typer.Argument(..., help="示例 ID。"),
+    output: OutputFormat = typer.Option(
+        "text",
+        "-o",
+        "--output",
+        help="text 或 json。",
+    ),
+) -> None:
+    try:
+        example = load_json_asset("examples", example_id)
+    except TacoError as error:
+        exit_with_error(ctx, error, json_default=True)
+    _emit_discovery_payload(ctx, example, output)
+
+
+@example_app.command("list", help="列出当前 CLI 内置的 DSL 示例。")
+def list_examples(
+    ctx: typer.Context,
+    output: OutputFormat = typer.Option(
+        "text",
+        "-o",
+        "--output",
+        help="text 或 json。",
+    ),
+) -> None:
+    _emit_discovery_payload(
+        ctx,
+        {"items": list_json_assets("examples")},
+        output,
+    )
+
+
+@scenario_app.command("describe", help="读取内置场景步骤与风险元数据。")
+def describe_scenario(
+    ctx: typer.Context,
+    scenario_id: str = typer.Argument(..., help="场景 ID。"),
+    output: OutputFormat = typer.Option(
+        "text",
+        "-o",
+        "--output",
+        help="text 或 json。",
+    ),
+) -> None:
+    try:
+        scenario = load_json_asset("scenarios", scenario_id)
+    except TacoError as error:
+        exit_with_error(ctx, error, json_default=True)
+    _emit_discovery_payload(ctx, scenario, output)
+
+
+@scenario_app.command("list", help="列出当前 CLI 内置的场景 playbook。")
+def list_scenarios(
+    ctx: typer.Context,
+    output: OutputFormat = typer.Option(
+        "text",
+        "-o",
+        "--output",
+        help="text 或 json。",
+    ),
+) -> None:
+    payload = {"items": list_json_assets("scenarios")}
+    _emit_discovery_payload(ctx, payload, output)
+
+
+@skills_app.command("install", help="安装或输出当前 wheel 内置的 taco Skill。")
+def install_skill(
+    ctx: typer.Context,
+    agent: AgentTarget = typer.Option(
+        "cursor",
+        "--agent",
+        help="cursor、codex 或 openclaw。",
+    ),
+    target_dir: Path | None = typer.Option(None, "--dir", help="自定义 Skill 目录。"),
+    yes: bool = typer.Option(False, "--yes", help="确认写入或覆盖 Skill。"),
+    stdout: bool = typer.Option(False, "--stdout", help="仅输出 SKILL.md，不写文件。"),
+) -> None:
+    try:
+        files = load_skill_files()
+        if stdout:
+            typer.echo(files["SKILL.md"], nl=False)
+            return
+        if not yes:
+            raise TacoError(
+                code="SKILL_INSTALL_CONFIRM_REQUIRED",
+                message="安装 Skill 前必须显式传入 --yes。",
+                exit_code=2,
+            )
+        target = _skill_target(agent, target_dir)
+        _install_skill_files(target, files)
+    except TacoError as error:
+        exit_with_error(ctx, error, json_default=True)
+    except OSError:
+        exit_with_error(
+            ctx,
+            TacoError(
+                code="SKILL_INSTALL_FAILED",
+                message="无法写入 Agent Skill 目录。",
+                exit_code=2,
+                hint="请检查 --dir 路径和目录权限。",
+            ),
+            json_default=True,
+        )
+    emit_success(
+        ctx,
+        {
+            "agent": agent,
+            "path": str(target),
+            "installed": True,
+            "fingerprint": _skill_fingerprint(files),
+        },
+        json_default=True,
+    )
+
+
+@skills_app.command("status", help="检查已安装 Skill 是否与当前 CLI 一致。")
+def skill_status(
+    ctx: typer.Context,
+    agent: AgentTarget = typer.Option(
+        "cursor",
+        "--agent",
+        help="cursor、codex 或 openclaw。",
+    ),
+    target_dir: Path | None = typer.Option(None, "--dir", help="自定义 Skill 目录。"),
+    stdout: bool = typer.Option(False, "--stdout", help="输出当前内置 SKILL.md。"),
+) -> None:
+    try:
+        bundled = load_skill_files()
+        if stdout:
+            typer.echo(bundled["SKILL.md"], nl=False)
+            return
+        target = _skill_target(agent, target_dir)
+        if target.is_symlink():
+            raise OSError("Skill 目标不能是符号链接")
+        installed = {
+            name: target.joinpath(name).read_text(encoding="utf-8")
+            for name in bundled
+            if target.joinpath(name).is_file()
+        }
+    except TacoError as error:
+        exit_with_error(ctx, error, json_default=True)
+    except OSError:
+        exit_with_error(
+            ctx,
+            TacoError(
+                code="SKILL_STATUS_FAILED",
+                message="无法读取 Agent Skill 目录。",
+                exit_code=2,
+            ),
+            json_default=True,
+        )
+    is_installed = set(installed) == set(bundled)
+    emit_success(
+        ctx,
+        {
+            "agent": agent,
+            "path": str(target),
+            "installed": is_installed,
+            "current": is_installed
+            and _skill_fingerprint(installed) == _skill_fingerprint(bundled),
+            "bundled_fingerprint": _skill_fingerprint(bundled),
+            "installed_fingerprint": (
+                _skill_fingerprint(installed) if is_installed else None
+            ),
+        },
+        json_default=True,
+    )
+
+
+def _skill_target(agent: str, target_dir: Path | None) -> Path:
+    if target_dir is not None:
+        return target_dir.expanduser()
+    target = _SKILL_TARGETS.get(agent)
+    if target is None:
+        raise TacoError(
+            code="SKILL_AGENT_UNSUPPORTED",
+            message=f"不支持的 Agent 工作台：{agent}",
+            exit_code=2,
+        )
+    return target
+
+
+def _install_skill_files(target: Path, files: dict[str, str]) -> None:
+    if target.is_symlink() or (target.exists() and not target.is_dir()):
+        raise OSError("Skill 目标必须是普通目录")
+    if target.exists() and any(
+        target.joinpath(name).is_symlink() for name in files
+    ):
+        raise OSError("Skill 文件不能是符号链接")
+    if target.exists():
+        entries = {entry.name for entry in target.iterdir()}
+        manifest_path = target / "manifest.json"
+        try:
+            manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError) as error:
+            raise _unmanaged_skill_target_error(target) from error
+        if (
+            not isinstance(manifest, dict)
+            or manifest.get("name") != "taco"
+            or not entries.issubset(files)
+        ):
+            raise _unmanaged_skill_target_error(target)
+
+    parent = target.parent
+    parent.mkdir(parents=True, exist_ok=True)
+    staging = Path(tempfile.mkdtemp(dir=parent, prefix=f".{target.name}.staging-"))
+    backup: Path | None = None
+    try:
+        for name, content in files.items():
+            staging.joinpath(name).write_text(content, encoding="utf-8")
+        if target.exists():
+            backup = parent / f".{target.name}.backup-{uuid4().hex}"
+            target.rename(backup)
+        try:
+            staging.rename(target)
+        except OSError:
+            if backup is not None and backup.exists() and not target.exists():
+                backup.rename(target)
+            raise
+        if backup is not None:
+            shutil.rmtree(backup)
+            backup = None
+    finally:
+        if staging.exists():
+            shutil.rmtree(staging, ignore_errors=True)
+        if backup is not None and backup.exists() and not target.exists():
+            try:
+                backup.rename(target)
+            except OSError:
+                pass
+
+
+def _unmanaged_skill_target_error(target: Path) -> TacoError:
+    return TacoError(
+        code="SKILL_TARGET_NOT_OWNED",
+        message=f"目标目录不是仅由 TACO 管理的 Skill 目录：{target}",
+        exit_code=2,
+        hint="请传入 taco Skill 的专用目录，不要传入 skills 根目录。",
+    )
+
+
+def _skill_fingerprint(files: dict[str, str]) -> str:
+    digest = hashlib.sha256()
+    for name in sorted(files):
+        digest.update(name.encode())
+        digest.update(b"\0")
+        digest.update(files[name].encode())
+        digest.update(b"\0")
+    return digest.hexdigest()
+
+
+def _emit_discovery_payload(
+    ctx: typer.Context,
+    payload: dict[str, Any],
+    output: OutputFormat,
+) -> None:
+    if output == "json":
+        emit_success(ctx, payload, json_default=True)
+    elif output == "text":
+        typer.echo(json.dumps(payload, ensure_ascii=False, indent=2))
+    else:
+        exit_with_error(ctx, _invalid_output_error(), json_default=True)
+
+
+def _invalid_output_error() -> TacoError:
+    return TacoError(
+        code="OUTPUT_FORMAT_INVALID",
+        message="输出格式只支持 text 或 json。",
+        exit_code=2,
+    )
+
+
+def _serialize_command(command: Any, *, name: str) -> dict[str, Any]:
+    payload: dict[str, Any] = {
+        "name": name,
+        "help": command.help or "",
+        "params": [
+            _serialize_parameter(param)
+            for param in command.params
+            if param.name not in _INTERNAL_PARAMETER_NAMES
+        ],
+    }
+    commands = getattr(command, "commands", None)
+    if isinstance(commands, dict):
+        payload["commands"] = [
+            _serialize_command(child, name=child_name)
+            for child_name, child in sorted(commands.items())
+        ]
+    return payload
+
+
+def _serialize_parameter(parameter: Any) -> dict[str, Any]:
+    is_option = type(parameter).__name__.endswith("Option")
+    parameter_type = getattr(parameter, "type", None)
+    payload: dict[str, Any] = {
+        "name": parameter.name,
+        "required": parameter.required,
+        "kind": "option" if is_option else "argument",
+        "type": getattr(parameter_type, "name", type(parameter_type).__name__.lower()),
+        "help": getattr(parameter, "help", None) or "",
+    }
+    if is_option:
+        payload["flags"] = [*parameter.opts, *parameter.secondary_opts]
+    choices = getattr(parameter_type, "choices", None)
+    if choices is not None:
+        payload["choices"] = list(choices)
+    default = parameter.default
+    if isinstance(default, (str, int, float, bool, list, dict)) or default is None:
+        payload["default"] = default
+    return payload
+
+
+def _command_lines(command: dict[str, Any], prefix: str = "") -> list[str]:
+    name = f"{prefix} {command['name']}".strip()
+    lines = [f"{name}: {command['help']}".rstrip()]
+    for child in command.get("commands", []):
+        lines.extend(_command_lines(child, name))
+    return lines

taco/commands/model.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import typer
+
+from taco.core.context import get_cli_context
+from taco.core.errors import TacoError
+from taco.core.output import emit_success, exit_with_error
+from taco.services.model_service import ModelService
+
+
+model_app = typer.Typer(help="模型发现")
+
+
+@model_app.command("list", help="列出 LLM，可按智能体分类过滤。")
+def list_models(
+    ctx: typer.Context,
+    category: str | None = typer.Option(
+        None,
+        "--category",
+        help="只返回该分类可用模型。",
+    ),
+) -> None:
+    cli_context = get_cli_context(ctx)
+    try:
+        result = ModelService().list_models(
+            category=category,
+            profile=cli_context.profile,
+        )
+    except TacoError as error:
+        exit_with_error(ctx, error, json_default=True)
+    emit_success(ctx, result, json_default=True)
+
+
+@model_app.command("describe", help="获取模型详情及 completion 参数规则。")
+def describe_model(
+    ctx: typer.Context,
+    provider: str = typer.Option(..., "--provider", help="Provider ID。"),
+    model: str = typer.Option(..., "--model", help="模型 ID。"),
+    category: str | None = typer.Option(
+        None,
+        "--category",
+        help="校验模型是否支持该分类。",
+    ),
+) -> None:
+    cli_context = get_cli_context(ctx)
+    try:
+        result = ModelService().describe_model(
+            provider=provider,
+            model=model,
+            category=category,
+            profile=cli_context.profile,
+        )
+    except TacoError as error:
+        exit_with_error(ctx, error, json_default=True)
+    emit_success(ctx, result, json_default=True)