@nexus-ai-fs/tui 0.9.18

package/src/panels/access/permission-checker.tsx

@@ -0,0 +1,231 @@
+/**
+ * Permission checker form: evaluate a tool permission against a manifest.
+ *
+ * Uses the server-side evaluation trace (proof tree) from the backend
+ * evaluate endpoint. Shows which manifest entries were checked, which
+ * one matched (first-match-wins), and the final decision.
+ *
+ * Tab cycles between fields.
+ * Enter evaluates using the store's checkPermission().
+ * Escape cancels and returns to normal mode.
+ */
+
+import React, { useState, useCallback } from "react";
+import { useAccessStore } from "../../stores/access-store.js";
+import type { PermissionCheck, GovernanceCheckResult } from "../../stores/access-store.js";
+import { useKeyboard } from "../../shared/hooks/use-keyboard.js";
+import { useApi } from "../../shared/hooks/use-api.js";
+
+type ActiveField = "manifestId" | "toolName" | "fromAgentId" | "toAgentId";
+
+interface PermissionCheckerProps {
+  readonly initialManifestId: string;
+  readonly lastResult: PermissionCheck | null;
+  readonly loading: boolean;
+  readonly governanceCheck: GovernanceCheckResult | null;
+  readonly governanceCheckLoading: boolean;
+  readonly zoneId: string | undefined;
+  readonly onClose: () => void;
+}
+
+export function PermissionChecker({
+  initialManifestId,
+  lastResult,
+  loading,
+  governanceCheck,
+  governanceCheckLoading,
+  zoneId,
+  onClose,
+}: PermissionCheckerProps): React.ReactNode {
+  const client = useApi();
+  const checkPermission = useAccessStore((s) => s.checkPermission);
+  const checkGovernanceEdge = useAccessStore((s) => s.checkGovernanceEdge);
+  const manifests = useAccessStore((s) => s.manifests);
+
+  const [manifestId, setManifestId] = useState(initialManifestId);
+  const [toolName, setToolName] = useState("");
+  const [fromAgentId, setFromAgentId] = useState("");
+  const [toAgentId, setToAgentId] = useState("");
+  const [activeField, setActiveField] = useState<ActiveField>("toolName");
+
+  const FIELD_ORDER: readonly ActiveField[] = ["manifestId", "toolName", "fromAgentId", "toAgentId"];
+
+  const setters: Readonly<Record<ActiveField, (fn: (b: string) => string) => void>> = {
+    manifestId: (fn) => setManifestId((b) => fn(b)),
+    toolName: (fn) => setToolName((b) => fn(b)),
+    fromAgentId: (fn) => setFromAgentId((b) => fn(b)),
+    toAgentId: (fn) => setToAgentId((b) => fn(b)),
+  };
+
+  const handleSubmit = useCallback(() => {
+    if (!client) return;
+    // Manifest permission check (requires both fields)
+    if (manifestId.trim() && toolName.trim()) {
+      checkPermission(manifestId.trim(), toolName.trim(), client);
+    }
+    // Governance edge check (requires both agent IDs)
+    if (fromAgentId.trim() && toAgentId.trim()) {
+      checkGovernanceEdge(fromAgentId.trim(), toAgentId.trim(), zoneId, client);
+    }
+  }, [client, manifestId, toolName, fromAgentId, toAgentId, zoneId, checkPermission, checkGovernanceEdge]);
+
+  const handleUnhandledKey = useCallback(
+    (keyName: string) => {
+      const setter = setters[activeField];
+      if (keyName.length === 1) {
+        setter((b) => b + keyName);
+      } else if (keyName === "space") {
+        setter((b) => b + " ");
+      }
+    },
+    [activeField],
+  );
+
+  useKeyboard(
+    {
+      return: handleSubmit,
+      escape: onClose,
+      backspace: () => {
+        setters[activeField]((b) => b.slice(0, -1));
+      },
+      tab: () => {
+        const currentIdx = FIELD_ORDER.indexOf(activeField);
+        const nextIdx = (currentIdx + 1) % FIELD_ORDER.length;
+        const next = FIELD_ORDER[nextIdx];
+        if (next) {
+          setActiveField(next);
+        }
+      },
+    },
+    handleUnhandledKey,
+  );
+
+  const cursor = "\u2588";
+
+  // Look up manifest metadata for display
+  const matchedManifest = lastResult
+    ? manifests.find((m) => m.manifest_id === lastResult.manifest_id)
+    : null;
+
+  // Server-side trace from the evaluate endpoint
+  const trace = lastResult?.trace ?? null;
+
+  const fields: readonly { readonly key: ActiveField; readonly label: string; readonly value: string; readonly hint?: string }[] = [
+    { key: "manifestId", label: "Manifest ID  ", value: manifestId },
+    { key: "toolName", label: "Tool Name    ", value: toolName },
+    { key: "fromAgentId", label: "From Agent ID", value: fromAgentId, hint: "governance check" },
+    { key: "toAgentId", label: "To Agent ID  ", value: toAgentId, hint: "governance check" },
+  ];
+
+  return (
+    <box height="100%" width="100%" flexDirection="column">
+      {/* Form fields */}
+      {fields.map((f) => (
+        <box key={f.key} height={1} width="100%">
+          <text>
+            {activeField === f.key
+              ? `> ${f.label}: ${f.value}${cursor}${f.hint ? `  (${f.hint})` : ""}`
+              : `  ${f.label}: ${f.value}${f.hint && !f.value ? `  (${f.hint})` : ""}`}
+          </text>
+        </box>
+      ))}
+
+      {/* Loading indicator */}
+      {(loading || governanceCheckLoading) && (
+        <box height={1} width="100%">
+          <text>Evaluating...</text>
+        </box>
+      )}
+
+      {/* Structured result display — server-side proof tree */}
+      {lastResult && !loading && (
+        <box flexGrow={1} width="100%" flexDirection="column">
+          {/* Decision banner */}
+          <box height={1} width="100%">
+            <text>
+              {lastResult.permission === "allow"
+                ? `[ALLOW] ${lastResult.tool_name} -> agent=${lastResult.agent_id}`
+                : `[DENY]  ${lastResult.tool_name} -> agent=${lastResult.agent_id}`}
+            </text>
+          </box>
+
+          {/* Server-side evaluation trace (proof tree) */}
+          {trace && trace.entries.length > 0 && (
+            <>
+              <box height={1} width="100%">
+                <text>{"--- Evaluation Trace (server-side, first-match-wins) ---"}</text>
+              </box>
+              {trace.entries.map((entry) => {
+                const prefix = entry.matched && entry.index === trace.matched_index ? ">> " : "   ";
+                const matchLabel = entry.matched ? (entry.index === trace.matched_index ? "MATCH" : "match") : "     ";
+                const rateStr = entry.max_calls_per_minute
+                  ? `  rate=${entry.max_calls_per_minute}/min`
+                  : "";
+                return (
+                  <box key={`trace-${entry.index}`} height={1} width="100%">
+                    <text>
+                      {`${prefix}[${matchLabel}] ${entry.tool_pattern.padEnd(30)} ${entry.permission.padEnd(6)}${rateStr}`}
+                    </text>
+                  </box>
+                );
+              })}
+            </>
+          )}
+
+          {/* Default deny notice */}
+          {trace?.default_applied && (
+            <box height={1} width="100%">
+              <text>{"No entry matched -> default DENY applied"}</text>
+            </box>
+          )}
+
+          {/* Matched entry summary */}
+          {trace && trace.matched_index >= 0 && trace.entries[trace.matched_index] && (
+            <box height={1} width="100%">
+              <text>
+                {`Deciding entry #${trace.matched_index}: pattern="${trace.entries[trace.matched_index]!.tool_pattern}" permission=${trace.entries[trace.matched_index]!.permission}`}
+              </text>
+            </box>
+          )}
+
+          {/* Manifest metadata */}
+          {matchedManifest && (
+            <box height={1} width="100%">
+              <text>
+                {`Manifest: ${matchedManifest.name}  status=${matchedManifest.status}  zone=${matchedManifest.zone_id}`}
+              </text>
+            </box>
+          )}
+        </box>
+      )}
+
+      {/* Governance edge check result */}
+      {governanceCheck && !governanceCheckLoading && (
+        <box flexDirection="column" width="100%">
+          <box height={1} width="100%">
+            <text>{"--- Governance Edge Check ---"}</text>
+          </box>
+          <box height={1} width="100%">
+            <text>
+              {governanceCheck.allowed
+                ? `[ALLOWED] ${governanceCheck.reason}`
+                : `[BLOCKED] ${governanceCheck.reason}`}
+            </text>
+          </box>
+          {governanceCheck.constraint_type && (
+            <box height={1} width="100%">
+              <text>{`  Constraint: ${governanceCheck.constraint_type}  edge=${governanceCheck.edge_id}`}</text>
+            </box>
+          )}
+        </box>
+      )}
+
+      {/* Help */}
+      <box height={1} width="100%">
+        <text>
+          {"Tab:cycle fields  Enter:evaluate  Escape:cancel  Backspace:delete"}
+        </text>
+      </box>
+    </box>
+  );
+}

