plugin-scanner 2.0.369__tar.gz → 2.0.370__tar.gz

{plugin_scanner-2.0.369 → plugin_scanner-2.0.370}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plugin-scanner
-Version: 2.0.369
+Version: 2.0.370
 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.369 → plugin_scanner-2.0.370}/dashboard/src/guard-api.ts

@@ -13,6 +13,15 @@ import type {
   GuardApprovalPage,
   GuardApprovalPageFilters,
   GuardApprovalPageStatus,
+  PackageFirewallActionResponse,
+  PackageFirewallActionState,
+  PackageFirewallActionType,
+  PackageFirewallCliFallback,
+  PackageFirewallEntitlement,
+  PackageFirewallGlobalActionType,
+  PackageFirewallReceipt,
+  PackageShimEntry,
+  PackageFirewallStatusResponse,
   GuardApprovalRequest,
   GuardArtifactDiff,
   GuardDecisionV2,
@@ -1444,6 +1453,204 @@ export async function loadAuditPage(): Promise<AuditPageData> {
   return { snapshot, receipts };
 }
 
+function stringValue(value: unknown): string | null {
+  return typeof value === "string" && value.trim() ? value : null;
+}
+
+function booleanValue(value: unknown): boolean {
+  return value === true;
+}
+
+function numberValue(value: unknown): number | null {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+
+function normalizePackageFirewallEntitlement(value: unknown): PackageFirewallEntitlement {
+  const record = isRecord(value) ? value : {};
+  return {
+    allowed: booleanValue(record.allowed),
+    reason: stringValue(record.reason) ?? "unknown",
+    tier: stringValue(record.tier) ?? "free",
+    upgrade_cta: stringValue(record.upgrade_cta),
+    upgrade_url: stringValue(record.upgrade_url),
+  };
+}
+
+function normalizePackageFirewallReceipt(value: unknown): PackageFirewallReceipt | null {
+  if (!isRecord(value)) {
+    return null;
+  }
+  const id = stringValue(value.id);
+  const operation = stringValue(value.operation);
+  const status = stringValue(value.status);
+  const timestamp = stringValue(value.timestamp);
+  if (id === null || operation === null || status === null || timestamp === null) {
+    return null;
+  }
+  return { id, operation, status, timestamp };
+}
+
+function normalizePackageFirewallActions(
+  value: unknown,
+): PackageFirewallStatusResponse["actions"] {
+  if (!isRecord(value)) {
+    return {};
+  }
+  const allowedStates = new Set(["available", "paid_required", "pending", "disabled"]);
+  const entries = Object.entries(value).filter(
+    (entry): entry is [PackageFirewallActionType | PackageFirewallGlobalActionType, PackageFirewallActionState] =>
+      typeof entry[1] === "string" && allowedStates.has(entry[1]),
+  );
+  return Object.fromEntries(entries);
+}
+
+function normalizePackageFirewallCliFallback(value: unknown): PackageFirewallCliFallback | null {
+  if (!isRecord(value)) {
+    return null;
+  }
+  const fallback: PackageFirewallCliFallback = {};
+  const install = stringValue(value.install);
+  const status = stringValue(value.status);
+  const remove = stringValue(value.remove);
+  if (install !== null) {
+    fallback.install = install;
+  }
+  if (status !== null) {
+    fallback.status = status;
+  }
+  if (remove !== null) {
+    fallback.remove = remove;
+  }
+  return Object.keys(fallback).length > 0 ? fallback : null;
+}
+
+function normalizePackageShimEntry(manager: string, detail: Record<string, unknown> | null): PackageShimEntry {
+  return {
+    active: booleanValue(detail?.path_active),
+    installed: detail !== null && stringValue(detail.integrity) !== "missing",
+    integrity: stringValue(detail?.integrity) ?? "uninstalled",
+    manager,
+    path_index: numberValue(detail?.path_index),
+    real_binary_found: booleanValue(detail?.real_binary_found),
+    real_binary_path: stringValue(detail?.real_binary_path),
+    real_binary_path_index: numberValue(detail?.real_binary_path_index),
+    shim_path: stringValue(detail?.shim_path),
+  };
+}
+
+function normalizePackageShimEntries(value: unknown, supportedManagers: string[]): PackageShimEntry[] {
+  const status = isRecord(value) ? value : {};
+  const detailRows = Array.isArray(status.manager_details)
+    ? status.manager_details.filter(isRecord)
+    : [];
+  const detailByManager = new Map<string, Record<string, unknown>>();
+  for (const detail of detailRows) {
+    const manager = stringValue(detail.manager);
+    if (manager !== null) {
+      detailByManager.set(manager, detail);
+    }
+  }
+  const managers = new Set([
+    ...supportedManagers,
+    ...normalizeStringArray(status.installed_managers),
+    ...normalizeStringArray(status.active_managers),
+    ...detailByManager.keys(),
+  ]);
+  return Array.from(managers)
+    .sort()
+    .map((manager) => normalizePackageShimEntry(manager, detailByManager.get(manager) ?? null));
+}
+
+function actionResultSummary(operation: string, detail: Record<string, unknown>): string {
+  const countKeys = ["installed_now_count", "repaired_count"];
+  for (const key of countKeys) {
+    const count = numberValue(detail[key]);
+    if (count !== null) {
+      return `${operation} completed for ${count} manager${count === 1 ? "" : "s"}.`;
+    }
+  }
+  const tested = normalizeStringArray(detail.tested_managers);
+  if (tested.length > 0) {
+    return `Test completed for ${tested.join(", ")}.`;
+  }
+  return `${operation} completed.`;
+}
+
+function normalizePackageFirewallStatus(value: unknown): PackageFirewallStatusResponse {
+  const record = isRecord(value) ? value : {};
+  const supportedManagers = normalizeStringArray(record.supported_managers);
+  return {
+    actions: normalizePackageFirewallActions(record.actions),
+    cli_fallback: normalizePackageFirewallCliFallback(record.cli_fallback),
+    entitlement: normalizePackageFirewallEntitlement(record.entitlement),
+    operation: stringValue(record.operation) ?? "status",
+    package_shims: normalizePackageShimEntries(record.package_shims, supportedManagers),
+    status: stringValue(record.status) ?? "unknown",
+    supported_managers: supportedManagers,
+  };
+}
+
+function normalizePackageFirewallAction(value: unknown): PackageFirewallActionResponse {
+  const record = isRecord(value) ? value : {};
+  const result = isRecord(record.result) ? record.result : {};
+  const operation = stringValue(record.operation) ?? "unknown";
+  return {
+    entitlement: normalizePackageFirewallEntitlement(record.entitlement),
+    operation,
+    receipt: normalizePackageFirewallReceipt(record.receipt),
+    result: typeof record.result === "string" ? record.result : actionResultSummary(operation, result),
+    result_detail: result,
+    status: stringValue(record.status) ?? "unknown",
+  };
+}
+
+export async function fetchPackageFirewallStatus(): Promise<PackageFirewallStatusResponse> {
+  return normalizePackageFirewallStatus(await readJson<unknown>("/v1/supply-chain/package-shims"));
+}
+
+export async function runPackageFirewallAction(
+  action: PackageFirewallActionType,
+  manager: string | null,
+): Promise<PackageFirewallActionResponse> {
+  const payload = manager !== null ? { managers: [manager] } : {};
+  const response = await readJson<unknown>(
+    `/v1/supply-chain/package-shims/${action}`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...guardAuthHeaders(),
+      },
+      body: JSON.stringify(payload),
+    },
+  );
+  return normalizePackageFirewallAction(response);
+}
+
+export async function runPackageAudit(): Promise<PackageFirewallActionResponse> {
+  const response = await readJson<unknown>("/v1/supply-chain/audit", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...guardAuthHeaders(),
+    },
+    body: JSON.stringify({}),
+  });
+  return normalizePackageFirewallAction(response);
+}
+
+export async function runPackageSync(): Promise<PackageFirewallActionResponse> {
+  const response = await readJson<unknown>("/v1/supply-chain/sync", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...guardAuthHeaders(),
+    },
+    body: JSON.stringify({}),
+  });
+  return normalizePackageFirewallAction(response);
+}
+
 export type EvidencePageData = {
   receipts: GuardReceipt[];
 };

