Skip to content

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

40.8 KB
Raw Blame
import { useLocation, useNavigate, useParams, useRouteContext } from "@tanstack/react-router";
import {
  BlocksIcon,
  BuildingIcon,
  CheckIcon,
  CogIcon,
  CreditCardIcon,
  DatabaseIcon,
  FileTextIcon,
  FolderOpenIcon,
  IdCardIcon,
  InboxIcon,
  KeyIcon,
  KeyRoundIcon,
  LayoutDashboardIcon,
  MoonIcon,
  SearchIcon,
  ServerCogIcon,
  SettingsIcon,
  ShieldCheckIcon,
  ShieldIcon,
  SunIcon,
  UserIcon,
  UsersIcon
} from "lucide-react";

import Telemetry from "@app/components/utilities/telemetry/Telemetry";
import {
  GlobalCommandMenu,
  type GlobalCommandMenuGroup,
  type GlobalCommandMenuItem,
  type GlobalCommandMenuSearchStatus
} from "@app/components/v3/generic/Command";
import { OrgIcon, ProjectIcon, SubOrgIcon } from "@app/components/v3/platform/ScopeIcons";
import {
  type Theme,
  type ThemeChangeSource,
  useTheme
} from "@app/components/v3/platform/ThemeProvider";
import {
  OrgPermissionActions,
  OrgPermissionAuditLogsActions,
  OrgPermissionBillingActions,
  OrgPermissionGroupActions,
  OrgPermissionIdentityActions,
  OrgPermissionMemberActions,
  OrgPermissionSubjects,
  ProjectPermissionActions,
  ProjectPermissionAuditLogsActions,
  ProjectPermissionCertificateActions,
  ProjectPermissionIdentityActions,
  ProjectPermissionKmipActions,
  ProjectPermissionMemberActions,
  ProjectPermissionPkiDiscoveryActions,
  ProjectPermissionSub,
  type TProjectPermission,
  useOrganization,
  useOrgPermission,
  useProject,
  useProjectPermission
} from "@app/context";
import { OrgPermissionAppConnectionActions } from "@app/context/OrgPermissionContext/types";
import {
  ProjectPermissionAppConnectionActions,
  ProjectPermissionSecretScanningFindingActions,
  ProjectPermissionSecretSyncActions
} from "@app/context/ProjectPermissionContext/types";
import { setCertManagerActiveProjectCookie } from "@app/helpers/certManagerActiveProject";
import { getOrganizationSwitchDestination } from "@app/helpers/organizationSwitch";
import { getProjectDisplayName, getProjectLucideIcon, getProjectTitle } from "@app/helpers/project";
import { setSecretScanningActiveProjectCookie } from "@app/helpers/secretScanningActiveProject";
import { useImplicitProduct } from "@app/hooks";
import { useGetOrganizationGroups, useGetOrganizationsWithSubOrgs } from "@app/hooks/api";
import { useCertManagerInstanceState } from "@app/hooks/api/certManagerInstance";
import { useGetAccessibleProjectsWithSubOrgs } from "@app/hooks/api/projects/queries";
import type { Project, TProjectNavigation } from "@app/hooks/api/projects/types";
import { ProjectType } from "@app/hooks/api/projects/types";
import { useGetUserOrgPermissions } from "@app/hooks/api/roles";
import { IntegrationsListPageTabs } from "@app/types/integrations";
import { OrgAccessControlTabSections } from "@app/types/org";

import { useSecretManagerCommandSearch } from "./useSecretManagerCommandSearch";

export type RootCommandMenuShell = "organization" | "admin" | "personal-settings";

type CommandContent = {
  browseGroups: GlobalCommandMenuGroup[];
  searchGroups: GlobalCommandMenuGroup[];
  searchStatus?: GlobalCommandMenuSearchStatus;
};

type AsyncCommandSearch = {
  groups: GlobalCommandMenuGroup[];
  searchStatus: GlobalCommandMenuSearchStatus;
  onSearchChange: (search: string) => void;
};

const COMMAND_MENU_EVENTS = {
  Opened: "Command Menu Opened",
  ActionSelected: "Command Menu Action Selected"
} as const;

const PRIVATE_ACTION_TYPES = [
  ["entity-project-", "Project"],
  ["entity-organization-", "Organization"],
  ["entity-team-", "Team"],
  ["project-resource-folder-", "Folder"],
  ["project-resource-dynamic-", "Dynamic Secret"],
  ["project-resource-rotation-", "Secret Rotation"],
  ["project-resource-secret-", "Secret"]
] as const;

const getCommandMenuAction = ({ id, label }: Pick<GlobalCommandMenuItem, "id" | "label">) =>
  PRIVATE_ACTION_TYPES.find(([prefix]) => id.startsWith(prefix))?.[1] ?? label;

const projectIconClassNames: Record<ProjectType, string> = {
  [ProjectType.SecretManager]: "text-product-sm",
  [ProjectType.CertificateManager]: "text-product-pki",
  [ProjectType.KMS]: "text-product-kms",
  [ProjectType.SecretScanning]: "text-product-ss",
  [ProjectType.PAM]: "text-product-pam",
  [ProjectType.AgentVault]: "text-product-av"
};

