toolframe-streamlit-dashboard 0.4.2__py3-none-any.whl

toolframe_streamlit_dashboard/__init__.py

@@ -0,0 +1 @@
+"""One replaceable Streamlit runtime per shared page environment."""

toolframe_streamlit_dashboard/app.py

@@ -0,0 +1,73 @@
+"""Executed by Streamlit in its normal script thread."""
+
+from functools import partial
+from pathlib import Path
+
+import streamlit as st
+from toolframe_sdk import PluginError
+
+from toolframe_streamlit_dashboard.management import render_management
+from toolframe_streamlit_dashboard.plugin import current
+
+provider = current()
+epoch, pages = provider.snapshot
+st.set_page_config(page_title="Toolframe", layout="wide")
+st.html(Path(__file__).with_name("chrome.css"))
+
+
+@st.fragment(run_every=1)
+def access_header():
+    try:
+        current_access = provider.access("presentation")
+    except PluginError as error:
+        st.error(error.message)
+        return
+    if current_access["local_control"]:
+        st.caption("本機控制 · Local control")
+    if current_access["mode"] == "public":
+        reason = (
+            "Auth unavailable: " + current_access.get("detail", "")
+            if current_access["reason"] == "auth_unavailable"
+            else "Public business access"
+        )
+        st.warning("目前處於公開訪問模式 · " + reason)
+    elif current_access["mode"] == "waiting":
+        st.info("Access is preparing. Reconnecting shortly…")
+    else:
+        st.caption("Protected access")
+
+
+try:
+    access = provider.access("presentation")
+except PluginError as error:
+    st.error(error.message)
+    st.stop()
+access_header()
+if access["actor"] in {"password", "operator", "user"}:
+    st.markdown(
+        '<form method="post" action="/_toolframe/auth/logout"><button type="submit">Sign out</button></form>',
+        unsafe_allow_html=True,
+    )
+else:
+    st.link_button("Sign in", access["login_url"])
+navigation = [
+    st.Page(
+        partial(provider.render_page, page, epoch),
+        title=page.resource.resource.title or page.resource.resource.id,
+        url_path=f"{page.resource.owner}--{page.resource.resource.id}",
+    )
+    for page in pages
+    if set(page.resource.resource.required_scopes) <= set(access["allowed_scopes"])
+]
+if "system.plugins.read" in access["allowed_scopes"]:
+    navigation.append(
+        st.Page(
+            partial(render_management, provider),
+            title="Plugin management",
+            url_path="plugins",
+        )
+    )
+if navigation:
+    st.navigation(navigation).run()
+else:
+    st.info("No Dashboard pages are available for this access grant.")

toolframe_streamlit_dashboard/chrome.css

@@ -0,0 +1,27 @@
+/* Streamlit 1.61's native busy widget still owns visibility, its accessible
+   "Running..." label and the adjacent Stop button. Replace only its artwork. */
+[data-testid="stStatusWidgetRunningIcon"] > * {
+  display: none;
+}
+
+[data-testid="stStatusWidgetRunningIcon"]::after {
+  content: "";
+  display: block;
+  width: 1rem;
+  height: 1rem;
+  box-sizing: border-box;
+  border: 2px solid currentColor;
+  border-right-color: transparent;
+  border-radius: 50%;
+  animation: toolframe-busy-spin 0.8s linear infinite;
+}
+
+@keyframes toolframe-busy-spin {
+  to { transform: rotate(360deg); }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  [data-testid="stStatusWidgetRunningIcon"]::after {
+    animation: none;
+  }
+}

toolframe_streamlit_dashboard/dependencies.py