{plugin_scanner-2.0.369 → plugin_scanner-2.0.370}/dashboard/src/guard-types.ts

@@ -506,3 +506,62 @@ export type GuardSettingsExport = {
   privacy_warning: string;
   settings: GuardSettings;
 };
+
+export const PACKAGE_FIREWALL_ACTION_TYPES = ["install", "repair", "test", "remove"] as const;
+export type PackageFirewallActionType = (typeof PACKAGE_FIREWALL_ACTION_TYPES)[number];
+export const PACKAGE_FIREWALL_GLOBAL_ACTION_TYPES = ["audit", "sync"] as const;
+export type PackageFirewallGlobalActionType = (typeof PACKAGE_FIREWALL_GLOBAL_ACTION_TYPES)[number];
+
+export type PackageFirewallActionState = "available" | "paid_required" | "pending" | "disabled";
+
+export type PackageFirewallEntitlement = {
+  allowed: boolean;
+  reason: string;
+  tier: string;
+  upgrade_cta: string | null;
+  upgrade_url: string | null;
+};
+
+export type PackageShimEntry = {
+  active: boolean;
+  installed: boolean;
+  integrity: string;
+  manager: string;
+  path_index: number | null;
+  real_binary_found: boolean;
+  real_binary_path: string | null;
+  real_binary_path_index: number | null;
+  shim_path: string | null;
+};
+
+export type PackageFirewallReceipt = {
+  id: string;
+  operation: string;
+  status: string;
+  timestamp: string;
+};
+
+export type PackageFirewallCliFallback = {
+  install?: string;
+  status?: string;
+  remove?: string;
+};
+
+export type PackageFirewallStatusResponse = {
+  operation: string;
+  status: string;
+  supported_managers: string[];
+  package_shims: PackageShimEntry[];
+  entitlement: PackageFirewallEntitlement;
+  actions: Partial<Record<PackageFirewallActionType | PackageFirewallGlobalActionType, PackageFirewallActionState>>;
+  cli_fallback: PackageFirewallCliFallback | null;
+};
+
+export type PackageFirewallActionResponse = {
+  operation: string;
+  status: string;
+  result: string;
+  result_detail: Record<string, unknown>;
+  receipt: PackageFirewallReceipt | null;
+  entitlement: PackageFirewallEntitlement;
+};

