Self-hosted, plugin-based server management.
TypeScript dockerhomelabpluginsrdpremote-desktopself-hostedserver-managementsftpsshterminaltermixvnc
import { vi } from "vitest";
export interface FakeUser {
id: string;
username: string;
passwordHash: string;
isAdmin: boolean;
}
/** In-memory stand-ins for the repositories the login pipeline touches. */
export function createAuthState() {
return {
users: new Map<string, FakeUser>(),
identities: [] as Array<{
id: number;
userId: string;
providerId: string;
subject: string;
email: string | null;
}>,
factors: [] as Array<{
userId: string;
pluginId: string;
factorId: string;
}>,
roles: [] as Array<{ userId: string; roleName: string }>,
settings: new Map<string, string>(),
audits: [] as Array<Record<string, unknown>>,
trusted: new Set<string>(),
trustedAdded: [] as string[],
pendingTokens: new Map<string, string>(),
};
}
export type AuthState = ReturnType<typeof createAuthState>;
/** The user as UserRepository returns it, with isExternal filled in. */
function withIdentities(state: AuthState, user: FakeUser | undefined) {
if (!user) return null;
return {
...user,
isExternal: state.identities.some((row) => row.userId === user.id),
};
}
export function fakeFactory(state: AuthState) {
return {
createCurrentUserRepository: () => ({
findById: async (id: string) =>
withIdentities(state, state.users.get(id)),
findByUsername: async (username: string) =>
withIdentities(
state,
[...state.users.values()].find((u) => u.username === username),
),
countAll: async () => state.users.size,
listAll: async () =>
[...state.users.values()].map((u) => withIdentities(state, u)),
createFirstSsoUser: async (user: FakeUser) => {
const isFirstUser = state.users.size === 0;
const created = {
...user,
isAdmin: isFirstUser || !!user.isAdmin,
};
state.users.set(user.id, created);
return { user: created, isFirstUser };
},
update: async (id: string, changes: Partial<FakeUser>) => {
const user = state.users.get(id);
if (!user) return null;
Object.assign(user, changes);
return user;
},
delete: async (id: string) => state.users.delete(id),
}),
createCurrentUserAuthRepository: () => ({
listIdentitiesForUser: async (userId: string) =>
state.identities.filter((row) => row.userId === userId),
findIdentity: async (providerId: string, subject: string) =>
state.identities.find(
(row) => row.providerId === providerId && row.subject === subject,
) ?? null,
linkIdentity: async (input: {
userId: string;
providerId: string;
subject: string;
email?: string | null;
}) => {
const existing = state.identities.find(
(row) =>
row.providerId === input.providerId &&
row.subject === input.subject,
);
if (existing) {
existing.userId = input.userId;
return;
}
state.identities.push({
id: state.identities.length + 1,
userId: input.userId,
providerId: input.providerId,
subject: input.subject,
email: input.email ?? null,
});
},
countUsersForProvider: async (providerId: string) =>
new Set(
state.identities
.filter((row) => row.providerId === providerId)
.map((row) => row.userId),
).size,
listSecondFactors: async (userId: string) =>
state.factors.filter((row) => row.userId === userId),
hasSecondFactor: async (userId: string) =>
state.factors.some((row) => row.userId === userId),
listUserIdsWithSecondFactors: async () =>
new Set(state.factors.map((row) => row.userId)),
countUsersWithSecondFactors: async () =>
new Set(state.factors.map((row) => row.userId)).size,
recordSecondFactor: async (
userId: string,
pluginId: string,
factorId: string,
) => {
if (
!state.factors.some(
(row) =>
row.userId === userId &&
row.pluginId === pluginId &&
row.factorId === factorId,
)
) {
state.factors.push({ userId, pluginId, factorId });
}
},
removeSecondFactor: async (
userId: string,
pluginId: string,
factorId: string,
) => {
state.factors = state.factors.filter(
(row) =>
!(
row.userId === userId &&
row.pluginId === pluginId &&
row.factorId === factorId
),
);
return true;
},
clearSecondFactors: async (userId: string) => {
state.factors = state.factors.filter((row) => row.userId !== userId);
return 1;
},
}),
createCurrentRoleRepository: () => ({
assignRoleNameToUser: async (input: {
userId: string;
roleName: string;
}) => {
state.roles.push({ userId: input.userId, roleName: input.roleName });
return true;
},
switchUserRoleName: async (input: {
userId: string;
addRoleName: string;
removeRoleName: string;
}) => {
state.roles = state.roles.filter(
(role) =>
!(
role.userId === input.userId &&
role.roleName === input.removeRoleName
),
);
state.roles.push({ userId: input.userId, roleName: input.addRoleName });
},
listUserRoles: async (userId: string) =>
state.roles
.filter((role) => role.userId === userId)
.map((role, index) => ({ roleId: index, roleName: role.roleName })),
removeRoleFromUser: async () => true,
}),
createCurrentSettingsRepository: () => ({
get: async (key: string) => state.settings.get(key) ?? null,
getBoolean: async (key: string, fallback: boolean) =>
state.settings.has(key) ? state.settings.get(key) === "true" : fallback,
set: async (key: string, value: string) => {
state.settings.set(key, value);
},
delete: async (key: string) => state.settings.delete(key),
}),
getCurrentSettingValue: (key: string) => state.settings.get(key) ?? null,
createCurrentTrustedDeviceRepository: () => ({
deleteByUserId: async () => {},
}),
};
}
export function fakeAuthManager(state: AuthState) {
let tokenCount = 0;
return {
generateJWTToken: vi.fn(
async (userId: string, options: { pendingTOTP?: boolean } = {}) => {
if (!options.pendingTOTP) return `jwt-${++tokenCount}`;
const token = `pending-${++tokenCount}`;
state.pendingTokens.set(token, userId);
return token;
},
),
verifyJWTToken: vi.fn(async (token: string) => {
const userId = state.pendingTokens.get(token);
return userId ? { userId, pendingTOTP: true } : null;
}),
authenticateUser: vi.fn(async () => true),
authenticateExternalUser: vi.fn(async () => true),
revokeSessionsByExternalSession: vi.fn(async () => 1),
unlockWithSystemKey: vi.fn(async () => true),
registerExternalUser: vi.fn(async () => {}),
isTrustedDevice: vi.fn(async (userId: string, fingerprint: string) =>
state.trusted.has(`${userId}:${fingerprint}`),
),
addTrustedDevice: vi.fn(async (userId: string, fingerprint: string) => {
state.trustedAdded.push(`${userId}:${fingerprint}`);
}),
getSecureCookieOptions: vi.fn((_req: unknown, maxAge: number) => ({
httpOnly: true,
maxAge,
})),
getClearCookieOptions: vi.fn(() => ({ httpOnly: true })),
getUserDataKey: vi.fn(() => Buffer.alloc(32, 7)),
};
}
export function fakeRequest(overrides: Record<string, unknown> = {}) {
const headers: Record<string, string> = {
"user-agent": "Mozilla/5.0 (X11; Linux x86_64) Firefox/120.0",
...(overrides.headers as Record<string, string> | undefined),
};
return {
body: {},
query: {},
params: {},
cookies: {},
ip: "10.0.0.1",
socket: { remoteAddress: "10.0.0.1" },
...overrides,
headers,
get: (name: string) => headers[name.toLowerCase()],
} as Record<string, unknown> & { headers: Record<string, string> };
}
export function fakeResponse() {
const res = {
statusCode: 200,
body: undefined as unknown,
cookies: [] as Array<{ name: string; value: string; options: unknown }>,
cleared: [] as string[],
redirectedTo: null as string | null,
status(code: number) {
res.statusCode = code;
return res;
},
json(body: unknown) {
res.body = body;
return res;
},
cookie(name: string, value: string, options: unknown) {
res.cookies.push({ name, value, options });
return res;
},
clearCookie(name: string) {
res.cleared.push(name);
return res;
},
redirect(url: string) {
res.redirectedTo = url;
return res;
},
};
return res;
}