@@ -0,0 +1,187 @@
+"""Render the host's topology without planning or performing an operation."""
+
+import json
+import textwrap
+
+import streamlit as st
+
+
+def dot_quote(value):
+    return json.dumps(str(value), ensure_ascii=False)
+
+
+def graph_dot(report, focus=None, action="reload"):
+    impact = report.get("impacts", {}).get(focus, {}).get(action, {})
+    affected = set(impact.get("affected", []))
+    optional = set(impact.get("optional_consumers", []))
+    entrances = {item["provider"] for item in impact.get("presentations", [])}
+    lines = [
+        "digraph plugins {",
+        'graph [rankdir=TB, bgcolor="transparent", pad=0.12, nodesep=0.2, ranksep=0.35];',
+        'node [shape=box, style="rounded,filled", fontname="sans-serif", fontsize=13, margin="0.16,0.12"];',
+        'edge [fontname="sans-serif", fontsize=10, color="#94a3b8", fontcolor="#94a3b8", arrowsize=0.7];',
+    ]
+    for node in report["nodes"]:
+        state = node["state"]
+        if node.get("healthy"):
+            fill, stroke, health = "#dcfce7", "#15803d", "healthy"
+        elif state in {"failed", "blocked", "missing", "ambiguous"}:
+            fill, stroke, health = "#ffe4e6", "#be123c", "not ready"
+        elif state in {"disabled", "stopped", "removed", "installed"}:
+            fill, stroke, health = "#e2e8f0", "#64748b", ""
+        else:
+            fill, stroke, health = "#fef3c7", "#b45309", "not ready"
+        outline, role = stroke, ""
+        if node["id"] == focus:
+            outline, role = "#2563eb", "selected"
+        elif node["id"] in affected:
+            outline, role = "#ea580c", "affected"
+        elif node["id"] in optional:
+            outline, role = "#d97706", "optional consumer"
+        elif node["id"] in entrances:
+            outline, role = "#a855f7", "entry refresh"
+        status = f"{state} · {health}" if health and state != health else state
+        name = "\n".join(textwrap.wrap(node["label"], width=18))
+        label = f"{name}\n{status}" + (f"\n{role}" if role else "")
+        lines.append(
+            f"{dot_quote(node['id'])} [label={dot_quote(label)}, "
+            f'fillcolor="{fill}", color="{outline}", fontcolor="#0f172a", '
+            f"penwidth={3 if role else 1.2}];"
+        )
+    for edge in report["edges"]:
+        kind = edge["kind"]
+        style = {"required": "solid", "optional": "dashed", "presentation": "dotted"}[
+            kind
+        ]
+        color = "#a78bfa" if kind == "presentation" else "#94a3b8"
+        if edge["state"] == "missing":
+            color = "#f87171"
+        # Keep the overview readable; exact services and versions are listed in
+        # the relationship table. Arrow direction is consumer -> supplier.
+        label = edge["label"].split(".")[0] if kind == "presentation" else kind
+        lines.append(
+            f"{dot_quote(edge['source'])} -> {dot_quote(edge['target'])} "
+            f'[label={dot_quote(label)}, style="{style}", color="{color}", '
+            f'fontcolor="{color}", minlen={3 if kind == "presentation" else 1}];'
+        )
+    lines.append("}")
+    return "\n".join(lines)
+
+
+def render_dependencies(status):
+    with st.expander("Plugin dependencies & impact", expanded=False):
+        st.caption(
+            "This graph follows installed plugins and their current state. "
+            "Refresh status after installing or changing a plugin. "
+            "Creating source with plugin new does not install it; use plugin add first."
+        )
+        report = status.get("dependency_graph")
+        if not report:
+            st.info("Update core to view the dependency graph.")
+            return
+        plugins = [node for node in report["nodes"] if node["kind"] != "unresolved"]
+        if not plugins:
+            st.info("No plugins are installed yet.")
+            return
+        left, right = st.columns(2)
+        focus = left.selectbox(
+            "Inspect plugin",
+            [None, *(node["id"] for node in plugins)],
+            format_func=lambda name: name or "All plugins",
+            key="dependency-focus",
+        )
+        action = right.selectbox(
+            "Impact of",
+            ["reload", "disable"],
+            key="dependency-action",
+            disabled=focus is None,
+        )
+        st.caption(
+            "Arrows point from a plugin to its dependency or presentation provider. "
+            "Solid: required · Dashed: optional · Dotted: presentation."
+        )
+        with st.container(key="dependency-diagram"):
+            # Streamlit's chart CSS otherwise overrides DOT's measured text
+            # sizes with 9.6px, making a narrow embedded graph hard to read.
+            st.html(
+                """<style>
+                .st-key-dependency-diagram .stGraphVizChart .node text { font-size: 13px; }
+                .st-key-dependency-diagram .stGraphVizChart .edge text { font-size: 10px; }
+                </style>"""
+            )
+            st.graphviz_chart(graph_dot(report, focus, action), width="stretch")
+        st.caption(
+            "Green: healthy · Amber: not ready · Red: blocked / failed / missing · "
+            "Gray: inactive. Select a plugin to highlight its impact. "
+            "Use the graph's full-screen control for a larger view."
+        )
+        if focus:
+            node = next(node for node in plugins if node["id"] == focus)
+            st.caption(
+                f"{focus} · {node['state']} · version {node.get('version') or 'unknown'} · "
+                f"{node.get('in_flight', 0)} in-flight calls · "
+                f"definition: {node['definition_source']}"
+            )
+            if node.get("blocked_by"):
+                st.warning("Blocked by: " + ", ".join(node["blocked_by"]))
+            impact = report["impacts"].get(focus, {}).get(action)
+            if impact:
+                st.markdown("**Restart / stop cohort**")
+                st.write(", ".join(impact["affected"]) or "None")
+                if impact["presentation_providers"]:
+                    st.caption(
+                        "Includes shared presentation processes: "
+                        + ", ".join(impact["presentation_providers"])
+                        + ". Related clients may reconnect."
+                    )
+                if impact["optional_consumers"]:
+                    st.write(
+                        "Optional consumers (not restarted): "
+                        + ", ".join(impact["optional_consumers"])
+                    )
+                if impact["presentations"]:
+                    st.markdown("**Entries that may reconnect or refresh**")
+                    st.dataframe(
+                        [
+                            {
+                                "Plugin": item["owner"],
+                                "Provider": item["provider"],
+                                "Entry": item["kind"],
+                                "Resources": ", ".join(item["resources"]),
+                            }
+                            for item in impact["presentations"]
+                        ],
+                        hide_index=True,
+                        width="stretch",
+                    )
+            else:
+                st.info(
+                    "This plugin is outside the selected runtime graph. Its last known "
+                    "declarations are shown; preview enable to inspect an activation."
+                )
+        st.caption(
+            "Read-only view of the selected definitions. Inactive declarations are "
+            "not live bindings. A new candidate, changed bindings or other pending "
+            "changes can alter the impact; use Preview operation before applying."
+        )
+        relationships = [
+            edge
+            for edge in report["edges"]
+            if focus is None or focus in (edge["source"], edge["target"])
+        ]
+        if relationships:
+            st.markdown("**Relationships**")
+            st.dataframe(
+                [
+                    {
+                        "Plugin": edge["source"],
+                        "Dependency / provider": edge["target"],
+                        "Relation": edge["kind"],
+                        "Service / resource": edge["label"],
+                        "Binding": edge["state"],
+                    }
+                    for edge in relationships
+                ],
+                hide_index=True,
+                width="stretch",
+            )

