Skip to content

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

48.7 KB
Raw Blame
import { ClipboardEvent, KeyboardEvent, useEffect, useMemo, useRef, useState } from "react";
import { Controller, useFieldArray, useForm } from "react-hook-form";
import { subject } from "@casl/ability";
import { zodResolver } from "@hookform/resolvers/zod";
import {
  AlertTriangleIcon,
  CircleHelpIcon,
  InfoIcon,
  PlusIcon,
  TrashIcon,
  TriangleAlertIcon,
  UploadIcon
} from "lucide-react";
import { twMerge } from "tailwind-merge";
import { z } from "zod";

import { createNotification } from "@app/components/notifications";
import { parsePastedEnv } from "@app/components/utilities/parseSecrets";
import {
  Accordion,
  AccordionContent,
  AccordionItem,
  AccordionTrigger,
  Button,
  Combobox,
  IconButton,
  InfisicalSecretInput,
  Input,
  PasswordGenerator,
  SheetFooter,
  TextArea,
  Toggle,
  Tooltip,
  TooltipContent,
  TooltipTrigger
} from "@app/components/v3";
import {
  Field,
  FieldContent,
  FieldDescription,
  FieldError,
  FieldGroup,
  FieldLabel
} from "@app/components/v3/generic/Field";
import { HIDDEN_SECRET_VALUE } from "@app/const/secrets";
import {
  ProjectPermissionActions,
  ProjectPermissionSub,
  useProject,
  useProjectPermission
} from "@app/context";
import { ProjectPermissionSecretActions } from "@app/context/ProjectPermissionContext/types";
import { getKeyValue } from "@app/helpers/parseEnvVar";
import {
  useCreateSecretV3,
  useCreateWsTag,
  useGetOrCreateFolder,
  useGetWsTags
} from "@app/hooks/api";
import { PendingAction } from "@app/hooks/api/secretFolders/types";
import { useCreateCommit } from "@app/hooks/api/secrets/mutations";
import { SecretType } from "@app/hooks/api/types";
import { slugSchema } from "@app/lib/schemas";
import { useBatchStoreApi } from "@app/pages/secret-manager/SecretDashboardPage/SecretMainPage.store";

import {
  overviewCountBucket,
  overviewResponsePhase,
  useOverviewTelemetry
} from "../../OverviewTelemetry";
import {
  notifySecretsCreatedWithoutShare,
  TNotifySecretsCreated
} from "../../useNotifySecretsCreated";
import { didAllSecretCreationsSucceed } from "./createSecretFormState";

const MAX_SECRETS_PER_COMMIT = 1000;
const MAX_TAGS_PER_COMMITTED_SECRET = 100;

const formSchema = (enforceEncryptedMetadata: boolean) =>
  z
    .object({
      environments: z
        .object({ name: z.string(), slug: z.string() })
        .array()
        .min(1, { message: "Required" }),
      secrets: z
        .array(
          z.object({
            key: z.string().trim().min(1, "Key is required"),
            value: z.string().optional(),
            comment: z.string().optional(),
            skipMultilineEncoding: z.boolean().optional(),
            tags: z
              .array(z.object({ label: z.string().trim(), value: z.string().trim() }))
              .optional(),
            metadata: z
              .array(
                z.object({
                  id: z.string(),
                  key: z.string().min(1, "Key is required"),
                  value: z.string(),
                  isEncrypted: enforceEncryptedMetadata
                    ? z.literal(true)
                    : z.boolean().default(false)
                })
              )
              .optional()
          })
        )
        .min(1)
    })
    .superRefine(({ secrets }, context) => {
      const seenKeys = new Set<string>();
      secrets.forEach((secret, index) => {
        const normalizedKey = secret.key.trim();
        if (seenKeys.has(normalizedKey)) {
          context.addIssue({
            code: z.ZodIssueCode.custom,
            message: "Key must be unique",
            path: ["secrets", index, "key"]
          });
        }
        seenKeys.add(normalizedKey);
      });
    });

type TFormSchema = z.infer<ReturnType<typeof formSchema>>;

type TParsedEnv = Record<string, { value: string; comments: string[] }>;

export type TSecretEditChanges = {
  value?: string;
  secretComment?: string;
  tags?: { id: string; slug: string }[];
  secretMetadata?: { key: string; value: string; isEncrypted?: boolean }[];
  skipMultilineEncoding?: boolean;
};

type Props = {
  secretPath?: string;
  defaultSelectedEnvs?: { name: string; slug: string }[];
  onClose: () => void;
  isBatchMode?: boolean;
  editSecret?: {
    key: string;
    value: string;
    comment?: string;
    tags?: { id: string; slug: string }[];
    metadata?: { key: string; value: string; isEncrypted?: boolean }[];
    skipMultilineEncoding?: boolean | null;
    canEditButNotView: boolean;
    isReadOnly: boolean;
    onDirtyChange: (isDirty: boolean) => void;
    onSubmit: (changes: TSecretEditChanges) => Promise<void>;
  };
  // Called after the user actually creates a secret (non-batch path) so the parent can run the
  // activation nudge. The parent owns the nudge hook + modal state, so this stays a callback.
  onSecretCreated?: () => void;
  notifySecretsCreated?: TNotifySecretsCreated;
  // Called when the user opts to bulk-upload secrets instead. The parent owns the import modal,
  // so it swaps popups; when the user pasted multiple KEY=VALUE pairs, the parsed set is passed
  // along so the modal can skip its upload step.
  onUploadSecrets?: (env?: TParsedEnv) => void;
};

