procesio-cli 0.1.1__py3-none-any.whl

procesio_cli/dashboard/tests/test_procesio_env.py

@@ -0,0 +1,159 @@
+"""procesio_env dashboard routes — thin wrappers over existing tool actions.
+
+runner.run_tool is monkeypatched to a recorder, so these assert argv construction,
+mutation-triggered cache invalidation, error passthrough, and required-field guards
+without ever launching a subprocess.
+"""
+from __future__ import annotations
+
+from dashboard.server import procesio_env as PE
+
+
+class _Req:
+    def __init__(self, body=None):
+        self.body = body or {}
+
+    def q(self, name, default=None):
+        return default
+
+
+def _recorder(result):
+    calls = []
+
+    def fake_run(tool, argv, timeout=60):
+        calls.append({"tool": tool, "argv": argv, "timeout": timeout})
+        return result
+
+    return calls, fake_run
+
+
+def _patch(monkeypatch, result, *, track_invalidate=True):
+    calls, fake = _recorder(result)
+    monkeypatch.setattr(PE.runner, "run_tool", fake)
+    invalidated = []
+    monkeypatch.setattr(PE.inventory, "invalidate", lambda: invalidated.append(True))
+    return calls, invalidated
+
+
+_OK = {"ok": True, "data": {"default_environment": "Internal-QA"}, "error": None}
+_ERR = {"ok": False, "data": None, "error": {"code": "x", "message": "boom"}}
+
+
+# -- state (read) -----------------------------------------------------------
+
+def test_state_runs_both_read_actions(monkeypatch):
+    calls, _ = _patch(monkeypatch, _OK)
+    out = PE.state(_Req())
+    argvs = [c["argv"] for c in calls]
+    assert ["list-environments"] in argvs
+    assert ["list-credentials"] in argvs
+    assert out["environments"] == _OK["data"]
+
+
+def test_state_does_not_invalidate(monkeypatch):
+    _, invalidated = _patch(monkeypatch, _OK)
+    PE.state(_Req())
+    assert invalidated == []  # reads never drop the inventory cache
+
+
+def test_state_surfaces_errors(monkeypatch):
+    _patch(monkeypatch, _ERR)
+    out = PE.state(_Req())
+    assert out["environments_error"]["message"] == "boom"
+    assert out["environments"] is None
+
+
+# -- set-environment --------------------------------------------------------
+
+def test_set_environment_builds_argv_and_invalidates(monkeypatch):
+    calls, invalidated = _patch(monkeypatch, _OK)
+    out = PE.set_environment(_Req({"name": "Internal-QA"}))
+    assert calls[0]["argv"] == ["set-environment", "--name", "Internal-QA"]
+    assert out["ok"] is True
+    assert invalidated == [True]  # default moved -> card + probe must re-read
+
+
+def test_set_environment_requires_name(monkeypatch):
+    calls, _ = _patch(monkeypatch, _OK)
+    status, body = PE.set_environment(_Req({"name": "  "}))
+    assert status == 400 and "name" in body["error"]
+    assert calls == []  # never touched the tool
+
+
+def test_failed_mutation_does_not_invalidate(monkeypatch):
+    _, invalidated = _patch(monkeypatch, _ERR)
+    out = PE.set_environment(_Req({"name": "Ghost-PROD"}))
+    assert out["ok"] is False and out["error"]["message"] == "boom"
+    assert invalidated == []
+
+
+# -- add-environment --------------------------------------------------------
+
+def test_add_environment_full_argv(monkeypatch):
+    calls, invalidated = _patch(monkeypatch, _OK)
+    PE.add_environment(_Req({
+        "name": "Delgaz-PROD", "web_base": "https://w", "app_base": "https://a",
+        "forms_base": "https://f", "auth_base": "https://au", "make_default": True,
+    }))
+    assert calls[0]["argv"] == [
+        "add-environment", "--name", "Delgaz-PROD",
+        "--web-base", "https://w", "--app-base", "https://a", "--forms-base", "https://f",
+        "--auth-base", "https://au", "--make-default"]
+    assert invalidated == [True]
+
+
+def test_add_environment_omits_optional_flags(monkeypatch):
+    calls, _ = _patch(monkeypatch, _OK)
+    PE.add_environment(_Req({
+        "name": "X-PROD", "web_base": "https://w", "app_base": "https://a",
+        "forms_base": "https://f"}))
+    argv = calls[0]["argv"]
+    assert "--auth-base" not in argv and "--make-default" not in argv
+
+
+def test_add_environment_requires_all_urls(monkeypatch):
+    calls, _ = _patch(monkeypatch, _OK)
+    status, body = PE.add_environment(_Req({"name": "X-PROD", "web_base": "https://w"}))
+    assert status == 400
+    assert calls == []
+
+
+# -- remove-environment / credentials ---------------------------------------
+
+def test_remove_environment_argv(monkeypatch):
+    calls, invalidated = _patch(monkeypatch, _OK)
+    PE.remove_environment(_Req({"name": "Delgaz-PROD"}))
+    assert calls[0]["argv"] == ["remove-environment", "--name", "Delgaz-PROD"]
+    assert invalidated == [True]
+
+
+def test_set_default_credential_uses_set_default(monkeypatch):
+    calls, invalidated = _patch(monkeypatch, _OK)
+    PE.set_default_credential(_Req({"name": "qa-me"}))
+    assert calls[0]["argv"] == ["set-default", "--name", "qa-me"]
+    assert invalidated == [True]
+
+
+def test_remove_credential_uses_remove_credential(monkeypatch):
+    calls, _ = _patch(monkeypatch, _OK)
+    PE.remove_credential(_Req({"name": "old"}))
+    assert calls[0]["argv"] == ["remove-credential", "--name", "old"]
+
+
+def test_credential_actions_guard_name(monkeypatch):
+    calls, _ = _patch(monkeypatch, _OK)
+    assert PE.set_default_credential(_Req({}))[0] == 400
+    assert PE.remove_credential(_Req({}))[0] == 400
+    assert calls == []
+
+
+# -- routes are wired -------------------------------------------------------
+
+def test_routes_registered():
+    from dashboard.server import routes
+    assert routes.resolve("GET", "/api/procesio/state") is not None
+    assert routes.resolve("POST", "/api/procesio/set-environment") is not None
+    assert routes.resolve("POST", "/api/procesio/add-environment") is not None
+    assert routes.resolve("POST", "/api/procesio/remove-environment") is not None
+    assert routes.resolve("POST", "/api/procesio/set-default-credential") is not None
+    assert routes.resolve("POST", "/api/procesio/remove-credential") is not None