const NavigationCommandMenu = ({
  shell,
  browseGroups,
  searchGroups,
  searchStatus,
  asyncSearch
}: CommandContent & {
  shell: RootCommandMenuShell;
  asyncSearch?: AsyncCommandSearch;
}) => {
  const telemetry = new Telemetry().getInstance();

  return (
    <GlobalCommandMenu
      groups={browseGroups}
      searchGroups={[...searchGroups, ...(asyncSearch?.groups ?? [])]}
      searchStatus={
        [searchStatus, asyncSearch?.searchStatus].find((status) => status?.state === "loading") ??
        [searchStatus, asyncSearch?.searchStatus].find((status) => status?.state === "error")
      }
      onSearchChange={asyncSearch?.onSearchChange}
      onShortcutToggle={(open) => {
        if (open) {
          telemetry.capture(COMMAND_MENU_EVENTS.Opened, { shell, source: "keyboard-shortcut" });
        }
      }}
      onItemSelect={(item, { mode }) => {
        telemetry.capture(COMMAND_MENU_EVENTS.ActionSelected, {
          shell,
          mode,
          action: getCommandMenuAction(item),
          actionType: item.children ? "drill-down" : "navigation"
        });
      }}
      title="Search Infisical"
      description="Search pages, projects, organizations, teams, and commands."
      placeholder="Find..."
      emptyMessage="No matching pages or commands."
      showFooter={false}
    />
  );
};

const navigateToProject = (
  navigate: ReturnType<typeof useNavigate>,
  project: TProjectNavigation
) => {
  switch (project.type) {
    case ProjectType.SecretManager:
      return navigate({
        to: "/organizations/$orgId/projects/secret-management/$projectId/overview",
        params: { orgId: project.orgId, projectId: project.id }
      });
    case ProjectType.CertificateManager:
      setCertManagerActiveProjectCookie(project.orgId, project.id);
      return navigate({
        to: "/organizations/$orgId/cert-manager/overview",
        params: { orgId: project.orgId }
      });
    case ProjectType.SecretScanning:
      setSecretScanningActiveProjectCookie(project.orgId, project.id);
      return navigate({
        to: "/organizations/$orgId/secret-scanning/data-sources",
        params: { orgId: project.orgId }
      });
    case ProjectType.PAM:
      return navigate({
        to: "/organizations/$orgId/pam/accounts",
        params: { orgId: project.orgId }
      });
    case ProjectType.AgentVault:
      return navigate({
        to: "/organizations/$orgId/agent-vault",
        params: { orgId: project.orgId }
      });
    case ProjectType.KMS:
    default:
      return navigate({
        to: "/organizations/$orgId/projects/kms/$projectId/overview",
        params: { orgId: project.orgId, projectId: project.id }
      });
  }
};

const useEntityCommandGroups = ({
  currentOrganizationId,
  currentOrganizationName
}: {
  currentOrganizationId?: string;
  currentOrganizationName?: string;
}) => {
  const navigate = useNavigate();
  const location = useLocation();
  const projectsQuery = useGetAccessibleProjectsWithSubOrgs(currentOrganizationId ?? "");
  const organizationsQuery = useGetOrganizationsWithSubOrgs();
  const { data: projects = [] } = projectsQuery;
  const { data: rootOrganizations = [] } = organizationsQuery;
  const { data: orgPermissionData } = useGetUserOrgPermissions({
    orgId: currentOrganizationId ?? ""
  });
  const canReadTeams = Boolean(
    orgPermissionData?.permission.can(OrgPermissionGroupActions.Read, OrgPermissionSubjects.Groups)
  );
  const { data: teams = [] } = useGetOrganizationGroups(
    canReadTeams ? (currentOrganizationId ?? "") : ""
  );
  const organizations = rootOrganizations.flatMap((organization) => [
    { ...organization, rootOrganizationName: undefined, isSubOrganization: false },
    ...organization.subOrganizations.map((subOrganization) => ({
      ...subOrganization,
      rootOrganizationName: organization.name,
      isSubOrganization: true
    }))
  ]);
  const organizationsById = new Map(
    organizations.map((organization) => [organization.id, organization])
  );

  const certManagerProjectCountByOrg: Record<string, number> = {};
  projects.forEach((project) => {
    if (project.type === ProjectType.CertificateManager) {
      certManagerProjectCountByOrg[project.orgId] =
        (certManagerProjectCountByOrg[project.orgId] ?? 0) + 1;
    }
  });

  const projectItems: GlobalCommandMenuItem[] = projects.map((project) => {
    const organization = organizationsById.get(project.orgId);
    const organizationPath = [
      organization?.rootOrganizationName,
      organization?.name ?? "Organization"
    ]
      .filter(Boolean)
      .join(" / ");

    return {
      id: `entity-project-${project.id}`,
      label: getProjectDisplayName(project, (certManagerProjectCountByOrg[project.orgId] ?? 0) > 1),
      breadcrumb: `${organizationPath} / ${getProjectTitle(project.type)}`,
      icon: getProjectLucideIcon(project.type),
      iconClassName: projectIconClassNames[project.type],
      keywords: [project.slug, project.type, getProjectTitle(project.type), "project"],
      priority: project.orgId === currentOrganizationId ? 20 : 0,
      onSelect: () => navigateToProject(navigate, project)
    };
  });

  const organizationItems: GlobalCommandMenuItem[] = organizations.map((organization) => ({
    id: `entity-organization-${organization.id}`,
    label: organization.name,
    breadcrumb: organization.isSubOrganization
      ? `${organization.rootOrganizationName} / Sub-Organization`
      : "Organization",
    icon: organization.isSubOrganization ? SubOrgIcon : OrgIcon,
    iconClassName: organization.isSubOrganization ? "text-sub-org" : "text-org",
    keywords: [
      organization.slug,
      "organization",
      "workspace",
      ...(organization.isSubOrganization ? ["sub", "sub-org", "sub-organization"] : [])
    ],
    priority: organization.id === currentOrganizationId ? 20 : 0,
    onSelect: () => {
      if (organization.id === currentOrganizationId) {
        return navigate({
          to: "/organizations/$orgId/projects",
          params: { orgId: organization.id }
        });
      }
      return navigate(
        getOrganizationSwitchDestination(location, organization.id, organization.isSubOrganization)
      );
    }
  }));

  const teamItems: GlobalCommandMenuItem[] = teams.map((team) => ({
    id: `entity-team-${team.id}`,
    label: team.name,
    breadcrumb: `${currentOrganizationName ?? "Organization"} / Team`,
    icon: UsersIcon,
    iconClassName: "text-org",
    keywords: [team.slug, "team", "group"],
    priority: 15,
    onSelect: () =>
      navigate({
        to: "/organizations/$orgId/groups/$groupId",
        params: { orgId: currentOrganizationId!, groupId: team.id }
      })
  }));

  let searchStatus: GlobalCommandMenuSearchStatus = { state: "idle" };
  if (projectsQuery.isLoading || organizationsQuery.isLoading) {
    searchStatus = { state: "loading", message: "Loading projects and organizations…" };
  } else if (projectsQuery.isError || organizationsQuery.isError) {
    searchStatus = { state: "error", message: "Could not load projects or organizations." };
  }

  return {
    projectItems,
    organizationItems,
    teamItems,
    searchStatus,
    searchGroups: [
      { heading: "Projects", items: projectItems },
      { heading: "Organizations", items: organizationItems },
      { heading: "Teams", items: teamItems }
    ]
  };
};