package/src/panels/agents/agent-status-view.tsx

@@ -0,0 +1,196 @@
+/**
+ * Agent status detail view: phase badge, conditions, resource usage, identity.
+ */
+
+import React from "react";
+import type { AgentStatus, AgentSpec, AgentIdentity, AgentPhase } from "../../stores/agents-store.js";
+import { LoadingIndicator } from "../../shared/components/loading-indicator.js";
+
+interface AgentStatusViewProps {
+  readonly status: AgentStatus | null;
+  readonly spec: AgentSpec | null;
+  readonly identity: AgentIdentity | null;
+  readonly loading: boolean;
+  readonly trustScore?: number | null;
+  readonly reputation?: unknown | null;
+}
+
+const PHASE_BADGES: Readonly<Record<AgentPhase, string>> = {
+  warming: "[WRM]",
+  ready: "[RDY]",
+  active: "[ACT]",
+  thinking: "[THK]",
+  idle: "[IDL]",
+  suspended: "[SUS]",
+  evicted: "[EVT]",
+};
+
+function formatTimestamp(ts: string | null): string {
+  if (!ts) return "n/a";
+  try {
+    return new Date(ts).toLocaleString();
+  } catch {
+    return ts;
+  }
+}
+
+function renderUsageBar(pct: number, width: number): string {
+  const filled = Math.round((pct / 100) * width);
+  const empty = width - filled;
+  return `[${"#".repeat(filled)}${"-".repeat(empty)}] ${pct.toFixed(0)}%`;
+}
+
+export function AgentStatusView({
+  status,
+  spec,
+  identity,
+  loading,
+  trustScore,
+  reputation,
+}: AgentStatusViewProps): React.ReactNode {
+  if (loading) {
+    return <LoadingIndicator message="Loading agent status..." />;
+  }
+
+  if (!status) {
+    return (
+      <box height="100%" width="100%" justifyContent="center" alignItems="center">
+        <text>Select an agent to view status</text>
+      </box>
+    );
+  }
+
+  const badge = PHASE_BADGES[status.phase] ?? `[${status.phase.toUpperCase()}]`;
+
+  return (
+    <scrollbox height="100%" width="100%">
+      {/* Phase and generation */}
+      <box height={1} width="100%">
+        <text>{`Phase: ${badge} ${status.phase}  |  Generation: ${status.observed_generation}`}</text>
+      </box>
+
+      {/* Timestamps */}
+      <box height={1} width="100%">
+        <text>{`Last heartbeat: ${formatTimestamp(status.last_heartbeat)}`}</text>
+      </box>
+      <box height={1} width="100%">
+        <text>{`Last activity:  ${formatTimestamp(status.last_activity)}`}</text>
+      </box>
+
+      {/* Inbox and context */}
+      <box height={1} width="100%">
+        <text>{`Inbox depth: ${status.inbox_depth}  |  Context usage: ${status.context_usage_pct}%`}</text>
+      </box>
+
+      {/* Resource usage */}
+      <box height={1} width="100%" marginTop={1}>
+        <text>--- Resource Usage ---</text>
+      </box>
+      <box height={1} width="100%">
+        <text>{`Tokens used:    ${status.resource_usage.tokens_used}`}</text>
+      </box>
+      <box height={1} width="100%">
+        <text>{`Storage:        ${status.resource_usage.storage_used_mb} MB`}</text>
+      </box>
+      <box height={1} width="100%">
+        <text>{`Context:        ${renderUsageBar(status.resource_usage.context_usage_pct, 20)}`}</text>
+      </box>
+
+      {/* Conditions */}
+      {status.conditions.length > 0 && (
+        <>
+          <box height={1} width="100%" marginTop={1}>
+            <text>--- Conditions ---</text>
+          </box>
+          {status.conditions.map((cond, i) => (
+            <box key={`cond-${i}`} height={1} width="100%">
+              <text>{`[${cond.status}] ${cond.type}: ${cond.reason} - ${cond.message}`}</text>
+            </box>
+          ))}
+        </>
+      )}
+
+      {/* Spec info */}
+      {spec && (
+        <>
+          <box height={1} width="100%" marginTop={1}>
+            <text>--- Spec ---</text>
+          </box>
+          <box height={1} width="100%">
+            <text>{`Type: ${spec.agent_type}  |  QoS: ${spec.qos_class}  |  Gen: ${spec.spec_generation}`}</text>
+          </box>
+          {spec.zone_affinity && (
+            <box height={1} width="100%">
+              <text>{`Zone affinity: ${spec.zone_affinity}`}</text>
+            </box>
+          )}
+          {spec.capabilities.length > 0 && (
+            <box height={1} width="100%">
+              <text>{`Capabilities: ${spec.capabilities.join(", ")}`}</text>
+            </box>
+          )}
+        </>
+      )}
+
+      {/* Identity */}
+      {identity && (
+        <>
+          <box height={1} width="100%" marginTop={1}>
+            <text>--- Identity ---</text>
+          </box>
+          <box height={1} width="100%">
+            <text>{`DID: ${identity.did}`}</text>
+          </box>
+          <box height={1} width="100%">
+            <text>{`Key ID: ${identity.key_id}`}</text>
+          </box>
+          <box height={1} width="100%">
+            <text>{`Algorithm: ${identity.algorithm}`}</text>
+          </box>
+          <box height={1} width="100%">
+            <text>{`Public key: ${truncateHex(identity.public_key_hex)}`}</text>
+          </box>
+          {identity.created_at && (
+            <box height={1} width="100%">
+              <text>{`Created: ${formatTimestamp(identity.created_at)}`}</text>
+            </box>
+          )}
+          {identity.expires_at && (
+            <box height={1} width="100%">
+              <text>{`Expires: ${formatTimestamp(identity.expires_at)}`}</text>
+            </box>
+          )}
+        </>
+      )}
+
+      {/* Trust Score */}
+      {trustScore != null && (
+        <>
+          <box height={1} width="100%" marginTop={1}>
+            <text>--- Trust ---</text>
+          </box>
+          <box height={1} width="100%">
+            <text>{`Trust score: ${trustScore.toFixed(2)} ${renderUsageBar(trustScore * 100, 20)}`}</text>
+          </box>
+        </>
+      )}
+
+      {/* Reputation */}
+      {reputation != null && (
+        <>
+          <box height={1} width="100%" marginTop={1}>
+            <text>--- Reputation ---</text>
+          </box>
+          <box height={1} width="100%">
+            <text>{`${JSON.stringify(reputation, null, 2)}`}</text>
+          </box>
+        </>
+      )}
+    </scrollbox>
+  );
+}
+
+function truncateHex(hex: string): string {
+  if (hex.length <= 20) return hex;
+  return `${hex.slice(0, 10)}...${hex.slice(-10)}`;
+}