Skip to content

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

refactor(gateways): gate direct transport on the CLI version

bernie-g276a8be04b47
diff --git a/backend/src/ee/routes/v1/pam-routers/pam-session-router.ts b/backend/src/ee/routes/v1/pam-routers/pam-session-router.ts
index 2a9bfde4b2..757d3aa44d 100644
--- a/backend/src/ee/routes/v1/pam-routers/pam-session-router.ts
+++ b/backend/src/ee/routes/v1/pam-routers/pam-session-router.ts
@@ -3,7 +3,6 @@ import z from "zod";
import { PamSessionsSchema } from "@app/db/schemas";
import { EventType, UserAgentType } from "@app/ee/services/audit-log/audit-log-types";
-import { GatewayTransport } from "@app/ee/services/gateway-v2/gateway-v2-constants";
import { PamAccessMethod, PamAccountType, PamSessionStatus } from "@app/ee/services/pam/pam-enums";
import { PamPolicyRulesSchema } from "@app/ee/services/pam/pam-policies";
import { hostPattern } from "@app/ee/services/pam-account/pam-account-schemas";
@@ -324,14 +323,7 @@ export const registerPamWebAccessRouter = async (server: FastifyZodProvider) =>
.max(255)
.regex(hostPattern, "Must be a valid hostname or IP address")
.optional()
- .describe("Target host to connect to, for accounts that allow multiple hosts"),
- supportedTransports: z
- .array(z.nativeEnum(GatewayTransport))
- .max(2)
- .optional()
- .describe(
- "Transports the client can dial. Omit to let the platform choose. A CLI that predates direct connections omits it, so the platform treats an omitted list as relay-only for CLI access."
- )
+ .describe("Target host to connect to, for accounts that allow multiple hosts")
}),
response: {
200: z.object({
@@ -386,10 +378,7 @@ export const registerPamWebAccessRouter = async (server: FastifyZodProvider) =>
mfaSessionId: req.body.mfaSessionId,
tokenVersionId: isUserSessionAuth(req.auth) ? req.auth.tokenVersionId : undefined,
accessMethod: req.body.accessMethod === "web" ? PamAccessMethod.Web : PamAccessMethod.Cli,
- targetHost: req.body.targetHost,
- // [] is an older CLI that only knows relays, so it must not collapse to undefined.
- supportedTransports:
- req.body.accessMethod === PamAccessMethod.Web ? undefined : (req.body.supportedTransports ?? [])
+ targetHost: req.body.targetHost
});
await server.services.auditLog.createAuditLog({
diff --git a/backend/src/ee/services/gateway-v2/gateway-v2-service.ts b/backend/src/ee/services/gateway-v2/gateway-v2-service.ts
index 1136fb1e90..227cb3664a 100644
--- a/backend/src/ee/services/gateway-v2/gateway-v2-service.ts
+++ b/backend/src/ee/services/gateway-v2/gateway-v2-service.ts
@@ -504,7 +504,7 @@ export const gatewayV2ServiceFactory = ({
host,
port,
actorMetadata,
- supportedTransports
+ clientSupportsDirect
}: {
gatewayId: string;
sessionId: string;
@@ -513,7 +513,7 @@ export const gatewayV2ServiceFactory = ({
host: string;
port?: number;
actorMetadata: { id: string; type: ActorType; name: string };
- supportedTransports?: GatewayTransport[];
+ clientSupportsDirect: boolean;
}) => {
const gateway = await gatewayV2DAL.findById(gatewayId);
if (!gateway) {
@@ -525,8 +525,10 @@ export const gatewayV2ServiceFactory = ({
throw new NotFoundError({ message: `Gateway Config for org ${gateway.orgId} not found.` });
}
- const { allowDirect, allowRelay, hasTransport, isDirectOnlyForOlderClient, gatewayHasTransport } =
- resolveClientTransports({ gateway, supportedTransports });
+ const { allowDirect, hasTransport, isDirectOnlyForOlderClient, gatewayHasTransport } = resolveClientTransports({
+ gateway,
+ clientSupportsDirect
+ });
if (isDirectOnlyForOlderClient) {
throw new BadRequestError({
@@ -647,17 +649,16 @@ export const gatewayV2ServiceFactory = ({
const gatewayClientCertPrivateKey = crypto.nativeCrypto.KeyObject.from(clientKeys.privateKey);
- const relayCredentials =
- allowRelay && gateway.relayId
- ? await relayService.getCredentialsForClient({
- relayId: gateway.relayId,
- orgId: gateway.orgId,
- orgName: gateway.orgName,
- gatewayId,
- gatewayName: gateway.name,
- duration
- })
- : undefined;
+ const relayCredentials = gateway.relayId
+ ? await relayService.getCredentialsForClient({
+ relayId: gateway.relayId,
+ orgId: gateway.orgId,
+ orgName: gateway.orgName,
+ gatewayId,
+ gatewayName: gateway.name,
+ duration
+ })
+ : undefined;
return {
gatewayId,
diff --git a/backend/src/ee/services/gateway-v2/gateway-v2-transport-fns.test.ts b/backend/src/ee/services/gateway-v2/gateway-v2-transport-fns.test.ts
index 09cfd3fd11..e6d75ea876 100644
--- a/backend/src/ee/services/gateway-v2/gateway-v2-transport-fns.test.ts
+++ b/backend/src/ee/services/gateway-v2/gateway-v2-transport-fns.test.ts
@@ -141,72 +141,59 @@ describe("resolveClientTransports", () => {
const relay = { directAddress: null, relayId: "relay-1", heartbeatTTL: TTL };
const dual = { directAddress: "gw.internal:8443", relayId: "relay-1", heartbeatTTL: TTL };
- test("browser access omits the list and takes whatever the gateway has", () => {
- expect(resolveClientTransports({ gateway: { ...dual, directHeartbeat: fresh } })).toMatchObject({
- useDirect: true,
- useRelay: true
- });
+ test("browser access takes whatever the gateway has", () => {
+ expect(
+ resolveClientTransports({ gateway: { ...dual, directHeartbeat: fresh }, clientSupportsDirect: true })
+ ).toMatchObject({ useDirect: true, useRelay: true });
});
// Covers a real bug: direct went out on client capability alone, so every session paid the timeout.
test("a stale direct probe is skipped when the relay can take over", () => {
expect(
- resolveClientTransports({
- gateway: { ...dual, directHeartbeat: stale },
- supportedTransports: [GatewayTransport.Direct, GatewayTransport.Relay]
- })
+ resolveClientTransports({ gateway: { ...dual, directHeartbeat: stale }, clientSupportsDirect: true })
).toMatchObject({ useDirect: false, useRelay: true, hasTransport: true });
});
test("a stale direct probe is still used when it is the only path the client has", () => {
expect(
- resolveClientTransports({
- gateway: { ...direct, directHeartbeat: stale },
- supportedTransports: [GatewayTransport.Direct]
- })
- ).toMatchObject({ useDirect: true, useRelay: false, hasTransport: true });
- });
-
- test("a stale direct probe is still used when the client cannot dial the relay", () => {
- expect(
- resolveClientTransports({
- gateway: { ...dual, directHeartbeat: stale },
- supportedTransports: [GatewayTransport.Direct]
- })
+ resolveClientTransports({ gateway: { ...direct, directHeartbeat: stale }, clientSupportsDirect: true })
).toMatchObject({ useDirect: true, useRelay: false, hasTransport: true });
});
- test("an empty list is an older CLI, which gets the relay and never the direct address", () => {
+ test("an older CLI gets the relay and never the direct address", () => {
expect(
- resolveClientTransports({ gateway: { ...dual, directHeartbeat: fresh }, supportedTransports: [] })
+ resolveClientTransports({ gateway: { ...dual, directHeartbeat: fresh }, clientSupportsDirect: false })
).toMatchObject({ useDirect: false, useRelay: true, hasTransport: true });
});
test("an older CLI against a direct-only gateway is told to upgrade rather than given nothing", () => {
expect(
- resolveClientTransports({ gateway: { ...direct, directHeartbeat: fresh }, supportedTransports: [] })
+ resolveClientTransports({ gateway: { ...direct, directHeartbeat: fresh }, clientSupportsDirect: false })
).toMatchObject({ hasTransport: false, isDirectOnlyForOlderClient: true, gatewayHasTransport: true });
});
test("a relay-only gateway serves an older CLI", () => {
expect(
- resolveClientTransports({ gateway: { ...relay, directHeartbeat: null }, supportedTransports: [] })
+ resolveClientTransports({ gateway: { ...relay, directHeartbeat: null }, clientSupportsDirect: false })
).toMatchObject({ useDirect: false, useRelay: true, isDirectOnlyForOlderClient: false });
});
test("a gateway with no transport is reported as such, not as a client problem", () => {
expect(
resolveClientTransports({
- gateway: { directAddress: null, relayId: null, directHeartbeat: null, heartbeatTTL: TTL }
+ gateway: { directAddress: null, relayId: null, directHeartbeat: null, heartbeatTTL: TTL },
+ clientSupportsDirect: true
})
).toMatchObject({ hasTransport: false, gatewayHasTransport: false, isDirectOnlyForOlderClient: false });
});
test("the TTL kill switch drops a dual gateway to its relay", () => {
- expect(resolveClientTransports({ gateway: { ...dual, directHeartbeat: fresh, heartbeatTTL: 0 } })).toMatchObject({
- useDirect: false,
- useRelay: true
- });
+ expect(
+ resolveClientTransports({
+ gateway: { ...dual, directHeartbeat: fresh, heartbeatTTL: 0 },
+ clientSupportsDirect: true
+ })
+ ).toMatchObject({ useDirect: false, useRelay: true });
});
});
diff --git a/backend/src/ee/services/gateway-v2/gateway-v2-transport-fns.ts b/backend/src/ee/services/gateway-v2/gateway-v2-transport-fns.ts
index cf509509e6..38d7f1d8ad 100644
--- a/backend/src/ee/services/gateway-v2/gateway-v2-transport-fns.ts
+++ b/backend/src/ee/services/gateway-v2/gateway-v2-transport-fns.ts
@@ -71,10 +71,9 @@ export const gatewayTransports = ({
return transports;
};
-// undefined means the platform dials on the client's behalf; [] is an older CLI that only knows relays.
export const resolveClientTransports = ({
gateway,
- supportedTransports
+ clientSupportsDirect
}: {
gateway: {
directAddress?: string | null;
@@ -82,31 +81,22 @@ export const resolveClientTransports = ({
directHeartbeat?: Date | null;
heartbeatTTL?: number | null;
};
- supportedTransports?: GatewayTransport[];
+ clientSupportsDirect: boolean;
}) => {
- const clientAllowsDirect = supportedTransports === undefined || supportedTransports.includes(GatewayTransport.Direct);
- const allowRelay =
- supportedTransports === undefined ||
- supportedTransports.length === 0 ||
- supportedTransports.includes(GatewayTransport.Relay);
-
// Skip a stale direct address only when the relay can take over; otherwise it is the client's only path.
- const canFallBackToRelay = allowRelay && Boolean(gateway.relayId);
const allowDirect =
- clientAllowsDirect &&
- (!canFallBackToRelay ||
- isTransportHealthy({ probedAt: gateway.directHeartbeat, heartbeatTTL: gateway.heartbeatTTL }));
+ clientSupportsDirect &&
+ (!gateway.relayId || isTransportHealthy({ probedAt: gateway.directHeartbeat, heartbeatTTL: gateway.heartbeatTTL }));
const useDirect = allowDirect && Boolean(gateway.directAddress);
- const useRelay = allowRelay && Boolean(gateway.relayId);
+ const useRelay = Boolean(gateway.relayId);
return {
allowDirect,
- allowRelay,
useDirect,
useRelay,
hasTransport: useDirect || useRelay,
- isDirectOnlyForOlderClient: Boolean(gateway.directAddress) && !gateway.relayId && !clientAllowsDirect,
+ isDirectOnlyForOlderClient: Boolean(gateway.directAddress) && !gateway.relayId && !clientSupportsDirect,
gatewayHasTransport: Boolean(gateway.directAddress || gateway.relayId)
};
};
diff --git a/backend/src/ee/services/pam-session/pam-session-fns.ts b/backend/src/ee/services/pam-session/pam-session-fns.ts
index a6935be046..28702db1cc 100644
--- a/backend/src/ee/services/pam-session/pam-session-fns.ts
+++ b/backend/src/ee/services/pam-session/pam-session-fns.ts
@@ -116,7 +116,8 @@ export const sendPamSessionCancellationSignal = ({
accountType: accountType as PamAccountType,
host: "0.0.0.0",
port: 0,
- actorMetadata: { id: actorId, type: actorType, name: actorEmail }
+ actorMetadata: { id: actorId, type: actorType, name: actorEmail },
+ clientSupportsDirect: true
});
if (!certs) {
logger.error(
diff --git a/backend/src/ee/services/pam-session/pam-session-service.ts b/backend/src/ee/services/pam-session/pam-session-service.ts
index dd0060c67c..1f6e8fec4f 100644
--- a/backend/src/ee/services/pam-session/pam-session-service.ts
+++ b/backend/src/ee/services/pam-session/pam-session-service.ts
@@ -1,9 +1,9 @@
import RE2 from "re2";
import { TGatewayPoolServiceFactory } from "@app/ee/services/gateway-pool/gateway-pool-service";
-import { GatewayTransport } from "@app/ee/services/gateway-v2/gateway-v2-constants";
import { TGatewayV2ServiceFactory } from "@app/ee/services/gateway-v2/gateway-v2-service";
import { TPermissionServiceFactory } from "@app/ee/services/permission/permission-service-types";
+import { CliCapability, cliSupports } from "@app/lib/cli-version/cli-version-fns";
import { BadRequestError, ForbiddenRequestError, NotFoundError } from "@app/lib/errors";
import { ms } from "@app/lib/ms";
import { alphaNumericNanoId } from "@app/lib/nanoid";
@@ -442,8 +442,7 @@ export const pamSessionServiceFactory = ({
mfaSessionId,
tokenVersionId,
accessMethod = PamAccessMethod.Cli,
- targetHost,
- supportedTransports
+ targetHost
}: {
path: string;
projectId: string;
@@ -458,7 +457,6 @@ export const pamSessionServiceFactory = ({
tokenVersionId?: string;
accessMethod?: PamAccessMethod;
targetHost?: string;
- supportedTransports?: GatewayTransport[];
}) => {
const account = await resolveAccountByPath(projectId, path);
@@ -715,7 +713,9 @@ export const pamSessionServiceFactory = ({
type: actor.actor,
name: user?.email ?? actorName
},
- supportedTransports
+ // The platform dials for web sessions, so only a CLI caller is gated on its version.
+ clientSupportsDirect:
+ accessMethod === PamAccessMethod.Web || cliSupports(actorUserAgent, CliCapability.DirectGatewayTransport)
});
if (!certs) {
diff --git a/backend/src/ee/services/pam-web-access/pam-web-access-service.ts b/backend/src/ee/services/pam-web-access/pam-web-access-service.ts
index bfd4c0461c..d0ed5164b6 100644
--- a/backend/src/ee/services/pam-web-access/pam-web-access-service.ts
+++ b/backend/src/ee/services/pam-web-access/pam-web-access-service.ts
@@ -543,7 +543,9 @@ export const pamWebAccessServiceFactory = ({
id: userId,
type: ActorType.USER,
name: user?.email ?? ""
- }
+ },
+ // The platform opens this tunnel itself, so no client version gates the transport.
+ clientSupportsDirect: true
});
if (!attemptCerts) {
diff --git a/backend/src/lib/cli-version/cli-version-fns.test.ts b/backend/src/lib/cli-version/cli-version-fns.test.ts
new file mode 100644
index 0000000000..a7d1a7bb9c
--- /dev/null
+++ b/backend/src/lib/cli-version/cli-version-fns.test.ts
@@ -0,0 +1,108 @@
+import { UserAgentType } from "@app/ee/services/audit-log/audit-log-types";
+
+import {
+ CLI_CAPABILITY_MIN_VERSION,
+ CLI_USER_AGENT_NAME,
+ CliCapability,
+ cliSupports,
+ isCliAtLeastVersion,
+ isCliUserAgent,
+ isDevelopmentCli,
+ parseCliVersion
+} from "./cli-version-fns";
+
+describe("CLI_USER_AGENT_NAME", () => {
+ test("matches the audit log's own CLI user agent", () => {
+ expect(CLI_USER_AGENT_NAME).toBe(UserAgentType.CLI);
+ });
+});
+
+describe("isCliUserAgent", () => {
+ test("accepts a versioned CLI and the bare token older releases send", () => {
+ expect(isCliUserAgent("cli/0.43.131")).toBe(true);
+ expect(isCliUserAgent("cli/devel")).toBe(true);
+ expect(isCliUserAgent("cli")).toBe(true);
+ });
+
+ test("rejects anything else, including a user agent that merely starts with the token", () => {
+ expect(isCliUserAgent(undefined)).toBe(false);
+ expect(isCliUserAgent("")).toBe(false);
+ expect(isCliUserAgent("client/1.0.0")).toBe(false);
+ expect(isCliUserAgent("k8-operator/0.11.4")).toBe(false);
+ expect(isCliUserAgent("Mozilla/5.0")).toBe(false);
+ });
+});
+
+describe("parseCliVersion", () => {
+ test("reads the release number, ignoring any suffix a pre-release carries", () => {
+ expect(parseCliVersion("cli/0.43.131")).toEqual([0, 43, 131]);
+ expect(parseCliVersion("cli/1.2.3-rc1")).toEqual([1, 2, 3]);
+ });
+
+ test("returns null for a CLI that does not report a version, and for non-CLI callers", () => {
+ expect(parseCliVersion("cli")).toBeNull();
+ expect(parseCliVersion("cli/devel")).toBeNull();
+ expect(parseCliVersion("terraform")).toBeNull();
+ expect(parseCliVersion(undefined)).toBeNull();
+ });
+});
+
+describe("isDevelopmentCli", () => {
+ test("only a source build counts", () => {
+ expect(isDevelopmentCli("cli/devel")).toBe(true);
+ expect(isDevelopmentCli("cli/0.43.131")).toBe(false);
+ expect(isDevelopmentCli("cli")).toBe(false);
+ expect(isDevelopmentCli(undefined)).toBe(false);
+ });
+});
+
+describe("isCliAtLeastVersion", () => {
+ test("the boundary release itself satisfies its own minimum", () => {
+ expect(isCliAtLeastVersion("cli/0.43.131", "0.43.131")).toBe(true);
+ });
+
+ test("later releases satisfy it, across every position", () => {
+ expect(isCliAtLeastVersion("cli/0.43.132", "0.43.131")).toBe(true);
+ expect(isCliAtLeastVersion("cli/0.44.0", "0.43.131")).toBe(true);
+ expect(isCliAtLeastVersion("cli/1.0.0", "0.43.131")).toBe(true);
+ });
+
+ test("earlier releases do not, including ones whose later segments read as larger", () => {
+ expect(isCliAtLeastVersion("cli/0.43.130", "0.43.131")).toBe(false);
+ expect(isCliAtLeastVersion("cli/0.42.999", "0.43.131")).toBe(false);
+ expect(isCliAtLeastVersion("cli/0.9.999", "0.43.131")).toBe(false);
+ });
+
+ test("a source build satisfies any minimum", () => {
+ expect(isCliAtLeastVersion("cli/devel", "0.43.131")).toBe(true);
+ expect(isCliAtLeastVersion("cli/devel", "99.0.0")).toBe(true);
+ });
+
+ test("a caller that is not a versioned CLI never satisfies a minimum", () => {
+ expect(isCliAtLeastVersion("cli", "0.43.131")).toBe(false);
+ expect(isCliAtLeastVersion(undefined, "0.43.131")).toBe(false);
+ expect(isCliAtLeastVersion("k8-operator/9.9.9", "0.43.131")).toBe(false);
+ expect(isCliAtLeastVersion("Mozilla/5.0", "0.43.131")).toBe(false);
+ });
+
+ test("a malformed minimum is a programming error and fails loudly", () => {
+ expect(() => isCliAtLeastVersion("cli/0.43.131", "0.43")).toThrow("Invalid CLI version");
+ expect(() => isCliAtLeastVersion("cli/0.43.131", "v0.43.131")).toThrow("Invalid CLI version");
+ expect(() => isCliAtLeastVersion("cli/devel", "0.43.131-rc1")).toThrow("Invalid CLI version");
+ });
+});
+
+describe("cliSupports", () => {
+ test("every registered capability carries a well-formed minimum", () => {
+ Object.values(CliCapability).forEach((capability) => {
+ expect(() => isCliAtLeastVersion("cli/devel", CLI_CAPABILITY_MIN_VERSION[capability])).not.toThrow();
+ });
+ });
+
+ test("direct gateway transport starts at the release that shipped it", () => {
+ expect(cliSupports("cli/0.43.131", CliCapability.DirectGatewayTransport)).toBe(true);
+ expect(cliSupports("cli/0.43.130", CliCapability.DirectGatewayTransport)).toBe(false);
+ expect(cliSupports("cli", CliCapability.DirectGatewayTransport)).toBe(false);
+ expect(cliSupports(undefined, CliCapability.DirectGatewayTransport)).toBe(false);
+ });
+});
diff --git a/backend/src/lib/cli-version/cli-version-fns.ts b/backend/src/lib/cli-version/cli-version-fns.ts
new file mode 100644
index 0000000000..b3f0b71e08
--- /dev/null
+++ b/backend/src/lib/cli-version/cli-version-fns.ts
@@ -0,0 +1,60 @@
+import RE2 from "re2";
+
+// Duplicates UserAgentType.CLI to keep this module out of the audit-log type graph; a test guards the drift.
+export const CLI_USER_AGENT_NAME = "cli";
+
+// A source build reports no release number and satisfies every capability.
+const DEVELOPMENT_VERSION = "devel";
+
+const VERSION_REGEX = new RE2(/^(\d+)\.(\d+)\.(\d+)/);
+const STRICT_VERSION_REGEX = new RE2(/^(\d+)\.(\d+)\.(\d+)$/);
+
+export enum CliCapability {
+ DirectGatewayTransport = "direct-gateway-transport"
+}
+
+export const CLI_CAPABILITY_MIN_VERSION: Record<CliCapability, string> = {
+ [CliCapability.DirectGatewayTransport]: "0.43.131"
+};
+
+const getCliVersionSegment = (userAgent?: string) => {
+ if (!userAgent) return null;
+ const prefix = `${CLI_USER_AGENT_NAME}/`;
+ return userAgent.startsWith(prefix) ? userAgent.slice(prefix.length) : null;
+};
+
+export const isCliUserAgent = (userAgent?: string) =>
+ userAgent === CLI_USER_AGENT_NAME || getCliVersionSegment(userAgent) !== null;
+
+export const isDevelopmentCli = (userAgent?: string) => getCliVersionSegment(userAgent) === DEVELOPMENT_VERSION;
+
+export const parseCliVersion = (userAgent?: string): [number, number, number] | null => {
+ const segment = getCliVersionSegment(userAgent);
+ if (!segment) return null;
+
+ const match = VERSION_REGEX.exec(segment);
+ return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null;
+};
+
+const parseMinimum = (minimum: string): [number, number, number] => {
+ const match = STRICT_VERSION_REGEX.exec(minimum);
+ // Every minimum is a literal we control, so a malformed one is a bug rather than bad input.
+ if (!match) throw new Error(`Invalid CLI version '${minimum}': expected the major.minor.patch format`);
+ return [Number(match[1]), Number(match[2]), Number(match[3])];
+};
+
+export const isCliAtLeastVersion = (userAgent: string | undefined, minimum: string) => {
+ const floor = parseMinimum(minimum);
+ if (isDevelopmentCli(userAgent)) return true;
+
+ const version = parseCliVersion(userAgent);
+ if (!version) return false;
+
+ for (let i = 0; i < floor.length; i += 1) {
+ if (version[i] !== floor[i]) return version[i] > floor[i];
+ }
+ return true;
+};
+
+export const cliSupports = (userAgent: string | undefined, capability: CliCapability) =>
+ isCliAtLeastVersion(userAgent, CLI_CAPABILITY_MIN_VERSION[capability]);
diff --git a/backend/src/server/plugins/audit-log.ts b/backend/src/server/plugins/audit-log.ts
index 3dd63c28a5..dec39d85cc 100644
--- a/backend/src/server/plugins/audit-log.ts
+++ b/backend/src/server/plugins/audit-log.ts
@@ -2,6 +2,7 @@ import { requestContext } from "@fastify/request-context";
import fp from "fastify-plugin";
import { UserAgentType } from "@app/ee/services/audit-log/audit-log-types";
+import { isCliUserAgent } from "@app/lib/cli-version/cli-version-fns";
import { BadRequestError } from "@app/lib/errors";
import { RequestContextKey } from "@app/lib/request-context/request-context-keys";
import { ActorType, AuthMode } from "@app/services/auth/auth-type";
@@ -10,7 +11,7 @@ export const getUserAgentType = (userAgent: string | undefined) => {
if (userAgent === undefined) {
return UserAgentType.OTHER;
}
- if (userAgent === UserAgentType.CLI) {
+ if (isCliUserAgent(userAgent)) {
return UserAgentType.CLI;
}
// also match the versioned UA, e.g. "k8-operator/0.11.4"