Infisical is the open-source platform for securing secrets, certificates, access, and AI Agents.
TypeScript acmeagentsai-agentscertificate-managementdevsecopsenvironment-variableskubernetesopen-sourcepampkipostgresprivate-caprivileged-access-managementsecret-managementsecret-managersecretssecrets-managementsecuritysecurity-toolsvault
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;
}
};