toolframe_streamlit_dashboard/history.py

@@ -0,0 +1,126 @@
+"""Paged journal queries with permanent record numbers and browser-local time."""
+
+from datetime import UTC, datetime, timedelta, timezone
+from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
+
+import streamlit as st
+from toolframe_sdk import PluginError
+
+_PREFIX = "operation_history_"
+
+
+def reset_history():
+    st.session_state[_PREFIX + "page"] = 1
+    st.session_state[_PREFIX + "through"] = None
+
+
+def move_page(page):
+    st.session_state[_PREFIX + "page"] = page
+
+
+def local_timestamp(value):
+    if value is None:
+        return "Time unavailable"
+    zone = UTC
+    name, offset = st.context.timezone, st.context.timezone_offset
+    if name:
+        try:
+            zone = ZoneInfo(name)
+        except ZoneInfoNotFoundError, ValueError:
+            name = None
+    if not name and offset is not None and -1440 < offset < 1440:
+        zone = timezone(-timedelta(minutes=offset))
+    return datetime.fromtimestamp(value, zone).strftime("%Y-%m-%d %H:%M:%S %Z")
+
+
+def render_history(provider, permissions, track_operation, submit):
+    st.subheader("Operations")
+    state = st.session_state
+    params = {
+        "page": state.get(_PREFIX + "page", 1),
+        "page_size": state.get(_PREFIX + "page_size", 10),
+        "through": state.get(_PREFIX + "through"),
+    }
+    selectors = (
+        ("target", "Filter by plugin", "All plugins"),
+        ("kind", "Filter by action", "All actions"),
+        ("status", "Filter by result", "All results"),
+    )
+    for field, _, all_label in selectors:
+        choice = state.get(_PREFIX + field, all_label)
+        if choice != all_label:
+            params[field] = (
+                "" if field == "target" and choice == "Application" else choice
+            )
+    try:
+        result = provider.manage("operations", params)
+    except PluginError as error:
+        st.error(f"Unable to load operation history: {error.message}")
+        return
+    state[_PREFIX + "page"] = result["page"]
+    state[_PREFIX + "through"] = result["through"]
+    for column, (field, label, all_label) in zip(st.columns(3), selectors):
+        options = [all_label] + (["Application"] if field == "target" else [])
+        options += result["filters"][field]
+        selected = state.get(_PREFIX + field, all_label)
+        if selected not in options:
+            options.append(selected)
+        with column:
+            st.selectbox(label, options, key=_PREFIX + field, on_change=reset_history)
+    size, refresh = st.columns(2, vertical_alignment="bottom")
+    with size:
+        st.selectbox(
+            "Rows per page",
+            [10, 25, 50],
+            key=_PREFIX + "page_size",
+            on_change=reset_history,
+        )
+    with refresh, st.container(horizontal=True, horizontal_alignment="right"):
+        st.button("Refresh history", on_click=reset_history)
+    page, total = result["page"], result["total"]
+    first = (page - 1) * result["page_size"] + 1 if total else 0
+    last = first + len(result["items"]) - 1 if total else 0
+    st.caption(
+        f"Newest first · Page {page} of {result['pages']} · {first}–{last} of {total} operations. "
+        "Permanent operation numbers; times use your browser's time zone."
+    )
+    if result["newer_count"]:
+        st.info(
+            f"{result['newer_count']} newer operations. Refresh history to include them."
+        )
+    if not result["items"]:
+        st.info("No operations match these filters.")
+    for operation in result["items"]:
+        action = (
+            f"plan {operation['request'].get('action', 'apply')}"
+            if operation["kind"] == "plan"
+            else operation["kind"]
+        )
+        label = (
+            f"#{operation['sequence']} · {local_timestamp(operation['created'])} · "
+            f"{action} · {operation.get('target') or 'application'} · {operation['status']}"
+        )
+        with st.expander(label):
+            st.json(operation)
+            label = "Review preview" if operation["kind"] == "plan" else "View result"
+            if st.button(label, key=f"view-{operation['id']}"):
+                track_operation(operation["id"])
+            scope = (
+                "system.migrations.manage"
+                if operation["kind"] in {"migrate-plan", "migrate-apply"}
+                else "system.plugins.manage"
+            )
+            if operation["status"] in {"queued", "running"} and st.button(
+                "Request cancellation",
+                key=f"cancel-{operation['id']}",
+                disabled=scope not in permissions,
+            ):
+                submit(provider, "cancel", {"id": operation["id"]})
+    with st.container(horizontal=True, horizontal_alignment="distribute"):
+        st.button("Newer", disabled=page <= 1, on_click=move_page, args=(page - 1,))
+        st.button(
+            "Older",
+            disabled=page >= result["pages"],
+            on_click=move_page,
+            args=(page + 1,),
+        )