export const CreateSecretForm = ({
  secretPath = "/",
  defaultSelectedEnvs,
  onClose,
  editSecret,
  onSecretCreated,
  notifySecretsCreated = notifySecretsCreatedWithoutShare,
  onUploadSecrets
}: Props) => {
  const overviewTelemetry = useOverviewTelemetry();
  const formOwner = useRef({ telemetry: overviewTelemetry, invocation: {} });
  if (formOwner.current.telemetry !== overviewTelemetry)
    formOwner.current = { telemetry: overviewTelemetry, invocation: {} };
  useEffect(
    () => () => {
      formOwner.current.invocation = {};
    },
    []
  );
  const { currentProject, projectId } = useProject();
  const { permission } = useProjectPermission();
  const canReadTags = permission.can(ProjectPermissionActions.Read, ProjectPermissionSub.Tags);
  const canCreateTags = permission.can(ProjectPermissionActions.Create, ProjectPermissionSub.Tags);
  const environments = currentProject?.environments || [];

  const defaultEnvs = useMemo(() => {
    if (defaultSelectedEnvs && defaultSelectedEnvs.length > 0) return defaultSelectedEnvs;
    // if all envs are selected on the dashboard the array is empty so we need to resolve here
    return environments.filter((env) =>
      permission.can(
        ProjectPermissionSecretActions.Create,
        subject(ProjectPermissionSub.Secrets, {
          environment: env.slug,
          secretPath,
          secretName: "*",
          secretTags: ["*"]
        })
      )
    );
  }, [defaultSelectedEnvs, environments, permission, secretPath]);

  const editValuesJson =
    editSecret &&
    JSON.stringify({
      environments: defaultEnvs,
      secrets: [
        {
          key: editSecret.key,
          value: editSecret.value,
          comment: editSecret.comment ?? "",
          skipMultilineEncoding: editSecret.skipMultilineEncoding ?? false,
          tags: editSecret.tags?.map((tag) => ({ label: tag.slug, value: tag.id })) ?? [],
          metadata:
            editSecret.metadata?.map((entry) => ({
              ...entry,
              isEncrypted: currentProject?.enforceEncryptedSecretManagerSecretMetadata
                ? true
                : (entry.isEncrypted ?? false)
            })) ?? []
        }
      ]
    });
  const editValues = useMemo(() => {
    if (!editValuesJson) return undefined;
    const values = JSON.parse(editValuesJson) as TFormSchema;
    values.secrets[0].metadata = values.secrets[0].metadata?.map((entry) => ({
      ...entry,
      id: crypto.randomUUID()
    }));
    return values;
  }, [editValuesJson]);

  const {
    handleSubmit,
    control,
    reset,
    setValue,
    getValues,
    watch,
    formState: { isSubmitting, errors, dirtyFields }
  } = useForm<TFormSchema>({
    resolver: zodResolver(
      formSchema(Boolean(currentProject?.enforceEncryptedSecretManagerSecretMetadata))
    ),
    values: editValues,
    resetOptions: { keepDirtyValues: true },
    defaultValues: editValues ?? {
      environments: defaultEnvs,
      secrets: [
        {
          key: "",
          value: "",
          comment: "",
          skipMultilineEncoding: false,
          metadata: [],
          tags: []
        }
      ]
    }
  });

  const {
    fields: secretFields,
    append: appendSecret,
    remove: removeSecret
  } = useFieldArray({ control, name: "secrets" });

  const { mutateAsync: createSecretV3 } = useCreateSecretV3();
  const { mutateAsync: createCommit } = useCreateCommit();
  const batchStore = useBatchStoreApi();
  const { mutateAsync: getOrCreateFolder } = useGetOrCreateFolder();
  const { data: projectTags, isPending: isTagsLoading } = useGetWsTags(
    canReadTags ? projectId : ""
  );

  const tagOptions = useMemo(
    () => projectTags?.map((el) => ({ label: el.slug, value: el.id })) ?? [],
    [projectTags]
  );
  const [tagSearches, setTagSearches] = useState<Record<string, string>>({});

  const secretKeyInputRefs = useRef<Array<HTMLInputElement | null>>([]);
  const generateButtonRefs = useRef<Array<HTMLButtonElement | null>>([]);
  const selectedEnvironments = watch("environments");
  const isEditReadOnly = Boolean(editSecret?.isReadOnly);
  const [hasEditedHiddenValue, setHasEditedHiddenValue] = useState(false);
  const watchedValue = watch("secrets.0.value");
  const hasValueChanges = Boolean(dirtyFields.secrets?.[0]?.value || hasEditedHiddenValue);
  const hasEditChanges = Boolean(
    hasValueChanges ||
    Object.keys(dirtyFields.secrets?.[0] ?? {}).some((field) => field !== "value")
  );
  const onEditDirtyChange = editSecret?.onDirtyChange;

  const handleValueChange = (value: string, onChange: (value: string) => void) => {
    if (editSecret?.canEditButNotView && value === HIDDEN_SECRET_VALUE) {
      setHasEditedHiddenValue(false);
      onChange(editSecret.value);
      return;
    }
    if (editSecret?.canEditButNotView) setHasEditedHiddenValue(true);
    onChange(value);
  };
  useEffect(() => {
    onEditDirtyChange?.(hasEditChanges);
  }, [hasEditChanges, onEditDirtyChange]);

  const handleFormSubmit = async ({ environments: selectedEnv, secrets }: TFormSchema) => {
    const { invocation } = formOwner.current;
    if (editSecret) {
      if (isEditReadOnly || !hasEditChanges) return;
      const secret = secrets[0];
      const dirtySecret = dirtyFields.secrets?.[0];
      await editSecret.onSubmit({
        value: hasValueChanges ? (secret.value ?? "") : undefined,
        secretComment: dirtySecret?.comment ? (secret.comment ?? "") : undefined,
        tags: dirtySecret?.tags
          ? (secret.tags?.map((tag) => ({ id: tag.value, slug: tag.label })) ?? [])
          : undefined,
        secretMetadata: dirtySecret?.metadata
          ? (secret.metadata?.map(({ key, value, isEncrypted }) => ({ key, value, isEncrypted })) ??
            [])
          : undefined,
        skipMultilineEncoding: dirtySecret?.skipMultilineEncoding
          ? secret.skipMultilineEncoding
          : undefined
      });
      return;
    }
    const telemetry = overviewTelemetry;
    const flow = {
      action: "create" as const,
      resourceType: "secret" as const,
      source: "form" as const,
      countBucket: overviewCountBucket(secrets.length * selectedEnv.length)
    };
    const attempt = telemetry.startFlow(flow);
    const { currentContext, pendingChanges: storedPendingChanges } = batchStore.getState();
    const isPendingContextTargeted =
      currentContext?.secretPath === secretPath &&
      selectedEnv.some((env) => env.slug === currentContext?.environment);
    const reservedByPendingChange = new Set(
      (isPendingContextTargeted ? storedPendingChanges.secrets : []).flatMap((change) => {
        if (change.type === PendingAction.Create) return [change.secretKey];
        return change.type === PendingAction.Update && change.newSecretName
          ? [change.newSecretName]
          : [];
      })
    );
    const conflictingKeys = secrets
      .map((secret) => secret.key)
      .filter((key) => reservedByPendingChange.has(key));
    if (conflictingKeys.length) {
      attempt.flow({ ...flow, phase: "failed" });
      createNotification({
        type: "error",
        text: `A pending change already uses ${conflictingKeys.map((key) => `"${key}"`).join(", ")}. Save or discard that change first.`
      });
      return;
    }
    if (selectedEnv.length === 1 && secrets.length > 1) {
      const overTagLimitKeys = secrets
        .filter((secret) => (secret.tags?.length ?? 0) > MAX_TAGS_PER_COMMITTED_SECRET)
        .map((secret) => secret.key);
      let limitError: string | undefined;
      if (secrets.length > MAX_SECRETS_PER_COMMIT)
        limitError = `You can create up to ${MAX_SECRETS_PER_COMMIT} secrets at once, and this has ${secrets.length}. Split them into smaller batches.`;
      else if (overTagLimitKeys.length)
        limitError = `A secret can have up to ${MAX_TAGS_PER_COMMITTED_SECRET} tags. Remove tags from ${overTagLimitKeys.map((key) => `"${key}"`).join(", ")}.`;
      if (limitError) {
        attempt.flow({ ...flow, phase: "failed" });
        createNotification({ type: "error", text: limitError });
        return;
      }
    }
    await Promise.all(
      selectedEnv.map(async (env) => {
        if (secretPath !== "/") {
          const pathSegment = secretPath.split("/").filter(Boolean);
          const parentPath = `/${pathSegment.slice(0, -1).join("/")}`;
          const folderName = pathSegment.at(-1);
          const canCreateFolder = permission.can(
            ProjectPermissionActions.Create,
            subject(ProjectPermissionSub.SecretFolders, {
              environment: env.slug,
              secretPath: parentPath
            })
          );

          if (folderName && parentPath && canCreateFolder) {
            await getOrCreateFolder({
              projectId,
              path: parentPath,
              environment: env.slug,
              name: folderName
            });
          }
        }
      })
    ).catch((error) => {
      attempt.flow({ ...flow, phase: "failed" });
      throw error;
    });

    if (selectedEnv.length === 1 && secrets.length > 1) {
      const result = await createCommit({
        projectId,
        environment: selectedEnv[0].slug,
        secretPath,
        message: "",
        pendingChanges: {
          folders: [],
          secrets: secrets.map((secret) => {
            const filteredMetadata = secret.metadata
              ?.filter((metadata) => metadata.key && metadata.value)
              .map(({ key, value, isEncrypted }) => ({ key, value, isEncrypted }));
            return {
              id: crypto.randomUUID(),
              resourceType: "secret" as const,
              type: PendingAction.Create as const,
              secretKey: secret.key,
              secretValue: secret.value || "",
              secretComment: secret.comment || undefined,
              skipMultilineEncoding: secret.skipMultilineEncoding || undefined,
              tags: secret.tags?.map((tag) => ({ id: tag.value, slug: tag.label })),
              secretMetadata: filteredMetadata?.length ? filteredMetadata : undefined,
              timestamp: Date.now()
            };
          })
        }
      }).catch((error) => {
        attempt.flow({ ...flow, commitKind: "batch", phase: "failed" });
        throw error;
      });
      attempt.flow({
        ...flow,
        commitKind: "batch",
        phase: result.approval ? "approval-requested" : "response-received"
      });
      if (result.approval) {
        createNotification({
          type: "info",
          text: "Requested changes have been sent for review"
        });
      } else {
        notifySecretsCreated(
          result.secrets.created.length,
          secrets.map((secret) => ({
            environment: selectedEnv[0].slug,
            key: secret.key,
            value: secret.value,
            tags: secret.tags?.map((tag) => tag.label)
          }))
        );
        onSecretCreated?.();
      }
      if (attempt.isCurrent() && formOwner.current.invocation === invocation) {
        onClose();
        reset();
      }
      return;
    }

    const promises = selectedEnv.flatMap((env) =>
      secrets.map(async (secret) => {
        const environment = env.slug;
        const filteredMetadata = secret.metadata
          ?.filter((metadata) => metadata.key && metadata.value)
          .map(({ key, value, isEncrypted }) => ({ key, value, isEncrypted }));
        return {
          ...(await createSecretV3({
            environment,
            projectId,
            secretPath,
            secretKey: secret.key,
            secretValue: secret.value || "",
            secretComment: secret.comment || "",
            skipMultilineEncoding: secret.skipMultilineEncoding || undefined,
            type: SecretType.Shared,
            tagIds: secret.tags?.map((tag) => tag.value),
            secretMetadata: filteredMetadata?.length ? filteredMetadata : undefined
          })),
          environment,
          secret
        };
      })
    );

    const results = await Promise.allSettled(promises);
    const allRequestsSucceeded = didAllSecretCreationsSucceed(results);
    const forApprovalEnvs = [
      ...new Set(
        results
          .map((result) =>
            result.status === "fulfilled" && "approval" in result.value
              ? result.value.environment
              : undefined
          )
          .filter(Boolean) as string[]
      )
    ];

    const updatedEnvs = [
      ...new Set(
        results
          .map((result) =>
            result.status === "fulfilled" && !("approval" in result.value)
              ? result.value.environment
              : undefined
          )
          .filter(Boolean) as string[]
      )
    ];
    const responseCount = results.filter(
      (result) => result.status === "fulfilled" && !("approval" in result.value)
    ).length;
    const approvalCount = results.filter(
      (result) => result.status === "fulfilled" && "approval" in result.value
    ).length;
    const failureCount = results.filter((result) => result.status === "rejected").length;
    attempt.flow({
      ...flow,
      phase: overviewResponsePhase(responseCount, approvalCount, failureCount),
      responseCountBucket: overviewCountBucket(responseCount),
      approvalCountBucket: overviewCountBucket(approvalCount),
      failureCountBucket: overviewCountBucket(failureCount)
    });

    if (forApprovalEnvs.length) {
      createNotification({
        type: "info",
        text: `Change request submitted for ${
          forApprovalEnvs.length > 1 ? "environments" : "environment"
        }: ${forApprovalEnvs.join(", ")}`
      });
    }

    if (updatedEnvs.length) {
      const createdSecrets = results.flatMap((result) =>
        result.status === "fulfilled" && !("approval" in result.value)
          ? [
              {
                environment: result.value.environment,
                key: result.value.secret.key,
                value: result.value.secret.value,
                tags: result.value.secret.tags?.map((tag) => tag.label)
              }
            ]
          : []
      );
      notifySecretsCreated(
        new Set(createdSecrets.map(({ key }) => key)).size,
        createdSecrets,
        updatedEnvs.length > 1 ? `Added to ${updatedEnvs.length} environments` : undefined
      );

      // The user just created a secret: let the parent check whether to surface the nudge.
      onSecretCreated?.();
    }

    if (!updatedEnvs.length && !forApprovalEnvs.length) {
      // this should only occur when a toast notifcation is created from failed mutation
      console.warn("failed to create secrets");
    }

    if (
      allRequestsSucceeded &&
      attempt.isCurrent() &&
      formOwner.current.invocation === invocation
    ) {
      onClose();
      reset();
    }
  };

  const handlePaste = (e: ClipboardEvent<HTMLInputElement>, index: number) => {
    if (editSecret) return;
    const delimitters = [":", "="];
    const pastedContent = e.clipboardData.getData("text");
    const { key, value } = getKeyValue(pastedContent, delimitters);

    const isWholeKeyHighlighted =
      e.currentTarget.selectionStart === 0 &&
      e.currentTarget.selectionEnd === e.currentTarget.value.length;

    if (!getValues(`secrets.${index}.key`) || isWholeKeyHighlighted) {
      e.preventDefault();

      const parsedEnv = parsePastedEnv(pastedContent);
      const parsedEntries = Object.entries(parsedEnv);
      if (parsedEntries.length > 1) {
        const toSecret = ([parsedKey, parsedValue]: (typeof parsedEntries)[number]) => ({
          key: currentProject.autoCapitalization ? parsedKey.toUpperCase() : parsedKey,
          value: parsedValue.value,
          comment: parsedValue.comments.join("\n"),
          skipMultilineEncoding: false,
          tags: [],
          metadata: []
        });
        setValue(`secrets.${index}`, toSecret(parsedEntries[0]));
        parsedEntries.slice(1).forEach((entry) => appendSecret(toSecret(entry)));
        return;
      }

      const keyStr = currentProject.autoCapitalization ? key.toUpperCase() : key;
      setValue(`secrets.${index}.key`, keyStr);
      if (value) {
        setValue(`secrets.${index}.value`, value);
      }
    }
  };

  const createWsTag = useCreateWsTag();

  const createNewTag = async (slug: string, index: number, secretFieldId: string) => {
    if (!canCreateTags) return;
    const parsedSlug = slugSchema().safeParse(slug);
    if (!parsedSlug.success) return;
    const newTag = await createWsTag.mutateAsync({
      projectId,
      tagSlug: parsedSlug.data,
      tagColor: ""
    });
    const currentTags = getValues(`secrets.${index}.tags`) ?? [];
    setValue(`secrets.${index}.tags`, [...currentTags, { label: newTag.slug, value: newTag.id }], {
      shouldDirty: true
    });
    setTagSearches((current) => ({ ...current, [secretFieldId]: "" }));
  };

  const submitForm = handleSubmit(handleFormSubmit);
  const editSubmitLabel = "Save Changes";

  const handleFormKeyDown = (e: KeyboardEvent<HTMLFormElement>) => {
    // Allow Cmd+Enter (macOS) / Ctrl+Enter (other OSes) to submit the form.
    // react-hook-form's handleSubmit wrapper still runs validation, so this
    // does not bypass the required key/value checks.
    if ((e.metaKey || e.ctrlKey) && e.key === "Enter" && !isSubmitting) {
      e.preventDefault();
      submitForm();
    }
  };

  return (
    // eslint-disable-next-line jsx-a11y/no-noninteractive-element-interactions
    <form
      onSubmit={submitForm}
      onKeyDown={handleFormKeyDown}
      noValidate
      className="flex min-h-0 flex-1 flex-col overflow-hidden"
    >
      <div className="flex thin-scrollbar flex-1 flex-col gap-4 overflow-y-auto p-4">
        <Controller
          control={control}
          name="environments"
          render={({ field: { value, onChange }, fieldState: { error } }) => (
            <Field>
              <FieldLabel htmlFor="create-secret-environments">
                {editSecret ? "Environment" : "Environments"}
              </FieldLabel>
              <FieldContent>
                <Combobox
                  id="create-secret-environments"
                  multiple
                  isClearable={!editSecret}
                  isDisabled={Boolean(editSecret)}
                  options={environments.filter((environment) =>
                    permission.can(
                      ProjectPermissionSecretActions.Create,
                      subject(ProjectPermissionSub.Secrets, {
                        environment: environment.slug,
                        secretPath,
                        secretName: "*",
                        secretTags: ["*"]
                      })
                    )
                  )}
                  value={value}
                  onValueChange={onChange}
                  isError={Boolean(error)}
                  modal
                  placeholder="Select environments to create secret in..."
                  searchPlaceholder="Search environments..."
                  searchAriaLabel="Search environments"
                  emptyMessage="No environments found."
                  getOptionLabel={(option) => option.name}
                  getOptionValue={(option) => option.slug}
                />
                <FieldError errors={[error]} />
              </FieldContent>
            </Field>
          )}
        />
        {secretFields.map((secretField, index) => {
          const secretKey = watch(`secrets.${index}.key`);
          const metadata = watch(`secrets.${index}.metadata`) ?? [];
          const tagSlug = tagSearches[secretField.id]?.trim() ?? "";
          const canCreateTag =
            canCreateTags &&
            slugSchema().safeParse(tagSlug).success &&
            !tagOptions.some((option) => option.label === tagSlug);

          return (
            <div
              key={editSecret ? "edit-secret" : secretField.id}
              className={twMerge(
                "relative flex flex-col gap-4 rounded-md border border-transparent bg-transparent p-0 transition-[padding,background-color,border-color] duration-200 ease-out motion-reduce:transition-none",
                secretFields.length > 1 && "border-border bg-container/50 p-4"
              )}
            >
              <div className="flex items-start gap-2">
                <Controller
                  control={control}
                  name={`secrets.${index}.key`}
                  render={({ field, fieldState: { error } }) => (
                    <Field className="flex-1">
                      <FieldLabel htmlFor={`create-secret-${index}-key`}>Key</FieldLabel>
                      <FieldContent>
                        <div className="relative">
                          <Input
                            ref={(element) => {
                              secretKeyInputRefs.current[index] = element;
                            }}
                            id={`create-secret-${index}-key`}
                            value={field.value ?? ""}
                            readOnly={Boolean(editSecret)}
                            onChange={(e) => {
                              const val = currentProject?.autoCapitalization
                                ? e.target.value.toUpperCase()
                                : e.target.value;
                              field.onChange(val);
                            }}
                            onBlur={field.onBlur}
                            placeholder="Type your secret name"
                            onPaste={(event) => handlePaste(event, index)}
                            autoComplete="off"
                            isError={Boolean(error)}
                            className={currentProject?.autoCapitalization ? "uppercase" : undefined}
                          />
                          {secretKey?.trim().includes(" ") && (
                            <Tooltip>
                              <TooltipTrigger asChild>
                                <AlertTriangleIcon className="absolute top-1/2 right-3 size-4 -translate-y-1/2 text-warning" />
                              </TooltipTrigger>
                              <TooltipContent className="max-w-72">
                                Secret key contains whitespaces. If this is the desired format, you
                                need to provide it as{" "}
                                <code className="rounded-md bg-container px-1 py-0.5">
                                  {encodeURIComponent(secretKey.trim())}
                                </code>{" "}
                                when making API requests.
                              </TooltipContent>
                            </Tooltip>
                          )}
                        </div>
                        <FieldError errors={[error]} />
                      </FieldContent>
                    </Field>
                  )}
                />
                {secretFields.length > 1 && (
                  <IconButton
                    type="button"
                    variant="ghost"
                    size="xs"
                    className="mt-6.5"
                    aria-label={`Remove secret ${index + 1}`}
                    onClick={() => removeSecret(index)}
                  >
                    <TrashIcon className="size-4" />
                  </IconButton>
                )}
              </div>

              <Controller
                control={control}
                name={`secrets.${index}.value`}
                render={({ field }) => (
                  <Field className="grid grid-cols-[1fr_auto]">
                    <div className="flex items-end">
                      <FieldLabel htmlFor={`create-secret-${index}-value`}>
                        Value
                        <Tooltip>
                          <TooltipTrigger asChild>
                            <InfoIcon />
                          </TooltipTrigger>
                          <TooltipContent>
                            You can add references to other secrets using the format{" "}
                            <code className="rounded-sm bg-accent px-1 py-0.5 text-background">
                              &#36;{"{"}secret_name{"}"}
                            </code>
                          </TooltipContent>
                        </Tooltip>
                      </FieldLabel>
                    </div>
                    <FieldContent className="col-span-2 row-start-2">
                      <InfisicalSecretInput
                        id={`create-secret-${index}-value`}
                        autoFocus={Boolean(editSecret)}
                        value={
                          editSecret?.canEditButNotView && !hasValueChanges
                            ? HIDDEN_SECRET_VALUE
                            : (field.value ?? "")
                        }
                        onChange={(value) => handleValueChange(value, field.onChange)}
                        isReadOnly={editSecret ? isEditReadOnly : undefined}
                        canEditButNotView={editSecret?.canEditButNotView}
                        secretPath={editSecret ? secretPath : undefined}
                        environment={editSecret ? selectedEnvironments[0]?.slug : undefined}
                        onKeyDown={(event) => {
                          if (event.key === "Tab" && !event.shiftKey && !event.defaultPrevented) {
                            event.preventDefault();
                            generateButtonRefs.current[index]?.focus();
                          }
                        }}
                        placeholder="Enter secret value..."
                      />
                      {editSecret && hasValueChanges && !watchedValue && (
                        <FieldDescription>
                          Saving removes the value, not the secret.
                        </FieldDescription>
                      )}
                      <FieldError errors={[errors.secrets?.[index]?.value]} />
                    </FieldContent>
                    <div className="col-start-2 row-start-1 flex items-center">
                      <PasswordGenerator
                        isDisabled={Boolean(editSecret && isEditReadOnly)}
                        trigger={
                          <Button
                            ref={(element) => {
                              generateButtonRefs.current[index] = element;
                            }}
                            variant="ghost"
                            size="xs"
                          >
                            Generate
                          </Button>
                        }
                        selectedEnvironments={selectedEnvironments}
                        onUsePassword={(value) => handleValueChange(value, field.onChange)}
                        projectId={projectId}
                        secretPath={secretPath}
                      />
                    </div>
                  </Field>
                )}
              />

              <Controller
                control={control}
                name={`secrets.${index}.comment`}
                render={({ field }) => (
                  <Field>
                    <FieldLabel htmlFor={`create-secret-${index}-comment`}>Comment</FieldLabel>
                    <FieldContent>
                      <TextArea
                        {...field}
                        id={`create-secret-${index}-comment`}
                        placeholder="Add a comment for this secret..."
                        className="max-h-32 min-h-[60px] resize-y"
                        readOnly={editSecret ? isEditReadOnly : undefined}
                      />
                    </FieldContent>
                  </Field>
                )}
              />

              <Accordion type="single" collapsible variant="ghost">
                <AccordionItem value="advanced" className="border-b-0">
                  <AccordionTrigger>Advanced Options</AccordionTrigger>
                  <AccordionContent>
                    <div className="flex flex-col gap-4">
                      <Controller
                        control={control}
                        name={`secrets.${index}.tags`}
                        render={({ field }) => (
                          <Field>
                            <FieldLabel htmlFor={`create-secret-${index}-tags`}>Tags</FieldLabel>
                            <FieldContent>
                              {!canReadTags ? (
                                <FieldDescription>
                                  <span className="flex items-center gap-1.5 text-warning">
                                    <TriangleAlertIcon className="size-3" />
                                    You do not have permission to read tags.
                                  </span>
                                </FieldDescription>
                              ) : (
                                <Combobox
                                  key={`${editSecret ? "edit-secret" : secretField.id}-${tagOptions.length}`}
                                  id={`create-secret-${index}-tags`}
                                  multiple
                                  modal
                                  isClearable={!editSecret}
                                  options={tagOptions}
                                  value={field.value ?? []}
                                  onValueChange={field.onChange}
                                  onInputValueChange={(search) =>
                                    setTagSearches((current) => ({
                                      ...current,
                                      [secretField.id]: search
                                    }))
                                  }
                                  getOptionLabel={(option) => option.label}
                                  getOptionValue={(option) => option.value}
                                  placeholder="Select tags to assign to secret..."
                                  searchPlaceholder="Search tags..."
                                  searchAriaLabel="Search tags"
                                  emptyMessage="No tags found."
                                  isLoading={isTagsLoading && canReadTags}
                                  isDisabled={Boolean(editSecret && isEditReadOnly)}
                                  listFooter={
                                    canCreateTag && (
                                      <Button
                                        variant="ghost"
                                        size="sm"
                                        className="w-full justify-start"
                                        onClick={() => createNewTag(tagSlug, index, secretField.id)}
                                      >
                                        <PlusIcon className="size-3" />
                                        Create Tag &ldquo;{tagSlug}&rdquo;
                                      </Button>
                                    )
                                  }
                                />
                              )}
                            </FieldContent>
                          </Field>
                        )}
                      />

                      <Controller
                        control={control}
                        name={`secrets.${index}.skipMultilineEncoding`}
                        render={({ field }) => (
                          <Field orientation="horizontal">
                            <div className="flex flex-1 items-center gap-1.5">
                              <FieldLabel
                                htmlFor={`create-secret-${index}-multiline-encoding`}
                                className="cursor-pointer"
                              >
                                Enable Multiline Encoding
                              </FieldLabel>
                              <Tooltip>
                                <TooltipTrigger asChild>
                                  <button
                                    type="button"
                                    aria-label="About multiline encoding"
                                    className="text-muted hover:text-foreground focus-visible:rounded-sm focus-visible:outline-2 focus-visible:outline-ring"
                                  >
                                    <CircleHelpIcon className="size-3.5" />
                                  </button>
                                </TooltipTrigger>
                                <TooltipContent>
                                  When enabled, newlines in secret values are escaped as \n for
                                  environment variable output.
                                </TooltipContent>
                              </Tooltip>
                            </div>
                            <Toggle
                              id={`create-secret-${index}-multiline-encoding`}
                              variant="project"
                              checked={field.value}
                              disabled={Boolean(editSecret && isEditReadOnly)}
                              onCheckedChange={field.onChange}
                            />
                          </Field>
                        )}
                      />

                      <FieldGroup>
                        <Field>
                          <FieldLabel>Metadata</FieldLabel>
                          <FieldContent>
                            <div className="mb-1.5 flex max-h-64 thin-scrollbar flex-col gap-3 overflow-y-auto rounded-md border border-border bg-container/50 p-4">
                              {metadata.length === 0 && (
                                <p className="py-2 text-center text-sm text-muted">
                                  No metadata entries.
                                </p>
                              )}
                              {metadata.map((metadataEntry, metadataIndex) => (
                                <div key={metadataEntry.id} className="flex items-start gap-3">
                                  <Field className="flex-1">
                                    <FieldLabel
                                      htmlFor={`create-secret-${index}-metadata-${metadataIndex}-key`}
                                      className={metadataIndex === 0 ? "text-xs" : "sr-only"}
                                    >
                                      Key
                                    </FieldLabel>
                                    <FieldContent>
                                      <Controller
                                        control={control}
                                        name={`secrets.${index}.metadata.${metadataIndex}.key`}
                                        render={({ field: inputField, fieldState: { error } }) => (
                                          <>
                                            <Input
                                              {...inputField}
                                              id={`create-secret-${index}-metadata-${metadataIndex}-key`}
                                              placeholder="Enter key"
                                              readOnly={Boolean(editSecret && isEditReadOnly)}
                                              className="h-8"
                                            />
                                            <FieldError errors={[error]} />
                                          </>
                                        )}
                                      />
                                    </FieldContent>
                                  </Field>

                                  <Field className="flex-1">
                                    <FieldLabel
                                      htmlFor={`create-secret-${index}-metadata-${metadataIndex}-value`}
                                      className={metadataIndex === 0 ? "text-xs" : "sr-only"}
                                    >
                                      Value
                                    </FieldLabel>
                                    <FieldContent>
                                      <Controller
                                        control={control}
                                        name={`secrets.${index}.metadata.${metadataIndex}.value`}
                                        render={({ field: inputField, fieldState: { error } }) => (
                                          <>
                                            <Input
                                              {...inputField}
                                              id={`create-secret-${index}-metadata-${metadataIndex}-value`}
                                              placeholder="Enter value"
                                              readOnly={Boolean(editSecret && isEditReadOnly)}
                                              className="h-8"
                                            />
                                            <FieldError errors={[error]} />
                                          </>
                                        )}
                                      />
                                    </FieldContent>
                                  </Field>

                                  <Field className="w-10">
                                    <FieldLabel
                                      htmlFor={`create-secret-${index}-metadata-${metadataIndex}-encrypted`}
                                      className={metadataIndex === 0 ? "text-xs" : "sr-only"}
                                    >
                                      Encrypt
                                    </FieldLabel>
                                    <Controller
                                      control={control}
                                      name={`secrets.${index}.metadata.${metadataIndex}.isEncrypted`}
                                      render={({ field: switchField }) => (
                                        <>
                                          <Toggle
                                            id={`create-secret-${index}-metadata-${metadataIndex}-encrypted`}
                                            className="mt-2"
                                            variant="project"
                                            size="default"
                                            checked={switchField.value}
                                            disabled={Boolean(
                                              currentProject?.enforceEncryptedSecretManagerSecretMetadata ||
                                              (editSecret && isEditReadOnly)
                                            )}
                                            onCheckedChange={switchField.onChange}
                                          />
                                          <FieldError
                                            errors={[
                                              errors.secrets?.[index]?.metadata?.[metadataIndex]
                                                ?.isEncrypted
                                            ]}
                                          />
                                        </>
                                      )}
                                    />
                                  </Field>

                                  <IconButton
                                    variant="ghost"
                                    size="xs"
                                    type="button"
                                    aria-label={`Remove metadata entry ${metadataIndex + 1}`}
                                    isDisabled={Boolean(editSecret && isEditReadOnly)}
                                    className={twMerge(
                                      metadataIndex === 0 ? "mt-6.5" : "mt-0.5",
                                      "transition-transform hover:text-danger"
                                    )}
                                    onClick={() =>
                                      setValue(
                                        `secrets.${index}.metadata`,
                                        metadata.filter(
                                          (__, currentIndex) => currentIndex !== metadataIndex
                                        ),
                                        { shouldDirty: true }
                                      )
                                    }
                                  >
                                    <TrashIcon className="size-4" />
                                  </IconButton>
                                </div>
                              ))}
                              <Button
                                variant="ghost"
                                size="xs"
                                type="button"
                                className={metadata.length === 0 ? "mx-auto" : ""}
                                isDisabled={Boolean(editSecret && isEditReadOnly)}
                                onClick={() =>
                                  setValue(
                                    `secrets.${index}.metadata`,
                                    [
                                      ...metadata,
                                      {
                                        id: crypto.randomUUID(),
                                        key: "",
                                        value: "",
                                        isEncrypted:
                                          currentProject?.enforceEncryptedSecretManagerSecretMetadata ??
                                          false
                                      }
                                    ],
                                    { shouldDirty: true }
                                  )
                                }
                              >
                                <PlusIcon className="mr-1 size-4" />
                                Add Entry
                              </Button>
                            </div>
                            <FieldDescription>
                              Encrypted Metadata will not be searchable via the UI or API.
                            </FieldDescription>
                          </FieldContent>
                        </Field>
                      </FieldGroup>
                    </div>
                  </AccordionContent>
                </AccordionItem>
              </Accordion>
            </div>
          );
        })}
        <Button
          type="button"
          variant="outline"
          className={editSecret ? "hidden" : undefined}
          onClick={() => {
            appendSecret({
              key: "",
              value: "",
              comment: "",
              skipMultilineEncoding: false,
              tags: [],
              metadata: []
            });
            setTimeout(() => secretKeyInputRefs.current[secretFields.length]?.focus(), 0);
          }}
        >
          <PlusIcon className="size-4" />
          Add More
        </Button>
      </div>
      <SheetFooter className="justify-between border-t">
        {onUploadSecrets && (
          <Button variant="outline" type="button" onClick={() => onUploadSecrets()}>
            <UploadIcon className="size-4" />
            Upload
          </Button>
        )}
        <div className="ml-auto flex gap-2">
          <Button
            onClick={() => {
              formOwner.current.invocation = {};
              if (!editSecret)
                overviewTelemetry.flow({
                  action: "create",
                  resourceType: "secret",
                  source: "form",
                  phase: "canceled"
                });
              onClose();
            }}
            variant="ghost"
            type="button"
          >
            Cancel
          </Button>
          <Button
            isPending={isSubmitting}
            isDisabled={isSubmitting || Boolean(editSecret && (isEditReadOnly || !hasEditChanges))}
            variant="project"
            type="submit"
          >
            {editSecret ? editSubmitLabel : "Create"}
          </Button>
        </div>
      </SheetFooter>
    </form>
  );
};