aisc-cli 0.1.0__py3-none-any.whl

aisc/cli/commands/usage.py

@@ -0,0 +1,74 @@
+"""``aisc usage`` command layer (IDEA-2 2c).
+
+Thin wrapper over ``aisc.application.usage`` — subscription status plus
+per-provider token usage aggregated across all data-root workspaces.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+
+def cmd_usage_overview(args: Any) -> Dict[str, Any]:
+    from aisc.application.usage import usage_overview
+
+    return usage_overview(
+        range_key=getattr(args, "range", "7d") or "7d",
+        workspace=getattr(args, "workspace", None),
+    )
+
+
+def _fmt_tokens(n: int) -> str:
+    if n >= 1_000_000_000:
+        return f"{n / 1_000_000_000:.2f}B"
+    if n >= 1_000_000:
+        return f"{n / 1_000_000:.2f}M"
+    if n >= 1_000:
+        return f"{n / 1_000:.1f}k"
+    return str(n)
+
+
+def print_usage_overview_text(data: Optional[Dict[str, Any]]) -> None:
+    """Human-readable output (secret-free: masked subscription URL only)."""
+    if not isinstance(data, dict):
+        return
+    sub = data.get("subscription") or {}
+    if sub.get("configured"):
+        userinfo = sub.get("userinfo")
+        if isinstance(userinfo, dict):
+            total = userinfo.get("total")
+            used = userinfo.get("upload", 0) + userinfo.get("download", 0)
+            usage_bit = (f"{_fmt_tokens(used)} / {_fmt_tokens(total)} bytes"
+                         if total else f"{_fmt_tokens(used)} bytes (unlimited)")
+        else:
+            # null userinfo = the source provided no usage header (manual
+            # content import, or a provider that omits subscription-userinfo)
+            usage_bit = "no usage info"
+        print(f"Subscription: {sub.get('url_masked') or '(manually imported)'}"
+              f"  [{sub.get('source')}]  {usage_bit}")
+    else:
+        print("Subscription: none configured")
+
+    print(f"Range: {data.get('range')}")
+    for ws in data.get("workspaces", []):
+        name = ws.get("workspace_path") or ws.get("workspace_hash") or "?"
+        try:
+            from pathlib import Path as _P
+            name = _P(str(name)).name or str(name)
+        except Exception:
+            pass
+        state = ("live" if ws.get("source") == "live"
+                 else "cache" if ws.get("source") == "cache" else "no data")
+        print(f"\nWorkspace {name} [{state}]")
+        for p in ws.get("providers", []):
+            print(f"  {p['app']:7} {p['provider_name']:24} "
+                  f"req={p['requests']:>6} ok={p['success']:>6} "
+                  f"tokens={_fmt_tokens(p['tokens_total']):>9} "
+                  f"${p['cost_estimate']:.4f}")
+        if not ws.get("providers"):
+            print("  (no usage rows)")
+
+    totals = data.get("totals") or {}
+    print(f"\nTotals: requests={totals.get('requests', 0)} "
+          f"tokens={_fmt_tokens(totals.get('tokens_total', 0))} "
+          f"cost=${totals.get('cost_estimate', 0.0):.4f}")

aisc/cli/commands/wizard.py

@@ -0,0 +1,130 @@
+"""Build configuration wizard for aisc build command.
+
+Interactive wizard that prompts for:
+- Image name/tag
+- Proxy configuration
+- Build cache options
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Optional, Tuple
+
+
+def _prompt(message: str, default: str = "") -> str:
+    """Prompt user for input with optional default."""
+    if default:
+        prompt_text = f"{message} [{default}]: "
+    else:
+        prompt_text = f"{message}: "
+
+    try:
+        response = input(prompt_text).strip()
+        return response if response else default
+    except (EOFError, KeyboardInterrupt):
+        print("\nCancelled.", file=sys.stderr)
+        sys.exit(130)
+
+
+def _prompt_yes_no(message: str, default: bool = False) -> bool:
+    """Prompt user for yes/no confirmation."""
+    default_str = "Y/n" if default else "y/N"
+    prompt_text = f"{message} [{default_str}]: "
+
+    try:
+        response = input(prompt_text).strip().lower()
+        if not response:
+            return default
+        return response in ("y", "yes")
+    except (EOFError, KeyboardInterrupt):
+        print("\nCancelled.", file=sys.stderr)
+        sys.exit(130)
+
+
+def run_build_wizard(
+    default_tag: str = "super-claude:latest",
+    aisc_root: Optional[Path] = None,
+) -> Tuple[str, bool, bool, Optional[str]]:
+    """Run interactive build configuration wizard.
+
+    Args:
+        default_tag: Default image tag to suggest
+        aisc_root: AISC repository root for proxy config path
+
+    Returns:
+        Tuple of (tag, no_cache, pull, proxy_config_path)
+        - tag: Docker image tag
+        - no_cache: Whether to disable build cache
+        - pull: Whether to pull base image
+        - proxy_config_path: Path to proxy config file, or None
+    """
+    print("\n🚀 AISC Build Configuration Wizard")
+    print("=" * 50)
+
+    # 1. Image name/tag
+    print("\n📦 Docker Image Configuration")
+    tag = _prompt("Image tag", default=default_tag)
+    if ":" not in tag:
+        tag = f"{tag}:latest"
+
+    # 2. Build cache
+    print("\n🔧 Build Options")
+    no_cache = _prompt_yes_no("Disable Docker build cache?", default=False)
+    pull = _prompt_yes_no("Always pull base image?", default=False)
+
+    # 3. Proxy configuration
+    print("\n🌐 Proxy Configuration (for container network access)")
+    use_proxy = _prompt_yes_no("Configure proxy network?", default=False)
+
+    proxy_config_path: Optional[str] = None
+    if use_proxy:
+        print("\nProxy configuration options:")
+        print("  1) Local file - Enter absolute path to config file")
+        print("  2) URL - Enter subscription/config URL")
+
+        mode = _prompt("Select [1/2]", default="2")
+
+        if mode == "1":
+            # Local file → store as manually imported subscription content
+            path_input = _prompt("Local config file absolute path")
+            if path_input and Path(path_input).is_file():
+                from aisc.application.network_subscription import (
+                    import_subscription_content,
+                )
+                try:
+                    snap = import_subscription_content(Path(path_input).read_bytes())
+                    proxy_config_path = snap["config_path"]
+                    print(f"✅ Config imported: {snap['config_path']}")
+                except Exception as e:  # noqa: BLE001 - wizard stays chatty
+                    print(f"❌ Import failed: {e}")
+            else:
+                print(f"⚠️  File not found: {path_input}, skipping proxy.")
+        else:
+            # URL download (IDEA-2: data-root subscription store; the clash
+            # UA, retries and userinfo capture live in the application layer)
+            url = _prompt("Config URL")
+            if url:
+                from aisc.application.network_subscription import import_subscription
+                from aisc.domain.models import CliError
+
+                print("⬇️  Downloading subscription...")
+                try:
+                    snap = import_subscription(url)
+                    proxy_config_path = snap["config_path"]
+                    print(f"✅ Subscription imported: {snap['config_path']}")
+                    if snap.get("userinfo"):
+                        print(f"📊 Usage header captured: {snap['userinfo']}")
+                except CliError as e:
+                    print(f"❌ Import failed: {e.message}")
+
+    print("\n" + "=" * 50)
+    print("Configuration Summary:")
+    print(f"  Image tag:    {tag}")
+    print(f"  No cache:     {no_cache}")
+    print(f"  Pull base:    {pull}")
+    print(f"  Proxy config: {proxy_config_path or 'None (direct connection)'}")
+    print("=" * 50 + "\n")
+
+    return tag, no_cache, pull, proxy_config_path

