procesio-cli 0.1.1__py3-none-any.whl

procesio_cli/dashboard/server/setup.py

@@ -0,0 +1,211 @@
+"""Setup actions the dashboard performs on the user's behalf.
+
+Everything a colleague would otherwise do in a terminal or a chat: store/delete
+credentials, seed the user-data folder, edit validated config, capture a web
+login, run an OAuth flow. Secrets flow browser -> loopback POST -> the existing
+set-credential script (stdin) -> Windows Credential Manager; they are never
+logged, echoed, or written to disk here. Config edits and jobs stay under
+context-state-knowledge/ via userdata, preserving the wipe-safe boundary.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from agents.orchestrator import bootstraplib
+from tools._lib import userdata
+
+from . import config_schemas, inventory, jobs, runner
+
+
+def _resolve_secret(tool: str, secret: str) -> tuple[str, str]:
+    """A `namespace:name` secret (e.g. google:oauth-client) is stored under the
+    namespace, matching registry._has_secret. Everything else stays as-is."""
+    if ":" in secret:
+        ns, _, name = secret.partition(":")
+        return ns, name
+    return tool, secret
+
+
+# ---- credentials --------------------------------------------------------
+def credential_set(req) -> Any:
+    tool = (req.body.get("tool") or "").strip()
+    secret = (req.body.get("secret") or "").strip()
+    value = req.body.get("value")
+    if not tool or not secret:
+        return (400, {"error": "tool and secret are required"})
+    if not value or not str(value).strip():
+        return (400, {"error": "value is empty"})
+    rtool, rsecret = _resolve_secret(tool, secret)
+    res = runner.set_credential(rtool, rsecret, str(value))
+    if res["ok"]:
+        inventory.invalidate()
+    # res["message"] is set-credential's own output ("stored: ... (N bytes)") -
+    # it never contains the secret value.
+    return {"ok": res["ok"], "message": res["message"], "tool": tool, "secret": secret}
+
+
+def credential_delete(req) -> Any:
+    tool = (req.body.get("tool") or "").strip()
+    secret = (req.body.get("secret") or "").strip()
+    if not tool or not secret:
+        return (400, {"error": "tool and secret are required"})
+    rtool, rsecret = _resolve_secret(tool, secret)
+    res = runner.delete_credential(rtool, rsecret)
+    if res["ok"]:
+        inventory.invalidate()
+    return {"ok": res["ok"], "message": res["message"]}
+
+
+def credential_check(req) -> Any:
+    tool = (req.q("tool") or "").strip()
+    secret = (req.q("secret") or "").strip()
+    if not tool or not secret:
+        return (400, {"error": "tool and secret are required"})
+    rtool, rsecret = _resolve_secret(tool, secret)
+    return {"present": runner.check_credential(rtool, rsecret)}
+
+
+# ---- bootstrap ----------------------------------------------------------
+def bootstrap(req) -> Any:
+    # Seeding the user-data folder is the orchestrator's job. Not every
+    # distribution of this framework ships that agent, and a missing agent came
+    # back as a bare 500 that read like the dashboard was broken.
+    import registry
+    try:
+        registry.get_agent("orchestrator")
+    except KeyError:
+        return (501, {"error": "bootstrap is not available in this installation",
+                      "detail": "the orchestrator agent, which seeds the user-data "
+                                "folder, is not installed here. Credentials and "
+                                "config can still be set from this page."})
+    with_templates = bool(req.body.get("with_templates", True))
+    argv = ["bootstrap"] + (["--with-templates"] if with_templates else [])
+    res = runner.run_agent("orchestrator", argv, timeout=90)
+    if res["ok"]:
+        inventory.invalidate()
+        return res["data"]
+    return (500, {"error": "bootstrap failed", "detail": res["error"]})
+
+
+# ---- config editor ------------------------------------------------------
+def _config_path(component: str, name: str) -> Path:
+    # config_dir sanitizes the component; name is constrained to a bare filename.
+    safe_name = "".join(c for c in name if c.isalnum() or c in "._-")
+    return userdata.config_dir(component) / f"{safe_name}.json"
+
+
+def config_list(req) -> Any:
+    """Every framework config template + whether the user's copy exists."""
+    out = []
+    for t in bootstraplib.find_templates():
+        component = t["component"]
+        name = Path(t["target"]).stem
+        out.append({
+            "component": component,
+            "name": name,
+            "template": t["template"],
+            "exists": t["target_exists"],
+            "has_schema": config_schemas.has_schema(component, name),
+        })
+    return {"configs": out}
+
+
+def config_get(req) -> Any:
+    component = (req.q("component") or "").strip()
+    name = (req.q("name") or "").strip()
+    if not component or not name:
+        return (400, {"error": "component and name are required"})
+    path = _config_path(component, name)
+    data, err = None, None
+    if path.exists():
+        try:
+            data = json.loads(path.read_text(encoding="utf-8"))
+        except ValueError as e:
+            err = f"existing file is not valid JSON: {e}"
+    # the framework template, for reference / starting point
+    tpl = None
+    for t in bootstraplib.find_templates():
+        if t["component"] == component and Path(t["target"]).stem == name:
+            tpl_path = bootstraplib.FRAMEWORK_ROOT / t["template"]
+            try:
+                tpl = json.loads(tpl_path.read_text(encoding="utf-8"))
+            except (OSError, ValueError):
+                tpl = None
+            break
+    return {"component": component, "name": name, "exists": path.exists(),
+            "data": data, "template": tpl, "read_error": err,
+            "has_schema": config_schemas.has_schema(component, name)}
+
+
+def config_validate(req) -> Any:
+    component = (req.body.get("component") or "").strip()
+    name = (req.body.get("name") or "").strip()
+    return config_schemas.validate(component, name, req.body.get("data"))
+
+
+def config_set(req) -> Any:
+    component = (req.body.get("component") or "").strip()
+    name = (req.body.get("name") or "").strip()
+    data = req.body.get("data")
+    if not component or not name:
+        return (400, {"error": "component and name are required"})
+    verdict = config_schemas.validate(component, name, data)
+    if not verdict["ok"]:
+        return (400, {"error": "validation failed", "errors": verdict["errors"]})
+    path = _config_path(component, name)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    text = json.dumps(data, ensure_ascii=False, indent=2) + "\n"
+    path.write_bytes(text.encode("utf-8"))  # bytes+LF: no Windows CRLF flip
+    inventory.invalidate()
+    return {"ok": True, "path": str(path), "warnings": verdict["warnings"]}
+
+
+# ---- web session capture ------------------------------------------------
+def session_start(req) -> Any:
+    name = (req.body.get("name") or "").strip()
+    url = (req.body.get("url") or "").strip()
+    if not name or not url:
+        return (400, {"error": "name and url are required"})
+    argv = ["run-tool.py", "web", "save-session", "--name", name, "--url", url]
+    if req.body.get("channel"):
+        argv += ["--channel", str(req.body["channel"])]
+    if req.body.get("persistent"):
+        argv += ["--persistent"]
+    job = jobs.create("session", argv, stdin_signal=True)
+    return job.snapshot()
+
+
+def session_commit(req) -> Any:
+    """The user has logged in; send the ENTER the save-session is blocking on and
+    wait for it to persist and exit."""
+    job = jobs.get((req.body.get("job_id") or "").strip())
+    if job is None:
+        return (404, {"error": "unknown job"})
+    if not job.signal():
+        return (409, {"error": "job is not awaiting a login signal",
+                      "status": job.status})
+    job.wait(90)
+    inventory.invalidate()
+    return job.snapshot()
+
+
+# ---- OAuth --------------------------------------------------------------
+def oauth_start(req) -> Any:
+    tool = (req.body.get("tool") or "").strip()
+    if not tool:
+        return (400, {"error": "tool is required"})
+    # google-*/linkedin expose auth-login; it opens a browser and self-completes
+    # on the localhost redirect, so no stdin signal is needed.
+    job = jobs.create("oauth", ["run-tool.py", tool, "auth-login"], stdin_signal=False)
+    return job.snapshot()
+
+
+def job_get(req) -> Any:
+    job = jobs.get((req.q("id") or "").strip())
+    if job is None:
+        return (404, {"error": "unknown job"})
+    if job.status in ("done", "failed"):
+        inventory.invalidate()
+    return job.snapshot()