procesio_cli/dashboard/web/actions.js

@@ -0,0 +1,274 @@
+// Setup + verification interactions: modals and API calls. Attached to
+// window.Actions; app.js routes card buttons here via App.act(name, data).
+(function () {
+  const App = window.App;
+  const el = App.el;
+  const toast = App.toast;
+
+  // ---- modal plumbing ---------------------------------------------------
+  function closeModal() { document.getElementById("modalRoot").innerHTML = ""; }
+  function modal(title, hint, bodyNodes, footNodes) {
+    const root = document.getElementById("modalRoot");
+    root.innerHTML = "";
+    const box = el("div", { class: "modal" },
+      el("h3", null, title),
+      hint ? el("p", { class: "hint" }, hint) : null,
+      ...bodyNodes,
+      el("div", { class: "modal-foot" }, ...footNodes));
+    const bg = el("div", { class: "modal-bg" }, box);
+    bg.addEventListener("click", (e) => { if (e.target === bg) closeModal(); });
+    root.appendChild(bg);
+    return box;
+  }
+  function field(labelText, inputNode) {
+    return el("div", { class: "field" }, el("label", null, labelText), inputNode);
+  }
+  function input(attrs) { return el("input", attrs || {}); }
+
+  async function withBtn(btn, fn) {
+    const old = btn.textContent; btn.disabled = true; btn.textContent = "working...";
+    try { await fn(); } finally { btn.disabled = false; btn.textContent = old; }
+  }
+
+  // ---- credentials ------------------------------------------------------
+  function setCred(data) {
+    const ns = data.secret.includes(":");
+    const valIn = input({ type: "password", placeholder: "paste the secret value", autocomplete: "off" });
+    const save = el("button", { class: "btn" }, "Store");
+    save.addEventListener("click", () => withBtn(save, async () => {
+      const value = valIn.value;
+      if (!value || value.length < 4) { toast("value looks too short", "bad"); return; }
+      const r = await API.post("/api/credential/set",
+        { tool: data.tool, secret: data.secret, value });
+      if (r.ok) { toast("stored " + data.secret, "ok"); closeModal(); App.refresh(); }
+      else { toast(r.message || "failed", "bad"); }
+    }));
+    modal("Store credential",
+      data.tool + " / " + data.secret + (ns ? "  (shared namespace secret)" : "") +
+      "  -  written straight to Windows Credential Manager, never to disk.",
+      [field("Value", valIn)],
+      [el("button", { class: "btn ghost", onclick: closeModal }, "Cancel"), save]);
+    setTimeout(() => valIn.focus(), 30);
+  }
+
+  async function delCred(data) {
+    if (!confirm("Delete credential " + data.secret + " for " + data.tool + "?")) return;
+    const r = await API.post("/api/credential/delete", { tool: data.tool, secret: data.secret });
+    if (r.ok) { toast("deleted", "ok"); App.refresh(); } else toast(r.message || "failed", "bad");
+  }
+
+  // ---- bootstrap --------------------------------------------------------
+  async function bootstrap(data) {
+    toast("initializing user-data folder...", "");
+    try {
+      const r = await API.post("/api/bootstrap", { with_templates: !!data.withTemplates });
+      toast("bootstrap done: " + (r.templates_copied ? r.templates_copied.length : 0) +
+        " templates copied", "ok");
+      App.refresh();
+    } catch (e) { toast("bootstrap failed: " + e.message, "bad"); }
+  }
+
+  // ---- config editor ----------------------------------------------------
+  async function editConfig(data) {
+    let cfg;
+    try { cfg = await API.get("/api/config/get?component=" + encodeURIComponent(data.component) +
+      "&name=" + encodeURIComponent(data.name)); }
+    catch (e) { toast("cannot load config: " + e.message, "bad"); return; }
+    const start = cfg.data != null ? cfg.data : (cfg.template != null ? cfg.template : {});
+    const ta = el("textarea", { spellcheck: "false" });
+    ta.value = JSON.stringify(start, null, 2);
+    const msg = el("div", { class: "field" });
+    const showVerdict = (v) => {
+      msg.innerHTML = "";
+      (v.errors || []).forEach(e2 => msg.appendChild(el("div", { class: "err" }, "error: " + e2)));
+      (v.warnings || []).forEach(w => msg.appendChild(el("div", { class: "err", style: "color:var(--amber)" }, "warn: " + w)));
+      if (!(v.errors || []).length && !(v.warnings || []).length)
+        msg.appendChild(el("div", { class: "meta" }, "looks valid"));
+    };
+    const parse = () => { try { return [JSON.parse(ta.value), null]; } catch (e) { return [null, e.message]; } };
+    const validate = el("button", { class: "btn ghost" }, "Validate");
+    validate.addEventListener("click", async () => {
+      const [obj, err] = parse();
+      if (err) { showVerdict({ errors: ["invalid JSON: " + err] }); return; }
+      const v = await API.post("/api/config/validate", { component: data.component, name: data.name, data: obj });
+      showVerdict(v);
+    });
+    const save = el("button", { class: "btn" }, "Save");
+    save.addEventListener("click", () => withBtn(save, async () => {
+      const [obj, err] = parse();
+      if (err) { showVerdict({ errors: ["invalid JSON: " + err] }); return; }
+      try {
+        const r = await API.post("/api/config/set", { component: data.component, name: data.name, data: obj });
+        toast("saved " + data.component + "/" + data.name, "ok");
+        if (r.warnings && r.warnings.length) showVerdict({ warnings: r.warnings });
+        else { closeModal(); App.refresh(); }
+      } catch (e) {
+        showVerdict({ errors: (e.payload && e.payload.errors) || [e.message] });
+      }
+    }));
+    modal("Edit config - " + data.component + "/" + data.name,
+      cfg.has_schema ? "This config is schema-validated." :
+        "Saved to context-state-knowledge/config/" + data.component + "/" + data.name + ".json",
+      [field("JSON", ta), msg],
+      [el("button", { class: "btn ghost", onclick: closeModal }, "Cancel"), validate, save]);
+  }
+
+  // ---- web session capture ---------------------------------------------
+  // data (optional prefill from a tool card): {name, login_url, persistent, channel, label, present}
+  function webLogin(data) {
+    data = data || {};
+    const prefilled = !!data.name;
+    const isReconnect = !!data.present;
+    const nameIn = input({ placeholder: "session name (e.g. ryver, whatsapp)" });
+    nameIn.value = data.name || "";
+    const urlIn = input({ placeholder: "https://login-url" });
+    urlIn.value = data.login_url || data.url || "";
+    const persist = input({ type: "checkbox" });
+    persist.checked = !!data.persistent;
+    const channel = el("select", null,
+      el("option", { value: "" }, "bundled Chromium"),
+      el("option", { value: "chrome" }, "chrome (real Chrome, for Google sign-in)"),
+      el("option", { value: "msedge" }, "msedge"));
+    channel.value = data.channel || "";
+
+    // The 3-step flow, spelled out so a first-timer knows exactly what to do.
+    const steps = el("ol", { class: "steps" },
+      el("li", null, "Click ", el("b", null, "Open browser"), " below - a real browser window opens at the login page."),
+      el("li", null, "Log in there the way you normally would (username, password, 2FA)."),
+      el("li", null, "Come back here and click ", el("b", null, "I have logged in"), "."));
+
+    const fields = [field("Session name", nameIn), field("Login URL", urlIn),
+      el("div", { class: "field" }, el("label", null, "Browser channel"), channel),
+      el("label", { class: "chk" }, persist, " Persistent profile (needed for WhatsApp)")];
+    // When opened from a card these are already correct - tuck them away so a
+    // first-time user isn't unsure whether to change them.
+    const fieldBlock = prefilled
+      ? el("details", { class: "advanced" },
+          el("summary", null, "Advanced - already set for this tool, no need to change"), ...fields)
+      : el("div", null, ...fields);
+
+    const status = el("div", { class: "field" });
+    const startBtn = el("button", { class: "btn" }, "Open browser");
+    startBtn.addEventListener("click", () => withBtn(startBtn, async () => {
+      if (!nameIn.value || !urlIn.value) { toast("session name and login URL are required", "bad"); return; }
+      const job = await API.post("/api/session/start", {
+        name: nameIn.value.trim(), url: urlIn.value.trim(),
+        persistent: persist.checked, channel: channel.value || null });
+      status.innerHTML = "";
+      status.appendChild(el("div", { class: "meta" },
+        "Browser opened. Finish logging in there, then click below."));
+      const commit = el("button", { class: "btn" }, "I have logged in - save");
+      commit.addEventListener("click", () => withBtn(commit, async () => {
+        const res = await API.post("/api/session/commit", { job_id: job.id });
+        if (res.status === "done") { toast("login saved for " + nameIn.value, "ok"); closeModal(); App.refresh(); }
+        else { toast("save failed: " + (res.error || res.status), "bad"); }
+      }));
+      status.appendChild(commit);
+    }));
+
+    const hint = isReconnect
+      ? "You're already connected. Only re-connect if the login stopped working or you want to switch the logged-in account - nothing to change here, just:"
+      : "This tool has no API - it signs in through your browser. Your login is saved locally on this machine; the dashboard never sees your password. To connect:";
+
+    modal(prefilled ? (isReconnect ? "Re-connect " : "Connect ") + (data.label || data.name) + " login"
+                    : "Capture a web login",
+      hint, [steps, status, fieldBlock],
+      [el("button", { class: "btn ghost", onclick: closeModal }, "Close"), startBtn]);
+  }
+  const webConnect = webLogin;  // card "Connect"/"reconnect" passes the tool's prefill
+
+  // ---- OAuth ------------------------------------------------------------
+  async function oauthLogin(data) {
+    toast("starting OAuth for " + data.tool + "...", "");
+    let job;
+    try { job = await API.post("/api/oauth/start", { tool: data.tool }); }
+    catch (e) { toast("oauth start failed: " + e.message, "bad"); return; }
+    const logbox = el("pre", { class: "log" }, "launching browser...");
+    modal("OAuth login - " + data.tool,
+      "A browser opened for consent. It completes automatically on redirect.",
+      [logbox], [el("button", { class: "btn ghost", onclick: closeModal }, "Close")]);
+    const poll = setInterval(async () => {
+      let s;
+      try { s = await API.get("/api/job/get?id=" + job.id); } catch (e) { return; }
+      logbox.textContent = (s.logs || []).join("\n") || s.status;
+      if (s.status === "done" || s.status === "failed") {
+        clearInterval(poll);
+        toast(s.status === "done" ? "OAuth complete" : "OAuth failed: " + (s.error || ""),
+          s.status === "done" ? "ok" : "bad");
+        App.refresh();
+      }
+    }, 1500);
+  }
+
+  // ---- details ----------------------------------------------------------
+  function details(data) {
+    const list = (data.kind === "tool" ? App.state.inv.tools :
+      data.kind === "agent" ? App.state.inv.agents : App.state.inv.skills) || [];
+    const item = list.find(i => i.name === data.name);
+    if (!item) { toast("not found", "bad"); return; }
+    const body = [el("p", { class: "card-desc" }, item.description || "")];
+    const hasOauth = (item.actions || []).some(a => a.name === "auth-login");
+    if (hasOauth) {
+      const b = el("button", { class: "btn" }, "Run OAuth login");
+      b.addEventListener("click", () => { closeModal(); oauthLogin({ tool: item.name }); });
+      body.push(el("div", { class: "card-foot" }, b));
+    }
+    if (item.actions && item.actions.length) {
+      body.push(el("div", { class: "section-title" }, el("h2", null, "actions"), el("span", { class: "line" })));
+      const rows = el("div", { class: "rows" });
+      item.actions.forEach(a => rows.appendChild(el("div", { class: "row" },
+        el("div", { class: "k" }, a.name),
+        el("div", { class: "v meta" }, (a.args || []).map(x => x.name).join(", ")))));
+      body.push(rows);
+    }
+    modal(item.name, item.kind, body, [el("button", { class: "btn ghost", onclick: closeModal }, "Close")]);
+  }
+
+  // ---- M4 verification (endpoints land in M4) ---------------------------
+  async function testProvider(data) {
+    toast("testing provider " + data.provider + "...", "");
+    try {
+      const r = await API.post("/api/llm/provider/test", { provider: data.provider });
+      toast(r.ok ? "provider OK (" + (r.model || "") + ")" : "failed: " + (r.detail || ""), r.ok ? "ok" : "bad");
+    } catch (e) { toast("test failed: " + e.message, "bad"); }
+  }
+  async function testTool(data) { runTest("/api/test/tool", { name: data.name }, "tool " + data.name); }
+  async function testAgent(data) { runTest("/api/test/agent", { name: data.name }, "agent " + data.name); }
+  async function runTest(path, body, label) {
+    const logbox = el("pre", { class: "log" }, "running...");
+    modal("Test " + label, "Runs a live check and, if a provider is configured, an LLM judgement.",
+      [logbox], [el("button", { class: "btn ghost", onclick: closeModal }, "Close")]);
+    try {
+      const r = await API.post(path, body);
+      logbox.textContent = JSON.stringify(r, null, 2);
+      toast(r.ok ? label + " works" : label + ": " + (r.summary || "issue"), r.ok ? "ok" : "bad");
+    } catch (e) { logbox.textContent = "error: " + e.message; }
+  }
+  async function explainProbe(data) {
+    const path = data.kind === "agent" ? "/api/test/agent" : "/api/test/tool";
+    const box = el("pre", { class: "log" }, "asking the AI why this is failing...");
+    modal("Why isn't " + data.name + " working?",
+      "The live check plus a plain-language explanation from your AI model.",
+      [box], [el("button", { class: "btn ghost", onclick: closeModal }, "Close")]);
+    try {
+      const r = await API.post(path, { name: data.name });
+      box.textContent = r.llm || r.summary || JSON.stringify(r, null, 2);
+    } catch (e) { box.textContent = "error: " + e.message; }
+  }
+
+  async function inspectContext() {
+    const logbox = el("pre", { class: "log" }, "inspecting...");
+    modal("Context & state inspection", "Summarized via the configured LLM provider.",
+      [logbox], [el("button", { class: "btn ghost", onclick: closeModal }, "Close")]);
+    try { const r = await API.get("/api/context/inspect"); logbox.textContent = r.summary || JSON.stringify(r, null, 2); }
+    catch (e) { logbox.textContent = "error: " + e.message; }
+  }
+
+  const wlBtn = document.getElementById("webLoginBtn");
+  if (wlBtn) wlBtn.addEventListener("click", webLogin);
+
+  window.Actions = {
+    setCred, delCred, bootstrap, editConfig, details, webLogin, webConnect, oauthLogin,
+    testProvider, testTool, testAgent, explainProbe, inspectContext,
+  };
+})();