const getNestedCommandGroup = ({
  projectItems,
  organizationItems,
  teamItems,
  theme,
  setTheme
}: {
  projectItems: GlobalCommandMenuItem[];
  organizationItems: GlobalCommandMenuItem[];
  teamItems: GlobalCommandMenuItem[];
  theme: Theme;
  setTheme: (theme: Theme, source: ThemeChangeSource) => void;
}): GlobalCommandMenuGroup => ({
  heading: "Explore",
  items: [
    {
      id: "command-search-projects",
      label: "Search Projects…",
      breadcrumb: "Global / Projects",
      icon: SearchIcon,
      keywords: ["find", "switch", "project"],
      children: [{ heading: "Projects", items: projectItems }],
      drilldownPlaceholder: "Search projects..."
    },
    {
      id: "command-switch-organization",
      label: "Switch Organization…",
      breadcrumb: "Global / Organizations",
      icon: BuildingIcon,
      keywords: ["team", "workspace", "organization"],
      children: [{ heading: "Organizations", items: organizationItems }],
      drilldownPlaceholder: "Search organizations..."
    },
    ...(teamItems.length
      ? [
          {
            id: "command-search-teams",
            label: "Search Teams…",
            breadcrumb: "Current Organization / Teams",
            icon: UsersIcon,
            keywords: ["group", "members"],
            children: [{ heading: "Teams", items: teamItems }],
            drilldownPlaceholder: "Search teams..."
          }
        ]
      : []),
    {
      id: "command-change-theme",
      label: "Change Theme…",
      breadcrumb: "Global / Appearance",
      icon: theme === "dark" ? MoonIcon : SunIcon,
      keywords: ["dark", "light", "appearance"],
      children: [
        {
          heading: "Theme",
          items: [
            {
              id: "theme-dark",
              label: "Dark",
              breadcrumb: `Appearance / ${theme === "dark" ? "Current theme" : "Theme"}`,
              icon: theme === "dark" ? CheckIcon : MoonIcon,
              keywords: ["theme"],
              isDisabled: theme === "dark",
              onSelect: () => setTheme("dark", "command-menu")
            },
            {
              id: "theme-light",
              label: "Light",
              breadcrumb: `Appearance / ${theme === "light" ? "Current theme" : "Theme"}`,
              icon: theme === "light" ? CheckIcon : SunIcon,
              keywords: ["theme"],
              isDisabled: theme === "light",
              onSelect: () => setTheme("light", "command-menu")
            }
          ]
        }
      ],
      drilldownPlaceholder: "Choose a theme..."
    }
  ]
});

const getAccountItems = (navigate: ReturnType<typeof useNavigate>): GlobalCommandMenuItem[] => [
  {
    id: "account-personal-settings",
    label: "Personal Settings",
    breadcrumb: "Account / General",
    icon: UserIcon,
    keywords: ["profile", "name", "email", "account"],
    priority: 5,
    onSelect: () => navigate({ to: "/personal-settings", search: { selectedTab: "general" } })
  },
  {
    id: "account-authentication",
    label: "Authentication",
    breadcrumb: "Account / Personal Settings",
    icon: ShieldCheckIcon,
    keywords: ["password", "mfa", "passkeys", "sessions"],
    priority: 5,
    onSelect: () =>
      navigate({ to: "/personal-settings", search: { selectedTab: "authentication" } })
  },
  {
    id: "account-api-keys",
    label: "API Keys",
    breadcrumb: "Account / Personal Settings",
    icon: KeyRoundIcon,
    keywords: ["tokens"],
    priority: 5,
    onSelect: () => navigate({ to: "/personal-settings", search: { selectedTab: "api-keys" } })
  }
];

