Skip to content

Infisical is the open-source platform for securing secrets, certificates, access, and AI Agents.

38.0 KB
Raw Blame
import { ComponentProps, Fragment, ReactNode, useCallback, useEffect, useState } from "react";
import { subject } from "@casl/ability";
import {
  BanIcon,
  BellIcon,
  ChevronDownIcon,
  ClipboardCheckIcon,
  CodeXmlIcon,
  CopyIcon,
  EditIcon,
  EyeIcon,
  EyeOffIcon,
  GitBranchIcon,
  HexagonIcon,
  ImportIcon,
  KeyIcon,
  MessageSquareIcon,
  RefreshCcwIcon,
  RefreshCwIcon,
  TagsIcon
} from "lucide-react";
import { twMerge } from "tailwind-merge";

import { createNotification } from "@app/components/notifications";
import {
  Badge,
  Button,
  Checkbox,
  Dialog,
  DialogContent,
  DialogHeader,
  DialogTitle,
  IconButton,
  Table,
  TableBody,
  TableCell,
  TableHead,
  TableHeader,
  TableRow,
  type TableSortDirection,
  Tooltip,
  TooltipContent,
  TooltipTrigger
} from "@app/components/v3";
import { HIDDEN_SECRET_VALUE } from "@app/const/secrets";
import { ProjectPermissionActions, useProject, useProjectPermission } from "@app/context";
import {
  ProjectPermissionSecretActions,
  ProjectPermissionSub
} from "@app/context/ProjectPermissionContext/types";
import { useToggle } from "@app/hooks";
import { useUpdateSecretV3 } from "@app/hooks/api";
import { PendingAction } from "@app/hooks/api/secretFolders/types";
import { SecretType, SecretV3RawSanitized } from "@app/hooks/api/secrets/types";
import { ProjectEnv } from "@app/hooks/api/types";
import { hasSecretReadValueOrDescribePermission } from "@app/lib/fn/permission";

import { useOverviewTelemetry } from "../../OverviewTelemetry";
import { pendingActionBorderClass, pendingActionRowClass } from "../pendingActionStyles";
import { EnvironmentStatus, ResourceEnvironmentStatusCell } from "../ResourceEnvironmentStatusCell";
import {
  TABLE_BODY_ROW_FILTER_CLASS_NAME,
  TABLE_BODY_ROW_FILTER_DIMMED_CLASS_NAME,
  TABLE_CELL_ACTION_BAR_CLASS_NAME,
  TABLE_CELL_ACTION_BUTTON_CLASS_NAME,
  TABLE_ROW_ACTIVE_FILTER_CLASS_NAME,
  TABLE_ROW_NAME_COLUMN_CLASS_NAME
} from "../tableRowActionStyles";
import type { TableRowActivityChangeHandler, TableRowActivityId } from "../tableRowActivity";
import { EnvironmentSecretAction, SecretEditTableRow } from "./SecretEditTableRow";
import { SecretOverrideRow } from "./SecretOverrideRow";
import SecretRenameForm from "./SecretRenameForm";

type Props = {
  secretKey: string;
  secretPath: string;
  environments: { name: string; slug: string }[];
  isSelected: boolean;
  onToggleSecretSelect: (key: string, isShiftKey: boolean) => void;
  isExpanded: boolean;
  onToggleExpand: (key: string) => void;
  isSecretVisible: boolean;
  onToggleSecretVisible: (key: string) => void;
  getSecretByKey: (slug: string, key: string) => SecretV3RawSanitized | undefined;
  onSecretCreate: (env: string, key: string, value: string, type?: SecretType) => Promise<void>;
  onSecretUpdate: (params: {
    env: string;
    key: string;
    value: string | undefined;
    secretValueHidden: boolean;
    type?: SecretType;
    secretId?: string;
    newSecretName?: string;
    secretComment?: string;
    tags?: { id: string; slug: string }[];
    secretMetadata?: { key: string; value: string; isEncrypted?: boolean }[];
    skipMultilineEncoding?: boolean | null;
    originalValue?: string;
  }) => Promise<void>;
  onSecretDelete: (env: string, key: string, secretId?: string, type?: SecretType) => Promise<void>;
  isImportedSecretPresentInEnv: (env: string, secretName: string) => boolean;
  getImportedSecretByKey: (
    env: string,
    secretName: string
  ) =>
    | {
        secret?: SecretV3RawSanitized;
        secretPath: string;
        environment: string;
        environmentInfo?: ProjectEnv;
      }
    | undefined;
  importedBy?: {
    environment: { name: string; slug: string };
    folders: {
      name: string;
      secrets?: { secretId: string; referencedSecretKey: string; referencedSecretEnv: string }[];
      isImported: boolean;
    }[];
  }[];
  isSingleEnvSecretsVisible?: boolean;
  onBatchRevert?: (env: string, key: string) => void;
  onPendingSave?: (env: string, key: string, pendingChangeId?: string) => Promise<void>;
  isSelectionDisabled?: boolean;
  onCopySecret?: (request: {
    source: { id: string; name: string; path: string; isValueHidden: boolean };
    environmentSlug: string;
  }) => void;
  onAccessInsightsUpgrade: (onGranted: () => void) => void;
  timestampSortField?: "createdAt" | "updatedAt";
  activityId: TableRowActivityId;
  onActivityChange: TableRowActivityChangeHandler;
};