aisc/cli/commands/workspaces.py

@@ -0,0 +1,162 @@
+"""F2-C addendum (user request 2026-09-09): ``aisc workspaces`` — the
+machine-wide management view of CLI-activated workspaces.
+
+Scans every workspace registry under the data root, joins the activation
+history for aliases, and cross-references live Docker state. ``--stop``
+sweeps the RUNNING CLI-owned activations (Workbench-managed runtimes are
+never touched — the GUI owns their lifecycle).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+from aisc.adapters.container_registry import (
+    gc as registry_gc,
+    list_containers,
+    unregister,
+)
+from aisc.adapters.docker_ import DockerExecutor, RealDockerExecutor
+from aisc.application.data_root import DataRootResolver
+
+
+def registry_entries(
+    executor: Optional[DockerExecutor] = None,
+    data_root: Optional[str] = None,
+) -> Tuple[List[Any], set]:
+    """Every ``(name, meta)`` across all workspace registries (CLI and
+    Workbench-owned alike — the caller filters), plus the set of registry
+    DEFAULT pointers (the bare ``aisc claude`` target of each workspace —
+    r2 #B: stars must mark the pointer, not "same workspace").
+
+    Lazy-GCs each registry so stale records from deleted containers do not
+    surface. *data_root* (a dir containing ``workspaces/``) overrides the
+    resolved shared root — injection seam for tests and ``aisc ps``.
+    """
+    from aisc.adapters.container_registry import get_default
+
+    base = Path(data_root) if data_root else DataRootResolver().resolve_shared_root()
+    shared = base / "workspaces"
+    out: List[Any] = []
+    defaults: set = set()
+    if not shared.is_dir():
+        return out, defaults
+    for reg_dir in sorted(shared.glob("*/runtime")):
+        if (reg_dir / "containers.json").is_file():
+            try:
+                registry_gc(reg_dir, executor)
+            except Exception:
+                pass
+            out.extend(list_containers(reg_dir).items())
+            try:
+                d = get_default(reg_dir)
+            except Exception:
+                d = ""
+            if d:
+                defaults.add(d)
+    return out, defaults
+
+
+def docker_states(executor: DockerExecutor) -> Tuple[Dict[str, str], bool]:
+    """name → docker status string (one ``docker ps -a`` round trip).
+
+    Second element: whether docker answered at all. When False the map is
+    empty and callers must NOT read absence as "container gone".
+    """
+    proc = executor.run_captured([
+        "ps", "-a", "--format", "{{.Names}}\t{{.Status}}",
+    ])
+    states: Dict[str, str] = {}
+    if proc.exit_code != 0:
+        return states, False
+    for line in (proc.stdout or "").splitlines():
+        name, _, status = line.partition("\t")
+        if name:
+            states[name] = status
+    return states, True
+
+
+def cmd_workspaces(
+    executor: Optional[DockerExecutor] = None,
+) -> List[Dict[str, Any]]:
+    """List every CLI-activated workspace with live Docker state."""
+    exec_ = executor or RealDockerExecutor()
+    from aisc.cli.commands.runs import list_runs
+
+    alias_by_path = {r.get("path", ""): r.get("alias", "") for r in list_runs()}
+    states, _docker_ok = docker_states(exec_)
+    entries, defaults = registry_entries(exec_)
+
+    rows: List[Dict[str, Any]] = []
+    for cname, meta in entries:
+        meta = meta or {}
+        if meta.get("owner") == "workbench":
+            continue
+        name = str(cname)
+        if not name:
+            continue
+        ws = str(meta.get("workspace", ""))
+        status = states.get(name, "")
+        rows.append({
+            "workspace": ws,
+            "alias": alias_by_path.get(ws, ""),
+            "label": str(meta.get("label", "")),
+            "container": name,
+            "image": str(meta.get("image", "")),
+            "status": status,
+            "running": status.startswith("Up"),
+            # r2 #E: which row a bare `aisc claude` actually lands in —
+            # the registry default pointer, not "any row of that workspace"
+            "active": name in defaults,
+        })
+    rows.sort(key=lambda r: (not r["running"], r["workspace"]))
+    return rows
+
+
+def cmd_workspaces_stop(
+    executor: Optional[DockerExecutor] = None,
+) -> Dict[str, Any]:
+    """Stop + remove every RUNNING CLI-owned activation (the batch sweep)."""
+    exec_ = executor or RealDockerExecutor()
+    from aisc.application.data_root import DataRootResolver
+
+    rows = [r for r in cmd_workspaces(executor=exec_) if r["running"]]
+    stopped: List[Dict[str, Any]] = []
+    shared = DataRootResolver().resolve_shared_root() / "workspaces"
+    for row in rows:
+        name = row["container"]
+        stop = exec_.run_captured(["stop", name], timeout=30.0)
+        rm = exec_.run_captured(["rm", "-f", name], timeout=30.0)
+        # unregister from its workspace registry (best-effort locate)
+        try:
+            for reg_dir in shared.glob("*/runtime"):
+                if (reg_dir / "containers.json").is_file():
+                    unregister(reg_dir, name)
+        except Exception:
+            pass
+        stopped.append({
+            "workspace": row["workspace"],
+            "alias": row["alias"],
+            "container": name,
+            "exit_code": rm.exit_code if rm.exit_code != 0 else stop.exit_code,
+        })
+    return {"stopped": stopped, "running_found": len(rows)}
+
+
+def print_workspaces_text(rows: List[Dict[str, Any]]) -> None:
+    """Human table: alias, status, workspace (ACTIVE workspace starred)."""
+    if not rows:
+        print("当前没有 CLI 激活的工作区 — aisc run <路径> 开始")
+        return
+    width = max(len(r.get("alias", "") or "-")
+                + (len(r.get("label", "")) + 4 if r.get("label") else 0)
+                for r in rows) + 2
+    for r in rows:
+        alias = r.get("alias", "") or "-"
+        if r.get("label"):
+            alias = f"{alias}[{r['label']}]"  # bypass slot — distinguish
+        alias += " *" if r.get("active") else ""
+        status = r.get("status", "") or "(容器不存在)"
+        print(f"  {alias:<{width}} {status:<22} {r['workspace']}")
+    print("批量停止运行中的: aisc workspaces --stop · 单个: aisc stop")