const PersonalSettingsCommandMenu = () => {
  const { theme, setTheme } = useTheme();
  const organizationId = useRouteContext({
    from: "/_authenticate",
    select: (context) => context.organizationId
  });
  const navigate = useNavigate();
  const accountItems = getAccountItems(navigate).map((item) => ({ ...item, priority: 30 }));
  const entityGroups = useEntityCommandGroups({ currentOrganizationId: organizationId });
  const nestedGroup = getNestedCommandGroup({ ...entityGroups, theme, setTheme });

  return (
    <NavigationCommandMenu
      shell="personal-settings"
      searchStatus={entityGroups.searchStatus}
      browseGroups={[{ heading: "Account", items: accountItems }, nestedGroup]}
      searchGroups={[
        { heading: "Pages & Settings", items: accountItems },
        ...entityGroups.searchGroups
      ]}
    />
  );
};

const AdminCommandMenu = () => {
  const { theme, setTheme } = useTheme();
  const { currentOrg } = useOrganization();
  const navigate = useNavigate();
  const accountItems = getAccountItems(navigate);
  const entityGroups = useEntityCommandGroups({
    currentOrganizationId: currentOrg.id,
    currentOrganizationName: currentOrg.name
  });
  const adminItems: GlobalCommandMenuItem[] = [
    {
      id: "admin-general",
      label: "General",
      breadcrumb: "Server Console / Settings",
      icon: CogIcon,
      keywords: ["server", "configuration"],
      priority: 30,
      onSelect: () => navigate({ to: "/admin" })
    },
    {
      id: "admin-resource-overview",
      label: "Resource Overview",
      breadcrumb: "Server Console / Resources",
      icon: BuildingIcon,
      keywords: ["organizations", "users", "machine identities", "email domains"],
      priority: 30,
      onSelect: () =>
        navigate({
          to: "/admin/resources/overview",
          search: { selectedTab: "organizations" }
        })
    },
    {
      id: "admin-access-control",
      label: "Access Control",
      breadcrumb: "Server Console / Administration",
      icon: ShieldIcon,
      keywords: ["permissions", "admins"],
      priority: 30,
      onSelect: () => navigate({ to: "/admin/access-management" })
    }
  ];

  return (
    <NavigationCommandMenu
      shell="admin"
      searchStatus={entityGroups.searchStatus}
      browseGroups={[
        { heading: "Server Console", items: adminItems },
        { heading: "Global", items: accountItems.slice(0, 1) },
        getNestedCommandGroup({ ...entityGroups, theme, setTheme })
      ]}
      searchGroups={[
        { heading: "Pages & Settings", items: [...adminItems, ...accountItems] },
        ...entityGroups.searchGroups
      ]}
    />
  );
};