type ExpandedTableSortColumn = "environment";

type ExpandedTableSort = {
  column: ExpandedTableSortColumn;
  direction: Exclude<TableSortDirection, "none">;
};

export const SecretTableRow = ({
  secretKey,
  environments = [],
  secretPath,
  getSecretByKey,
  onSecretUpdate,
  onSecretCreate,
  onSecretDelete,
  isImportedSecretPresentInEnv,
  getImportedSecretByKey,
  onToggleSecretSelect,
  isExpanded,
  onToggleExpand,
  isSecretVisible,
  onToggleSecretVisible,
  isSelected,
  importedBy,
  isSingleEnvSecretsVisible,
  onBatchRevert,
  onPendingSave,
  isSelectionDisabled,
  onCopySecret,
  onAccessInsightsUpgrade,
  timestampSortField,
  activityId,
  onActivityChange
}: Props) => {
  const telemetry = useOverviewTelemetry();
  const totalCols = environments.length + 2; // secret key row + icon
  const [isEditSecretNameOpen, setIsEditSecretNameOpen] = useState(false);
  const [isSingleEnvBaseActive, setIsSingleEnvBaseActive] = useState(false);
  const [isSingleEnvOverrideActive, setIsSingleEnvOverrideActive] = useState(false);
  const [isSecNameCopied, setIsSecNameCopied] = useToggle(false);
  const [creatingOverrideEnvs, setCreatingOverrideEnvs] = useState<Set<string>>(new Set());
  const [expandedTableSort, setExpandedTableSort] = useState<ExpandedTableSort | null>(null);
  const [activeEnvSlugs, setActiveEnvSlugs] = useState<Set<string>>(new Set());
  const [pendingEnvAction, setPendingEnvAction] = useState<{
    slug: string;
    action: EnvironmentSecretAction;
  } | null>(null);
  const clearPendingEnvAction = useCallback(() => setPendingEnvAction(null), []);

  const openEnvironment = (slug: string, action: EnvironmentSecretAction) => {
    setPendingEnvAction({ slug, action });
    if (!isExpanded) onToggleExpand(secretKey);
  };

  const setEnvActive = (slug: string, isActive: boolean) =>
    setActiveEnvSlugs((prev) => {
      if (prev.has(slug) === isActive) return prev;
      const next = new Set(prev);
      if (isActive) next.add(slug);
      else next.delete(slug);
      return next;
    });

  const isSingleEnvView = environments.length === 1;
  const isRowActive = isSingleEnvView
    ? isSingleEnvBaseActive || isSingleEnvOverrideActive
    : isExpanded;
  const { projectId } = useProject();
  const { mutateAsync: updateSecretV3ForRename } = useUpdateSecretV3();

  useEffect(() => {
    onActivityChange(activityId, isRowActive);
  }, [activityId, isRowActive, onActivityChange]);

  useEffect(
    () => () => {
      onActivityChange(activityId, false);
    },
    [activityId, onActivityChange]
  );

  // Pre-compute single-env data
  const singleEnvSlug = isSingleEnvView ? environments[0].slug : "";
  const singleEnvName = isSingleEnvView ? environments[0].name : "";
  const singleEnvSecret = isSingleEnvView ? getSecretByKey(singleEnvSlug, secretKey) : undefined;
  const singleEnvIsCreatable = isSingleEnvView ? !singleEnvSecret : false;
  const singleEnvIsImported = isSingleEnvView
    ? isImportedSecretPresentInEnv(singleEnvSlug, secretKey)
    : false;
  const singleEnvImportedSecret = isSingleEnvView
    ? getImportedSecretByKey(singleEnvSlug, secretKey)
    : undefined;
  const singleEnvPendingAction = isSingleEnvView
    ? (singleEnvSecret as SecretV3RawSanitized & { pendingAction?: PendingAction })?.pendingAction
    : undefined;
  const singleEnvHasOverride = isSingleEnvView ? Boolean(singleEnvSecret?.idOverride) : false;
  const singleEnvIsCreatingOverride = isSingleEnvView
    ? creatingOverrideEnvs.has(singleEnvSlug)
    : false;
  const singleEnvShowOverride = singleEnvHasOverride || singleEnvIsCreatingOverride;

  const handleSecretRename = async (newName: string) => {
    if (!isSingleEnvView || !singleEnvSecret) return;
    try {
      await updateSecretV3ForRename({
        environment: singleEnvSecret.env,
        projectId,
        secretPath,
        secretKey: singleEnvSecret.key,
        type: SecretType.Shared,
        newSecretName: newName
      });
      createNotification({ type: "success", text: "Successfully renamed the secret" });
    } catch {
      createNotification({ type: "error", text: "Error renaming the secret" });
    }
  };

  // Clean up creatingOverrideEnvs once the query refetch confirms the override exists.
  // This prevents the override row from flickering between "creating" and "has override" states.
  useEffect(() => {
    if (creatingOverrideEnvs.size === 0) return;

    const toRemove: string[] = [];
    creatingOverrideEnvs.forEach((slug) => {
      const secret = getSecretByKey(slug, secretKey);
      if (secret?.idOverride) {
        toRemove.push(slug);
      }
    });

    if (toRemove.length > 0) {
      setCreatingOverrideEnvs((prev) => {
        const next = new Set(prev);
        toRemove.forEach((slug) => next.delete(slug));
        return next;
      });
    }
  }, [creatingOverrideEnvs, getSecretByKey, secretKey]);

  const copyTokenToClipboard = () => {
    navigator.clipboard.writeText(secretKey);
    setIsSecNameCopied.on();
  };

  const { permission } = useProjectPermission();

  const getDefaultValue = (
    secret: SecretV3RawSanitized | undefined,
    importedSecret: { secret?: SecretV3RawSanitized } | undefined
  ) => {
    const canEditSecretValue = permission.can(
      ProjectPermissionSecretActions.Edit,
      subject(ProjectPermissionSub.Secrets, {
        environment: secret?.env || "",
        secretPath: secret?.path || "",
        secretName: secret?.key || "",
        secretTags: ["*"]
      })
    );

    if (secret?.secretValueHidden) {
      return canEditSecretValue ? HIDDEN_SECRET_VALUE : "";
    }
    return secret?.value || importedSecret?.secret?.value || "";
  };

  const getExpandedTableSortDirection = (column: ExpandedTableSortColumn): TableSortDirection =>
    expandedTableSort?.column === column ? expandedTableSort.direction : "none";

  const handleExpandedTableSortChange = (
    column: ExpandedTableSortColumn,
    direction: TableSortDirection
  ) => {
    setExpandedTableSort(direction === "none" ? null : { column, direction });
  };

  const getExpandedTableSortIconClassName = (column: ExpandedTableSortColumn) => {
    const direction = getExpandedTableSortDirection(column);

    return twMerge(
      "transition-transform",
      direction === "descending" && "rotate-180",
      direction === "none" && "opacity-30"
    );
  };

  const sortedEnvironments = [...environments];

  const canReadTags = permission.can(ProjectPermissionActions.Read, ProjectPermissionSub.Tags);
  const renderEnvironmentAnnotations = (slug: string) => {
    const secret = getSecretByKey(slug, secretKey);
    if (!secret) return null;
    const canDescribeSecret = hasSecretReadValueOrDescribePermission(
      permission,
      ProjectPermissionSecretActions.DescribeSecret,
      {
        environment: slug,
        secretPath,
        secretName: secretKey,
        secretTags: secret.tags?.map(({ slug: tagSlug }) => tagSlug) ?? []
      }
    );
    const comment =
      canDescribeSecret && !secret.revokedProjectFolderGrant ? secret.comment : undefined;
    const tagSlugs = canReadTags ? (secret.tags?.map(({ slug: tagSlug }) => tagSlug) ?? []) : [];
    const metadataCount = secret.secretMetadata?.length ?? 0;
    const annotations = [
      comment && {
        action: "comment" as const,
        label: "View secret comment",
        icon: <MessageSquareIcon />,
        tooltip: <p className="line-clamp-2 break-words whitespace-pre-wrap">{comment}</p>
      },
      tagSlugs.length > 0 && {
        action: "tags" as const,
        label: "View secret tags",
        icon: <TagsIcon />,
        tooltip: tagSlugs.join(", ")
      },
      secret.reminder && {
        action: "reminder" as const,
        label: "View secret reminder",
        icon: <BellIcon />,
        tooltip: "Rotation reminder"
      },
      metadataCount > 0 && {
        action: "metadata" as const,
        label: "View secret metadata",
        icon: <CodeXmlIcon />,
        tooltip: `${metadataCount} metadata ${metadataCount === 1 ? "entry" : "entries"}`
      }
    ].filter((annotation) => Boolean(annotation)) as {
      action: EnvironmentSecretAction;
      label: string;
      icon: ReactNode;
      tooltip: ReactNode;
    }[];
    if (!annotations.length) return null;

    return (
      <span className="flex shrink-0 items-center gap-0.5">
        {annotations.map(({ action, label, icon, tooltip }) => (
          <Tooltip key={action}>
            <TooltipTrigger asChild>
              <IconButton
                aria-label={label}
                variant="ghost-muted"
                size="2xs"
                onClick={() => openEnvironment(slug, action)}
              >
                {icon}
              </IconButton>
            </TooltipTrigger>
            <TooltipContent className="max-w-72 break-words">{tooltip}</TooltipContent>
          </Tooltip>
        ))}
      </span>
    );
  };

  const getEnvironmentSecretRowProps = (
    slug: string,
    name: string
  ): ComponentProps<typeof SecretEditTableRow> => {
    const secret = getSecretByKey(slug, secretKey);
    const isCreatable = !secret;
    const isImportedSecret = isImportedSecretPresentInEnv(slug, secretKey);
    const importedSecret = getImportedSecretByKey(slug, secretKey);

    return {
      secretPath,
      secretName: secretKey,
      isEmpty: secret ? secret.isEmpty : importedSecret?.secret?.isEmpty,
      secretValueHidden: secret?.secretValueHidden || false,
      defaultValue: getDefaultValue(secret, importedSecret),
      secretId: secret?.id,
      isOverride: Boolean(secret?.idOverride),
      isImportedSecret,
      importedSecret,
      isCreatable,
      onSecretDelete,
      onSecretCreate,
      onSecretUpdate,
      onAddOverride: () => {
        setCreatingOverrideEnvs((prev) => new Set([...prev, slug]));
        if (!isExpanded) onToggleExpand(secretKey);
      },
      environment: slug,
      environmentName: name,
      isRotatedSecret: secret?.isRotatedSecret,
      isHoneyTokenSecret: secret?.isHoneyTokenSecret,
      importedBy,
      isSecretPresent: Boolean(secret),
      comment: secret?.comment,
      tags: secret?.tags,
      secretMetadata: secret?.secretMetadata,
      skipMultilineEncoding: secret?.skipMultilineEncoding,
      reminder: secret?.reminder,
      revokedProjectFolderGrant: secret?.revokedProjectFolderGrant,
      onCopySecret: secret?.id
        ? () =>
            onCopySecret?.({
              source: {
                id: secret.id,
                name: secretKey,
                path: secret.path ?? secretPath,
                isValueHidden: secret.secretValueHidden
              },
              environmentSlug: slug
            })
        : undefined,
      onAccessInsightsUpgrade,
      onExpandedChange: (isActive) => setEnvActive(slug, isActive)
    };
  };

  if (expandedTableSort) {
    sortedEnvironments.sort((a, b) => {
      const comparison = a.name.localeCompare(b.name);
      return expandedTableSort.direction === "ascending" ? comparison : -comparison;
    });
  }

  return (
    <>
      <TableRow
        onClick={isSingleEnvView ? undefined : () => onToggleExpand(secretKey)}
        className={twMerge(
          "group hover:z-10",
          (isSingleEnvView ? isSingleEnvBaseActive || isSelected : isRowActive || isSelected) &&
            TABLE_ROW_ACTIVE_FILTER_CLASS_NAME,
          pendingActionRowClass(singleEnvPendingAction)
        )}
      >
        {(isSingleEnvView || !isExpanded) && (
          <TableCell
            isTopAligned
            className={twMerge(
              "w-10 max-w-10 min-w-10 p-0",
              !isSingleEnvView && "sticky left-0 z-10",
              !singleEnvPendingAction &&
                "bg-container transition-colors duration-75 group-hover:bg-container-hover",
              isSingleEnvView && singleEnvShowOverride && "border-b-border/50",
              isSingleEnvView && "relative",
              pendingActionBorderClass(singleEnvPendingAction)
            )}
          >
            <div className="relative flex h-10 items-center justify-center [&>svg]:size-4">
              <Checkbox
                variant="project"
                id={`checkbox-${secretKey}`}
                isChecked={isSelected}
                onClick={(e) => {
                  e.stopPropagation();
                  onToggleSecretSelect(secretKey, e.shiftKey);
                }}
                className={twMerge(
                  "hidden",
                  !isSelectionDisabled && "group-hover:flex",
                  isSelected && "flex"
                )}
              />
              <KeyIcon
                className={twMerge(
                  "block text-secret",
                  !isSelectionDisabled && "group-hover:!hidden",
                  isSelected && "!hidden"
                )}
              />
              {singleEnvSecret?.isRotatedSecret && isSingleEnvView && (
                <RefreshCwIcon
                  className={twMerge(
                    "absolute right-2 bottom-2 !size-2.5 text-secret-rotation",
                    !isSelectionDisabled && "group-hover:!hidden",
                    isSelected && "!hidden"
                  )}
                />
              )}
              {singleEnvSecret?.isHoneyTokenSecret && isSingleEnvView && (
                <HexagonIcon
                  className={twMerge(
                    "absolute right-2 bottom-2 !size-2.5 text-warning",
                    !isSelectionDisabled && "group-hover:!hidden",
                    isSelected && "!hidden"
                  )}
                />
              )}
            </div>
          </TableCell>
        )}
        {isSingleEnvView ? (
          <SecretEditTableRow
            isSingleEnvView
            isBatchMode
            onBatchRevert={onBatchRevert}
            onPendingSave={onPendingSave}
            isPendingCreate={singleEnvPendingAction === PendingAction.Create}
            isPendingDelete={singleEnvPendingAction === PendingAction.Delete}
            hasPendingChange={Boolean(singleEnvSecret?.isPending)}
            hasPendingValueChange={Boolean(singleEnvSecret?.hasPendingValueChange)}
            pendingKeyName={
              singleEnvSecret?.isPending && singleEnvSecret.key !== secretKey
                ? singleEnvSecret.key
                : undefined
            }
            onSecretRename={handleSecretRename}
            secretPath={secretPath}
            isVisible={isSecretVisible || isSingleEnvSecretsVisible}
            secretName={secretKey}
            isEmpty={
              singleEnvSecret ? singleEnvSecret.isEmpty : singleEnvImportedSecret?.secret?.isEmpty
            }
            secretValueHidden={singleEnvSecret?.secretValueHidden || false}
            defaultValue={getDefaultValue(singleEnvSecret, singleEnvImportedSecret)}
            secretId={singleEnvSecret?.id}
            isOverride={Boolean(singleEnvSecret?.idOverride)}
            isImportedSecret={singleEnvIsImported}
            importedSecret={singleEnvImportedSecret}
            isCreatable={singleEnvIsCreatable}
            onSecretDelete={onSecretDelete}
            onSecretCreate={onSecretCreate}
            onSecretUpdate={onSecretUpdate}
            onAddOverride={() => {
              setCreatingOverrideEnvs((prev) => new Set([...prev, singleEnvSlug]));
            }}
            environment={singleEnvSlug}
            environmentName={singleEnvName}
            isRotatedSecret={singleEnvSecret?.isRotatedSecret}
            isHoneyTokenSecret={singleEnvSecret?.isHoneyTokenSecret}
            importedBy={importedBy}
            isSecretPresent={Boolean(singleEnvSecret)}
            comment={singleEnvSecret?.comment}
            tags={singleEnvSecret?.tags}
            secretMetadata={singleEnvSecret?.secretMetadata}
            skipMultilineEncoding={singleEnvSecret?.skipMultilineEncoding}
            reminder={singleEnvSecret?.reminder}
            revokedProjectFolderGrant={singleEnvSecret?.revokedProjectFolderGrant}
            onCopySecret={
              singleEnvSecret?.id
                ? () =>
                    onCopySecret?.({
                      source: {
                        id: singleEnvSecret.id,
                        name: secretKey,
                        path: singleEnvSecret.path ?? secretPath,
                        isValueHidden: singleEnvSecret.secretValueHidden
                      },
                      environmentSlug: singleEnvSlug
                    })
                : undefined
            }
            onAccessInsightsUpgrade={onAccessInsightsUpgrade}
            onExpandedChange={setIsSingleEnvBaseActive}
            lastEdited={timestampSortField ? singleEnvSecret : undefined}
            timestampField={timestampSortField}
          />
        ) : (
          <TableCell
            isTruncatable={!isExpanded}
            colSpan={isExpanded ? totalCols : undefined}
            className={twMerge(
              "group/cell sticky left-10 z-10 border-r bg-container transition-colors duration-75 group-hover:bg-container-hover",
              isExpanded && "relative left-auto border-r-0 border-b-0 bg-container-hover !p-0"
            )}
          >
            <div
              className={twMerge(
                isExpanded &&
                  "sticky left-0 flex min-h-10 max-w-(--overview-table-width) min-w-(--overview-table-width) items-center bg-container-hover"
              )}
            >
              {isExpanded && (
                <div className="flex w-10 shrink-0 cursor-pointer items-center justify-center [&>svg]:size-4">
                  <ChevronDownIcon />
                </div>
              )}
              <div
                className={twMerge(
                  isExpanded && "relative flex min-h-10 min-w-0 flex-1 items-center px-1 py-1.5"
                )}
              >
                <div className="flex min-w-0 items-center gap-2">
                  <Tooltip delayDuration={1000} skipDelayDuration={0}>
                    <TooltipTrigger asChild>
                      <span
                        className={twMerge(
                          isExpanded ? "break-all whitespace-normal" : "min-w-0 truncate",
                          singleEnvPendingAction === PendingAction.Delete &&
                            "text-danger/75 line-through"
                        )}
                      >
                        {secretKey}
                      </span>
                    </TooltipTrigger>
                    <TooltipContent className="max-w-(--radix-tooltip-content-available-width) break-all whitespace-normal">
                      {secretKey}
                    </TooltipContent>
                  </Tooltip>
                  {!isExpanded &&
                    environments.some(
                      ({ slug }) => getSecretByKey(slug, secretKey)?.revokedProjectFolderGrant
                    ) && (
                      <Badge variant="danger">
                        <BanIcon className="size-3.5" />
                        Secret share revoked
                      </Badge>
                    )}
                </div>
                <div
                  className={twMerge(
                    "absolute z-20",
                    "flex items-center rounded-md border border-border bg-container-hover px-0.5 py-0.5 shadow-md",
                    TABLE_CELL_ACTION_BAR_CLASS_NAME,
                    "top-1/2 right-[3px] -translate-y-1/2"
                  )}
                >
                  <Tooltip>
                    <TooltipTrigger>
                      <IconButton
                        aria-label="Copy secret name"
                        variant="ghost"
                        size="xs"
                        onClick={(e) => {
                          e.preventDefault();
                          e.stopPropagation();
                          copyTokenToClipboard();
                        }}
                        className={TABLE_CELL_ACTION_BUTTON_CLASS_NAME}
                      >
                        {isSecNameCopied ? <ClipboardCheckIcon /> : <CopyIcon />}
                      </IconButton>
                    </TooltipTrigger>
                    <TooltipContent>Copy Secret Name</TooltipContent>
                  </Tooltip>
                  <Tooltip>
                    <TooltipTrigger>
                      <IconButton
                        aria-label="Edit secret name"
                        variant="ghost"
                        size="xs"
                        onClick={(e) => {
                          setIsEditSecretNameOpen(true);
                          e.stopPropagation();
                        }}
                        className={TABLE_CELL_ACTION_BUTTON_CLASS_NAME}
                      >
                        <EditIcon />
                      </IconButton>
                    </TooltipTrigger>
                    <TooltipContent>Edit Secret Name</TooltipContent>
                  </Tooltip>
                </div>
              </div>
            </div>
          </TableCell>
        )}
        {environments.length > 1 &&
          !isExpanded &&
          environments.map(({ slug }, i) => {
            const secret = getSecretByKey(slug, secretKey);

            const isSecretImported = isImportedSecretPresentInEnv(slug, secretKey);

            const isSecretPresent = Boolean(secret);
            const isSecretEmpty = secret?.isEmpty;

            let status: EnvironmentStatus;

            if (isSecretEmpty) {
              status = "empty";
            } else if (isSecretPresent) {
              status = "present";
            } else if (isSecretImported) {
              status = "imported";
            } else {
              status = "missing";
            }

            return (
              <ResourceEnvironmentStatusCell
                key={`sec-overview-${slug}-${i + 1}-value`}
                status={status}
                hasOverride={Boolean(secret?.idOverride)}
                className="group/cell cursor-pointer"
                onClick={(event) => {
                  event.stopPropagation();
                  const target = event.target as HTMLElement;
                  if (!event.currentTarget.contains(target) || target.closest("button")) return;
                  openEnvironment(slug, "value");
                }}
              >
                {renderEnvironmentAnnotations(slug)}
              </ResourceEnvironmentStatusCell>
            );
          })}
      </TableRow>
      {isSingleEnvView && singleEnvShowOverride && (
        <TableRow
          className={twMerge(
            "group bg-gradient-to-r from-override/[0.03] from-[1%] via-override/[0.075] to-override/[0.03] to-[99%]",
            (isSingleEnvOverrideActive || isSelected) && TABLE_ROW_ACTIVE_FILTER_CLASS_NAME
          )}
        >
          <TableCell isTopAligned>
            <div className="flex h-7 items-center">
              <GitBranchIcon className="size-4 text-override-foreground" />
            </div>
          </TableCell>
          <TableCell
            isTopAligned
            className={twMerge(
              "border-r text-override-foreground",
              singleEnvHasOverride && "border-l border-l-override"
            )}
          >
            <div className="flex min-h-7 items-center">{secretKey}</div>
          </TableCell>
          <TableCell isTopAligned className="max-w-0">
            <SecretOverrideRow
              isSingleEnvView
              secretName={secretKey}
              environment={singleEnvSlug}
              secretPath={secretPath}
              isVisible={isSecretVisible || isSingleEnvSecretsVisible}
              isOverrideEmpty={singleEnvSecret?.isOverrideEmpty}
              idOverride={singleEnvSecret?.idOverride}
              valueOverride={singleEnvSecret?.valueOverride}
              isCreatingOverride={singleEnvIsCreatingOverride}
              onCreatingOverrideChange={(value) => {
                setCreatingOverrideEnvs((prev) => {
                  const next = new Set(prev);
                  if (value) {
                    next.add(singleEnvSlug);
                  } else {
                    next.delete(singleEnvSlug);
                  }
                  return next;
                });
              }}
              onSecretCreate={onSecretCreate}
              onSecretUpdate={onSecretUpdate}
              onSecretDelete={onSecretDelete}
              onActiveChange={setIsSingleEnvOverrideActive}
            />
          </TableCell>
        </TableRow>
      )}
      {!isSingleEnvView && (
        <Dialog open={isEditSecretNameOpen} onOpenChange={setIsEditSecretNameOpen}>
          <DialogContent className="max-w-md">
            <DialogHeader>
              <DialogTitle>Edit Secret Name</DialogTitle>
            </DialogHeader>
            <SecretRenameForm
              secretKey={secretKey}
              environments={environments}
              secretPath={secretPath}
              getSecretByKey={getSecretByKey}
            />
          </DialogContent>
        </Dialog>
      )}
      {!isSingleEnvView && isExpanded && (
        <TableRow
          className={twMerge("border-0 hover:bg-transparent", TABLE_ROW_ACTIVE_FILTER_CLASS_NAME)}
        >
          <TableCell colSpan={totalCols} className="border-0 p-0">
            <div className="@container sticky left-0 max-w-(--overview-table-width) min-w-(--overview-table-width) border-y border-border bg-container">
              <Table
                className="w-full min-w-[600px] table-fixed"
                containerClassName="rounded-none border-0 @min-[600px]:overflow-hidden"
              >
                <colgroup>
                  <col className="w-10" />
                  <col className="w-60" />
                  <col />
                  <col className="w-32" />
                </colgroup>
                <TableHeader className="bg-container-hover">
                  <TableRow>
                    <TableHead aria-hidden="true" className="w-10 max-w-10 min-w-10 p-0" />
                    <TableHead
                      isTruncatable
                      className={TABLE_ROW_NAME_COLUMN_CLASS_NAME}
                      sortDirection={getExpandedTableSortDirection("environment")}
                      onSortChange={(direction) =>
                        handleExpandedTableSortChange("environment", direction)
                      }
                    >
                      Environment
                      <ChevronDownIcon
                        className={getExpandedTableSortIconClassName("environment")}
                      />
                    </TableHead>
                    <TableHead>Value</TableHead>
                    <TableHead variant="action" className="w-px font-normal">
                      <Button
                        variant="ghost"
                        size="xs"
                        onClick={() => {
                          telemetry.interaction({
                            action: isSecretVisible ? "hide" : "reveal",
                            source: "row",
                            resourceType: "secret"
                          });
                          onToggleSecretVisible(secretKey);
                        }}
                      >
                        {isSecretVisible ? (
                          <>
                            <EyeOffIcon />
                            Hide Values
                          </>
                        ) : (
                          <>
                            <EyeIcon />
                            Show Values
                          </>
                        )}
                      </Button>
                    </TableHead>
                  </TableRow>
                </TableHeader>
                <TableBody
                  className={twMerge(
                    TABLE_BODY_ROW_FILTER_CLASS_NAME,
                    activeEnvSlugs.size > 0 && TABLE_BODY_ROW_FILTER_DIMMED_CLASS_NAME
                  )}
                >
                  {sortedEnvironments.map(({ name, slug }) => {
                    const secret = getSecretByKey(slug, secretKey);

                    const isImportedSecret = isImportedSecretPresentInEnv(slug, secretKey);
                    const importedSecret = getImportedSecretByKey(slug, secretKey);

                    const hasOverride = Boolean(secret?.idOverride);
                    const isCreatingOverride = creatingOverrideEnvs.has(slug);
                    const showOverrideRow = hasOverride || isCreatingOverride;

                    return (
                      <Fragment key={`secret-expanded-${slug}-${secretKey}`}>
                        <TableRow
                          className={twMerge(
                            "group hover:z-10",
                            activeEnvSlugs.has(slug) && TABLE_ROW_ACTIVE_FILTER_CLASS_NAME
                          )}
                        >
                          <TableCell
                            aria-hidden="true"
                            className={twMerge(
                              "w-10 max-w-10 min-w-10 p-0",
                              hasOverride && "border-b-border/50"
                            )}
                          />
                          <SecretEditTableRow
                            nameCellContent={
                              <>
                                <Tooltip>
                                  <TooltipTrigger asChild>
                                    <span className="truncate">{name}</span>
                                  </TooltipTrigger>
                                  <TooltipContent side="right" className="max-w-2xl break-all">
                                    {name}
                                  </TooltipContent>
                                </Tooltip>
                                {isImportedSecret && (
                                  <Tooltip>
                                    <TooltipTrigger asChild>
                                      <ImportIcon className="size-4 text-import" />
                                    </TooltipTrigger>
                                    <TooltipContent>
                                      Imported from {importedSecret?.environmentInfo?.name}{" "}
                                      environment
                                    </TooltipContent>
                                  </Tooltip>
                                )}
                                {secret?.isRotatedSecret && (
                                  <Tooltip>
                                    <TooltipTrigger asChild>
                                      <RefreshCcwIcon className="size-4 text-secret-rotation" />
                                    </TooltipTrigger>
                                    <TooltipContent>Rotated secret</TooltipContent>
                                  </Tooltip>
                                )}
                                {secret?.isHoneyTokenSecret && (
                                  <Tooltip>
                                    <TooltipTrigger asChild>
                                      <HexagonIcon className="size-4 text-warning" />
                                    </TooltipTrigger>
                                    <TooltipContent>Honey Token secret</TooltipContent>
                                  </Tooltip>
                                )}
                              </>
                            }
                            isVisible={isSecretVisible}
                            initialAction={
                              pendingEnvAction?.slug === slug ? pendingEnvAction.action : undefined
                            }
                            onInitialActionHandled={clearPendingEnvAction}
                            {...getEnvironmentSecretRowProps(slug, name)}
                          />
                        </TableRow>
                        {showOverrideRow && (
                          <TableRow
                            className="group bg-gradient-to-r from-override/[0.03] from-[1%] via-override/[0.075] to-override/[0.03] to-[99%]"
                            key={`secret-override-${slug}-${secretKey}`}
                          >
                            <TableCell aria-hidden="true" className="w-10 max-w-10 min-w-10 p-0" />
                            <TableCell
                              className={hasOverride ? "border-l border-l-override" : undefined}
                            />
                            <TableCell isTopAligned colSpan={2} className="max-w-0">
                              <SecretOverrideRow
                                secretName={secretKey}
                                environment={slug}
                                secretPath={secretPath}
                                isVisible={isSecretVisible}
                                isOverrideEmpty={secret?.isOverrideEmpty}
                                idOverride={secret?.idOverride}
                                valueOverride={secret?.valueOverride}
                                isCreatingOverride={isCreatingOverride}
                                onCreatingOverrideChange={(value) => {
                                  setCreatingOverrideEnvs((prev) => {
                                    const next = new Set(prev);
                                    if (value) {
                                      next.add(slug);
                                    } else {
                                      next.delete(slug);
                                    }
                                    return next;
                                  });
                                }}
                                onSecretCreate={onSecretCreate}
                                onSecretUpdate={onSecretUpdate}
                                onSecretDelete={onSecretDelete}
                              />
                            </TableCell>
                          </TableRow>
                        )}
                      </Fragment>
                    );
                  })}
                </TableBody>
              </Table>
            </div>
          </TableCell>
        </TableRow>
      )}
    </>
  );
};