wealthbox-cli 1.2.0__tar.gz → 1.4.0__tar.gz

{wealthbox_cli-1.2.0 → wealthbox_cli-1.4.0}/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
       "name": "wealthbox-crm",
       "source": "./plugins/wealthbox-crm",
       "description": "Wealthbox CRM agent skill — natural-language CRM automation backed by the `wbox` CLI.",
-      "version": "1.2.0",
+      "version": "1.3.0",
       "category": "productivity",
       "tags": [
         "wealthbox",

{wealthbox_cli-1.2.0 → wealthbox_cli-1.4.0}/.codex-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "wealthbox-crm",
   "description": "Wealthbox CRM agent skill — drive contacts, tasks, notes, events, and households via natural language. Bundles SKILL.md, references, and firm-bootstrap workflow. Requires the `wbox` CLI (auto-install instructions in SKILL.md).",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "author": "Kadin Bullock",
   "homepage": "https://github.com/massive-value/wealthbox-cli",
   "repository": "https://github.com/massive-value/wealthbox-cli",

{wealthbox_cli-1.2.0 → wealthbox_cli-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wealthbox-cli
-Version: 1.2.0
+Version: 1.4.0
 Summary: CLI and client library for the Wealthbox CRM API
 Project-URL: Homepage, https://github.com/massive-value/wealthbox-cli
 Project-URL: Documentation, https://massive-value.github.io/wealthbox-cli/

{wealthbox_cli-1.2.0 → wealthbox_cli-1.4.0}/docs/changelog.md

@@ -6,6 +6,22 @@ This project uses [Semantic Versioning](https://semver.org/).
 
 ---
 
+## [1.3.0](https://github.com/massive-value/wealthbox-cli/releases/tag/v1.3.0) — 2026-05-03
+
+### Added
+
+- **`wbox doctor`** — comprehensive top-level health check at the CLI root. Reports the wbox CLI version + Python version + binary location; authentication source detection (flag / env var / config file / `.env`) plus a smoke test against `/me`; agent CLI presence (`claude` / `codex` on PATH); legacy skill installs; plugin installs (managed via `claude plugin install` / `codex plugin install`); firm data state with file count, generated-vs-hand-edited split, and oldest-generated-file timestamp; and a Summary section listing actionable issues. `wbox skills doctor` keeps working as an alias of the new top-level command — both call the same function so output never drifts.
+- `wbox skills list` and `wbox skills doctor` now detect plugin-installed copies of `wealthbox-crm` under `~/.claude/plugins/cache/.../skills/wealthbox-crm/` and `~/.codex/plugins/cache/.../skills/wealthbox-crm/`. Previously a user who installed via the marketplace plugin path saw "not installed" everywhere even though the plugin was actively serving the skill.
+- Bootstrap installer (`scripts/install.sh` / `scripts/install.ps1`) now prefers the Claude Code plugin marketplace path when `claude` is on PATH — runs `claude plugin marketplace add` + `claude plugin install` directly, then offers a separate Codex install. Falls back to the legacy `wbox skills install` picker when no `claude` CLI is detected.
+- Bootstrap installer pre-flight checks Windows PowerShell `ExecutionPolicy` and offers to set `RemoteSigned` for the current user if needed (no admin required), instead of bombing partway through with Astral's terse error.
+
+### Fixed
+
+- Bootstrap `install.sh` no longer hangs at startup. The previous version did `exec </dev/tty` at the top, which cut off bash's source of piped script content (`curl … | bash`) and waited forever for the rest of the script to arrive on the user's keyboard. The whole body is now wrapped in a `main()` function so bash reads it fully before executing.
+- Bootstrap `install.ps1` no longer auto-closes its window on error. Wrapped in try/catch/finally with explicit step headers and a "Press Enter to close" pause so a transient PowerShell host stays open long enough to show the actual error.
+
+---
+
 ## [1.2.0](https://github.com/massive-value/wealthbox-cli/releases/tag/v1.2.0) — 2026-05-02
 
 ### Changed

{wealthbox_cli-1.2.0 → wealthbox_cli-1.4.0}/plugins/wealthbox-crm/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "wealthbox-crm",
   "description": "Wealthbox CRM agent skill — drive contacts, tasks, notes, events, and households via natural language. Bundles SKILL.md, references, and firm-bootstrap workflow. Requires the `wbox` CLI (auto-install instructions in SKILL.md).",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "author": {
     "name": "Kadin Bullock"
   },

{wealthbox_cli-1.2.0 → wealthbox_cli-1.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "wealthbox-cli"
-version = "1.2.0"
+version = "1.4.0"
 description = "CLI and client library for the Wealthbox CRM API"
 readme = "README.md"
 requires-python = ">=3.11"

wealthbox_cli-1.4.0/src/wealthbox_tools/cli/_skill_platforms.py

@@ -0,0 +1,235 @@
+from __future__ import annotations
+
+import json
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+
+SKILL_NAME = "wealthbox-crm"
+
+
+@dataclass(frozen=True)
+class Platform:
+    id: str
+    label: str
+    root_dir: Path
+    skill_filename: str
+    requires_project_cwd: bool
+
+
+@dataclass(frozen=True)
+class PluginInstall:
+    """A copy of `wealthbox-crm` discovered inside an agent host's plugin cache.
+
+    These are managed by the host CLI (`claude plugin install ...` or the
+    Codex equivalent) — `wbox skills install` does not write here, and
+    `wbox skills uninstall` does not touch them.
+
+    `active` is True when the host's `installed_plugins.json` has a record
+    pointing at this version's installPath. Old/cached versions kept around
+    by the host for rollback report active=False. If the host has no
+    `installed_plugins.json` (e.g., older Claude Code, or a Codex setup that
+    hasn't shipped one yet), `active` defaults to True since we can't tell.
+    """
+    host: str        # 'claude-code-user' | 'claude-code-project' | 'codex'
+    marketplace: str
+    version: str
+    skill_dir: Path
+    active: bool = True
+
+
+def _home() -> Path:
+    return Path.home()
+
+
+def _read_active_install_paths(plugins_root: Path) -> set[Path] | None:
+    """Read <plugins_root>/installed_plugins.json and return the set of
+    install-path roots the host considers active across every scope.
+
+    Returns None when no state file exists — caller should treat every
+    discovered plugin as active in that case (we don't have enough info
+    to differentiate cached vs active).
+    """
+    state_file = plugins_root / "installed_plugins.json"
+    if not state_file.is_file():
+        return None
+    try:
+        data = json.loads(state_file.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError):
+        return None
+    active: set[Path] = set()
+    for entries in (data.get("plugins") or {}).values():
+        if not isinstance(entries, list):
+            continue
+        for entry in entries:
+            install_path = entry.get("installPath")
+            if not install_path:
+                continue
+            try:
+                active.add(Path(install_path).resolve())
+            except OSError:
+                active.add(Path(install_path))
+    return active
+
+
+def _scan_plugin_cache(
+    cache_root: Path,
+    host: str,
+    active_paths: set[Path] | None,
+) -> list[PluginInstall]:
+    """Find any `<marketplace>/<plugin-name>/<version>/skills/wealthbox-crm/`
+    matches under a Claude Code- or Codex-style plugin cache root."""
+    if not cache_root.is_dir():
+        return []
+    out: list[PluginInstall] = []
+    for marketplace_dir in cache_root.iterdir():
+        if not marketplace_dir.is_dir():
+            continue
+        plugin_dir = marketplace_dir / SKILL_NAME
+        if not plugin_dir.is_dir():
+            continue
+        for version_dir in plugin_dir.iterdir():
+            if not version_dir.is_dir():
+                continue
+            skill_dir = version_dir / "skills" / SKILL_NAME
+            if not (skill_dir / "SKILL.md").is_file():
+                continue
+            try:
+                version_dir_resolved = version_dir.resolve()
+            except OSError:
+                version_dir_resolved = version_dir
+            if active_paths is None:
+                is_active = True
+            else:
+                is_active = version_dir_resolved in active_paths
+            out.append(PluginInstall(
+                host=host,
+                marketplace=marketplace_dir.name,
+                version=version_dir.name,
+                skill_dir=skill_dir,
+                active=is_active,
+            ))
+    return out
+
+
+def detect_plugin_installs() -> list[PluginInstall]:
+    """Discover every host-managed plugin copy of wealthbox-crm on this
+    machine. Includes Claude Code user scope, Claude Code project scope
+    (cwd-relative), and Codex.
+
+    Deduped by resolved skill_dir path so a single install isn't reported
+    twice when home and cwd point at the same directory (rare in real use,
+    common in tests).
+    """
+    home = _home()
+    cwd = Path.cwd()
+    candidates = [
+        (home / ".claude" / "plugins", "claude-code-user"),
+        (cwd / ".claude" / "plugins", "claude-code-project"),
+        (home / ".codex" / "plugins", "codex"),
+    ]
+    installs: list[PluginInstall] = []
+    seen: set[Path] = set()
+    for plugins_root, host in candidates:
+        active_paths = _read_active_install_paths(plugins_root)
+        for pi in _scan_plugin_cache(
+            plugins_root / "cache", host=host, active_paths=active_paths,
+        ):
+            try:
+                key = pi.skill_dir.resolve()
+            except OSError:
+                key = pi.skill_dir
+            if key in seen:
+                continue
+            seen.add(key)
+            installs.append(pi)
+    return installs
+
+
+def detect_platforms() -> list[Platform]:
+    home = _home()
+    cwd = Path.cwd()
+    return [
+        Platform(
+            id="claude-code-user",
+            label="Claude Code (user)",
+            root_dir=home / ".claude" / "skills",
+            skill_filename="SKILL.md",
+            requires_project_cwd=False,
+        ),
+        Platform(
+            id="claude-code-project",
+            label="Claude Code (current project)",
+            root_dir=cwd / ".claude" / "skills",
+            skill_filename="SKILL.md",
+            requires_project_cwd=True,
+        ),
+        Platform(
+            id="codex",
+            label="Codex",
+            root_dir=home / ".codex" / "skills",
+            skill_filename="SKILL.md",
+            requires_project_cwd=False,
+        ),
+    ]
+
+
+def skill_dir(platform: Platform) -> Path:
+    return platform.root_dir / "wealthbox-crm"
+
+
+class SkillInstallError(Exception):
+    """Raised when a skill install/uninstall cannot proceed safely."""
+
+
+def is_installed(platform: Platform) -> bool:
+    dest = skill_dir(platform)
+    return dest.is_dir() and (dest / platform.skill_filename).is_file()
+
+
+def install_skill(platform: Platform, src: Path, *, force: bool) -> None:
+    dest = skill_dir(platform)
+    if dest.exists() and not force:
+        raise SkillInstallError(
+            f"Skill already installed at {dest} (use --force to overwrite)"
+        )
+    if dest.exists():
+        _safe_rmtree(platform, dest)
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copytree(src, dest)
+
+
+def upgrade_skill(platform: Platform, src: Path) -> None:
+    """Re-copy the bundled template over an existing install.
+
+    Preserves the user's `firm/` directory and root `_meta.json` (the
+    bundled template ships neither). Refreshes SKILL.md, references/,
+    firm-examples/, and bootstrap.md.
+    """
+    dest = skill_dir(platform)
+    if not dest.is_dir() or not (dest / platform.skill_filename).is_file():
+        raise SkillInstallError(
+            f"Cannot upgrade: nothing installed at {dest}"
+        )
+    shutil.copytree(src, dest, dirs_exist_ok=True)
+
+
+def uninstall_skill(platform: Platform) -> None:
+    dest = skill_dir(platform)
+    if not dest.exists():
+        return
+    _safe_rmtree(platform, dest)
+
+
+def _safe_rmtree(platform: Platform, target: Path) -> None:
+    root = platform.root_dir.resolve()
+    try:
+        resolved = target.resolve(strict=True)
+    except FileNotFoundError:
+        return
+    # Guard: resolved target must sit inside resolved root AND end with "wealthbox-crm".
+    if resolved.name != "wealthbox-crm" or root not in resolved.parents:
+        raise SkillInstallError(
+            f"refusing to remove {resolved}: not a standard skill path under {root}"
+        )
+    shutil.rmtree(resolved)

{wealthbox_cli-1.2.0 → wealthbox_cli-1.4.0}/src/wealthbox_tools/cli/_util.py

@@ -416,6 +416,32 @@ def build_resource_filter(
     return result
 
 
+async def resolve_category_id(
+    client: WealthboxClient, category_type: CategoryType, value: str
+) -> int:
+    """Resolve a category name or numeric string to an integer ID.
+
+    If `value` is purely digits, returns int(value) without an API call.
+    Otherwise fetches all categories of the given type and case-insensitively
+    matches `name`. Raises typer.BadParameter on miss with available names.
+    """
+    if value.isdigit():
+        return int(value)
+    data = await client.list_all_categories(category_type)
+    items = data.get(category_type.value, [])
+    target = value.strip().casefold()
+    for item in items:
+        if str(item.get("name", "")).casefold() == target:
+            return int(item["id"])
+    available = sorted(str(i["name"]) for i in items if i.get("name"))
+    label = category_type.value.replace("_", " ")
+    if available:
+        raise typer.BadParameter(
+            f"Unknown {label} value '{value}'. Available: {', '.join(available)}"
+        )
+    raise typer.BadParameter(f"No {label} configured in this workspace.")
+
+
 def parse_more_fields(more_fields: str, reserved: set[str]) -> dict[str, Any]:
     """Parse --more-fields JSON and validate against reserved keys.
 

wealthbox_cli-1.4.0/src/wealthbox_tools/cli/doctor.py

@@ -0,0 +1,203 @@
+"""Comprehensive health check across the wbox install.
+
+`wbox doctor` and `wbox skills doctor` both call into `run_doctor()` so
+the legacy `skills doctor` command keeps working as an alias.
+"""
+from __future__ import annotations
+
+import os
+import platform as _platform_module
+import shutil
+import sys
+from datetime import datetime
+from importlib.metadata import version as _pkg_version
+
+import typer
+
+from ._config import _config_path, load_config
+from ._skill_bootstrap import migrate_legacy_firm, read_firm_meta, read_meta
+from ._skill_paths import firm_dir, firm_meta_path
+from ._skill_platforms import (
+    detect_platforms,
+    detect_plugin_installs,
+    is_installed,
+    skill_dir,
+)
+
+
+def _detect_token_source(token_arg: str | None) -> tuple[str | None, str]:
+    """Return (token, source_label) matching get_client's resolution order:
+    --token flag > WEALTHBOX_TOKEN env > config file > .env (loaded as env)."""
+    if token_arg:
+        return token_arg, "--token flag"
+    env_token = os.environ.get("WEALTHBOX_TOKEN")
+    if env_token:
+        return env_token, "env var (WEALTHBOX_TOKEN or .env)"
+    cfg = load_config()
+    cfg_token = cfg.get("token")
+    if cfg_token:
+        return cfg_token, f"config file ({_config_path()})"
+    return None, "not set"
+
+
+def run_doctor(token: str | None = None) -> int:
+    """Run all health checks. Returns exit code (0 = healthy, 1 = issues found)."""
+    issues: list[str] = []
+
+    migrated_from = _ensure_firm_migrated()
+    if migrated_from is not None:
+        typer.echo(f"! migrated legacy firm/ data from {migrated_from} to {firm_dir()}")
+        typer.echo("")
+
+    # --- wbox CLI ---------------------------------------------------------
+    typer.echo("# wbox CLI")
+    cli_version = _pkg_version("wealthbox-cli")
+    py_version = ".".join(str(v) for v in sys.version_info[:3])
+    binary = shutil.which("wbox") or "(not on PATH -running via python -m)"
+    typer.echo(f"  version:  {cli_version}")
+    typer.echo(f"  python:   {py_version} ({_platform_module.system()})")
+    typer.echo(f"  binary:   {binary}")
+
+    # --- Authentication ---------------------------------------------------
+    typer.echo("\n# Authentication")
+    config_path = _config_path()
+    if config_path.exists():
+        cfg = load_config()
+        cfg_token = cfg.get("token", "")
+        masked = f"...{cfg_token[-4:]}" if len(cfg_token) > 4 else "****"
+        typer.echo(f"  config:   {config_path} (present, masked: {masked})")
+    else:
+        typer.echo(f"  config:   {config_path} (not present)")
+    resolved_token, source = _detect_token_source(token)
+    typer.echo(f"  source:   {source}")
+    if not resolved_token:
+        typer.echo("  smoke:    skipped (no token)")
+        issues.append("token not configured - run 'wbox config set-token'")
+    else:
+        from wealthbox_tools.client import WealthboxAPIError
+
+        from ._util import run_client
+        try:
+            me = run_client(token, lambda c: c.get_me())
+            accounts = me.get("accounts") or []
+            firm_name = accounts[0].get("name") if accounts else "(no firm)"
+            typer.echo(
+                f"  smoke:    OK /me returned {me.get('name')} "
+                f"({firm_name}, user {me.get('id')})"
+            )
+        except WealthboxAPIError as e:
+            typer.echo(f"  smoke:    FAILED token rejected by /me: {e}")
+            issues.append("token rejected by /me - check it's still valid")
+        except Exception as e:
+            typer.echo(f"  smoke:    FAILED network/config error: {e}")
+            issues.append(f"smoke test failed: {e}")
+
+    # --- Agent CLIs -------------------------------------------------------
+    typer.echo("\n# Agent CLIs on PATH")
+    claude_path = shutil.which("claude") or shutil.which("claude.exe")
+    codex_path = shutil.which("codex") or shutil.which("codex.exe")
+    typer.echo(f"  claude:   {claude_path or 'not detected'}")
+    typer.echo(f"  codex:    {codex_path or 'not detected'}")
+
+    # --- Legacy skill installs --------------------------------------------
+    typer.echo("\n# Skill installs (legacy template-copy)")
+    for p in detect_platforms():
+        status = "installed" if is_installed(p) else "not installed"
+        meta = read_meta(skill_dir(p)) if is_installed(p) else {}
+        template_v = (meta.get("template") or {}).get("cli_version", "-")
+        upgrade_hint = ""
+        if template_v not in ("-", cli_version):
+            upgrade_hint = f"  [upgrade: {template_v} -> {cli_version}]"
+            issues.append(
+                f"{p.id} skill template is {template_v}, latest is {cli_version} "
+                f"- run 'wbox skills upgrade'"
+            )
+        typer.echo(
+            f"  {p.id:<22} {status:<16} template={template_v:<10} {skill_dir(p)}{upgrade_hint}"
+        )
+
+    # --- Plugin installs --------------------------------------------------
+    plugin_installs = detect_plugin_installs()
+    typer.echo("\n# Plugin installs (managed by host CLI: claude/codex plugin)")
+    if not plugin_installs:
+        typer.echo("  (none detected)")
+    else:
+        # Active first, then cached (descending version) so the live
+        # install is the first thing the eye lands on.
+        plugin_installs.sort(key=lambda p: (not p.active, p.version), reverse=False)
+        for pi in plugin_installs:
+            status_label = "active" if pi.active else "cached"
+            typer.echo(
+                f"  {pi.host:<22} plugin@{pi.marketplace:<18} "
+                f"version={pi.version:<8} {status_label:<7} {pi.skill_dir}"
+            )
+
+    # --- Firm data --------------------------------------------------------
+    typer.echo("\n# Firm data (canonical)")
+    typer.echo(f"  path:     {firm_dir()}")
+    typer.echo(f"  meta:     {firm_meta_path()}")
+    firm_meta = read_firm_meta()
+    if not firm_meta:
+        typer.echo("  state:    not bootstrapped")
+        issues.append("firm data not bootstrapped - run 'wbox skills bootstrap'")
+    else:
+        identity = firm_meta.get("identity") or {}
+        if firm_meta.get("onboarded_at"):
+            firm_state = "onboarded"
+        else:
+            firm_state = "bootstrapped (qualitative pending)"
+            issues.append(
+                "firm onboarding incomplete - open the skill in your agent to "
+                "walk through bootstrap.md (it'll call 'wbox skills mark-onboarded')"
+            )
+        typer.echo(f"  state:    {firm_state}")
+        typer.echo(f"  firm:     {identity.get('name', '-')}")
+        typer.echo(f"  user:     {identity.get('user_name', '-')}")
+        if firm_dir().exists():
+            md_files = sorted(p.name for p in firm_dir().glob("*.md"))
+            generated_set = set((firm_meta.get("files") or {}).keys())
+            handed = [f for f in md_files if f not in generated_set and not f.startswith("_")]
+            typer.echo(
+                f"  files:    {len(md_files)} markdown ({len(generated_set)} generated, "
+                f"{len(handed)} hand-edited)"
+            )
+            file_ts = list((firm_meta.get("files") or {}).values())
+            if file_ts:
+                try:
+                    oldest = min(datetime.fromisoformat(t).date() for t in file_ts)
+                    typer.echo(f"  oldest:   {oldest}")
+                except (ValueError, TypeError):
+                    pass
+
+    # --- Summary ----------------------------------------------------------
+    typer.echo("\n# Summary")
+    if not issues:
+        typer.echo("  All checks passed.")
+        return 0
+    typer.echo(f"  {len(issues)} issue(s) found:")
+    for i in issues:
+        typer.echo(f"    ! {i}")
+    return 1
+
+
+def _ensure_firm_migrated():
+    """Migrate legacy firm/ data on first read (idempotent)."""
+    installed = [skill_dir(p) for p in detect_platforms() if is_installed(p)]
+    return migrate_legacy_firm(installed)
+
+
+def doctor_cmd(
+    token: str | None = typer.Option(
+        None, "--token",
+        help="Override the API token for the smoke test. Overrides env var, config, .env.",
+    ),
+) -> None:
+    """Run the comprehensive doctor.
+
+    Always exits 0 — issues are surfaced in the Summary section. The doctor
+    is informational, not a CI gate. (A future --strict flag could change
+    this for scripting.) Token is intentionally NOT bound to
+    `envvar=WEALTHBOX_TOKEN` so the doctor can report whether the token came
+    from the flag, env var, config file, or .env file.
+    """
+    run_doctor(token=token)

{wealthbox_cli-1.2.0 → wealthbox_cli-1.4.0}/src/wealthbox_tools/cli/main.py

@@ -8,6 +8,7 @@ from .activity import app as activity_app
 from .categories import app as categories_app
 from .config import app as config_app
 from .contacts import app as contacts_app
+from .doctor import doctor_cmd as _doctor_cmd
 from .events import app as events_app
 from .households import app as households_app
 from .me import app as me_app
@@ -35,6 +36,12 @@ def _main(
         raise typer.Exit()
 
 
+app.command(
+    "doctor",
+    help="Comprehensive health check: CLI version, auth, agent CLIs, skills, plugins, firm.",
+)(_doctor_cmd)
+
+
 app.add_typer(activity_app, name="activity")
 app.add_typer(categories_app, name="categories")
 app.add_typer(config_app, name="config")