const getOrganizationItems = ({
  navigate,
  organizationId,
  organizationName,
  isRootOrganization,
  canReadAccessControl,
  canReadMachineIdentities,
  canReadRoles,
  canReadAuditLogs,
  canReadBilling,
  canReadAppConnections,
  canReadIntegrations,
  canReadSettings
}: {
  navigate: ReturnType<typeof useNavigate>;
  organizationId: string;
  organizationName: string;
  isRootOrganization: boolean;
  canReadAccessControl: boolean;
  canReadMachineIdentities: boolean;
  canReadRoles: boolean;
  canReadAuditLogs: boolean;
  canReadBilling: boolean;
  canReadAppConnections: boolean;
  canReadIntegrations: boolean;
  canReadSettings: boolean;
}): GlobalCommandMenuItem[] => [
  {
    id: `organization-${organizationId}-home`,
    label: "Organization Home",
    breadcrumb: organizationName,
    icon: isRootOrganization ? OrgIcon : SubOrgIcon,
    iconClassName: isRootOrganization ? "text-org" : "text-sub-org",
    keywords: ["projects", "home"],
    priority: 25,
    onSelect: () =>
      navigate({ to: "/organizations/$orgId/projects", params: { orgId: organizationId } })
  },
  ...(canReadIntegrations
    ? [
        {
          id: `organization-${organizationId}-integrations`,
          label: "Integrations",
          breadcrumb: `${organizationName} / Organization`,
          icon: BlocksIcon,
          iconClassName: isRootOrganization ? "text-org" : "text-sub-org",
          keywords: ["connections"],
          priority: 25,
          onSelect: () =>
            navigate({
              to: "/organizations/$orgId/integrations",
              params: { orgId: organizationId }
            })
        },
        ...(canReadAppConnections
          ? [
              {
                id: `organization-${organizationId}-app-connections`,
                label: "App Connections",
                breadcrumb: `${organizationName} / Integrations`,
                icon: BlocksIcon,
                iconClassName: isRootOrganization ? "text-org" : "text-sub-org",
                keywords: ["integrations", "connections"],
                priority: 25,
                onSelect: () =>
                  navigate({
                    to: "/organizations/$orgId/integrations",
                    params: { orgId: organizationId },
                    search: { selectedTab: IntegrationsListPageTabs.AppConnections }
                  })
              }
            ]
          : [])
      ]
    : []),
  ...(canReadAccessControl
    ? [
        {
          id: `organization-${organizationId}-access-control`,
          label: "Access Control",
          breadcrumb: `${organizationName} / Organization`,
          icon: ShieldIcon,
          iconClassName: isRootOrganization ? "text-org" : "text-sub-org",
          keywords: ["users", "groups", "teams", "roles", "machine identities"],
          priority: 25,
          onSelect: () =>
            navigate({
              to: "/organizations/$orgId/access-management",
              params: { orgId: organizationId }
            })
        }
      ]
    : []),
  ...(canReadMachineIdentities
    ? [
        {
          id: `organization-${organizationId}-machine-identities`,
          label: "Machine Identities",
          breadcrumb: `${organizationName} / Access Control`,
          icon: UserIcon,
          iconClassName: isRootOrganization ? "text-org" : "text-sub-org",
          keywords: ["identities", "identity", "access control"],
          priority: 25,
          onSelect: () =>
            navigate({
              to: "/organizations/$orgId/access-management",
              params: { orgId: organizationId },
              search: { selectedTab: OrgAccessControlTabSections.Identities }
            })
        }
      ]
    : []),
  ...(canReadRoles
    ? [
        {
          id: `organization-${organizationId}-roles`,
          label: "Roles",
          breadcrumb: `${organizationName} / Access Control`,
          icon: ShieldCheckIcon,
          iconClassName: isRootOrganization ? "text-org" : "text-sub-org",
          keywords: ["organization roles", "permissions", "access control"],
          priority: 25,
          onSelect: () =>
            navigate({
              to: "/organizations/$orgId/access-management",
              params: { orgId: organizationId },
              search: { selectedTab: OrgAccessControlTabSections.Roles }
            })
        }
      ]
    : []),
  ...(isRootOrganization && canReadBilling
    ? [
        {
          id: `organization-${organizationId}-billing`,
          label: "Usage & Billing",
          breadcrumb: `${organizationName} / Organization Settings`,
          icon: CreditCardIcon,
          iconClassName: "text-org",
          keywords: ["subscription", "plan"],
          priority: 25,
          onSelect: () =>
            navigate({ to: "/organizations/$orgId/billing", params: { orgId: organizationId } })
        }
      ]
    : []),
  ...(canReadAuditLogs
    ? [
        {
          id: `organization-${organizationId}-audit-logs`,
          label: "Audit Logs",
          breadcrumb: `${organizationName} / Organization`,
          icon: FileTextIcon,
          iconClassName: isRootOrganization ? "text-org" : "text-sub-org",
          priority: 25,
          onSelect: () =>
            navigate({
              to: "/organizations/$orgId/audit-logs",
              params: { orgId: organizationId }
            })
        }
      ]
    : []),
  ...(canReadSettings
    ? [
        {
          id: `organization-${organizationId}-settings`,
          label: "Settings",
          breadcrumb: `${organizationName} / Organization`,
          icon: SettingsIcon,
          iconClassName: isRootOrganization ? "text-org" : "text-sub-org",
          keywords: ["general", "organization settings"],
          priority: 25,
          onSelect: () =>
            navigate({
              to: "/organizations/$orgId/settings",
              params: { orgId: organizationId },
              search: { selectedTab: "tab-org-general" }
            })
        }
      ]
    : [])
];

const getProjectLandingItem = ({
  navigate,
  project,
  organizationName,
  isCertificateManagerAdmin,
  isCertManagerMultiInstance = false
}: {
  navigate: ReturnType<typeof useNavigate>;
  project: Project;
  organizationName: string;
  isCertificateManagerAdmin?: boolean;
  isCertManagerMultiInstance?: boolean;
}): GlobalCommandMenuItem => {
  const breadcrumb = `${organizationName} / ${getProjectDisplayName(project, isCertManagerMultiInstance)}`;

  if (project.type === ProjectType.CertificateManager && !isCertificateManagerAdmin) {
    return {
      id: `project-${project.id}-approval-requests`,
      label: "Approval Requests",
      breadcrumb,
      icon: InboxIcon,
      iconClassName: projectIconClassNames[project.type],
      keywords: [project.name, "certificate manager", "requests"],
      priority: 40,
      onSelect: () =>
        navigate({
          to: "/organizations/$orgId/cert-manager/requests",
          params: { orgId: project.orgId }
        })
    };
  }

  const presentation: Record<ProjectType, { label: string; icon: GlobalCommandMenuItem["icon"] }> =
    {
      [ProjectType.SecretManager]: { label: "Secrets", icon: ProjectIcon },
      [ProjectType.CertificateManager]: { label: "Dashboard", icon: LayoutDashboardIcon },
      [ProjectType.KMS]: { label: "Overview", icon: KeyIcon },
      [ProjectType.SecretScanning]: { label: "Data Sources", icon: DatabaseIcon },
      [ProjectType.PAM]: { label: "Accounts", icon: FolderOpenIcon },
      [ProjectType.AgentVault]: { label: "Sessions", icon: IdCardIcon }
    };

  return {
    id: `project-${project.id}-home`,
    label: presentation[project.type].label,
    breadcrumb,
    icon: presentation[project.type].icon,
    iconClassName: projectIconClassNames[project.type],
    keywords: [project.name, project.type, getProjectTitle(project.type)],
    priority: 40,
    onSelect: () => navigateToProject(navigate, project)
  };
};