toolframe_streamlit_dashboard/management.py

@@ -0,0 +1,281 @@
+"""Thin UI over host management operations, with no installer or database logic."""
+
+import streamlit as st
+from toolframe_sdk import PluginError
+
+from .dependencies import render_dependencies
+from .history import local_timestamp, render_history, reset_history
+
+_OPERATION_QUERY_KEY = "operation"
+_PLANNED_ACTIONS = {"enable", "reload", "disable", "stop", "remove"}
+_PENDING = {"queued", "running"}
+
+
+def render_management(provider):
+    st.title("Plugin management")
+    try:
+        permissions = provider.access("presentation")["allowed_scopes"]
+        status = provider.manage("status")
+    except PluginError as error:
+        st.error(str(error))
+        return
+    st.caption(f"Application: {status['application']} · Core: {status['core']}")
+    for field in ("configuration_error", "orphaned_workers", "forward_repair"):
+        if status.get(field):
+            st.error(field.replace("_", " ").capitalize())
+            st.json(status[field])
+    rows = [
+        {
+            "Plugin": item["id"],
+            "Enabled": item["desired"].get("enabled", False),
+            "State": item["runtime"].get("state", "installed"),
+            "Healthy": item.get(
+                "healthy",
+                item["health_fresh"] and item["runtime"].get("state") == "active",
+            ),
+            "Active": (item["active"] or "")[:12],
+            "Candidate": (item["candidate"] or "")[:12],
+        }
+        for item in status["plugins"]
+    ]
+    st.dataframe(rows, hide_index=True, width="stretch")
+    render_dependencies(status)
+    st.caption(
+        "Disabled plugins remain in this list so you can enable them again. "
+        "Their pages and tools are removed when disabling completes."
+    )
+    if st.button("Refresh status"):
+        st.rerun()
+    can_manage = "system.plugins.manage" in permissions
+    can_migrate = "system.migrations.manage" in permissions
+    if not can_manage and not can_migrate:
+        st.caption("Read-only plugin diagnostics")
+        render_operation(provider)
+        render_history(provider, permissions, track_operation, submit)
+        return
+    with st.form("install"):
+        source = st.text_input(
+            "Plugin source",
+            placeholder="path:/absolute/plugin or pypi:package==version",
+        )
+        enable = st.checkbox("Enable after validation", value=False)
+        if st.form_submit_button("Install and validate", disabled=not can_manage):
+            if not source.strip():
+                st.error("Enter a plugin source.")
+            else:
+                submit(provider, "add", {"source": source.strip(), "enable": enable})
+    identifiers = [
+        item["id"]
+        for item in status["plugins"]
+        if item["desired"].get("installed") is not False
+    ]
+    if identifiers:
+        with st.container(border=True):
+            identifier = st.selectbox("Plugin", identifiers)
+            enabled = next(
+                item["desired"].get("enabled", False)
+                for item in status["plugins"]
+                if item["id"] == identifier
+            )
+            actions = (
+                ["validate", "update", "enable", "reload", "disable", "stop", "remove"]
+                if enabled
+                else ["enable", "validate", "update", "remove"]
+            )
+            if not enabled:
+                st.caption(
+                    "This plugin is disabled. Enable it to restore its pages and tools."
+                )
+            action = st.selectbox(
+                "Operation",
+                (actions if can_manage else [])
+                + (["migrate-plan"] if can_migrate else []),
+            )
+            params = {"id": identifier}
+            if action == "validate":
+                params["runtime"] = st.checkbox(
+                    "Validate in a temporary runtime", value=False
+                )
+            if action == "stop":
+                params["force"] = st.checkbox(
+                    "Force stop (interrupts active calls)", value=False
+                )
+            planned = action in _PLANNED_ACTIONS and not params.get("force", False)
+            if planned:
+                st.caption(
+                    "First preview the affected plugins, then apply the operation below. "
+                    "Creating a preview does not change plugin state."
+                )
+            label = "Preview operation" if planned else "Run operation"
+            if st.button(label):
+                if planned:
+                    submit(
+                        provider,
+                        "plan",
+                        {"action": action, "id": identifier},
+                    )
+                else:
+                    submit(provider, action, params)
+            render_operation(provider)
+        with st.form("migration"):
+            migration_owner = st.selectbox("Migration owner", identifiers)
+            plan_id = st.text_input("Reviewed migration plan ID")
+            if st.form_submit_button(
+                "Apply reviewed migration", disabled=not can_migrate
+            ):
+                if plan_id.strip():
+                    submit(
+                        provider,
+                        "migrate-apply",
+                        {"id": migration_owner, "plan_id": plan_id.strip()},
+                    )
+                else:
+                    st.error("Run migrate-plan and review its result first.")
+    if not identifiers:
+        render_operation(provider)
+    render_history(provider, permissions, track_operation, submit)
+
+
+def submit(provider, action, params):
+    try:
+        result = provider.manage(action, params)
+    except PluginError as error:
+        st.error(f"{error.code}: {error}")
+        return
+    if isinstance(result, dict) and result.get("id"):
+        reset_history()
+        track_operation(result["id"])
+    else:
+        st.error(
+            "Core did not return an operation ID. Check operation history before retrying."
+        )
+
+
+def track_operation(operation_id):
+    # A Dashboard replacement clears Session State. The URL survives reconnects
+    # and lets a new worker resume reading the durable core operation journal.
+    st.query_params[_OPERATION_QUERY_KEY] = operation_id
+    st.rerun()
+
+
+def load_operation(provider, operation_id):
+    try:
+        operation = provider.manage("operation", {"id": operation_id})
+    except PluginError as error:
+        st.error(f"{error.code}: {error}")
+        return None
+    if not operation:
+        st.error(f"Operation {operation_id} was not found.")
+    return operation
+
+
+def operation_label(operation):
+    action = (
+        operation.get("request", {}).get("action", "operation")
+        if operation["kind"] == "plan"
+        else operation["kind"]
+    )
+    return f"{action} · {operation.get('target') or 'application'}"
+
+
+@st.fragment(run_every=1)
+def poll_operation(provider, operation_id):
+    operation = load_operation(provider, operation_id)
+    if not operation:
+        return
+    if operation["status"] not in _PENDING:
+        # Rebuild the status table and navigation, and remove this polling
+        # fragment once the operation is terminal.
+        st.rerun()
+    label = operation_label(operation)
+    if operation["kind"] == "plan":
+        st.info(f"Preparing preview: {label}. No changes have been applied.")
+    else:
+        st.info(f"In progress: {label} · {operation.get('phase', operation['status'])}")
+    st.caption(
+        "Status updates automatically. You can also refresh or reconnect to this page."
+    )
+    scope = (
+        "system.migrations.manage"
+        if operation["kind"] in {"migrate-plan", "migrate-apply"}
+        else "system.plugins.manage"
+    )
+    if st.button(
+        "Request cancellation",
+        key=f"pending-cancel-{operation_id}",
+        disabled=scope not in provider.access("presentation")["allowed_scopes"],
+    ):
+        submit(provider, "cancel", {"id": operation_id})
+
+
+def render_operation(provider):
+    operation_id = st.query_params.get(_OPERATION_QUERY_KEY)
+    if not operation_id:
+        return
+    operation = load_operation(provider, operation_id)
+    if not operation:
+        return
+    st.subheader("Operation result")
+    if operation.get("sequence"):
+        st.caption(
+            f"Operation #{operation['sequence']} · {local_timestamp(operation.get('created'))}"
+        )
+    st.caption(f"Operation ID: {operation_id}")
+    status = operation["status"]
+    if status in _PENDING:
+        poll_operation(provider, operation_id)
+        return
+    label = operation_label(operation)
+    if status != "succeeded":
+        error = operation.get("error") or {}
+        code = error.get("code", "operation_failed")
+        message = error.get("message", "The operation did not complete.")
+        st.error(f"{label} · {status} ({code}): {message}")
+        if code == "stale_plan":
+            st.info("Create a new preview to review the current state before applying.")
+    elif operation["kind"] == "plan":
+        render_plan_preview(provider, operation.get("result"))
+    else:
+        st.success(f"Completed: {label}.")
+    with st.expander("Operation details"):
+        st.json(operation)
+
+
+def render_plan_preview(provider, plan):
+    if not isinstance(plan, dict):
+        st.error("Plan operation completed without a reviewable plan.")
+        return
+    basis = plan.get("basis") or {}
+    if (
+        plan.get("action") not in _PLANNED_ACTIONS
+        or not all(plan.get(key) for key in ("target", "plan_id"))
+        or basis.get("revision") is None
+    ):
+        st.error("The completed plan is missing required apply details.")
+        return
+    st.info(
+        f"Preview ready: {plan['action']} · {plan['target']}. "
+        "No changes have been applied."
+    )
+    st.write("Affected plugins", plan.get("affected", []))
+    if "streamlit-dashboard" in plan.get("affected", []):
+        st.caption("The Dashboard may reconnect while this operation is applied.")
+    if plan.get("missing_dependencies"):
+        st.write("Missing dependencies", plan["missing_dependencies"])
+    if plan.get("migrations"):
+        st.write("Migration requirements", plan["migrations"])
+    if st.button(
+        f"Apply {plan['action']}",
+        type="primary",
+        disabled="system.plugins.manage"
+        not in provider.access("presentation")["allowed_scopes"],
+    ):
+        submit(
+            provider,
+            plan["action"],
+            {
+                "id": plan["target"],
+                "plan_id": plan["plan_id"],
+                "expected_revision": basis["revision"],
+            },
+        )