procesio_cli/dashboard/server/validate.py

@@ -0,0 +1,152 @@
+"""Live credential validation - the 'is it actually connected?' truth.
+
+Presence (secret exists in Credential Manager) comes free from the registry. This
+layer goes further: it runs a cheap, read-only probe and reports CONNECTED /
+INVALID / UNKNOWN.
+
+Probe resolution per capability:
+  1. explicit `healthcheck:` in the manifest  -> run that action, success = connected
+  2. else a conventional `auth-status` action  -> run it; its `ready` field decides
+  3. else                                       -> UNKNOWN (no way to probe)
+
+We only probe when every required secret is already present - a capability with
+missing creds is already known-unconfigured, so we skip the call (no point proving
+the obvious, and it keeps 'validate everything on load' fast). Probes run
+concurrently and stream back as they finish.
+"""
+from __future__ import annotations
+
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor
+from typing import Any, Iterator
+
+import registry
+
+from . import runner
+
+_MAX_WORKERS = 6
+_CACHE_TTL = 20.0
+_PROBE_TIMEOUT = 12.0  # a dead/unreachable system (e.g. VPN-gated) fails fast
+_cache: dict[str, tuple[float, dict]] = {}
+_lock = threading.Lock()
+# Single-flight: only one full sweep runs at a time. A second concurrent
+# request (e.g. a reconnecting client) is served the current cache snapshot
+# instead of storming the machine with a second wave of subprocesses.
+_sweep_lock = threading.Lock()
+
+
+def _index() -> dict[str, dict]:
+    """kind:name -> registry entry, for tools and agents."""
+    idx = {}
+    for t in registry.list_tools():
+        idx["tool:" + t["name"]] = t
+    for a in registry.list_agents():
+        idx["agent:" + a["name"]] = a
+    return idx
+
+
+def _probe_argv(entry: dict) -> list[str] | None:
+    """The argv to run for this entry's probe, or None if it has none."""
+    hc = entry.get("healthcheck")
+    if hc:
+        action = hc.get("action") or ""
+        argv = [action] if action else []
+        argv += runner.flags_from(hc.get("args") or {})
+        return argv
+    actions = {a["name"] for a in entry.get("actions", [])}
+    if "auth-status" in actions:
+        return ["auth-status"]
+    return None
+
+
+def _interpret(entry: dict, argv: list[str], result: dict) -> dict:
+    """Map a probe run to {status, detail}."""
+    using_authstatus = argv == ["auth-status"] and not entry.get("healthcheck")
+    if result["ok"]:
+        data = result.get("data")
+        # auth-status tools report their own readiness; honor it.
+        if using_authstatus and isinstance(data, dict) and "ready" in data and not data["ready"]:
+            return {"status": "invalid",
+                    "detail": "auth-status reports not ready: " + _short(data)}
+        return {"status": "connected", "detail": _short(data) if isinstance(data, dict) else ""}
+    err = result.get("error") or {}
+    return {"status": "invalid", "detail": (err.get("message") or err.get("code") or "probe failed")[:300]}
+
+
+def _short(data: dict) -> str:
+    keep = {k: v for k, v in list(data.items())[:6]
+            if isinstance(v, (str, int, float, bool)) and k not in ("error",)}
+    return ", ".join(f"{k}={v}" for k, v in keep.items())[:300]
+
+
+def probe(key: str, entry: dict, *, force: bool = False) -> dict:
+    """Run (or serve from cache) the probe for one capability."""
+    if not force:
+        with _lock:
+            hit = _cache.get(key)
+        if hit and (time.time() - hit[0]) < _CACHE_TTL:
+            return hit[1]
+
+    if entry.get("error"):
+        res = {"kind": key.split(":")[0], "name": entry["name"],
+               "status": "unknown", "detail": "manifest error"}
+    elif entry.get("missing_secrets"):
+        res = {"kind": key.split(":")[0], "name": entry["name"], "status": "unknown",
+               "detail": "credentials not set: " + ", ".join(entry["missing_secrets"])}
+    else:
+        argv = _probe_argv(entry)
+        if argv is None:
+            res = {"kind": key.split(":")[0], "name": entry["name"],
+                   "status": "unknown", "detail": "no healthcheck or auth-status"}
+        else:
+            run = runner.run_tool(entry["name"], argv, timeout=_PROBE_TIMEOUT)
+            verdict = _interpret(entry, argv, run)
+            res = {"kind": key.split(":")[0], "name": entry["name"], **verdict}
+    with _lock:
+        _cache[key] = (time.time(), res)
+    return res
+
+
+def stream_all(req) -> Iterator[tuple[str, dict]]:
+    """Probe every capability that CAN be probed, concurrently, yielding each
+    result as it lands. Items with no probe or missing creds resolve instantly."""
+    idx = _index()
+    force = req.q("force") in ("1", "true", "yes")
+    targets = list(idx.items())
+
+    # Single-flight: if a sweep is already running, don't launch a second wave -
+    # stream whatever the cache currently holds and return.
+    if not _sweep_lock.acquire(blocking=False):
+        for k, e in targets:
+            with _lock:
+                hit = _cache.get(k)
+            yield ("result", hit[1] if hit else
+                   {"kind": k.split(":")[0], "name": k.split(":", 1)[1],
+                    "status": "checking", "detail": "another check in progress"})
+        return
+    try:
+        with ThreadPoolExecutor(max_workers=_MAX_WORKERS) as pool:
+            futs = {pool.submit(probe, k, e, force=force): k for k, e in targets}
+            from concurrent.futures import as_completed
+            for fut in as_completed(futs):
+                try:
+                    yield ("result", fut.result())
+                except Exception as e:  # noqa: BLE001
+                    k = futs[fut]
+                    yield ("result", {"kind": k.split(":")[0], "name": k.split(":", 1)[1],
+                                      "status": "invalid", "detail": str(e)[:200]})
+    finally:
+        _sweep_lock.release()
+
+
+def validate_one_route(req) -> dict:
+    """POST {kind, name} -> fresh probe for a single capability (bypasses cache)."""
+    kind = (req.body.get("kind") or "").strip()
+    name = (req.body.get("name") or "").strip()
+    key = f"{kind}:{name}"
+    idx = _index()
+    entry = idx.get(key)
+    if entry is None:
+        return (404, {"error": "unknown capability", "key": key})
+    return probe(key, entry, force=True)