const getProjectPageItems = ({
  navigate,
  project,
  organizationName,
  pathname,
  isCertificateManagerAdmin,
  isCertManagerMultiInstance = false
}: {
  navigate: ReturnType<typeof useNavigate>;
  project: Project;
  organizationName: string;
  pathname: string;
  isCertificateManagerAdmin?: boolean;
  isCertManagerMultiInstance?: boolean;
}): GlobalCommandMenuItem[] => {
  const breadcrumb = `${organizationName} / ${getProjectDisplayName(project, isCertManagerMultiInstance)}`;
  const item = (
    id: string,
    label: string,
    icon: GlobalCommandMenuItem["icon"],
    pathSuffix: string,
    onSelect: () => void,
    keywords?: string[]
  ): GlobalCommandMenuItem => ({
    id: `project-${project.id}-${id}`,
    label,
    breadcrumb,
    icon,
    iconClassName: projectIconClassNames[project.type],
    keywords: [project.name, getProjectTitle(project.type), ...(keywords ?? [])],
    priority: pathname.includes(`/${pathSuffix}`) ? 50 : 35,
    onSelect
  });
  const sortByContext = (items: GlobalCommandMenuItem[]) =>
    items.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));

  switch (project.type) {
    case ProjectType.SecretManager:
      return sortByContext([
        getProjectLandingItem({ navigate, project, organizationName }),
        item("integrations", "Integrations", BlocksIcon, "integrations", () =>
          navigate({
            to: "/organizations/$orgId/projects/secret-management/$projectId/integrations",
            params: { orgId: project.orgId, projectId: project.id }
          })
        ),
        item("access-control", "Access Control", ShieldIcon, "access-management", () =>
          navigate({
            to: "/organizations/$orgId/projects/secret-management/$projectId/access-management",
            params: { orgId: project.orgId, projectId: project.id }
          })
        ),
        item("audit-logs", "Audit Logs", FileTextIcon, "audit-logs", () =>
          navigate({
            to: "/organizations/$orgId/projects/secret-management/$projectId/audit-logs",
            params: { orgId: project.orgId, projectId: project.id }
          })
        ),
        item("settings", "Settings", SettingsIcon, "settings", () =>
          navigate({
            to: "/organizations/$orgId/projects/secret-management/$projectId/settings",
            params: { orgId: project.orgId, projectId: project.id },
            search: { selectedTab: "tab-project-general" }
          })
        )
      ]);
    case ProjectType.KMS:
      return sortByContext([
        getProjectLandingItem({ navigate, project, organizationName }),
        item("kmip", "KMIP", KeyIcon, "kmip", () =>
          navigate({
            to: "/organizations/$orgId/projects/kms/$projectId/kmip",
            params: { orgId: project.orgId, projectId: project.id }
          })
        ),
        item("access-control", "Access Control", ShieldIcon, "access-management", () =>
          navigate({
            to: "/organizations/$orgId/projects/kms/$projectId/access-management",
            params: { orgId: project.orgId, projectId: project.id }
          })
        ),
        item("audit-logs", "Audit Logs", FileTextIcon, "audit-logs", () =>
          navigate({
            to: "/organizations/$orgId/projects/kms/$projectId/audit-logs",
            params: { orgId: project.orgId, projectId: project.id }
          })
        ),
        item("settings", "Settings", SettingsIcon, "settings", () =>
          navigate({
            to: "/organizations/$orgId/projects/kms/$projectId/settings",
            params: { orgId: project.orgId, projectId: project.id }
          })
        )
      ]);
    case ProjectType.SecretScanning:
      return sortByContext([
        getProjectLandingItem({ navigate, project, organizationName }),
        item("findings", "Findings", SearchIcon, "findings", () =>
          navigate({
            to: "/organizations/$orgId/secret-scanning/findings",
            params: { orgId: project.orgId }
          })
        ),
        item("app-connections", "App Connections", BlocksIcon, "app-connections", () =>
          navigate({
            to: "/organizations/$orgId/secret-scanning/app-connections",
            params: { orgId: project.orgId }
          })
        ),
        item("access-control", "Access Control", ShieldIcon, "access-management", () =>
          navigate({
            to: "/organizations/$orgId/secret-scanning/access-management",
            params: { orgId: project.orgId }
          })
        ),
        item("audit-logs", "Audit Logs", FileTextIcon, "audit-logs", () =>
          navigate({
            to: "/organizations/$orgId/secret-scanning/audit-logs",
            params: { orgId: project.orgId }
          })
        ),
        item("settings", "Settings", SettingsIcon, "settings", () =>
          navigate({
            to: "/organizations/$orgId/secret-scanning/settings",
            params: { orgId: project.orgId },
            search: { selectedTab: "general" }
          })
        )
      ]);
    case ProjectType.CertificateManager: {
      const landing = getProjectLandingItem({
        navigate,
        project,
        organizationName,
        isCertificateManagerAdmin,
        isCertManagerMultiInstance
      });
      if (!isCertificateManagerAdmin) return [landing];
      return sortByContext([
        landing,
        item("inventory", "Inventory", DatabaseIcon, "inventory", () =>
          navigate({
            to: "/organizations/$orgId/cert-manager/inventory",
            params: { orgId: project.orgId }
          })
        ),
        item("discovery", "Discovery", SearchIcon, "discovery", () =>
          navigate({
            to: "/organizations/$orgId/cert-manager/discovery",
            params: { orgId: project.orgId }
          })
        ),
        item("access-control", "Access Control", ShieldIcon, "access-management", () =>
          navigate({
            to: "/organizations/$orgId/cert-manager/access-management",
            params: { orgId: project.orgId }
          })
        ),
        item("audit-logs", "Audit Logs", FileTextIcon, "audit-logs", () =>
          navigate({
            to: "/organizations/$orgId/cert-manager/audit-logs",
            params: { orgId: project.orgId }
          })
        ),
        item("settings", "Settings", SettingsIcon, "settings", () =>
          navigate({
            to: "/organizations/$orgId/cert-manager/settings",
            params: { orgId: project.orgId }
          })
        )
      ]);
    }
    case ProjectType.PAM:
    default:
      return [getProjectLandingItem({ navigate, project, organizationName })];
  }
};