toolframe_streamlit_dashboard/plugin.py

@@ -0,0 +1,189 @@
+from __future__ import annotations
+
+import asyncio
+import inspect
+import threading
+from dataclasses import dataclass
+from pathlib import Path
+
+from toolframe_sdk import (
+    AuthorizationSpec,
+    OwnedResource,
+    PageContext,
+    Plugin,
+    PluginDefinition,
+    PluginError,
+    load_object,
+)
+
+_current = None
+
+
+def current():
+    if _current is None:
+        raise PluginError("dashboard_unavailable", "Dashboard runtime is not active")
+    return _current
+
+
+@dataclass(frozen=True)
+class Page:
+    resource: OwnedResource
+    render: object
+
+
+class DashboardProvider(Plugin):
+    def __init__(self, context):
+        super().__init__(context)
+        self.server = None
+        self.url = None
+        self.loop = None
+        self.snapshot = (None, ())
+        self.staged = {}
+
+    async def activate(self):
+        global _current
+        from streamlit import config
+        from streamlit.web.server import Server
+
+        self.loop = asyncio.get_running_loop()
+        for name, value in {
+            "server.address": "127.0.0.1",
+            "server.port": 0,
+            "server.headless": True,
+            "server.fileWatcherType": "none",
+            "server.runOnSave": False,
+            "server.enableStaticServing": False,
+            "browser.gatherUsageStats": False,
+            "client.toolbarMode": "viewer",
+        }.items():
+            config.set_option(name, value)
+        _current = self
+        self.server = Server(str(Path(__file__).with_name("app.py")), is_hello=False)
+        await self.server.start()
+        self.url = f"http://127.0.0.1:{config.get_option('server.port')}"
+
+    async def health(self):
+        return {
+            "runtime": "ready",
+            "business": "not_provided",
+            "http_url": self.url,
+            "epoch": self.snapshot[0],
+            "pages": [page.resource.key for page in self.snapshot[1]],
+        }
+
+    async def dispose(self):
+        global _current
+        if self.server:
+            self.server.stop()
+            async with asyncio.timeout(8):
+                await self.server.stopped
+            threads = [
+                thread
+                for thread in threading.enumerate()
+                if thread.name.startswith("ScriptRunner.scriptThread")
+            ]
+            for thread in threads:
+                await asyncio.to_thread(thread.join, 1)
+            if any(thread.is_alive() for thread in threads):
+                raise PluginError(
+                    "cleanup_failed", "A Streamlit script thread has not exited"
+                )
+        if _current is self:
+            _current = None
+        await super().dispose()
+
+    async def prepare(self, resources, epoch):
+        pages, seen = [], set()
+        for resource in resources:
+            if resource.resource.kind != "dashboard.page":
+                raise PluginError(
+                    "unsupported_resource",
+                    "Dashboard accepts whole-page resources only",
+                )
+            if resource.key in seen:
+                raise PluginError("duplicate_resource", resource.key)
+            seen.add(resource.key)
+            render = load_object(resource.resource.data["entrypoint"])
+            if not callable(render) or inspect.iscoroutinefunction(render):
+                raise PluginError(
+                    "invalid_page",
+                    "Page render(context) must be a synchronous callable",
+                )
+            pages.append(Page(resource, render))
+        self.staged[epoch] = tuple(
+            sorted(
+                pages,
+                key=lambda page: (
+                    page.resource.resource.data.get("order", 0),
+                    page.resource.key,
+                ),
+            )
+        )
+        return {"epoch": epoch}
+
+    async def commit(self, epoch):
+        if epoch not in self.staged:
+            raise PluginError("unknown_epoch", "No prepared page cohort for this epoch")
+        self.snapshot = (epoch, self.staged.pop(epoch))
+        return {"epoch": epoch}
+
+    async def abort(self, epoch):
+        self.staged.pop(epoch, None)
+        return {"epoch": epoch}
+
+    def render_page(self, page, epoch):
+        access = self.access("presentation")
+        if not set(page.resource.resource.required_scopes) <= set(
+            access["allowed_scopes"]
+        ):
+            raise PluginError("forbidden", "This page requires additional scopes")
+        page.render(
+            PageContext(
+                self.context,
+                page.resource,
+                epoch,
+                self.loop,
+                access_context=self.access_context(),
+                access=access,
+            )
+        )
+
+    def access_context(self):
+        import streamlit as st
+
+        reference = st.context.headers.get("X-Toolframe-Context")
+        if not reference:
+            raise PluginError(
+                "authentication_required",
+                "Open the Dashboard through the Toolframe application URL",
+            )
+        return reference
+
+    def access(self, action, params=None):
+        return asyncio.run_coroutine_threadsafe(
+            self.context.access(action, params, access_context=self.access_context()),
+            self.loop,
+        ).result(timeout=30)
+
+    def manage(self, action, params=None):
+        future = asyncio.run_coroutine_threadsafe(
+            self.context.manage(action, params, access_context=self.access_context()),
+            self.loop,
+        )
+        try:
+            return future.result(timeout=30)
+        except TimeoutError:
+            future.cancel()
+            raise PluginError(
+                "management_timeout",
+                "Management request timed out; inspect operation history before retrying",
+            ) from None
+
+
+plugin = PluginDefinition(
+    id="streamlit-dashboard",
+    kind="provider",
+    provider_kind="dashboard",
+    factory="toolframe_streamlit_dashboard.plugin:DashboardProvider",
+    authorization=AuthorizationSpec(),
+)

