Buriburizaemon/nodewarden
1
0
Fork 0
mirror of https://github.com/shuaiplus/nodewarden.git synced 2026-06-20 13:00:39 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
8f2704fd41150dbc8e1db18168106ca3b91d1c32
nodewarden/webapp/src/lib/demo.ts
T

1216 lines
44 KiB
TypeScript
Raw Blame History

import type { AppMainRoutesProps } from '@/components/AppMainRoutes';
import type { CompletedLogin, InitialAppBootstrapState } from '@/lib/app-auth';
import type {
AdminBackupImportResponse,
AdminBackupRunResponse,
AdminBackupSettings,
RemoteBackupBrowserResponse,
} from '@/lib/api/backup';
import type {
AdminInvite,
AdminUser,
AuthorizedDevice,
Cipher,
Folder,
Profile,
Send,
SendDraft,
SessionState,
VaultDraft,
} from '@/lib/types';
import { t } from '@/lib/i18n';
import { dispatchBackupProgress } from '@/lib/backup-restore-progress';
type Notify = (type: 'success' | 'error' | 'warning', text: string) => void;
type StateSetter<T> = (next: T[] | ((prev: T[]) => T[])) => void;
type BackupSettingsSetter = (next: AdminBackupSettings | ((prev: AdminBackupSettings) => AdminBackupSettings)) => void;
interface DemoRouteState {
ciphers: Cipher[];
folders: Folder[];
sends: Send[];
users: AdminUser[];
invites: AdminInvite[];
authorizedDevices: AuthorizedDevice[];
backupSettings: AdminBackupSettings;
setCiphers: StateSetter<Cipher>;
setFolders: StateSetter<Folder>;
setSends: StateSetter<Send>;
setUsers: StateSetter<AdminUser>;
setInvites: StateSetter<AdminInvite>;
setAuthorizedDevices: StateSetter<AuthorizedDevice>;
setBackupSettings: BackupSettingsSetter;
}
export const IS_DEMO_MODE = __NODEWARDEN_DEMO__;
const DEMO_USER_ID = 'demo-user-001';
const DEMO_NOW = '2026-05-04T08:00:00.000Z';
export const DEMO_PROFILE: Profile = {
id: DEMO_USER_ID,
email: 'demo@nodewarden.app',
name: 'NodeWarden Demo',
key: 'demo-profile-key',
masterPasswordHint: 'In demo mode, any input unlocks the vault.',
privateKey: null,
publicKey: 'demo-public-key',
role: 'admin',
premium: true,
object: 'profile',
};
export const DEMO_SESSION: SessionState = {
accessToken: 'demo-access-token',
refreshToken: 'demo-refresh-token',
email: DEMO_PROFILE.email,
authMode: 'token',
symEncKey: 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=',
symMacKey: 'BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB=',
};
export const DEMO_FOLDERS: Folder[] = [
{ id: 'folder-work', name: 'Work', decName: 'Work', creationDate: DEMO_NOW, revisionDate: DEMO_NOW },
{ id: 'folder-personal', name: 'Personal', decName: 'Personal', creationDate: DEMO_NOW, revisionDate: DEMO_NOW },
{ id: 'folder-devops', name: 'DevOps', decName: 'DevOps', creationDate: DEMO_NOW, revisionDate: DEMO_NOW },
];
export const DEMO_CIPHERS: Cipher[] = [
{
id: 'cipher-login-github',
type: 1,
folderId: 'folder-work',
favorite: true,
reprompt: 0,
name: 'GitHub',
notes: 'Main engineering organization account.',
decName: 'GitHub',
decNotes: 'Main engineering organization account.',
creationDate: '2026-04-12T09:20:00.000Z',
revisionDate: '2026-05-01T10:15:00.000Z',
login: {
username: 'demo@nodewarden.app',
password: 'correct-horse-battery-staple',
totp: 'otpauth://totp/GitHub:demo%40nodewarden.app?secret=JBSWY3DPEHPK3PXP&issuer=GitHub',
decUsername: 'demo@nodewarden.app',
decPassword: 'correct-horse-battery-staple',
decTotp: 'otpauth://totp/GitHub:demo%40nodewarden.app?secret=JBSWY3DPEHPK3PXP&issuer=GitHub',
uris: [{ uri: 'https://github.com', decUri: 'https://github.com', match: null }],
fido2Credentials: [{ creationDate: '2026-04-14T08:10:00.000Z', rpId: 'github.com' }],
},
fields: [
{ type: 0, name: 'Recovery email', value: 'ops@nodewarden.app', decName: 'Recovery email', decValue: 'ops@nodewarden.app' },
{ type: 1, name: 'Backup code', value: 'NW-DEMO-2026', decName: 'Backup code', decValue: 'NW-DEMO-2026' },
],
passwordHistory: [
{ password: 'old-demo-password', decPassword: 'old-demo-password', lastUsedDate: '2026-04-01T12:00:00.000Z' },
],
attachments: [
{ id: 'att-github-recovery', fileName: 'recovery-codes.txt', decFileName: 'recovery-codes.txt', size: 1540, sizeName: '1.5 KB' },
],
},
{
id: 'cipher-login-cloudflare',
type: 1,
folderId: 'folder-devops',
favorite: true,
reprompt: 1,
name: 'Cloudflare Dashboard',
notes: 'Reprompt preview item.',
decName: 'Cloudflare Dashboard',
decNotes: 'Reprompt preview item.',
creationDate: '2026-04-18T10:45:00.000Z',
revisionDate: '2026-05-02T14:00:00.000Z',
login: {
username: 'admin@nodewarden.app',
password: 'demo-cloudflare-password',
totp: 'otpauth://totp/Cloudflare:admin%40nodewarden.app?secret=JBSWY3DPEHPK3PXP&issuer=Cloudflare',
decUsername: 'admin@nodewarden.app',
decPassword: 'demo-cloudflare-password',
decTotp: 'otpauth://totp/Cloudflare:admin%40nodewarden.app?secret=JBSWY3DPEHPK3PXP&issuer=Cloudflare',
uris: [{ uri: 'https://dash.cloudflare.com', decUri: 'https://dash.cloudflare.com', match: null }],
},
},
{
id: 'cipher-login-google',
type: 1,
folderId: 'folder-work',
favorite: true,
reprompt: 0,
name: 'Google Workspace',
notes: 'Shared admin mailbox with passkey and recovery fields.',
decName: 'Google Workspace',
decNotes: 'Shared admin mailbox with passkey and recovery fields.',
creationDate: '2026-04-19T09:30:00.000Z',
revisionDate: '2026-05-03T09:30:00.000Z',
login: {
username: 'workspace.admin@nodewarden.app',
password: 'demo-google-password-2026',
totp: 'otpauth://totp/Google:workspace.admin%40nodewarden.app?secret=JBSWY3DPEHPK3PXP&issuer=Google',
decUsername: 'workspace.admin@nodewarden.app',
decPassword: 'demo-google-password-2026',
decTotp: 'otpauth://totp/Google:workspace.admin%40nodewarden.app?secret=JBSWY3DPEHPK3PXP&issuer=Google',
uris: [{ uri: 'https://accounts.google.com', decUri: 'https://accounts.google.com', match: null }],
fido2Credentials: [{ creationDate: '2026-04-20T07:00:00.000Z', rpId: 'google.com' }],
passwordRevisionDate: '2026-05-03T09:30:00.000Z',
},
fields: [
{ type: 0, name: 'Recovery email', value: 'recovery@nodewarden.app', decName: 'Recovery email', decValue: 'recovery@nodewarden.app' },
{ type: 1, name: 'Backup code', value: 'GOOG-NW-2026-01', decName: 'Backup code', decValue: 'GOOG-NW-2026-01' },
{ type: 2, name: 'Admin console', value: 'true', decName: 'Admin console', decValue: 'true' },
],
passwordHistory: [
{ password: 'demo-google-old-password', decPassword: 'demo-google-old-password', lastUsedDate: '2026-03-30T09:00:00.000Z' },
],
},
{
id: 'cipher-login-microsoft',
type: 1,
folderId: 'folder-work',
favorite: false,
reprompt: 0,
name: 'Microsoft 365',
notes: 'Demo tenant administrator.',
decName: 'Microsoft 365',
decNotes: 'Demo tenant administrator.',
creationDate: '2026-04-20T09:30:00.000Z',
revisionDate: '2026-05-03T10:30:00.000Z',
login: {
username: 'admin@nodewarden.onmicrosoft.com',
password: 'demo-microsoft-password-2026',
totp: 'otpauth://totp/Microsoft:admin%40nodewarden.onmicrosoft.com?secret=JBSWY3DPEHPK3PXP&issuer=Microsoft',
decUsername: 'admin@nodewarden.onmicrosoft.com',
decPassword: 'demo-microsoft-password-2026',
decTotp: 'otpauth://totp/Microsoft:admin%40nodewarden.onmicrosoft.com?secret=JBSWY3DPEHPK3PXP&issuer=Microsoft',
uris: [{ uri: 'https://login.microsoftonline.com', decUri: 'https://login.microsoftonline.com', match: null }],
fido2Credentials: [{ creationDate: '2026-04-21T07:00:00.000Z', rpId: 'login.microsoftonline.com' }],
passwordRevisionDate: '2026-05-03T10:30:00.000Z',
},
fields: [
{ type: 0, name: 'Tenant ID', value: '11111111-2222-3333-4444-555555555555', decName: 'Tenant ID', decValue: '11111111-2222-3333-4444-555555555555' },
{ type: 1, name: 'Recovery code', value: 'MSFT-NW-2026-02', decName: 'Recovery code', decValue: 'MSFT-NW-2026-02' },
{ type: 2, name: 'Conditional access', value: 'true', decName: 'Conditional access', decValue: 'true' },
],
},
{
id: 'cipher-login-amazon',
type: 1,
folderId: 'folder-personal',
favorite: false,
reprompt: 0,
name: 'Amazon',
notes: 'Shopping account with TOTP for code-list preview.',
decName: 'Amazon',
decNotes: 'Shopping account with TOTP for code-list preview.',
creationDate: '2026-04-21T09:30:00.000Z',
revisionDate: '2026-05-03T11:30:00.000Z',
login: {
username: 'demo@nodewarden.app',
password: 'demo-amazon-password-2026',
totp: 'otpauth://totp/Amazon:demo%40nodewarden.app?secret=JBSWY3DPEHPK3PXP&issuer=Amazon',
decUsername: 'demo@nodewarden.app',
decPassword: 'demo-amazon-password-2026',
decTotp: 'otpauth://totp/Amazon:demo%40nodewarden.app?secret=JBSWY3DPEHPK3PXP&issuer=Amazon',
uris: [{ uri: 'https://www.amazon.com', decUri: 'https://www.amazon.com', match: null }],
passwordRevisionDate: '2026-05-03T11:30:00.000Z',
},
fields: [
{ type: 0, name: 'Phone', value: '+1 555 0101', decName: 'Phone', decValue: '+1 555 0101' },
{ type: 1, name: 'Recovery code', value: 'AMZN-NW-2026-03', decName: 'Recovery code', decValue: 'AMZN-NW-2026-03' },
],
},
{
id: 'cipher-login-netflix',
type: 1,
folderId: 'folder-personal',
favorite: false,
reprompt: 0,
name: 'Netflix',
notes: 'Consumer account example.',
decName: 'Netflix',
decNotes: 'Consumer account example.',
creationDate: '2026-04-22T09:30:00.000Z',
revisionDate: '2026-05-03T12:30:00.000Z',
login: {
username: 'family@nodewarden.app',
password: 'demo-netflix-password-2026',
totp: 'otpauth://totp/Netflix:family%40nodewarden.app?secret=JBSWY3DPEHPK3PXP&issuer=Netflix',
decUsername: 'family@nodewarden.app',
decPassword: 'demo-netflix-password-2026',
decTotp: 'otpauth://totp/Netflix:family%40nodewarden.app?secret=JBSWY3DPEHPK3PXP&issuer=Netflix',
uris: [{ uri: 'https://www.netflix.com', decUri: 'https://www.netflix.com', match: null }],
passwordRevisionDate: '2026-05-03T12:30:00.000Z',
},
fields: [
{ type: 0, name: 'Profile PIN', value: '0426', decName: 'Profile PIN', decValue: '0426' },
{ type: 1, name: 'Backup code', value: 'NFLX-NW-2026-04', decName: 'Backup code', decValue: 'NFLX-NW-2026-04' },
],
},
{
id: 'cipher-login-paypal',
type: 1,
folderId: 'folder-personal',
favorite: true,
reprompt: 1,
name: 'PayPal',
notes: 'Financial account with reprompt and TOTP.',
decName: 'PayPal',
decNotes: 'Financial account with reprompt and TOTP.',
creationDate: '2026-04-23T09:30:00.000Z',
revisionDate: '2026-05-03T13:30:00.000Z',
login: {
username: 'billing@nodewarden.app',
password: 'demo-paypal-password-2026',
totp: 'otpauth://totp/PayPal:billing%40nodewarden.app?secret=JBSWY3DPEHPK3PXP&issuer=PayPal',
decUsername: 'billing@nodewarden.app',
decPassword: 'demo-paypal-password-2026',
decTotp: 'otpauth://totp/PayPal:billing%40nodewarden.app?secret=JBSWY3DPEHPK3PXP&issuer=PayPal',
uris: [{ uri: 'https://www.paypal.com', decUri: 'https://www.paypal.com', match: null }],
fido2Credentials: [{ creationDate: '2026-04-24T07:00:00.000Z', rpId: 'paypal.com' }],
passwordRevisionDate: '2026-05-03T13:30:00.000Z',
},
fields: [
{ type: 0, name: 'Recovery phone', value: '+1 555 0102', decName: 'Recovery phone', decValue: '+1 555 0102' },
{ type: 1, name: 'Backup code', value: 'PYPL-NW-2026-05', decName: 'Backup code', decValue: 'PYPL-NW-2026-05' },
{ type: 2, name: 'Business account', value: 'true', decName: 'Business account', decValue: 'true' },
],
},
{
id: 'cipher-card-company',
type: 3,
folderId: 'folder-work',
favorite: false,
name: 'Company Visa',
decName: 'Company Visa',
notes: 'Demo card data.',
decNotes: 'Demo card data.',
creationDate: '2026-03-22T09:00:00.000Z',
revisionDate: DEMO_NOW,
card: {
cardholderName: 'NodeWarden Demo',
number: '4111 1111 1111 1111',
brand: 'Visa',
expMonth: '12',
expYear: '2030',
code: '123',
decCardholderName: 'NodeWarden Demo',
decNumber: '4111 1111 1111 1111',
decBrand: 'Visa',
decExpMonth: '12',
decExpYear: '2030',
decCode: '123',
},
},
{
id: 'cipher-identity-team',
type: 4,
folderId: 'folder-personal',
name: 'Travel Identity',
decName: 'Travel Identity',
notes: 'Sample identity for form preview.',
decNotes: 'Sample identity for form preview.',
creationDate: '2026-02-20T11:00:00.000Z',
revisionDate: DEMO_NOW,
identity: {
title: 'Mr.',
firstName: 'Alex',
middleName: 'Morgan',
lastName: 'Chen',
username: 'alex.demo',
company: 'NodeWarden Labs',
ssn: '123-45-6789',
passportNumber: 'X12345678',
licenseNumber: 'D1234567',
email: 'alex.demo@example.com',
phone: '+1 555 0100',
address1: '100 Demo Street',
address2: 'Suite 42',
address3: 'Reception: Demo Desk',
city: 'San Francisco',
state: 'CA',
postalCode: '94105',
country: 'United States',
decTitle: 'Mr.',
decFirstName: 'Alex',
decMiddleName: 'Morgan',
decLastName: 'Chen',
decUsername: 'alex.demo',
decCompany: 'NodeWarden Labs',
decSsn: '123-45-6789',
decPassportNumber: 'X12345678',
decLicenseNumber: 'D1234567',
decEmail: 'alex.demo@example.com',
decPhone: '+1 555 0100',
decAddress1: '100 Demo Street',
decAddress2: 'Suite 42',
decAddress3: 'Reception: Demo Desk',
decCity: 'San Francisco',
decState: 'CA',
decPostalCode: '94105',
decCountry: 'United States',
},
},
{
id: 'cipher-note-release',
type: 2,
folderId: null,
favorite: false,
name: 'Release checklist',
decName: 'Release checklist',
notes: 'Review build, dry-run deploy, and release notes before shipping.',
decNotes: 'Review build, dry-run deploy, and release notes before shipping.',
creationDate: '2026-04-25T08:30:00.000Z',
revisionDate: DEMO_NOW,
secureNote: { type: 0 },
},
{
id: 'cipher-ssh-prod',
type: 5,
folderId: 'folder-devops',
favorite: false,
name: 'Production SSH key',
decName: 'Production SSH key',
notes: 'Fake SSH key material for UI preview.',
decNotes: 'Fake SSH key material for UI preview.',
creationDate: '2026-01-10T08:30:00.000Z',
revisionDate: DEMO_NOW,
sshKey: {
privateKey: '-----BEGIN OPENSSH PRIVATE KEY-----\nDEMO-PRIVATE-KEY\n-----END OPENSSH PRIVATE KEY-----',
publicKey: 'ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIDemoNodeWardenKey demo@nodewarden',
keyFingerprint: 'SHA256:demoNodeWardenFingerprint',
decPrivateKey: '-----BEGIN OPENSSH PRIVATE KEY-----\nDEMO-PRIVATE-KEY\n-----END OPENSSH PRIVATE KEY-----',
decPublicKey: 'ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIDemoNodeWardenKey demo@nodewarden',
decFingerprint: 'SHA256:demoNodeWardenFingerprint',
},
},
{
id: 'cipher-archived',
type: 1,
folderId: 'folder-personal',
favorite: false,
name: 'Archived demo login',
decName: 'Archived demo login',
notes: 'Archived state preview.',
decNotes: 'Archived state preview.',
archivedDate: '2026-05-03T06:00:00.000Z',
creationDate: '2026-04-05T06:00:00.000Z',
revisionDate: '2026-05-03T06:00:00.000Z',
login: {
username: 'archived@example.com',
password: 'archived-demo',
decUsername: 'archived@example.com',
decPassword: 'archived-demo',
uris: [{ uri: 'https://example.com', decUri: 'https://example.com', match: null }],
},
},
];
export const DEMO_SENDS: Send[] = [
{
id: 'send-demo-note',
accessId: 'demo-note',
type: 0,
name: 'Onboarding note',
decName: 'Onboarding note',
notes: 'Text Send preview.',
decNotes: 'Text Send preview.',
text: { text: 'Welcome to NodeWarden demo mode.', hidden: false },
decText: 'Welcome to NodeWarden demo mode.',
accessCount: 3,
maxAccessCount: 10,
disabled: false,
deletionDate: '2026-05-18T08:00:00.000Z',
expirationDate: null,
revisionDate: DEMO_NOW,
shareUrl: '/#/send/demo-note/demo-key',
},
{
id: 'send-demo-file',
accessId: 'demo-file',
type: 1,
name: 'Design handoff.zip',
decName: 'Design handoff.zip',
notes: 'File Send preview.',
decNotes: 'File Send preview.',
accessCount: 1,
maxAccessCount: null,
disabled: false,
deletionDate: '2026-05-11T08:00:00.000Z',
expirationDate: '2026-05-08T08:00:00.000Z',
revisionDate: DEMO_NOW,
shareUrl: '/#/send/demo-file/demo-key',
file: {
id: 'send-file-001',
fileName: 'design-handoff.zip',
size: 248000,
sizeName: '242 KB',
},
},
];
export function getDemoPublicSend(accessId: string): {
id: string;
type: 0 | 1;
decName: string;
decText?: string;
decFileName?: string;
expirationDate: string | null;
file?: { id: string; fileName: string; sizeName: string } | null;
} | null {
const normalized = String(accessId || '').trim().toLowerCase();
if (normalized === 'demo-note') {
return {
id: 'send-demo-note',
type: 0,
decName: 'Onboarding note',
decText: 'Welcome to NodeWarden demo mode. This public Send page is served entirely from demo data.',
expirationDate: '2026-05-18T08:00:00.000Z',
file: null,
};
}
if (normalized === 'demo-file') {
return {
id: 'send-demo-file',
type: 1,
decName: 'Design handoff.zip',
decFileName: 'design-handoff.zip',
expirationDate: '2026-05-08T08:00:00.000Z',
file: {
id: 'send-file-001',
fileName: 'design-handoff.zip',
sizeName: '242 KB',
},
};
}
return null;
}
export const DEMO_ADMIN_USERS: AdminUser[] = [
{ id: DEMO_USER_ID, email: DEMO_PROFILE.email, name: DEMO_PROFILE.name, role: 'admin', status: 'active' },
{ id: 'demo-user-002', email: 'viewer@example.com', name: 'Read Only Viewer', role: 'user', status: 'active' },
{ id: 'demo-user-003', email: 'suspended@example.com', name: 'Suspended User', role: 'user', status: 'banned' },
];
export const DEMO_ADMIN_INVITES: AdminInvite[] = [
{
code: 'DEMO-INVITE-2026',
inviteLink: '/register?invite=DEMO-INVITE-2026',
status: 'active',
expiresAt: '2026-05-11T08:00:00.000Z',
},
{
code: 'USED-DEMO',
inviteLink: '/register?invite=USED-DEMO',
status: 'used',
expiresAt: '2026-05-01T08:00:00.000Z',
},
];
export const DEMO_AUTHORIZED_DEVICES: AuthorizedDevice[] = [
{
id: 'demo-device-browser',
name: 'Chrome on Windows',
systemName: 'Windows',
deviceNote: 'Demo browser session',
identifier: 'demo-device-browser',
type: 9,
creationDate: '2026-05-01T08:00:00.000Z',
revisionDate: DEMO_NOW,
lastSeenAt: DEMO_NOW,
hasStoredDevice: true,
online: true,
trusted: true,
trustedTokenCount: 1,
trustedUntil: '2026-06-03T08:00:00.000Z',
},
{
id: 'demo-device-mobile',
name: 'iPhone',
systemName: 'iOS',
deviceNote: 'Mobile app preview',
identifier: 'demo-device-mobile',
type: 1,
creationDate: '2026-04-29T08:00:00.000Z',
revisionDate: DEMO_NOW,
lastSeenAt: '2026-05-03T20:30:00.000Z',
hasStoredDevice: true,
online: false,
trusted: false,
trustedTokenCount: 0,
trustedUntil: null,
},
];
export const DEMO_BACKUP_SETTINGS: AdminBackupSettings = {
destinations: [
{
id: 'demo-webdav',
name: 'Demo WebDAV',
type: 'webdav',
includeAttachments: true,
destination: {
baseUrl: 'https://dav.example.com/nodewarden',
username: 'demo-backup',
password: 'demo-password',
remotePath: 'nodewarden',
},
schedule: {
enabled: true,
intervalHours: 24,
startTime: '03:00',
timezone: 'UTC',
retentionCount: 14,
},
runtime: {
lastAttemptAt: '2026-05-04T03:00:00.000Z',
lastAttemptLocalDate: '2026-05-04',
lastSuccessAt: '2026-05-04T03:01:12.000Z',
lastErrorAt: null,
lastErrorMessage: null,
lastUploadedFileName: 'nodewarden_backup_20260504_030112_a1b2c.zip',
lastUploadedSizeBytes: 1048576,
lastUploadedDestination: 'Demo WebDAV',
},
},
],
};
function cloneJson<T>(value: T): T {
return JSON.parse(JSON.stringify(value)) as T;
}
export function createDemoBackupSettings(): AdminBackupSettings {
return cloneJson(DEMO_BACKUP_SETTINGS);
}
function createDemoId(prefix: string): string {
const random = typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function'
? crypto.randomUUID()
: `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
return `demo-${prefix}-${random}`;
}
function cipherFromDraft(draft: VaultDraft, current?: Cipher | null): Cipher {
const now = new Date().toISOString();
const type = Number(draft.type || current?.type || 1) || 1;
const next: Cipher = {
...(current || {}),
id: current?.id || createDemoId('cipher'),
type,
folderId: draft.folderId || null,
favorite: !!draft.favorite,
reprompt: draft.reprompt ? 1 : 0,
name: draft.name || '',
notes: draft.notes || '',
decName: draft.name || '',
decNotes: draft.notes || '',
creationDate: current?.creationDate || now,
revisionDate: now,
deletedDate: current?.deletedDate || null,
archivedDate: current?.archivedDate || null,
};
next.login = type === 1 ? {
...(current?.login || {}),
username: draft.loginUsername || '',
password: draft.loginPassword || '',
totp: draft.loginTotp || '',
decUsername: draft.loginUsername || '',
decPassword: draft.loginPassword || '',
decTotp: draft.loginTotp || '',
uris: draft.loginUris.map((uri) => ({
...(uri.extra || {}),
uri: uri.uri || '',
decUri: uri.uri || '',
match: uri.match ?? null,
})),
fido2Credentials: draft.loginFido2Credentials.map((credential) => ({ ...credential })),
} : null;
next.card = type === 3 ? {
...(current?.card || {}),
cardholderName: draft.cardholderName || '',
number: draft.cardNumber || '',
brand: draft.cardBrand || '',
expMonth: draft.cardExpMonth || '',
expYear: draft.cardExpYear || '',
code: draft.cardCode || '',
decCardholderName: draft.cardholderName || '',
decNumber: draft.cardNumber || '',
decBrand: draft.cardBrand || '',
decExpMonth: draft.cardExpMonth || '',
decExpYear: draft.cardExpYear || '',
decCode: draft.cardCode || '',
} : null;
next.identity = type === 4 ? {
...(current?.identity || {}),
title: draft.identTitle || '',
firstName: draft.identFirstName || '',
middleName: draft.identMiddleName || '',
lastName: draft.identLastName || '',
username: draft.identUsername || '',
company: draft.identCompany || '',
ssn: draft.identSsn || '',
passportNumber: draft.identPassportNumber || '',
licenseNumber: draft.identLicenseNumber || '',
email: draft.identEmail || '',
phone: draft.identPhone || '',
address1: draft.identAddress1 || '',
address2: draft.identAddress2 || '',
address3: draft.identAddress3 || '',
city: draft.identCity || '',
state: draft.identState || '',
postalCode: draft.identPostalCode || '',
country: draft.identCountry || '',
decTitle: draft.identTitle || '',
decFirstName: draft.identFirstName || '',
decMiddleName: draft.identMiddleName || '',
decLastName: draft.identLastName || '',
decUsername: draft.identUsername || '',
decCompany: draft.identCompany || '',
decSsn: draft.identSsn || '',
decPassportNumber: draft.identPassportNumber || '',
decLicenseNumber: draft.identLicenseNumber || '',
decEmail: draft.identEmail || '',
decPhone: draft.identPhone || '',
decAddress1: draft.identAddress1 || '',
decAddress2: draft.identAddress2 || '',
decAddress3: draft.identAddress3 || '',
decCity: draft.identCity || '',
decState: draft.identState || '',
decPostalCode: draft.identPostalCode || '',
decCountry: draft.identCountry || '',
} : null;
next.sshKey = type === 5 ? {
...(current?.sshKey || {}),
privateKey: draft.sshPrivateKey || '',
publicKey: draft.sshPublicKey || '',
keyFingerprint: draft.sshFingerprint || '',
fingerprint: draft.sshFingerprint || '',
decPrivateKey: draft.sshPrivateKey || '',
decPublicKey: draft.sshPublicKey || '',
decFingerprint: draft.sshFingerprint || '',
} : null;
next.fields = draft.customFields.map((field) => ({
type: field.type,
name: field.label,
value: field.value,
decName: field.label,
decValue: field.value,
}));
return next;
}
function sendFromDraft(draft: SendDraft, current?: Send | null): Send {
const now = new Date().toISOString();
const isFile = draft.type === 'file';
const fileName = String(draft.file?.name || current?.file?.fileName || 'demo-file.txt').trim();
const fileSize = typeof draft.file?.size === 'number' ? draft.file.size : Number(current?.file?.size || 0);
const deletionDays = Math.max(1, Number(draft.deletionDays || 7) || 7);
const expirationDays = Number(draft.expirationDays || 0) || 0;
return {
...(current || {}),
id: current?.id || createDemoId('send'),
accessId: current?.accessId || createDemoId('access'),
type: isFile ? 1 : 0,
name: draft.name || '',
decName: draft.name || '',
notes: draft.notes || '',
decNotes: draft.notes || '',
text: isFile ? null : { text: draft.text || '', hidden: false },
decText: isFile ? '' : draft.text || '',
key: current?.key || createDemoId('send-key'),
accessCount: current?.accessCount || 0,
maxAccessCount: draft.maxAccessCount ? Number(draft.maxAccessCount) : null,
disabled: !!draft.disabled,
deletionDate: new Date(Date.now() + deletionDays * 86400_000).toISOString(),
expirationDate: expirationDays > 0 ? new Date(Date.now() + expirationDays * 86400_000).toISOString() : null,
revisionDate: now,
shareUrl: current?.shareUrl || (isFile ? '/#/send/demo-file/demo-key' : '/#/send/demo-note/demo-key'),
file: isFile ? {
id: current?.file?.id || createDemoId('send-file'),
fileName,
size: fileSize,
sizeName: fileSize > 0 ? `${Math.ceil(fileSize / 1024)} KB` : '0 KB',
} : null,
};
}
function resetDemoVaultState(state: DemoRouteState): void {
state.setFolders(DEMO_FOLDERS.map((folder) => ({ ...folder })));
state.setCiphers(DEMO_CIPHERS.map((cipher) => cloneJson(cipher)));
state.setSends(DEMO_SENDS.map((send) => cloneJson(send)));
state.setBackupSettings(createDemoBackupSettings());
}
function sleep(ms: number): Promise<void> {
return new Promise((resolve) => window.setTimeout(resolve, ms));
}
async function runDemoRemoteRestoreProgress(fileName: string): Promise<void> {
const stages = [
['txt_backup_restore_progress_remote_fetch_title', 'txt_backup_restore_progress_remote_fetch_detail'],
['txt_backup_restore_progress_remote_shadow_title', 'txt_backup_restore_progress_remote_shadow_detail'],
['txt_backup_restore_progress_remote_data_title', 'txt_backup_restore_progress_remote_data_detail'],
['txt_backup_restore_progress_remote_files_title', 'txt_backup_restore_progress_remote_files_detail'],
['txt_backup_restore_progress_remote_finalize_title', 'txt_backup_restore_progress_remote_finalize_detail'],
] as const;
for (let index = 0; index < stages.length; index += 1) {
const [stageTitle, stageDetail] = stages[index];
dispatchBackupProgress({
operation: 'backup-restore',
source: 'remote',
step: String(index + 1),
fileName,
stageTitle,
stageDetail,
done: false,
});
await sleep(2000);
}
dispatchBackupProgress({
operation: 'backup-restore',
source: 'remote',
step: 'complete',
fileName,
stageTitle: 'txt_backup_restore_progress_remote_finalize_title',
stageDetail: 'txt_backup_restore_progress_remote_finalize_detail',
done: true,
ok: true,
});
}
export function createDemoInitialBootstrapState(): InitialAppBootstrapState {
return {
defaultKdfIterations: 600000,
registrationInviteRequired: true,
jwtWarning: null,
session: null,
phase: 'login',
};
}
export function createDemoCompletedLogin(emailInput: string = ''): CompletedLogin {
const email = String(emailInput || '').trim().toLowerCase() || DEMO_PROFILE.email;
const profile = { ...DEMO_PROFILE, email };
const session = { ...DEMO_SESSION, email };
return {
session,
profile,
profilePromise: Promise.resolve(profile),
};
}
function createDemoImportResult() {
return {
totalItems: 0,
folderCount: 0,
typeCounts: [],
attachmentCount: 0,
importedAttachmentCount: 0,
failedAttachments: [],
};
}
function createDemoImportBackupResult(): AdminBackupImportResponse {
return {
object: 'instance-backup-import',
imported: {
config: 0,
users: 0,
userRevisions: 0,
folders: 0,
ciphers: 0,
attachments: 0,
attachmentFiles: 0,
},
skipped: {
reason: 'demo-read-only',
attachments: 0,
items: [],
},
};
}
function createDemoRemoteBrowser(destinationId: string, path: string = ''): RemoteBackupBrowserResponse {
return {
object: 'backup-remote-browser',
destinationId,
destinationName: 'Demo WebDAV',
provider: 'webdav',
currentPath: path,
parentPath: path ? '' : null,
items: [
{
path: 'nodewarden_backup_20260504_030112_a1b2c.zip',
name: 'nodewarden_backup_20260504_030112_a1b2c.zip',
isDirectory: false,
size: 1048576,
modifiedAt: '2026-05-04T03:01:12.000Z',
},
{
path: 'archive',
name: 'archive',
isDirectory: true,
size: null,
modifiedAt: '2026-05-01T03:01:12.000Z',
},
],
};
}
function createDemoBackupRun(settings: AdminBackupSettings, destinationId: string | null | undefined): AdminBackupRunResponse {
const destination = settings.destinations.find((item) => item.id === destinationId) || settings.destinations[0] || DEMO_BACKUP_SETTINGS.destinations[0];
return {
object: 'backup-run',
result: {
fileName: 'nodewarden_backup_20260504_030112_a1b2c.zip',
fileSize: 1048576,
provider: destination.type,
remotePath: 'nodewarden/nodewarden_backup_20260504_030112_a1b2c.zip',
},
settings,
};
}
export function createDemoMainRoutesProps(base: AppMainRoutesProps, notify: Notify, state: DemoRouteState): AppMainRoutesProps {
const readonly = async () => {
notify('warning', t('txt_demo_readonly_message'));
};
const readonlyVoid = () => {
notify('warning', t('txt_demo_readonly_message'));
};
const readonlyString = async () => {
notify('warning', t('txt_demo_readonly_message'));
return 'DEMO-READ-ONLY';
};
return {
...base,
profile: DEMO_PROFILE,
profileLoading: false,
decryptedCiphers: state.ciphers,
decryptedFolders: state.folders,
decryptedSends: state.sends,
vaultError: '',
ciphersLoading: false,
foldersLoading: false,
sendsLoading: false,
users: state.users,
invites: state.invites,
adminLoading: false,
adminError: '',
totpEnabled: true,
authorizedDevices: state.authorizedDevices,
authorizedDevicesLoading: false,
authorizedDevicesError: '',
domainRulesLoading: false,
domainRulesError: '',
onImport: async () => {
await readonly();
return createDemoImportResult();
},
onImportEncryptedRaw: async () => {
await readonly();
return createDemoImportResult();
},
onExport: readonly,
onCreateVaultItem: async (draft) => {
const created = cipherFromDraft(draft);
state.setCiphers((prev) => [created, ...prev]);
notify('success', t('txt_item_created'));
},
onUpdateVaultItem: async (cipher, draft) => {
const updated = cipherFromDraft(draft, cipher);
state.setCiphers((prev) => prev.map((item) => (item.id === cipher.id ? updated : item)));
notify('success', t('txt_item_updated'));
},
onDeleteVaultItem: async (cipher) => {
if (cipher.deletedDate || (cipher as { deletedAt?: string | null }).deletedAt) {
state.setCiphers((prev) => prev.filter((item) => item.id !== cipher.id));
notify('success', t('txt_item_deleted_permanently'));
return;
}
const deletedDate = new Date().toISOString();
state.setCiphers((prev) => prev.map((item) => (
item.id === cipher.id ? { ...item, deletedDate, archivedDate: null, revisionDate: deletedDate } : item
)));
notify('success', t('txt_item_deleted'));
},
onArchiveVaultItem: async (cipher) => {
const archivedDate = new Date().toISOString();
state.setCiphers((prev) => prev.map((item) => (
item.id === cipher.id ? { ...item, archivedDate, deletedDate: null, revisionDate: archivedDate } : item
)));
notify('success', t('txt_item_archived'));
},
onUnarchiveVaultItem: async (cipher) => {
const revisionDate = new Date().toISOString();
state.setCiphers((prev) => prev.map((item) => (
item.id === cipher.id ? { ...item, archivedDate: null, revisionDate } : item
)));
notify('success', t('txt_item_unarchived'));
},
onBulkDeleteVaultItems: async (ids) => {
const idSet = new Set(ids);
const deletedDate = new Date().toISOString();
state.setCiphers((prev) => prev.map((item) => (
idSet.has(item.id) ? { ...item, deletedDate, archivedDate: null, revisionDate: deletedDate } : item
)));
notify('success', t('txt_deleted_selected_items'));
},
onBulkPermanentDeleteVaultItems: async (ids) => {
const idSet = new Set(ids);
state.setCiphers((prev) => prev.filter((item) => !idSet.has(item.id)));
notify('success', t('txt_deleted_selected_items_permanently'));
},
onRestoreVaultItems: async (ids) => {
const idSet = new Set(ids);
state.setCiphers((prev) => prev.map((item) => (idSet.has(item.id) ? { ...item, deletedDate: null } : item)));
notify('success', t('txt_restored_selected_items'));
},
onBulkRestoreVaultItems: async (ids) => {
const idSet = new Set(ids);
state.setCiphers((prev) => prev.map((item) => (idSet.has(item.id) ? { ...item, deletedDate: null } : item)));
notify('success', t('txt_restored_selected_items'));
},
onBulkArchiveVaultItems: async (ids) => {
const idSet = new Set(ids);
const archivedDate = new Date().toISOString();
state.setCiphers((prev) => prev.map((item) => (
idSet.has(item.id) ? { ...item, archivedDate, deletedDate: null, revisionDate: archivedDate } : item
)));
notify('success', t('txt_archived_selected_items'));
},
onBulkUnarchiveVaultItems: async (ids) => {
const idSet = new Set(ids);
state.setCiphers((prev) => prev.map((item) => (idSet.has(item.id) ? { ...item, archivedDate: null } : item)));
notify('success', t('txt_unarchived_selected_items'));
},
onBulkMoveVaultItems: async (ids, folderId) => {
const idSet = new Set(ids);
state.setCiphers((prev) => prev.map((item) => (idSet.has(item.id) ? { ...item, folderId } : item)));
notify('success', t('txt_moved_selected_items'));
},
onVerifyMasterPassword: async () => {},
onCreateFolder: async (name) => {
const trimmed = name.trim();
if (!trimmed) {
notify('error', t('txt_folder_name_is_required'));
return;
}
state.setFolders((prev) => [{ id: createDemoId('folder'), name: trimmed, decName: trimmed, creationDate: new Date().toISOString(), revisionDate: new Date().toISOString() }, ...prev]);
notify('success', t('txt_folder_created'));
},
onRenameFolder: async (folderId, name) => {
const trimmed = name.trim();
state.setFolders((prev) => prev.map((folder) => (folder.id === folderId ? { ...folder, name: trimmed, decName: trimmed, revisionDate: new Date().toISOString() } : folder)));
notify('success', t('txt_folder_updated'));
},
onDeleteFolder: async (folderId) => {
state.setFolders((prev) => prev.filter((folder) => folder.id !== folderId));
state.setCiphers((prev) => prev.map((cipher) => (cipher.folderId === folderId ? { ...cipher, folderId: null } : cipher)));
notify('success', t('txt_folder_deleted'));
},
onBulkDeleteFolders: async (folderIds) => {
const idSet = new Set(folderIds);
state.setFolders((prev) => prev.filter((folder) => !idSet.has(folder.id)));
state.setCiphers((prev) => prev.map((cipher) => (cipher.folderId && idSet.has(cipher.folderId) ? { ...cipher, folderId: null } : cipher)));
notify('success', t('txt_folders_deleted'));
},
onDownloadVaultAttachment: async () => {
notify('success', t('txt_demo_download_prepared'));
},
onRefreshVault: async () => {
resetDemoVaultState(state);
notify('success', t('txt_demo_data_reset'));
},
onCreateSend: async (draft, autoCopyLink) => {
const created = sendFromDraft(draft);
state.setSends((prev) => [created, ...prev]);
if (autoCopyLink && created.shareUrl && typeof navigator !== 'undefined') {
void navigator.clipboard?.writeText(new URL(created.shareUrl, window.location.origin).toString()).catch(() => undefined);
}
notify('success', t('txt_send_created'));
},
onUpdateSend: async (send, draft, autoCopyLink) => {
const updated = sendFromDraft(draft, send);
state.setSends((prev) => prev.map((item) => (item.id === send.id ? updated : item)));
if (autoCopyLink && updated.shareUrl && typeof navigator !== 'undefined') {
void navigator.clipboard?.writeText(new URL(updated.shareUrl, window.location.origin).toString()).catch(() => undefined);
}
notify('success', t('txt_send_updated'));
},
onDeleteSend: async (send) => {
state.setSends((prev) => prev.filter((item) => item.id !== send.id));
notify('success', t('txt_send_deleted'));
},
onBulkDeleteSends: async (ids) => {
const idSet = new Set(ids);
state.setSends((prev) => prev.filter((item) => !idSet.has(item.id)));
notify('success', t('txt_deleted_selected_sends'));
},
onChangePassword: readonly,
onSavePasswordHint: readonly,
onEnableTotp: readonly,
onOpenDisableTotp: readonlyVoid,
onGetRecoveryCode: readonlyString,
onGetApiKey: readonlyString,
onRotateApiKey: readonlyString,
onLockTimeoutChange: readonlyVoid,
onSessionTimeoutActionChange: readonlyVoid,
onRefreshAuthorizedDevices: async () => {
notify('success', t('txt_demo_devices_refreshed'));
},
onRefreshDomainRules: () => {
notify('success', t('txt_domain_rules_refreshed'));
},
onSaveDomainRules: readonly,
onRenameAuthorizedDevice: async (device, name) => {
const normalized = String(name || '').trim();
if (!normalized) {
notify('error', t('txt_device_note_required'));
return;
}
state.setAuthorizedDevices((prev) => prev.map((item) => (
item.identifier === device.identifier
? { ...item, name: normalized, deviceNote: normalized, revisionDate: new Date().toISOString() }
: item
)));
notify('success', t('txt_device_note_updated'));
},
onRevokeDeviceTrust: (device) => {
state.setAuthorizedDevices((prev) => prev.map((item) => (
item.identifier === device.identifier
? { ...item, trusted: false, trustedUntil: null, trustedTokenCount: 0, revisionDate: new Date().toISOString() }
: item
)));
notify('success', t('txt_device_authorization_revoked'));
},
onTrustDevicePermanently: (device) => {
state.setAuthorizedDevices((prev) => prev.map((item) => (
item.identifier === device.identifier && item.trusted
? { ...item, trustedUntil: '2099-12-31T23:59:59.000Z', revisionDate: new Date().toISOString() }
: item
)));
notify('success', t('txt_device_trusted_permanently'));
},
onRemoveDevice: (device) => {
state.setAuthorizedDevices((prev) => prev.filter((item) => item.identifier !== device.identifier));
notify('success', t('txt_device_removed'));
},
onRevokeAllDeviceTrust: () => {
state.setAuthorizedDevices((prev) => prev.map((item) => ({ ...item, trusted: false, trustedUntil: null, trustedTokenCount: 0 })));
notify('success', t('txt_all_device_authorizations_revoked'));
},
onRemoveAllDevices: () => {
state.setAuthorizedDevices([]);
notify('success', t('txt_all_devices_removed'));
},
onCreateInvite: async (hours) => {
const code = `DEMO-${Math.random().toString(36).slice(2, 8).toUpperCase()}`;
const expiresAt = new Date(Date.now() + Math.max(1, Number(hours || 168)) * 3600_000).toISOString();
state.setInvites((prev) => [{
code,
inviteLink: `/register?invite=${code}`,
status: 'active',
expiresAt,
}, ...prev]);
notify('success', t('txt_invite_created'));
},
onRefreshAdmin: () => {
notify('success', t('txt_demo_admin_refreshed'));
},
onDeleteAllInvites: async () => {
state.setInvites([]);
notify('success', t('txt_all_invites_deleted'));
},
onToggleUserStatus: async (userId, status) => {
state.setUsers((prev) => prev.map((user) => (
user.id === userId ? { ...user, status: status === 'active' ? 'banned' : 'active' } : user
)));
notify('success', t('txt_user_status_updated'));
},
onDeleteUser: async (userId) => {
state.setUsers((prev) => prev.filter((user) => user.id !== userId));
notify('success', t('txt_user_deleted'));
},
onRevokeInvite: async (code) => {
state.setInvites((prev) => prev.map((invite) => (
invite.code === code ? { ...invite, status: 'inactive' } : invite
)));
notify('success', t('txt_invite_revoked'));
},
onLoadAuditLogSettings: async () => ({ retentionDays: 90, maxEntries: null }),
onSaveAuditLogSettings: async (settings) => {
notify('success', t('txt_log_settings_saved'));
return settings;
},
onClearAuditLogs: async () => {
notify('success', t('txt_logs_cleared'));
return 0;
},
onExportBackup: async () => {
notify('success', t('txt_backup_export_success'));
},
onImportBackup: async () => {
resetDemoVaultState(state);
notify('success', t('txt_backup_import_success_relogin'));
return createDemoImportBackupResult();
},
onImportBackupAllowingChecksumMismatch: async () => {
resetDemoVaultState(state);
notify('success', t('txt_backup_import_success_relogin'));
return createDemoImportBackupResult();
},
onLoadBackupSettings: async () => state.backupSettings,
onSaveBackupSettings: async (settings) => {
const next = cloneJson(settings);
state.setBackupSettings(next);
notify('success', t('txt_backup_settings_saved'));
return next;
},
onRunRemoteBackup: async (destinationId?: string | null) => {
notify('success', t('txt_backup_remote_run_success'));
return createDemoBackupRun(state.backupSettings, destinationId);
},
onListRemoteBackups: async (destinationId: string, path: string) => createDemoRemoteBrowser(destinationId, path),
onDownloadRemoteBackup: async () => {
notify('success', t('txt_demo_download_prepared'));
},
onInspectRemoteBackup: async (_destinationId: string, path: string) => ({
object: 'backup-remote-integrity',
destinationId: _destinationId,
path,
fileName: path.split('/').pop() || 'nodewarden_backup_demo.zip',
integrity: {
hasChecksumPrefix: true,
expectedPrefix: 'a1b2c',
actualPrefix: 'a1b2c',
matches: true,
},
}),
onDeleteRemoteBackup: async () => {
notify('success', t('txt_backup_remote_delete_success'));
},
onRestoreRemoteBackup: async (_destinationId, path) => {
await runDemoRemoteRestoreProgress(path.split('/').pop() || path || 'nodewarden_backup_demo.zip');
resetDemoVaultState(state);
notify('success', t('txt_backup_remote_restore_completed_verified'));
return createDemoImportBackupResult();
},
onRestoreRemoteBackupAllowingChecksumMismatch: async (_destinationId, path) => {
await runDemoRemoteRestoreProgress(path.split('/').pop() || path || 'nodewarden_backup_demo.zip');
resetDemoVaultState(state);
notify('success', t('txt_backup_remote_restore_completed_verified'));
return createDemoImportBackupResult();
},
};
}
Reference in New Issue View Git Blame Copy Permalink