procesio_cli/dashboard/web/api.js

@@ -0,0 +1,79 @@
+// Thin fetch layer. Grabs the one-time token from the launch URL (or a prior
+// session, or a manual paste) and attaches it to every call. The token is kept
+// in the URL so a reload keeps working; a 401 shows a paste box (app.js).
+(function () {
+  const params = new URLSearchParams(location.search);
+  let TOKEN = params.get("token") || sessionStorage.getItem("aat_token") || "";
+  if (TOKEN) sessionStorage.setItem("aat_token", TOKEN);
+
+  function setToken(t) {
+    TOKEN = (t || "").trim();
+    sessionStorage.setItem("aat_token", TOKEN);
+    // Reflect it in the URL so a reload keeps working.
+    try {
+      const u = new URL(location.href);
+      u.searchParams.set("token", TOKEN);
+      history.replaceState({}, "", u);
+    } catch (_) {}
+  }
+
+  function headers() {
+    return { "Content-Type": "application/json", "X-Dashboard-Token": TOKEN };
+  }
+
+  function netError(e) {
+    // fetch() rejects with a TypeError ("Failed to fetch") when the server is
+    // unreachable - almost always because the dashboard server was stopped.
+    const err = new Error("Dashboard server is not responding. Is it still "
+      + "running? Restart it with: python dashboard/serve.py");
+    err.cause = e;
+    return err;
+  }
+
+  async function get(path) {
+    let r;
+    try { r = await fetch(path, { headers: headers() }); }
+    catch (e) { throw netError(e); }
+    return unwrap(r);
+  }
+
+  async function post(path, body) {
+    let r;
+    try {
+      r = await fetch(path, {
+        method: "POST", headers: headers(),
+        body: JSON.stringify(body || {}),
+      });
+    } catch (e) { throw netError(e); }
+    return unwrap(r);
+  }
+
+  async function unwrap(r) {
+    let data = null;
+    try { data = await r.json(); } catch (e) { data = { error: "bad_response" }; }
+    if (!r.ok) {
+      const msg = (data && (data.message || data.error)) || r.statusText;
+      const err = new Error(typeof msg === "string" ? msg : JSON.stringify(msg));
+      err.status = r.status; err.payload = data;
+      throw err;
+    }
+    return data;
+  }
+
+  // Server-Sent Events via EventSource (token goes in the query - loopback only).
+  function stream(path, handlers) {
+    const url = path + (path.includes("?") ? "&" : "?") + "token=" + encodeURIComponent(TOKEN);
+    const es = new EventSource(url);
+    for (const [evt, fn] of Object.entries(handlers)) {
+      es.addEventListener(evt, (e) => {
+        let d = {};
+        try { d = JSON.parse(e.data); } catch (_) {}
+        fn(d, es);
+      });
+    }
+    es.onerror = () => es.close();
+    return es;
+  }
+
+  window.API = { get, post, stream, setToken };
+})();