toolframe_streamlit_dashboard-0.4.2.dist-info/METADATA

@@ -0,0 +1,135 @@
+Metadata-Version: 2.5
+Name: toolframe-streamlit-dashboard
+Version: 0.4.2
+Summary: Native Streamlit page and management provider for Toolframe
+Project-URL: Homepage, https://github.com/toolframe/toolframe-streamlit-dashboard
+Project-URL: Repository, https://github.com/toolframe/toolframe-streamlit-dashboard
+Project-URL: Documentation, https://github.com/toolframe/toolframe-streamlit-dashboard#readme
+Project-URL: Issues, https://github.com/toolframe/toolframe-streamlit-dashboard/issues
+Author-email: byfb <62798989+byfb@users.noreply.github.com>
+License-Expression: Apache-2.0
+License-File: LICENSE
+License-File: NOTICE
+Requires-Python: >=3.14
+Requires-Dist: streamlit==1.61.0
+Requires-Dist: toolframe-sdk<0.4,>=0.2
+Requires-Dist: uvicorn==0.42.0
+Description-Content-Type: text/markdown
+
+# Toolframe Streamlit Dashboard
+
+This provider runs one native Streamlit process for the shared UI environment.
+Business plugins contribute synchronous `render(context)` pages; navigation and
+plugin management are provided here. Pages use the SDK's synchronous
+`context.services.require(name, version=1).call(method, params)` proxy.
+The Streamlit toolbar uses viewer mode, hiding its Deploy and developer controls.
+Its native running indicator shows a circular spinner instead of cycling sports
+icons. The Running label, Stop button and connection indicators remain available;
+reduced-motion preferences disable the rotation. The narrowly scoped styling
+targets Streamlit 1.61's busy-widget test ID and should be checked on upgrades.
+Plugin lifecycle operations remain available on the Toolframe management page.
+
+## Install
+
+Install the provider into a running [Toolframe application](https://github.com/toolframe/toolframe-core#readme):
+
+```sh
+toolframe --home APP plugin add pypi:toolframe-streamlit-dashboard==0.4.2 --enable
+```
+
+Core resolves dependencies and manages the provider's isolated Python environment.
+The Entry Register template already includes this provider.
+
+Core resolves the provider and all contributing plugin wheels (with their `ui`
+extras) together before replacing the worker. Changing any page package replaces
+the whole Dashboard. Browser sessions reconnect and session state may reset;
+business services and their persisted data remain independently owned.
+
+The provider binds an ephemeral private loopback port and reports it to core.
+Core owns the stable `/` gateway, management credentials and HTTP/WebSocket
+admission. Streamlit owns its server lifespan and script threads. A stuck script
+thread is a cleanup failure, never a successful in-process code reload.
+
+SDK 0.2 page contexts carry a host-issued reference for each browser connection.
+Pages use `context.can(scope)` to adapt controls; core checks every service call.
+Navigation filters page scopes and the plugin-management page requires
+`system.plugins.read`. Its mutation controls require the relevant management
+scopes. A password without system grants cannot reach these operations through
+the bridge. Incoming browser identity headers are not trusted.
+
+The shared header displays local control, protected access or public access with
+its reason. It remains present when the separate Dashboard Auth plugin is
+unavailable. Its one-second refresh is presentation polling and does not count
+as password activity. Use `activity=False` for other background service polling.
+
+`prepare` imports and validates page entry points without rendering them. A
+catalog epoch becomes visible only on `commit`; `abort` preserves live navigation.
+The management page submits operations to core and reads their journal; it does
+not install packages or access SQLite itself.
+
+For enable, reload, disable, stop and remove, choose **Preview operation**, review
+the affected plugins, then choose **Apply enable/reload/disable/stop/remove**.
+A preview does not change plugin state. Only stop offers the separate force-stop
+option; temporary runtime validation is offered only for validate.
+
+Pending operations update automatically. Completion or errors appear beside the
+controls, and the operation ID stays in the page URL so a browser refresh or
+Dashboard replacement can resume reading its result. Operation history can reopen
+a preview or result. Disabled plugins remain in the management list for re-enabling;
+their pages and tools disappear after the disable operation completes.
+Disabled plugins default to **enable** and do not offer reload/disable/stop.
+Enable restores the installed version; update stages a freshly resolved package.
+
+With core 0.5.0+, **Operations** queries the complete core journal with plugin,
+action and result filters. It defaults to 10 rows, with 25/50 options and
+Newer/Older navigation. Each row has a permanent operation number, browser-local
+creation time, action, target and result. Preview rows include the intended action
+(for example, `plan enable`). Viewing a result uses its durable UUID.
+The refresh button aligns with the bottom of the page-size selector, at the right
+edge. Newer and Older sit at opposite edges of one pagination row.
+
+Page navigation retains a sequence boundary so new arrivals do not shift older
+pages. **Refresh history**, changing filters or submitting an operation starts
+at the latest first page. The count indicates newer arrivals; statuses remain
+current. Read-only operators can filter, page and inspect results, while apply
+and cancel retain their existing scope checks.
+
+The **Plugin dependencies & impact** accordion sits directly below the status
+table and starts collapsed. It reads core's `dependency_graph` diagnostics
+(core 0.4.0+) under the existing `system.plugins.read` permission. Nodes show
+Cordis lifecycle state and current health; arrows run from consumer to supplier.
+Solid lines are required services, dashed lines optional services, and dotted
+lines presentation providers. Missing suppliers and inactive plugins stay visible.
+
+Select a plugin and **reload** or **disable** to highlight the lifecycle cohort,
+optional consumers, and page/tool/document entries that may reconnect or refresh.
+The cohort comes from core's actual planner. Presentation refreshes do not imply
+that the provider or every page's business process restarts. Use the full-screen
+control to enlarge the graph; the relationship table includes exact service names
+and versions.
+
+This view never installs, validates, submits an operation, or changes composition.
+It describes selected versions; inactive declarations are labeled `last_candidate`.
+New candidates or pending configuration changes can produce a different plan, so
+the existing **Preview operation** / **Apply** workflow remains authoritative.
+Refreshing status refreshes the graph too. An older core shows an upgrade hint.
+
+The graph is generated from core state, including newly installed plugins and
+their declared dependencies. `plugin new` only creates source and does not add a
+node; use `plugin add` to install it. Refresh status after changes made elsewhere.
+This is a refreshed snapshot, not a continuously pushed graph animation.
+
+Development: `uv sync --group dev`, `uv run pytest -q`, `uv build --no-sources`.
+Each lifecycle integration test uses a fresh subprocess because Streamlit's
+runtime singleton belongs to the process, not a reloadable plugin object.
+
+For fresh-environment CI checks, run
+`uv run --isolated --no-project --python 3.14.7 python -I scripts/validate.py`.
+See [CI and package publishing](docs/ci.md) for GitHub Actions, validation artifacts,
+pinned SDK prerequisites and manual TestPyPI/PyPI Trusted Publishing setup.
+
+For release validation and Trusted Publisher setup, see [releasing](docs/releasing.md).
+
+## License
+
+Licensed under the Apache License, Version 2.0. See [LICENSE](LICENSE) and [NOTICE](NOTICE).

toolframe_streamlit_dashboard-0.4.2.dist-info/RECORD

@@ -0,0 +1,13 @@
+toolframe_streamlit_dashboard/__init__.py,sha256=12jBy8V_p4pHLF1RtX3izR4SkKcztUzqiWZ7ebLn_ww,69
+toolframe_streamlit_dashboard/app.py,sha256=JlpqV1qye8DmCOIl20FVRyZX-dAYqqsfmbtWm6431Vc,2337
+toolframe_streamlit_dashboard/chrome.css,sha256=Z-7cueLlVKnoNJlPeVwDUc0yjrXD43vZTZ_iW3-Gu8A,710
+toolframe_streamlit_dashboard/dependencies.py,sha256=AqIvtGio6C_7O-d_Gd65FKXOvpAJByiuThp-8fB2bWk,8393
+toolframe_streamlit_dashboard/history.py,sha256=thyGPrTFigk3Ar-eo5YjEm6V6hNgdJXYF7ZVTd8hdJc,4920
+toolframe_streamlit_dashboard/management.py,sha256=OpBbDnctgs7pNqGzoqQwpAyh9lJc1RqDshxfDOMilFI,10591
+toolframe_streamlit_dashboard/plugin.py,sha256=WY7T17WY-Ky1_-e4HB9n3BzRvdoAOf9ptU65Go4Yal0,5994
+toolframe_streamlit_dashboard-0.4.2.dist-info/METADATA,sha256=YrVJz2XuMm8CSCJa7usOiHKQO-HUKsc4QWXGuaPmtBU,7734
+toolframe_streamlit_dashboard-0.4.2.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+toolframe_streamlit_dashboard-0.4.2.dist-info/entry_points.txt,sha256=I2Op8k_iCBIo4pzm4AeR3XkMolldFUrQ8GKnLT1LcyI,86
+toolframe_streamlit_dashboard-0.4.2.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+toolframe_streamlit_dashboard-0.4.2.dist-info/licenses/NOTICE,sha256=RQbS1vFz4MGxjzdtE8PMh_nZdq8IUEnUd-77y59Ivvo,50
+toolframe_streamlit_dashboard-0.4.2.dist-info/RECORD,,

toolframe_streamlit_dashboard-0.4.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

toolframe_streamlit_dashboard-0.4.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[toolframe.plugins]
+streamlit-dashboard = toolframe_streamlit_dashboard.plugin:plugin

toolframe_streamlit_dashboard-0.4.2.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

toolframe_streamlit_dashboard-0.4.2.dist-info/licenses/NOTICE

@@ -0,0 +1,2 @@
+toolframe-streamlit-dashboard
+Copyright 2026 byfb