Self-hosted, plugin-based server management.
TypeScript dockerhomelabpluginsrdpremote-desktopself-hostedserver-managementsftpsshterminaltermixvnc
/**
* Login policy from plugins through ctx.auth.policy.provide: idle timeout,
* session length, remember me and a required second factor. Core asks every
* provider and the strictest answer wins. A provider that throws at login
* refuses the login, since skipping a security rule is worse than a failed
* sign in. The idle timeout is stored on the session at login. Desktop
* loopback, sync link and plugin minted sessions are device credentials, not
* logins, so the policy never reaches them.
*/
import type {
PluginAuthPolicyDecision,
PluginAuthPolicyInput,
PluginAuthPolicyProvider,
} from "@termix-ssh/plugin-sdk/backend";
import { authLogger } from "../utils/logger.js";
import { LoginMethodError } from "./types.js";
/** sessions.restriction of a session that may only set up a second factor. */
export const SECOND_FACTOR_SETUP = "second-factor-setup";
interface Entry {
pluginId: string;
provider: PluginAuthPolicyProvider;
}
const providers = new Map<symbol, Entry>();
export function provideAuthPolicy(
pluginId: string,
provider: PluginAuthPolicyProvider,
): () => void {
const key = Symbol(pluginId);
providers.set(key, { pluginId, provider });
return () => {
providers.delete(key);
};
}
/** Test seam. */
export function clearAuthPolicies(): void {
providers.clear();
}
export function hasAuthPolicies(): boolean {
return providers.size > 0;
}
export interface AuthPolicy {
allowRememberDevice: boolean;
maxSessionSeconds: number | null;
idleTimeoutSeconds: number | null;
secondFactor: "always" | "new-device" | null;
}
const NO_POLICY: AuthPolicy = {
allowRememberDevice: true,
maxSessionSeconds: null,
idleTimeoutSeconds: null,
secondFactor: null,
};
function shortest(current: number | null, next: unknown): number | null {
if (typeof next !== "number" || !(next > 0)) return current;
const value = Math.floor(next);
return current === null ? value : Math.min(current, value);
}
function merge(policy: AuthPolicy, next: PluginAuthPolicyDecision): AuthPolicy {
let secondFactor = policy.secondFactor;
if (next.secondFactor === "always") secondFactor = "always";
else if (next.secondFactor === "new-device" && secondFactor !== "always") {
secondFactor = "new-device";
}
return {
allowRememberDevice:
policy.allowRememberDevice && next.allowRememberDevice !== false,
maxSessionSeconds: shortest(
policy.maxSessionSeconds,
next.maxSessionSeconds,
),
idleTimeoutSeconds: shortest(
policy.idleTimeoutSeconds,
next.idleTimeoutSeconds,
),
secondFactor,
};
}
export async function evaluateAuthPolicy(
input: PluginAuthPolicyInput,
): Promise<AuthPolicy> {
let policy = NO_POLICY;
for (const entry of providers.values()) {
let decision: PluginAuthPolicyDecision;
try {
decision = (await entry.provider.evaluate(input)) ?? {};
} catch (error) {
authLogger.warn("Login policy failed, refusing the login", {
operation: "auth_policy",
pluginId: entry.pluginId,
error: error instanceof Error ? error.message : String(error),
});
throw new LoginMethodError(
"Sign in is not available right now. Contact an admin.",
503,
"auth_policy_unavailable",
);
}
policy = merge(policy, decision);
}
return policy;
}
/** Whether the login page should offer remember me. */
export function rememberDeviceAllowed(): boolean {
for (const entry of providers.values()) {
try {
if (entry.provider.allowRememberDevice?.() === false) return false;
} catch {
return false;
}
}
return true;
}