procesio_cli/dashboard/tests/conftest.py

@@ -0,0 +1,16 @@
+"""Test setup for the dashboard package.
+
+Puts the repo root on sys.path (so `import dashboard...` / `import registry`
+resolve under importlib mode) and forces keyring's Windows backend to skip the
+auto-detection that can block in a console-less process.
+"""
+import os
+import sys
+from pathlib import Path
+
+_ROOT = Path(__file__).resolve().parents[2]
+if str(_ROOT) not in sys.path:
+    sys.path.insert(0, str(_ROOT))
+
+os.environ.setdefault("PYTHON_KEYRING_BACKEND",
+                      "keyring.backends.Windows.WinVaultKeyring")

procesio_cli/dashboard/tests/test_dashboard.py

@@ -0,0 +1,225 @@
+"""Dashboard tests - hermetic units + one in-process server smoke.
+
+Network/subprocess-touching pieces (validation probes, credential writes) are
+monkeypatched so the suite is fast and side-effect free.
+"""
+import json
+import threading
+import urllib.error
+import urllib.request
+from http.server import ThreadingHTTPServer
+
+import pytest
+
+from dashboard.server import (config_schemas, google, handler, inventory,
+                              routes, security, setup, validate)
+
+
+class _Req:
+    def __init__(self, body=None, query=None):
+        self.body = body or {}
+        self._q = query or {}
+
+    def q(self, name, default=None):
+        return self._q.get(name, default)
+
+
+# ---- config_schemas -----------------------------------------------------
+def test_llm_schema_rejects_bad_adapter():
+    v = config_schemas.validate("llm", "providers",
+                                {"providers": {"x": {"adapter": "nope"}}})
+    assert not v["ok"]
+    assert any("adapter" in e for e in v["errors"])
+
+
+def test_llm_schema_default_must_exist():
+    v = config_schemas.validate("llm", "providers", {
+        "providers": {"openai": {"adapter": "openai_compat"}}, "default": "ghost"})
+    assert not v["ok"]
+    assert any("default" in e for e in v["errors"])
+
+
+def test_llm_schema_accepts_good():
+    v = config_schemas.validate("llm", "providers", {
+        "providers": {"openai": {"adapter": "openai_compat", "model": "gpt-4o"}},
+        "default": "openai"})
+    assert v["ok"] and not v["warnings"]
+
+
+def test_placeholder_is_a_warning_not_error():
+    v = config_schemas.validate("anything", "cfg", {"host": "YOUR-HOST"})
+    assert v["ok"]
+    assert any("placeholder" in w for w in v["warnings"])
+
+
+def test_non_object_config_rejected():
+    v = config_schemas.validate("x", "y", [1, 2, 3])
+    assert not v["ok"]
+
+
+# ---- secret namespace resolution ---------------------------------------
+def test_namespaced_secret_resolves_to_namespace():
+    assert setup._resolve_secret("google-mail", "google:oauth-client") == (
+        "google", "oauth-client")
+    assert setup._resolve_secret("ryver", "token") == ("ryver", "token")
+
+
+# ---- validation interpretation (monkeypatched runner) -------------------
+def test_probe_skips_when_secret_missing():
+    entry = {"name": "t", "missing_secrets": ["token"], "actions": []}
+    res = validate.probe("tool:t", entry, force=True)
+    assert res["status"] == "unknown" and "credentials not set" in res["detail"]
+
+
+def test_probe_connected_on_healthcheck_ok(monkeypatch):
+    monkeypatch.setattr(validate.runner, "run_tool",
+                        lambda *a, **k: {"ok": True, "data": {"count": 3}, "error": None})
+    entry = {"name": "t", "missing_secrets": [],
+             "healthcheck": {"action": "ping", "args": {}}, "actions": []}
+    res = validate.probe("tool:t", entry, force=True)
+    assert res["status"] == "connected"
+
+
+def test_probe_invalid_on_authstatus_not_ready(monkeypatch):
+    monkeypatch.setattr(validate.runner, "run_tool",
+                        lambda *a, **k: {"ok": True, "data": {"ready": False}, "error": None})
+    entry = {"name": "t", "missing_secrets": [], "healthcheck": None,
+             "actions": [{"name": "auth-status"}]}
+    res = validate.probe("tool:t", entry, force=True)
+    assert res["status"] == "invalid"
+
+
+def test_probe_invalid_on_error(monkeypatch):
+    monkeypatch.setattr(validate.runner, "run_tool",
+                        lambda *a, **k: {"ok": False, "data": None,
+                                         "error": {"code": "x", "message": "bad key"}})
+    entry = {"name": "t", "missing_secrets": [], "healthcheck": {"action": "ping"},
+             "actions": []}
+    res = validate.probe("tool:t", entry, force=True)
+    assert res["status"] == "invalid" and "bad key" in res["detail"]
+
+
+# ---- google multi-account -----------------------------------------------
+def test_google_label_validation():
+    assert google._valid_label("personal")
+    assert google._valid_label("work-2")
+    assert not google._valid_label("bad@email")
+    assert not google._valid_label("UPPER")
+    assert not google._valid_label("")
+
+
+def test_google_login_builds_account_argv(monkeypatch):
+    captured = {}
+
+    class FakeJob:
+        def snapshot(self):
+            return {"id": "x", "status": "running"}
+
+    def fake_create(kind, argv, stdin_signal=False):
+        captured["argv"] = argv
+        return FakeJob()
+
+    monkeypatch.setattr(google.jobs, "create", fake_create)
+    google.login(_Req({"account": "work"}))
+    assert captured["argv"] == ["run-tool.py", "google-mail", "auth-login", "--account", "work"]
+    captured.clear()
+    google.login(_Req({"account": "default"}))  # default -> no --account
+    assert captured["argv"] == ["run-tool.py", "google-mail", "auth-login"]
+
+
+def test_google_login_rejects_email_label():
+    res = google.login(_Req({"account": "a@example.com"}))
+    assert isinstance(res, tuple) and res[0] == 400
+
+
+def test_google_remove_builds_logout_argv(monkeypatch):
+    captured = {}
+
+    def fake_run(tool, argv, timeout=30):
+        captured["argv"] = argv
+        return {"ok": True, "data": {"authenticated": False}, "error": None}
+
+    monkeypatch.setattr(google.runner, "run_tool", fake_run)
+    monkeypatch.setattr(google.inventory, "invalidate", lambda: None)
+    google.remove(_Req({"account": "personal"}))
+    assert captured["argv"] == ["auth-logout", "--account", "personal"]
+
+
+def test_google_accounts_fast_no_email(monkeypatch):
+    def fake_run(tool, argv, timeout=30):
+        assert argv == ["auth-accounts"]  # the fast list makes no get-profile call
+        return {"ok": True, "error": None, "data": {"active": "default", "accounts": [
+            {"account": "default", "has_token": True},
+            {"account": "personal", "has_token": True}]}}
+    monkeypatch.setattr(google.runner, "run_tool", fake_run)
+    out = google.accounts(_Req())
+    assert out["ok"] and out["active"] == "default"
+    assert [a["account"] for a in out["accounts"]] == ["default", "personal"]
+    assert out["accounts"][0]["active"] and not out["accounts"][1]["active"]
+    assert "email" not in out["accounts"][0]  # email is lazy, not in the list
+
+
+# ---- in-process server: auth gate + routing -----------------------------
+@pytest.fixture()
+def server():
+    srv = ThreadingHTTPServer(("127.0.0.1", 0), handler.Handler)
+    srv.daemon_threads = True
+    threading.Thread(target=srv.serve_forever, daemon=True).start()
+    yield f"http://127.0.0.1:{srv.server_address[1]}", security.token()
+    srv.shutdown()
+
+
+def _call(base, path, token=None, method="GET", body=None):
+    headers = {"Content-Type": "application/json"}
+    if token:
+        headers["X-Dashboard-Token"] = token
+    data = json.dumps(body).encode() if body is not None else None
+    req = urllib.request.Request(base + path, method=method, data=data, headers=headers)
+    try:
+        r = urllib.request.urlopen(req, timeout=30)
+        return r.status, json.loads(r.read())
+    except urllib.error.HTTPError as e:
+        return e.code, json.loads(e.read())
+
+
+def test_api_requires_token(server):
+    base, _ = server
+    status, _ = _call(base, "/api/health")
+    assert status == 401
+
+
+def test_health_ok_with_token(server):
+    base, tok = server
+    status, body = _call(base, "/api/health", token=tok)
+    assert status == 200 and body["ok"] is True
+
+
+def test_static_index_served_without_token(server):
+    base, _ = server
+    req = urllib.request.Request(base + "/")
+    r = urllib.request.urlopen(req, timeout=10)
+    assert r.status == 200 and b"Setup" in r.read()
+
+
+def test_unknown_api_route_404(server):
+    base, tok = server
+    status, _ = _call(base, "/api/nope", token=tok)
+    assert status == 404
+
+
+def test_routes_wired():
+    for p in ("/api/inventory", "/api/config/list", "/api/context/inspect"):
+        assert routes.resolve("GET", p) is not None
+    for p in ("/api/credential/set", "/api/validate/one", "/api/copilot",
+              "/api/test/tool"):
+        assert routes.resolve("POST", p) is not None
+
+
+# ---- inventory shape (real registry; slower integration check) ----------
+def test_inventory_shape():
+    inv = inventory.build(force=True)
+    assert set(("summary", "tools", "agents", "skills", "providers")) <= set(inv)
+    assert inv["summary"]["tools"]["total"] >= 1
+    # every tool entry carries the annotations the UI relies on
+    sample = inv["tools"][0]
+    assert "secrets_status" in sample and "probe" in sample and "kind" in sample