plugin_scanner-2.0.370/dashboard/src/supply-chain-firewall-panel.tsx

@@ -0,0 +1,398 @@
+import { useState, useEffect, useCallback } from "react";
+import {
+  HiMiniArrowPath,
+  HiMiniBugAnt,
+  HiMiniExclamationTriangle,
+} from "react-icons/hi2";
+import { SectionLabel, ActionButton, EmptyState } from "./approval-center-primitives";
+import type {
+  PackageFirewallStatusResponse,
+  PackageFirewallActionType,
+} from "./guard-types";
+import {
+  fetchPackageFirewallStatus,
+  runPackageFirewallAction,
+  runPackageAudit,
+  runPackageSync,
+} from "./guard-api";
+import { FreeUserView, ActionResultPanel } from "./supply-chain-firewall-views";
+import type { CompletedOp } from "./supply-chain-firewall-views";
+import { ManagerActionCard } from "./supply-chain-manager-card";
+
+type PanelLoadState =
+  | { phase: "loading" }
+  | { phase: "error"; message: string }
+  | { phase: "loaded"; data: PackageFirewallStatusResponse };
+
+type OpKey = PackageFirewallActionType | "audit" | "sync";
+
+type PendingOp = {
+  op: OpKey;
+  manager: string | null;
+};
+
+type FailedOp = {
+  op: OpKey;
+  manager: string | null;
+  message: string;
+};
+
+type LoadingRowProps = { width: string };
+
+function LoadingRow({ width }: LoadingRowProps) {
+  return (
+    <div className={`h-4 animate-pulse rounded-md bg-slate-100 ${width}`} aria-hidden="true" />
+  );
+}
+
+function LoadingSkeleton() {
+  return (
+    <div
+      className="space-y-3 px-4 py-5"
+      aria-label="Loading package firewall status"
+      aria-busy="true"
+    >
+      <LoadingRow width="w-1/3" />
+      <LoadingRow width="w-2/3" />
+      <LoadingRow width="w-1/2" />
+    </div>
+  );
+}
+
+type ErrorBannerProps = {
+  message: string;
+  onRetry: () => void;
+};
+
+function ErrorBanner({ message, onRetry }: ErrorBannerProps) {
+  return (
+    <div className="flex flex-wrap items-center justify-between gap-3 px-4 py-4">
+      <div className="flex items-start gap-2">
+        <HiMiniExclamationTriangle
+          className="mt-0.5 h-4 w-4 shrink-0 text-brand-attention"
+          aria-hidden="true"
+        />
+        <p className="text-sm text-brand-attention">{message}</p>
+      </div>
+      <ActionButton variant="outline" onClick={onRetry}>
+        Retry
+      </ActionButton>
+    </div>
+  );
+}
+
+type GlobalActionsBarProps = {
+  anyPending: boolean;
+  pendingOp: PendingOp | null;
+  onAudit: () => void;
+  onSync: () => void;
+};
+
+function GlobalActionsBar({ anyPending, pendingOp, onAudit, onSync }: GlobalActionsBarProps) {
+  const auditRunning = pendingOp?.op === "audit";
+  const syncRunning = pendingOp?.op === "sync";
+  return (
+    <div className="flex flex-wrap items-center gap-2">
+      <ActionButton
+        variant="outline"
+        onClick={onAudit}
+        disabled={anyPending}
+        aria-busy={auditRunning}
+      >
+        {auditRunning ? (
+          <HiMiniArrowPath className="mr-1.5 h-3.5 w-3.5 animate-spin" aria-hidden="true" />
+        ) : (
+          <HiMiniBugAnt className="mr-1.5 h-3.5 w-3.5" aria-hidden="true" />
+        )}
+        Audit
+      </ActionButton>
+      <ActionButton
+        variant="outline"
+        onClick={onSync}
+        disabled={anyPending}
+        aria-busy={syncRunning}
+      >
+        <HiMiniArrowPath
+          className={`mr-1.5 h-3.5 w-3.5 ${syncRunning ? "animate-spin" : ""}`}
+          aria-hidden="true"
+        />
+        Sync
+      </ActionButton>
+    </div>
+  );
+}
+
+type FailureBannerProps = {
+  failed: FailedOp;
+};
+
+function FailureBanner({ failed }: FailureBannerProps) {
+  return (
+    <div
+      className="flex items-start gap-2 rounded-xl border border-brand-attention/30 bg-brand-attention/[0.04] px-3 py-2.5"
+      role="alert"
+      aria-live="assertive"
+    >
+      <HiMiniExclamationTriangle
+        className="mt-0.5 h-4 w-4 shrink-0 text-brand-attention"
+        aria-hidden="true"
+      />
+      <div className="min-w-0">
+        <p className="text-sm font-medium text-brand-dark">
+          {failed.op} failed{failed.manager !== null ? ` for ${failed.manager}` : ""}
+        </p>
+        <p className="mt-0.5 text-xs text-slate-600">{failed.message}</p>
+      </div>
+    </div>
+  );
+}
+
+type PaidUserViewProps = {
+  data: PackageFirewallStatusResponse;
+  pendingOp: PendingOp | null;
+  lastCompleted: CompletedOp | null;
+  lastFailed: FailedOp | null;
+  confirmRemoveManager: string | null;
+  onInstall: (manager: string) => void;
+  onRepair: (manager: string) => void;
+  onTest: (manager: string) => void;
+  onRemoveRequest: (manager: string) => void;
+  onRemoveConfirm: (manager: string) => void;
+  onRemoveCancel: () => void;
+  onAudit: () => void;
+  onSync: () => void;
+  onDismissResult: () => void;
+};
+
+function PaidUserView({
+  data,
+  pendingOp,
+  lastCompleted,
+  lastFailed,
+  confirmRemoveManager,
+  onInstall,
+  onRepair,
+  onTest,
+  onRemoveRequest,
+  onRemoveConfirm,
+  onRemoveCancel,
+  onAudit,
+  onSync,
+  onDismissResult,
+}: PaidUserViewProps) {
+  const anyPending = pendingOp !== null;
+  return (
+    <div className="space-y-4 px-4 py-4">
+      <div className="flex flex-wrap items-center justify-between gap-2">
+        <SectionLabel>Package manager actions</SectionLabel>
+        <GlobalActionsBar
+          anyPending={anyPending}
+          pendingOp={pendingOp}
+          onAudit={onAudit}
+          onSync={onSync}
+        />
+      </div>
+
+      {lastFailed !== null && <FailureBanner failed={lastFailed} />}
+
+      {lastCompleted !== null && (
+        <ActionResultPanel completed={lastCompleted} onDismiss={onDismissResult} />
+      )}
+
+      {data.package_shims.length === 0 ? (
+        <EmptyState
+          title="No package managers detected"
+          body="Guard has not detected any package managers on this machine."
+          tone="teach"
+        />
+      ) : (
+        <div className="grid gap-3 sm:grid-cols-2">
+          {data.package_shims.map((shim) => (
+            <ManagerActionCard
+              key={shim.manager}
+              shim={shim}
+              actions={data.actions}
+              anyPending={anyPending}
+              isMine={pendingOp?.manager === shim.manager}
+              isConfirmingRemove={confirmRemoveManager === shim.manager}
+              onInstall={onInstall}
+              onRepair={onRepair}
+              onTest={onTest}
+              onRemoveRequest={onRemoveRequest}
+              onRemoveConfirm={onRemoveConfirm}
+              onRemoveCancel={onRemoveCancel}
+            />
+          ))}
+        </div>
+      )}
+    </div>
+  );
+}
+
+type RefreshButtonProps = {
+  disabled: boolean;
+  spinning: boolean;
+  onRefresh: () => void;
+};
+
+function RefreshButton({ disabled, spinning, onRefresh }: RefreshButtonProps) {
+  return (
+    <ActionButton
+      variant="ghost"
+      onClick={onRefresh}
+      disabled={disabled}
+      aria-label="Refresh status"
+    >
+      <HiMiniArrowPath
+        className={`h-4 w-4 ${spinning ? "animate-spin" : ""}`}
+        aria-hidden="true"
+      />
+    </ActionButton>
+  );
+}
+
+export function PackageFirewallPanel() {
+  const [panelLoad, setPanelLoad] = useState<PanelLoadState>({ phase: "loading" });
+  const [pendingOp, setPendingOp] = useState<PendingOp | null>(null);
+  const [lastCompleted, setLastCompleted] = useState<CompletedOp | null>(null);
+  const [lastFailed, setLastFailed] = useState<FailedOp | null>(null);
+  const [confirmRemoveManager, setConfirmRemoveManager] = useState<string | null>(null);
+
+  const load = useCallback(async () => {
+    setPanelLoad({ phase: "loading" });
+    try {
+      const data = await fetchPackageFirewallStatus();
+      setPanelLoad({ phase: "loaded", data });
+    } catch (err) {
+      const message =
+        err instanceof Error ? err.message : "Failed to load package firewall status.";
+      setPanelLoad({ phase: "error", message });
+    }
+  }, []);
+
+  useEffect(() => {
+    void load();
+  }, [load]);
+
+  const refreshAfterOp = useCallback(async () => {
+    try {
+      const data = await fetchPackageFirewallStatus();
+      setPanelLoad({ phase: "loaded", data });
+    } catch (err) {
+      const message =
+        err instanceof Error ? err.message : "Failed to refresh package firewall status.";
+      setPanelLoad({ phase: "error", message });
+    }
+  }, []);
+
+  const handleAction = useCallback(
+    async (op: PackageFirewallActionType, manager: string | null) => {
+      setPendingOp({ op, manager });
+      setLastFailed(null);
+      try {
+        const response = await runPackageFirewallAction(op, manager);
+        setLastCompleted({ op, manager, response });
+        await refreshAfterOp();
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Action failed.";
+        setLastFailed({ op, manager, message });
+      } finally {
+        setPendingOp(null);
+      }
+    },
+    [refreshAfterOp],
+  );
+
+  const handleGlobalOp = useCallback(
+    async (op: "audit" | "sync") => {
+      setPendingOp({ op, manager: null });
+      setLastFailed(null);
+      try {
+        const response = op === "audit" ? await runPackageAudit() : await runPackageSync();
+        setLastCompleted({ op, manager: null, response });
+        await refreshAfterOp();
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Operation failed.";
+        setLastFailed({ op, manager: null, message });
+      } finally {
+        setPendingOp(null);
+      }
+    },
+    [refreshAfterOp],
+  );
+
+  const handleInstall = useCallback(
+    (manager: string) => void handleAction("install", manager),
+    [handleAction],
+  );
+  const handleRepair = useCallback(
+    (manager: string) => void handleAction("repair", manager),
+    [handleAction],
+  );
+  const handleTest = useCallback(
+    (manager: string) => void handleAction("test", manager),
+    [handleAction],
+  );
+  const handleRemoveRequest = useCallback(
+    (manager: string) => setConfirmRemoveManager(manager),
+    [],
+  );
+  const handleRemoveConfirm = useCallback(
+    (manager: string) => {
+      setConfirmRemoveManager(null);
+      void handleAction("remove", manager);
+    },
+    [handleAction],
+  );
+  const handleRemoveCancel = useCallback(() => setConfirmRemoveManager(null), []);
+  const handleAudit = useCallback(() => void handleGlobalOp("audit"), [handleGlobalOp]);
+  const handleSync = useCallback(() => void handleGlobalOp("sync"), [handleGlobalOp]);
+  const handleDismissResult = useCallback(() => setLastCompleted(null), []);
+  const handleRetry = useCallback(() => void load(), [load]);
+
+  const anyPending = pendingOp !== null;
+
+  return (
+    <div className="rounded-2xl border border-slate-100 bg-white shadow-sm">
+      <div className="flex flex-wrap items-center justify-between gap-2 border-b border-slate-100 px-4 py-3">
+        <div>
+          <SectionLabel>Package firewall actions</SectionLabel>
+          <p className="mt-0.5 text-sm text-slate-500">
+            Protect, repair, test, or remove package manager shims.
+          </p>
+        </div>
+        {panelLoad.phase === "loaded" && (
+          <RefreshButton disabled={anyPending} spinning={anyPending} onRefresh={handleRetry} />
+        )}
+      </div>
+
+      {panelLoad.phase === "loading" && <LoadingSkeleton />}
+
+      {panelLoad.phase === "error" && (
+        <ErrorBanner message={panelLoad.message} onRetry={handleRetry} />
+      )}
+
+      {panelLoad.phase === "loaded" &&
+        (panelLoad.data.entitlement.allowed ? (
+          <PaidUserView
+            data={panelLoad.data}
+            pendingOp={pendingOp}
+            lastCompleted={lastCompleted}
+            lastFailed={lastFailed}
+            confirmRemoveManager={confirmRemoveManager}
+            onInstall={handleInstall}
+            onRepair={handleRepair}
+            onTest={handleTest}
+            onRemoveRequest={handleRemoveRequest}
+            onRemoveConfirm={handleRemoveConfirm}
+            onRemoveCancel={handleRemoveCancel}
+            onAudit={handleAudit}
+            onSync={handleSync}
+            onDismissResult={handleDismissResult}
+          />
+        ) : (
+          <FreeUserView data={panelLoad.data} />
+        ))}
+    </div>
+  );
+}