const filterProjectPageItems = (items: GlobalCommandMenuItem[], permission: TProjectPermission) => {
  const canReadAccessControl =
    permission.can(ProjectPermissionMemberActions.Read, ProjectPermissionSub.Member) ||
    permission.can(ProjectPermissionIdentityActions.Read, ProjectPermissionSub.Identity) ||
    permission.can(ProjectPermissionActions.Read, ProjectPermissionSub.Groups) ||
    permission.can(ProjectPermissionActions.Read, ProjectPermissionSub.Role) ||
    permission.can(ProjectPermissionActions.Read, ProjectPermissionSub.ServiceTokens);
  const canReadIntegrations =
    permission.can(ProjectPermissionActions.Read, ProjectPermissionSub.Integrations) ||
    permission.can(ProjectPermissionSecretSyncActions.Read, ProjectPermissionSub.SecretSyncs) ||
    permission.can(ProjectPermissionAppConnectionActions.Read, ProjectPermissionSub.AppConnections);
  const canReadSettings =
    permission.can(ProjectPermissionActions.Read, ProjectPermissionSub.Settings) ||
    permission.can(ProjectPermissionActions.Read, ProjectPermissionSub.Environments) ||
    permission.can(ProjectPermissionActions.Read, ProjectPermissionSub.Tags) ||
    permission.can(ProjectPermissionActions.Read, ProjectPermissionSub.Webhooks) ||
    permission.can(ProjectPermissionActions.Read, ProjectPermissionSub.IpAllowList);

  return items.filter(({ id }) => {
    if (id.endsWith("-access-control")) return canReadAccessControl;
    if (id.endsWith("-integrations")) return canReadIntegrations;
    if (id.endsWith("-audit-logs")) {
      return permission.can(ProjectPermissionAuditLogsActions.Read, ProjectPermissionSub.AuditLogs);
    }
    if (id.endsWith("-settings")) return canReadSettings;
    if (id.endsWith("-kmip")) {
      return permission.can(ProjectPermissionKmipActions.ReadClients, ProjectPermissionSub.Kmip);
    }
    if (id.endsWith("-inventory")) {
      return permission.can(
        ProjectPermissionCertificateActions.Read,
        ProjectPermissionSub.Certificates
      );
    }
    if (id.endsWith("-discovery")) {
      return permission.can(
        ProjectPermissionPkiDiscoveryActions.Read,
        ProjectPermissionSub.PkiDiscovery
      );
    }
    if (id.endsWith("-findings")) {
      return permission.can(
        ProjectPermissionSecretScanningFindingActions.Read,
        ProjectPermissionSub.SecretScanningFindings
      );
    }
    if (id.endsWith("-app-connections")) {
      return permission.can(
        ProjectPermissionAppConnectionActions.Read,
        ProjectPermissionSub.AppConnections
      );
    }
    return true;
  });
};

const CertificateProjectCommandMenu = ({
  content,
  hasProjectRole,
  permission
}: {
  content: CommandContent;
  hasProjectRole: (role: string) => boolean;
  permission: TProjectPermission;
}) => {
  const { currentOrg } = useOrganization();
  const { currentProject } = useProject();
  const navigate = useNavigate();
  const { pathname } = useLocation();
  const { data: certManagerInstance } = useCertManagerInstanceState();
  const isCertManagerMultiInstance = Boolean(certManagerInstance?.isMultiInstance);
  const projectItems = filterProjectPageItems(
    getProjectPageItems({
      navigate,
      project: currentProject,
      organizationName: currentOrg.name,
      pathname,
      isCertificateManagerAdmin: hasProjectRole("admin"),
      isCertManagerMultiInstance
    }),
    permission
  );
  const menuHeading = getProjectDisplayName(currentProject, isCertManagerMultiInstance);

  return (
    <NavigationCommandMenu
      shell="organization"
      searchStatus={content.searchStatus}
      browseGroups={[
        { heading: menuHeading, items: projectItems.slice(0, 2) },
        ...content.browseGroups
      ]}
      searchGroups={[{ heading: menuHeading, items: projectItems }, ...content.searchGroups]}
    />
  );
};

