plugin-scanner 2.0.558__tar.gz → 2.0.559__tar.gz

{plugin_scanner-2.0.558 → plugin_scanner-2.0.559}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plugin-scanner
-Version: 2.0.558
+Version: 2.0.559
 Summary: Lint, verify, and gate plugin ecosystems for maintainers, CI, and publish workflows.
 Project-URL: Homepage, https://github.com/hashgraph-online/hol-guard
 Project-URL: Repository, https://github.com/hashgraph-online/hol-guard

plugin_scanner-2.0.559/dashboard/src/scsr-phase09d-intercept-drawer.test.ts

@@ -0,0 +1,80 @@
+import {
+  parseInterceptProofSnapshot,
+  parsePackageFirewallActionResult,
+} from "./supply-chain-firewall-action-result";
+
+function assert(condition: boolean, message: string): void {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+
+const provedPayload = {
+  operation: "test",
+  status: "completed",
+  result: "completed",
+  result_detail: {
+    intercept_proved: true,
+    tested_managers: ["npm"],
+    path_repair_required: [],
+    manager_results: [
+      {
+        manager: "npm",
+        intercept_ran: true,
+        evaluator_invoked: true,
+      },
+    ],
+  },
+  receipt: {
+    id: "receipt-test-1",
+    operation: "test",
+    status: "completed",
+    timestamp: "2026-06-09T16:00:00.000Z",
+  },
+};
+
+const failedPayload = {
+  operation: "test",
+  status: "completed",
+  result_detail: {
+    intercept_proved: false,
+    tested_managers: ["npm"],
+    path_repair_required: ["npm"],
+    manager_results: [
+      {
+        manager: "npm",
+        intercept_ran: false,
+        skipped_reason: "path_inactive",
+      },
+    ],
+  },
+};
+
+const proved = parseInterceptProofSnapshot(provedPayload);
+assert(proved !== null, "SCSR157: intercept proof snapshot parses from test response");
+assert(proved!.interceptProved, "SCSR157: intercept_proved true surfaces in snapshot");
+assert(proved!.managerResults.length === 1, "SCSR157: manager_results normalize");
+assert(proved!.receiptId === "receipt-test-1", "SCSR157: proof receipt id surfaces");
+assert(proved!.tone === "success", "SCSR157: proved test uses success tone");
+
+const failed = parseInterceptProofSnapshot(failedPayload);
+assert(failed !== null, "SCSR157-B: failed intercept proof still parses");
+assert(!failed!.interceptProved, "SCSR157-B: intercept_proved false preserved");
+assert(
+  failed!.managerResults[0]?.skippedReason === "path_inactive",
+  "SCSR157-B: skipped reason preserved",
+);
+assert(
+  failed!.pathRepairRequired.includes("npm"),
+  "SCSR157-B: path repair managers preserved",
+);
+
+const parsedResult = parsePackageFirewallActionResult("test", failedPayload);
+assert(parsedResult !== null, "SCSR157-C: action result parser handles intercept proof");
+assert(parsedResult!.tone === "warning", "SCSR157-C: failed intercept proof warns in inline result");
+assert(
+  parsedResult!.lines.some((line) => line.includes("path inactive")),
+  "SCSR157-C: skipped reason appears in inline lines",
+);
+
+console.log("scsr-phase09d-intercept-drawer.test.ts: all assertions passed");

plugin_scanner-2.0.559/dashboard/src/supply-chain-firewall-action-result.ts

@@ -0,0 +1,268 @@
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function readString(value: unknown): string | null {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+function readStringArray(value: unknown): string[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value
+    .filter((entry): entry is string => typeof entry === "string" && entry.trim().length > 0)
+    .map((entry) => entry.trim());
+}
+
+export type PackageFirewallActionResultDetail = {
+  emptyState: boolean;
+  lines: string[];
+  summary: string;
+  tone: "success" | "warning" | "neutral";
+};
+
+function parseAuditActionResult(result: Record<string, unknown>): PackageFirewallActionResultDetail {
+  const evaluation = isRecord(result.evaluation) ? result.evaluation : null;
+  const decision = readString(evaluation?.decision) ?? readString(result.decision) ?? "monitor";
+  const manifestPaths = readStringArray(result.manifest_paths);
+  const lockfilePaths = readStringArray(result.lockfile_paths);
+  const inventory = isRecord(result.inventory) ? result.inventory : null;
+  const packageCount = typeof inventory?.packages === "number" ? inventory.packages : null;
+  const lockfileWarnings = Array.isArray(result.lockfile_warnings)
+    ? result.lockfile_warnings.filter(isRecord)
+    : [];
+
+  const lines: string[] = [];
+  if (manifestPaths.length > 0) {
+    lines.push(`Manifests scanned: ${manifestPaths.join(", ")}.`);
+  }
+  if (lockfilePaths.length > 0) {
+    lines.push(`Lockfiles scanned: ${lockfilePaths.join(", ")}.`);
+  }
+  if (packageCount !== null) {
+    lines.push(`${packageCount} dependency ${packageCount === 1 ? "entry" : "entries"} indexed.`);
+  }
+  for (const warning of lockfileWarnings.slice(0, 3)) {
+    const message = readString(warning.message);
+    if (message !== null) {
+      lines.push(message);
+    }
+  }
+
+  const emptyState = manifestPaths.length === 0 && lockfilePaths.length === 0;
+  if (emptyState) {
+    lines.push("No workspace manifests or lockfiles were found for this audit scope.");
+  }
+
+  return {
+    emptyState,
+    lines,
+    summary: `Workspace audit completed with ${decision} decision.`,
+    tone: decision === "block" || decision === "ask" ? "warning" : "success",
+  };
+}
+
+function parseSyncActionResult(result: Record<string, unknown>): PackageFirewallActionResultDetail {
+  const syncedAt =
+    readString(result.synced_at) ??
+    readString(result.generated_at) ??
+    readString(result.updated_at);
+  const receiptsStored = typeof result.receipts_stored === "number" ? result.receipts_stored : null;
+  const bundleVersion = readString(result.bundle_version);
+  const tier = readString(result.tier);
+
+  const lines: string[] = [];
+  if (syncedAt !== null) {
+    lines.push(`Cloud sync marker: ${syncedAt}.`);
+  }
+  if (receiptsStored !== null) {
+    lines.push(`${receiptsStored} receipt${receiptsStored === 1 ? "" : "s"} stored locally.`);
+  }
+  if (bundleVersion !== null) {
+    lines.push(`Advisory bundle ${bundleVersion}${tier ? ` (${tier})` : ""} is now active.`);
+  }
+
+  return {
+    emptyState: lines.length === 0,
+    lines,
+    summary: syncedAt
+      ? "Cloud intel sync completed. Feed freshness should update on the next status refresh."
+      : "Cloud intel sync completed.",
+    tone: "success",
+  };
+}
+
+function parseTestActionResult(result: Record<string, unknown>): PackageFirewallActionResultDetail {
+  const interceptProved = result.intercept_proved === true;
+  const testedManagers = readStringArray(result.tested_managers);
+  const pathRepairRequired = readStringArray(result.path_repair_required);
+  const managerResults = Array.isArray(result.manager_results)
+    ? result.manager_results.filter(isRecord)
+    : [];
+
+  const lines: string[] = [];
+  for (const entry of managerResults) {
+    const manager = readString(entry.manager) ?? "manager";
+    if (entry.intercept_ran === true) {
+      lines.push(
+        `${manager}: intercept probe ran${
+          entry.evaluator_invoked === true ? " with evaluator proof" : ""
+        }.`,
+      );
+      continue;
+    }
+    const skippedReason = readString(entry.skipped_reason);
+    if (skippedReason !== null) {
+      lines.push(`${manager}: skipped (${skippedReason.replaceAll("_", " ")}).`);
+      continue;
+    }
+    lines.push(`${manager}: no intercept proof recorded.`);
+  }
+
+  if (pathRepairRequired.length > 0) {
+    lines.push(`PATH repair still required for ${pathRepairRequired.join(", ")}.`);
+  }
+
+  if (lines.length === 0 && testedManagers.length > 0) {
+    lines.push(`Tested ${testedManagers.join(", ")}.`);
+  }
+  if (lines.length === 0) {
+    lines.push("Intercept test completed.");
+  }
+
+  return {
+    emptyState: false,
+    lines,
+    summary: interceptProved
+      ? "Intercept test proved Guard blocked the package manager call."
+      : "Intercept test finished without full proof. Review manager details below.",
+    tone: interceptProved ? "success" : "warning",
+  };
+}
+
+export function parsePackageFirewallActionResult(
+  op: string,
+  body: unknown,
+): PackageFirewallActionResultDetail | null {
+  if (!isRecord(body)) {
+    return null;
+  }
+  let result: Record<string, unknown>;
+  if (isRecord(body.result)) {
+    result = body.result;
+  } else if (isRecord(body.result_detail)) {
+    result = body.result_detail;
+  } else {
+    result = body;
+  }
+  if (!isRecord(result)) {
+    return null;
+  }
+
+  if (op === "audit") {
+    return parseAuditActionResult(result);
+  }
+  if (op === "sync") {
+    return parseSyncActionResult(result);
+  }
+  if (op === "test") {
+    return parseTestActionResult(result);
+  }
+  return null;
+}
+
+function readActionResultRecord(body: unknown): Record<string, unknown> | null {
+  if (!isRecord(body)) {
+    return null;
+  }
+  if (isRecord(body.result_detail)) {
+    return body.result_detail;
+  }
+  if (isRecord(body.result)) {
+    return body.result;
+  }
+  return body;
+}
+
+export type InterceptProofManagerResult = {
+  manager: string;
+  interceptRan: boolean;
+  evaluatorInvoked: boolean;
+  skippedReason: string | null;
+  detail: string;
+};
+
+export type InterceptProofSnapshot = {
+  interceptProved: boolean;
+  testedManagers: string[];
+  pathRepairRequired: string[];
+  managerResults: InterceptProofManagerResult[];
+  receiptId: string | null;
+  timestamp: string | null;
+  summary: string;
+  tone: "success" | "warning";
+};
+
+function buildInterceptProofManagerResult(entry: Record<string, unknown>): InterceptProofManagerResult {
+  const manager = readString(entry.manager) ?? "manager";
+  const interceptRan = entry.intercept_ran === true;
+  const evaluatorInvoked = entry.evaluator_invoked === true;
+  const skippedReason = readString(entry.skipped_reason);
+  let detail = `${manager}: no intercept proof recorded.`;
+  if (interceptRan) {
+    detail = evaluatorInvoked
+      ? `${manager}: intercept probe ran with evaluator proof.`
+      : `${manager}: intercept probe ran.`;
+  } else if (skippedReason !== null) {
+    detail = `${manager}: skipped (${skippedReason.replaceAll("_", " ")}).`;
+  }
+  return {
+    manager,
+    interceptRan,
+    evaluatorInvoked,
+    skippedReason,
+    detail,
+  };
+}
+
+export function parseInterceptProofSnapshot(body: unknown): InterceptProofSnapshot | null {
+  const result = readActionResultRecord(body);
+  if (result === null) {
+    return null;
+  }
+  const managerResultsRaw = Array.isArray(result.manager_results)
+    ? result.manager_results.filter(isRecord)
+    : [];
+  const testedManagers = readStringArray(result.tested_managers);
+  const pathRepairRequired = readStringArray(result.path_repair_required);
+  const interceptProved = result.intercept_proved === true;
+  const managerResults = managerResultsRaw.map(buildInterceptProofManagerResult);
+  const hasProofContext =
+    managerResults.length > 0 || testedManagers.length > 0 || pathRepairRequired.length > 0;
+  if (!hasProofContext && result.intercept_proved === undefined) {
+    return null;
+  }
+
+  const receipt = isRecord(body) && isRecord(body.receipt) ? body.receipt : null;
+  const receiptId = receipt !== null ? readString(receipt.id) : null;
+  const timestamp = receipt !== null ? readString(receipt.timestamp) : null;
+  const summary = interceptProved
+    ? "Intercept test proved Guard blocked the package manager call."
+    : "Intercept test finished without full proof. Review manager details below.";
+
+  return {
+    interceptProved,
+    testedManagers,
+    pathRepairRequired,
+    managerResults,
+    receiptId,
+    timestamp,
+    summary,
+    tone: interceptProved ? "success" : "warning",
+  };
+}

{plugin_scanner-2.0.558 → plugin_scanner-2.0.559}/dashboard/src/supply-chain-firewall-controls.tsx

@@ -105,6 +105,7 @@ export type FirewallControlsViewProps = {
   onDismissResult: () => void;
   onOpenShell: () => void;
   onRefreshStatus: () => void;
+  onOpenManagerDetails: (manager: string) => void;
 };
 
 export function FirewallControlsView({
@@ -131,6 +132,7 @@ export function FirewallControlsView({
   onDismissResult,
   onOpenShell,
   onRefreshStatus,
+  onOpenManagerDetails,
 }: FirewallControlsViewProps) {
   const anyPending = pendingOp !== null;
   const nextAction = useMemo(() => resolvePackageFirewallNextAction(data), [data]);
@@ -318,6 +320,7 @@ export function FirewallControlsView({
                   onRemoveRequest={onRemoveRequest}
                   onRemoveConfirm={onRemoveConfirm}
                   onRemoveCancel={onRemoveCancel}
+                  onOpenDetails={onOpenManagerDetails}
                 />
               );
             })}

{plugin_scanner-2.0.558 → plugin_scanner-2.0.559}/dashboard/src/supply-chain-firewall-manager-row.tsx

@@ -60,6 +60,7 @@ type ManagerRowProps = {
   onRemoveRequest: (manager: string) => void;
   onRemoveConfirm: (manager: string) => void;
   onRemoveCancel: () => void;
+  onOpenDetails: (manager: string) => void;
 };
 
 export function ManagerRow({
@@ -75,6 +76,7 @@ export function ManagerRow({
   onRemoveRequest,
   onRemoveConfirm,
   onRemoveCancel,
+  onOpenDetails,
 }: ManagerRowProps) {
   const status = resolveShimStatus(shim);
   const installState = actions.install ?? "disabled";
@@ -99,6 +101,7 @@ export function ManagerRow({
   const handleTest = useCallback(() => onTest(manager), [onTest, manager]);
   const handleRemoveRequest = useCallback(() => onRemoveRequest(manager), [onRemoveRequest, manager]);
   const handleRemoveConfirm = useCallback(() => onRemoveConfirm(manager), [onRemoveConfirm, manager]);
+  const handleOpenDetails = useCallback(() => onOpenDetails(manager), [onOpenDetails, manager]);
 
   return (
     <div className="border-b border-slate-100 last:border-b-0" role="row">
@@ -112,7 +115,14 @@ export function ManagerRow({
             ) : (
               <HiMiniExclamationTriangle className="h-4 w-4 shrink-0 text-brand-attention" aria-hidden="true" />
             )}
-            <span className="truncate font-mono text-sm font-semibold text-brand-dark">{manager}</span>
+            <button
+              type="button"
+              onClick={handleOpenDetails}
+              className="truncate text-left font-mono text-sm font-semibold text-brand-dark hover:text-brand-blue focus:outline-none focus:ring-2 focus:ring-brand-blue/30 rounded"
+              aria-label={`Open ${manager} manager details`}
+            >
+              {manager}
+            </button>
             {shim?.detected && <Tag tone="green">Detected</Tag>}
             {isMine && (
               <HiMiniArrowPath

{plugin_scanner-2.0.558 → plugin_scanner-2.0.559}/dashboard/src/supply-chain-firewall-panel.tsx

@@ -26,6 +26,9 @@ import {
   type FirewallStatusFilter,
 } from "./supply-chain-firewall-controls";
 import { useResolvedApprovalGate } from "./use-resolved-approval-gate";
+import { parseInterceptProofSnapshot, type InterceptProofSnapshot } from "./supply-chain-firewall-action-result";
+import { InterceptProofModal } from "./supply-chain-intercept-proof-modal";
+import { SupplyChainManagerDrawer } from "./supply-chain-manager-drawer";
 
 type PanelLoadState =
   | { phase: "loading" }
@@ -132,6 +135,8 @@ export function PackageFirewallPanel(props: {
   const [pendingApprovalOp, setPendingApprovalOp] = useState<ApprovalOp | null>(null);
   const [statusFilter, setStatusFilter] = useState<StatusFilter>("all");
   const [managerFilter, setManagerFilter] = useState("");
+  const [interceptProof, setInterceptProof] = useState<InterceptProofSnapshot | null>(null);
+  const [managerDrawerTarget, setManagerDrawerTarget] = useState<string | null>(null);
   const { resolvedApprovalGate, resolveApprovalGate } = useResolvedApprovalGate(approvalGate);
 
   const load = useCallback(async () => {
@@ -188,6 +193,13 @@ export function PackageFirewallPanel(props: {
       try {
         const response = await runPackageFirewallAction(op, manager, credentials);
         setLastCompleted({ op, manager, response });
+        if (op === "test") {
+          const proof = parseInterceptProofSnapshot(response);
+          if (proof !== null) {
+            setManagerDrawerTarget(null);
+            setInterceptProof(proof);
+          }
+        }
         await refreshAfterOp();
         await onStateChanged?.();
       } catch (err) {
@@ -324,6 +336,23 @@ export function PackageFirewallPanel(props: {
     setManagerFilter(e.target.value);
   }, []);
 
+  const handleOpenManagerDetails = useCallback((manager: string) => {
+    setManagerDrawerTarget(manager);
+  }, []);
+
+  const handleCloseManagerDrawer = useCallback(() => {
+    setManagerDrawerTarget(null);
+  }, []);
+
+  const handleCloseInterceptProof = useCallback(() => {
+    setInterceptProof(null);
+  }, []);
+
+  const managerDrawerShim =
+    panelLoad.phase === "loaded" && managerDrawerTarget !== null
+      ? panelLoad.data.package_shims.find((entry) => entry.manager === managerDrawerTarget)
+      : undefined;
+
   const anyPending = pendingOp !== null;
   return (
     <div className="rounded-2xl border border-slate-100 bg-white shadow-sm">
@@ -379,6 +408,7 @@ export function PackageFirewallPanel(props: {
             onDismissResult={handleDismissResult}
             onOpenShell={handleOpenShell}
             onRefreshStatus={handleRetry}
+            onOpenManagerDetails={handleOpenManagerDetails}
             openingShell={openingShell}
             activationAssistError={activationAssistError}
           />
@@ -395,6 +425,27 @@ export function PackageFirewallPanel(props: {
           onConfirm={handleApprovalConfirm}
         />
       )}
+
+      {panelLoad.phase === "loaded" && managerDrawerTarget !== null && (
+        <SupplyChainManagerDrawer
+          manager={managerDrawerTarget}
+          shim={managerDrawerShim}
+          actions={panelLoad.data.actions}
+          anyPending={anyPending}
+          isMine={pendingOp?.manager === managerDrawerTarget}
+          actionHandlers={{
+            install: handleInstall,
+            repair: handleRepair,
+            test: handleTest,
+            removeRequest: handleRemoveRequest,
+          }}
+          onClose={handleCloseManagerDrawer}
+        />
+      )}
+
+      {interceptProof !== null && (
+        <InterceptProofModal proof={interceptProof} onClose={handleCloseInterceptProof} />
+      )}
     </div>
   );
 }

plugin_scanner-2.0.559/dashboard/src/supply-chain-intercept-proof-modal.tsx

@@ -0,0 +1,129 @@
+import {
+  HiMiniCheckCircle,
+  HiMiniExclamationTriangle,
+  HiMiniXMark,
+} from "react-icons/hi2";
+import { ActionButton, Tag } from "./approval-center-primitives";
+import { formatRelativeTime } from "./approval-center-utils";
+import type { InterceptProofSnapshot } from "./supply-chain-firewall-action-result";
+
+type InterceptProofModalProps = {
+  proof: InterceptProofSnapshot;
+  onClose: () => void;
+};
+
+function ManagerProofRow({
+  manager,
+  detail,
+  interceptRan,
+}: {
+  manager: string;
+  detail: string;
+  interceptRan: boolean;
+}) {
+  return (
+    <div className="rounded-xl border border-slate-100 bg-slate-50/80 px-3 py-2.5">
+      <div className="flex flex-wrap items-center gap-2">
+        <span className="font-mono text-sm font-semibold text-brand-dark">{manager}</span>
+        <Tag tone={interceptRan ? "green" : "attention"}>
+          {interceptRan ? "Proof recorded" : "Needs attention"}
+        </Tag>
+      </div>
+      <p className="mt-1.5 text-xs leading-relaxed text-slate-600">{detail}</p>
+    </div>
+  );
+}
+
+export function InterceptProofModal({ proof, onClose }: InterceptProofModalProps) {
+  const toneClass = proof.interceptProved
+    ? "border-brand-green/20 bg-brand-green/[0.04]"
+    : "border-brand-attention/20 bg-brand-attention/[0.04]";
+  const Icon = proof.interceptProved ? HiMiniCheckCircle : HiMiniExclamationTriangle;
+  const iconClass = proof.interceptProved ? "text-brand-green" : "text-brand-attention";
+
+  return (
+    <div
+      role="dialog"
+      aria-label="Intercept proof details"
+      aria-modal="true"
+      className="fixed inset-0 z-50 flex items-end sm:items-center justify-center p-4"
+      data-testid="intercept-proof-modal"
+    >
+      <div className="absolute inset-0 bg-black/30 backdrop-blur-sm" onClick={onClose} aria-hidden="true" />
+      <div className="relative flex max-h-[85vh] w-full max-w-lg flex-col overflow-hidden rounded-2xl bg-white shadow-2xl">
+        <div className="flex items-start justify-between gap-3 border-b border-slate-100 px-5 py-4">
+          <div>
+            <p className="text-base font-semibold text-brand-dark">Intercept proof</p>
+            <p className="mt-1 text-sm text-slate-500">
+              Guard ran a controlled package-manager call to verify shim interception.
+            </p>
+          </div>
+          <button
+            type="button"
+            onClick={onClose}
+            aria-label="Close intercept proof modal"
+            className="flex h-8 w-8 shrink-0 items-center justify-center rounded-full text-slate-400 hover:bg-slate-100 hover:text-slate-600"
+          >
+            <HiMiniXMark className="h-5 w-5" aria-hidden="true" />
+          </button>
+        </div>
+
+        <div className="space-y-4 overflow-y-auto px-5 py-4">
+          <div className={`rounded-xl border px-4 py-3 ${toneClass}`}>
+            <div className="flex items-start gap-2.5">
+              <Icon className={`mt-0.5 h-4 w-4 shrink-0 ${iconClass}`} aria-hidden="true" />
+              <div>
+                <p className="text-sm font-medium text-brand-dark">{proof.summary}</p>
+                {proof.timestamp !== null && (
+                  <p className="mt-1 text-xs text-slate-500">
+                    Recorded {formatRelativeTime(proof.timestamp)}
+                  </p>
+                )}
+              </div>
+            </div>
+          </div>
+
+          {proof.managerResults.length > 0 ? (
+            <div className="space-y-2">
+              <p className="text-[11px] font-semibold uppercase tracking-[0.16em] text-slate-400">
+                Manager results
+              </p>
+              {proof.managerResults.map((entry) => (
+                <ManagerProofRow
+                  key={entry.manager}
+                  manager={entry.manager}
+                  detail={entry.detail}
+                  interceptRan={entry.interceptRan}
+                />
+              ))}
+            </div>
+          ) : null}
+
+          {proof.pathRepairRequired.length > 0 ? (
+            <div className="rounded-xl border border-amber-200 bg-amber-50/70 px-3 py-2.5">
+              <p className="text-xs font-medium text-amber-950">PATH repair still required</p>
+              <p className="mt-1 text-xs text-amber-900/90">
+                {proof.pathRepairRequired.join(", ")} need repair before intercept proof can complete.
+              </p>
+            </div>
+          ) : null}
+
+          {proof.receiptId !== null ? (
+            <div className="rounded-xl border border-slate-100 bg-slate-50 px-3 py-2.5">
+              <p className="text-[10px] font-semibold uppercase tracking-[0.18em] text-slate-400">
+                Proof receipt
+              </p>
+              <p className="mt-1 break-all font-mono text-xs text-brand-dark">{proof.receiptId}</p>
+            </div>
+          ) : null}
+        </div>
+
+        <div className="border-t border-slate-100 px-5 py-4">
+          <ActionButton variant="primary" onClick={onClose}>
+            Done
+          </ActionButton>
+        </div>
+      </div>
+    </div>
+  );
+}