const SecretManagerProjectCommandMenu = ({
  content,
  projectItems
}: {
  content: CommandContent;
  projectItems: GlobalCommandMenuItem[];
}) => {
  const { currentProject } = useProject();
  const asyncSearch = useSecretManagerCommandSearch(currentProject);

  return (
    <NavigationCommandMenu
      shell="organization"
      searchStatus={content.searchStatus}
      browseGroups={[
        { heading: currentProject.name, items: projectItems.slice(0, 2) },
        ...content.browseGroups
      ]}
      searchGroups={[{ heading: "Current Project", items: projectItems }, ...content.searchGroups]}
      asyncSearch={asyncSearch}
    />
  );
};

const CurrentProjectCommandMenu = ({ content }: { content: CommandContent }) => {
  const { currentOrg } = useOrganization();
  const { currentProject } = useProject();
  const navigate = useNavigate();
  const { pathname } = useLocation();
  const { hasProjectRole, permission } = useProjectPermission();

  if (currentProject.type === ProjectType.CertificateManager) {
    return (
      <CertificateProjectCommandMenu
        content={content}
        hasProjectRole={hasProjectRole}
        permission={permission}
      />
    );
  }

  const projectItems = filterProjectPageItems(
    getProjectPageItems({
      navigate,
      project: currentProject,
      organizationName: currentOrg.name,
      pathname
    }),
    permission
  );

  if (currentProject.type === ProjectType.SecretManager) {
    return <SecretManagerProjectCommandMenu content={content} projectItems={projectItems} />;
  }

  return (
    <NavigationCommandMenu
      shell="organization"
      searchStatus={content.searchStatus}
      browseGroups={[
        { heading: currentProject.name, items: projectItems.slice(0, 2) },
        ...content.browseGroups
      ]}
      searchGroups={[{ heading: "Current Project", items: projectItems }, ...content.searchGroups]}
    />
  );
};

const OrganizationCommandMenu = () => {
  const { theme, setTheme } = useTheme();
  const { projectId } = useParams({ strict: false }) as { projectId?: string };
  const orgScopedProduct = useImplicitProduct();
  const { currentOrg, isRootOrganization } = useOrganization();
  const user = useRouteContext({ from: "/_authenticate", select: (context) => context.user });
  const { permission } = useOrgPermission();
  const navigate = useNavigate();
  const entityGroups = useEntityCommandGroups({
    currentOrganizationId: currentOrg.id,
    currentOrganizationName: currentOrg.name
  });
  const organizationItems = getOrganizationItems({
    navigate,
    organizationId: currentOrg.id,
    organizationName: currentOrg.name,
    isRootOrganization,
    canReadAccessControl:
      permission.can(OrgPermissionMemberActions.Read, OrgPermissionSubjects.Member) ||
      permission.can(OrgPermissionIdentityActions.Read, OrgPermissionSubjects.Identity) ||
      permission.can(OrgPermissionGroupActions.Read, OrgPermissionSubjects.Groups) ||
      permission.can(OrgPermissionActions.Read, OrgPermissionSubjects.Role),
    canReadMachineIdentities: permission.can(
      OrgPermissionIdentityActions.Read,
      OrgPermissionSubjects.Identity
    ),
    canReadRoles: permission.can(OrgPermissionActions.Read, OrgPermissionSubjects.Role),
    canReadAuditLogs: permission.can(
      OrgPermissionAuditLogsActions.Read,
      OrgPermissionSubjects.AuditLogs
    ),
    canReadBilling: permission.can(OrgPermissionBillingActions.Read, OrgPermissionSubjects.Billing),
    canReadAppConnections: permission.can(
      OrgPermissionAppConnectionActions.Read,
      OrgPermissionSubjects.AppConnections
    ),
    canReadIntegrations:
      permission.can(
        OrgPermissionAppConnectionActions.Read,
        OrgPermissionSubjects.AppConnections
      ) || permission.can(OrgPermissionActions.Read, OrgPermissionSubjects.Settings),
    canReadSettings: permission.can(OrgPermissionActions.Read, OrgPermissionSubjects.Settings)
  });
  const accountItems = getAccountItems(navigate);
  const globalItems = [
    ...accountItems,
    ...(user.superAdmin
      ? [
          {
            id: "account-server-console",
            label: "Server Console",
            breadcrumb: "Global / Administration",
            icon: ServerCogIcon,
            keywords: ["admin", "server"],
            priority: 5,
            onSelect: () => navigate({ to: "/admin" })
          }
        ]
      : [])
  ];
  const content: CommandContent = {
    searchStatus: entityGroups.searchStatus,
    browseGroups: [
      { heading: currentOrg.name, items: organizationItems.slice(0, 3) },
      { heading: "Global", items: globalItems.slice(0, user.superAdmin ? 2 : 1) },
      getNestedCommandGroup({ ...entityGroups, theme, setTheme })
    ],
    searchGroups: [
      { heading: "Pages & Settings", items: [...organizationItems, ...globalItems] },
      ...entityGroups.searchGroups
    ]
  };
  if (projectId || orgScopedProduct) return <CurrentProjectCommandMenu content={content} />;
  return <NavigationCommandMenu shell="organization" {...content} />;
};

export const RootCommandMenu = ({ shell }: { shell: RootCommandMenuShell }) => {
  switch (shell) {
    case "organization":
      return <OrganizationCommandMenu />;
    case "admin":
      return <AdminCommandMenu />;
    case "personal-settings":
      return <PersonalSettingsCommandMenu />;
    default:
      return null;
  }
};