hfs 0.26.8 → 0.26.9

package/admin/src/FileForm.ts

@@ -1,148 +0,0 @@
-// This file is part of HFS - Copyright 2021-2022, Massimo Melina <a@rejetto.com> - License https://www.gnu.org/licenses/gpl-3.0.txt
-
-import { state } from './state'
-import { createElement as h, useEffect, useMemo, useState } from 'react'
-import { Alert, Button } from '@mui/material'
-import { BoolField, DisplayField, Field, FieldProps, Form, MultiSelectField, SelectField } from '@hfs/mui-grid-form'
-import { apiCall, useApiEx } from './api'
-import { formatBytes, isEqualLax, modifiedSx, onlyTruthy } from './misc'
-import { reloadVfs, VfsNode, Who } from './VfsPage'
-import md from './md'
-import _ from 'lodash'
-import FileField from './FileField'
-import { alertDialog } from './dialog'
-
-interface Account { username: string }
-
-export default function FileForm({ file }: { file: VfsNode }) {
-    const { parent, children, isRoot, ...rest } = file
-    const [values, setValues] = useState(rest)
-    useEffect(() => {
-        setValues(Object.assign({ can_see: null, can_read: null }, rest))
-    }, [file]) //eslint-disable-line
-
-    const { source } = file
-    const isDir = file.type === 'folder'
-    const hasSource = source !== undefined // we need a boolean
-    const realFolder = hasSource && isDir
-    const inheritedPerms = useMemo(() => {
-        const ret = { can_read: true, can_see: true }
-        // reconstruct parents backward
-        const parents = []
-        let run = parent
-        while (run) {
-            parents.unshift(run)
-            run = run.parent
-        }
-        for (const node of parents)
-            Object.assign(ret, node)
-        return ret
-    }, [parent])
-    const showCanSee = (values.can_read ?? inheritedPerms.can_read) === true
-    const showTimestamps = hasSource && Boolean(values.ctime)
-
-    const { data, element } = useApiEx<{ list: Account[] }>('get_accounts')
-    if (element || !data)
-        return element
-    const accounts = data.list
-
-    return h(Form, {
-        values,
-        set(v, k) {
-            setValues({ ...values, [k]: v })
-        },
-        addToBar: [
-            h(Button, { // not really useful, but users misled in thinking it's a dialog will find satisfaction in dismissing the form
-                sx: { ml: 2 },
-                onClick(){
-                    state.selectedFiles = []
-                }
-            }, "Close")
-        ],
-        onError: alertDialog,
-        save: {
-            sx: modifiedSx(!isEqualLax(values, file)),
-            async onClick() {
-                const props = { ...values }
-                if (!props.masks)
-                    props.masks = null // undefined cannot be serialized
-                if (!isRoot)
-                    delete props.source
-                await apiCall('set_vfs', {
-                    uri: values.id,
-                    props,
-                })
-                if (props.name !== file.name) // when the name changes, the id of the selected file is changing too, and we have to update it in the state if we want it to be correctly re-selected after reload
-                    state.selectedFiles[0].id = file.id.slice(0, -file.name.length) + props.name
-                reloadVfs()
-            }
-        },
-        fields: [
-            isRoot ? h(Alert,{ severity: 'info' }, "This is Home, the root of your shared files. Options set here will be applied to all files.")
-                : { k: 'name', required: true, helperText: source && "You can decide a name that's different from the one on your disk" },
-            isRoot ? { k: 'source', comp: FileField, files: false,  helperText: "If you specify a folder here, its files will be listed in the home" }
-                : (hasSource && { k: 'source', comp: DisplayField, multiline: true }),
-            { k: 'can_read', label:"Who can download", xl: showCanSee && 6, comp: WhoField, parent, accounts, inherit: inheritedPerms.can_read,
-                helperText: "Note: who can't download won't see it in the list"
-            },
-            showCanSee && { k: 'can_see', label:"Who can see", xl: 6, comp: WhoField, parent, accounts, inherit: inheritedPerms.can_see,
-                helperText: "If you hide this element it will not be listed, but will still be accessible if you have a direct link"
-            },
-            hasSource && !realFolder && { k: 'size', comp: DisplayField, toField: formatBytes },
-            showTimestamps && { k: 'ctime', comp: DisplayField, lg: 6, label: 'Created', toField: formatTimestamp },
-            showTimestamps && { k: 'mtime', comp: DisplayField, lg: 6, label: 'Modified', toField: formatTimestamp },
-            file.website && { k: 'default', comp: BoolField, label:"Serve index.html",
-                toField: Boolean, fromField: (v:boolean) => v ? 'index.html' : null,
-                helperText: md("This folder may be a website because contains `index.html`. Enabling this will show the website instead of the list of files.")
-            },
-            isDir && { k: 'masks', multiline: true, xl: true, toField: JSON.stringify, fromField: v => v ? JSON.parse(v) : undefined,
-                helperText: "This is a special field. Leave it empty unless you know what you are doing." }
-        ]
-    })
-}
-
-function formatTimestamp(x: string) {
-    return x ? new Date(x).toLocaleString() : '-'
-}
-
-interface WhoFieldProps extends FieldProps<Who> { accounts: Account[] }
-function WhoField({ value, onChange, parent, inherit, accounts, helperText, ...rest }: WhoFieldProps) {
-    const options = useMemo(() =>
-        onlyTruthy([
-            { value: null, label: (parent ? "Same as parent: " : "Default: " ) + who2desc(inherit === 0 ? true : inherit) },
-            { value: true },
-            { value: false },
-            { value: '*' },
-            { value: [], label: "Select accounts" },
-        ].map(x => x && x.value !== inherit // don't offer inherited value twice
-            && { label: _.capitalize(who2desc(x.value)), ...x })), // default label
-    [inherit, parent])
-
-    const arrayMode = Array.isArray(value)
-    return h('div', {},
-        h(SelectField as Field<Who>, {
-            ...rest,
-            helperText: !arrayMode && helperText,
-            value: arrayMode ? [] : value,
-            onChange(v, { was, event }) {
-                onChange(v, { was , event })
-            },
-            options
-        }),
-        arrayMode && h(MultiSelectField as Field<string[]>, {
-            label: accounts?.length ? "Choose accounts for " + rest.label : "You didn't create any account yet",
-            value,
-            onChange,
-            helperText,
-            options: accounts?.map(a => ({ value: a.username, label: a.username })) || [],
-        })
-    )
-}
-
-function who2desc(who: any) {
-    return who === false ? "no one"
-        : who === true ? "anyone"
-            : who === '*' ? "any account (login required)"
-                : Array.isArray(who) ? who.join(', ')
-                    : "*UNKNOWN*" + JSON.stringify(who)
-}

package/admin/src/FilePicker.ts

@@ -1,166 +0,0 @@
-// This file is part of HFS - Copyright 2021-2022, Massimo Melina <a@rejetto.com> - License https://www.gnu.org/licenses/gpl-3.0.txt
-
-import { createElement as h, Fragment, useEffect, useMemo, useRef, useState } from 'react'
-import { apiCall, useApiList } from './api'
-import _ from 'lodash'
-import {
-    Alert,
-    Box,
-    Button,
-    Checkbox,
-    ListItemIcon,
-    ListItemText,
-    MenuItem,
-    TextField,
-    Typography
-} from '@mui/material'
-import { enforceFinal, formatBytes, isWindowsDrive, spinner, Center, err2msg } from './misc'
-import { ArrowUpward, VerticalAlignTop } from '@mui/icons-material'
-import { StringField } from '@hfs/mui-grid-form'
-import { FileIcon, FolderIcon } from './VfsTree'
-import { FixedSizeList } from 'react-window'
-
-export interface DirEntry { n:string, s?:number, m?:string, c?:string, k?:'d' }
-
-interface FilePickerProps {
-    onSelect:(v:string[])=>void
-    multiple?: boolean
-    from?: string
-    folders?: boolean
-    files?: boolean
-    fileMask?: string
-}
-export default function FilePicker({ onSelect, multiple=true, files=true, folders=true, fileMask, from='' }: FilePickerProps) {
-    const [cwd, setCwd] = useState(from)
-    const [ready, setReady] = useState(false)
-    const isWindows = useRef(false)
-    useEffect(() => {
-        apiCall('resolve_path', { path: from, closestFolder: true }).then(res => {
-            if (typeof res.path === 'string') {
-                setCwd(res.path)
-                isWindows.current = res.path[1] === ':'
-            }
-        }).finally(() => setReady(true))
-    }, [from])
-    const { list, error, loading } = useApiList<DirEntry>(ready && 'ls', { path: cwd, files, fileMask })
-    useEffect(() => {
-        setSel([])
-        setFilter('')
-    }, [cwd])
-
-    const [sel, setSel] = useState<string[]>([])
-    const [filter, setFilter] = useState('')
-    const setFilterBounced = useMemo(() => _.debounce((x:string) => setFilter(x)), [])
-    const filterMatch = useMemo(() => {
-        const re = new RegExp(_.escapeRegExp(filter), 'i')
-        return (v:string) => re.test(v)
-    }, [filter])
-
-    const [listHeight, setListHeight] = useState(0)
-    const filteredList = useMemo(() => list.filter(it => filterMatch(it.n)), [list,filterMatch])
-    if (loading)
-        return spinner()
-    const root = isWindows.current ? '' : '/'
-    const pathDelimiter = isWindows.current ? '\\' : '/'
-    const cwdDelimiter = enforceFinal(pathDelimiter, cwd)
-    const isRoot = cwd.length < 2
-    return h(Fragment, {},
-        h(Box, { display: 'flex', gap: 1 },
-            h(Button, {
-                title: "root",
-                disabled: isRoot,
-                onClick() {
-                    setCwd(root)
-                }
-            }, h(VerticalAlignTop)),
-            h(Button, {
-                disabled: isRoot,
-                title: "parent folder",
-                onClick() {
-                    const cwdND = /[\\/]$/.test(cwd) ? cwd.slice(0,-1) : cwd // exclude final delimiter, if any
-                    const parent = isWindowsDrive(cwdND) ? root : cwdND.slice(0, cwdND.lastIndexOf(pathDelimiter) || 1)
-                    setCwd(parent)
-                }
-            }, h(ArrowUpward)),
-            h(StringField, {
-                label: "Current path",
-                value: cwd,
-                InputLabelProps: { shrink: true },
-                async onChange(v) {
-                    if (!v)
-                        return setCwd(root)
-                    const res = await apiCall('resolve_path', { path: v })
-                    setCwd(res.path)
-                },
-            }),
-        ),
-        error ? h(Alert, { severity: 'error' }, err2msg(error))
-            : h(Fragment, {},
-                h(Box, {
-                    ref(x?: HTMLElement){
-                        if (!x) return
-                        const h = x?.clientHeight - 1
-                        if (h - listHeight > 1)
-                            setListHeight(h)
-                    },
-                    sx: { flex: 1, display: 'flex', flexDirection: 'column' }
-                },
-                    !list.length ? h(Center, { flex: 1, mt: '4em' }, "No elements in this folder")
-                        : h(FixedSizeList, {
-                            width: '100%', height: listHeight,
-                            itemSize: 46, itemCount: filteredList.length, overscanCount: 5,
-                            children({ index, style }) {
-                                const it: DirEntry = filteredList[index]
-                                const isFolder = it.k === 'd'
-                                return h(MenuItem, {
-                                        style: { ...style, padding: 0 },
-                                        key: it.n,
-                                        onClick() {
-                                            if (isFolder)
-                                                setCwd(cwdDelimiter + it.n)
-                                            else
-                                                onSelect([cwdDelimiter + it.n])
-                                        }
-                                    },
-                                    multiple && h(Checkbox, {
-                                        checked: sel.includes(it.n),
-                                        disabled: !folders && isFolder,
-                                        onClick(ev) {
-                                            const id = it.n
-                                            const removed = sel.filter(x => x !== id)
-                                            setSel(removed.length < sel.length ? removed : [...sel, id])
-                                            ev.stopPropagation()
-                                        },
-                                    }),
-                                    h(ListItemIcon, {}, h(it.k ? FolderIcon : FileIcon)),
-                                    h(ListItemText, { sx: { whiteSpace: 'pre-wrap', wordBreak: 'break-all' } }, it.n),
-                                    !isFolder && it.s !== undefined && h(Typography, {
-                                        variant: 'body2',
-                                        color: 'text.secondary',
-                                        ml: 4, mr: 1,
-                                    }, formatBytes(it.s))
-                                )
-                            }
-                        })
-                ),
-                h(Box, { display:'flex', gap: 1 },
-                    (multiple || folders || !files) && h(Button, {
-                        variant: 'contained',
-                        disabled: !cwd || !folders && !sel.length && files,
-                        sx: { minWidth: 'max-content' },
-                        onClick() {
-                            onSelect(sel.length ? sel.map(x => cwdDelimiter + x) : [cwd])
-                        }
-                    }, files && (sel.length || !folders) ? `Select (${sel.length})` : `Select this folder`),
-                    h(TextField, {
-                        value: filter,
-                        label: `Filter results (${filteredList.length}${filteredList.length < list.length ? '/'+list.length : ''})`,
-                        onChange(ev) {
-                            setFilterBounced(ev.target.value)
-                        },
-                        sx: { flex: 1 },
-                    }),
-                ),
-            )
-    )
-}

package/admin/src/HomePage.ts

@@ -1,96 +0,0 @@
-// This file is part of HFS - Copyright 2021-2022, Massimo Melina <a@rejetto.com> - License https://www.gnu.org/licenses/gpl-3.0.txt
-
-import { createElement as h } from 'react'
-import { Box, Button, LinearProgress, Link } from '@mui/material'
-import { apiCall, useApi, useApiEx, useApiList } from './api'
-import { Dict, dontBotherWithKeys, InLink, objSameKeys, onlyTruthy } from './misc'
-import { CheckCircle, Error, Info, Launch, Warning } from '@mui/icons-material'
-import md from './md'
-import { useSnapState } from './state'
-import { confirmDialog } from './dialog'
-import { isCertError, isKeyError, makeCertAndSave } from './ConfigPage'
-import { VfsNode } from './VfsPage'
-import { Account } from './AccountsPage'
-
-interface ServerStatus { listening: boolean, port: number, error?: string, busy?: string }
-
-export default function HomePage() {
-    const SOLUTION_SEP = " — "
-    const { username } = useSnapState()
-    const { data: status, reload: reloadStatus, element: statusEl } = useApiEx<Dict<ServerStatus>>('get_status')
-    const { data: vfs } = useApiEx<{ root?: VfsNode }>('get_vfs')
-    const [account] = useApi<Account>(username && 'get_account')
-    const { data: cfg, reload: reloadCfg } = useApiEx('get_config', { only: ['https_port', 'cert', 'private_key', 'proxies', 'ignore_proxies'] })
-    const { list: plugins } = useApiList('get_plugins')
-    if (statusEl || !status)
-        return statusEl
-    const { http, https } = status
-    const goSecure = !http?.listening && https?.listening ? 's' : ''
-    const srv = goSecure ? https : (http?.listening && http)
-    const href = srv && `http${goSecure}://`+window.location.hostname + (srv.port === (goSecure ? 443 : 80) ? '' : ':'+srv.port)
-    const errorMap = objSameKeys(status, v =>
-        v.busy ? [`port ${v.port} already used by ${v.busy}${SOLUTION_SEP}choose a `, cfgLink('different port'), ` or stop ${v.busy}`]
-            : v.error )
-    const errors = errorMap && onlyTruthy(Object.entries(errorMap).map(([k,v]) =>
-        v && [md(`Protocol _${k}_ cannot work: `), v,
-            (isCertError(v) || isKeyError(v)) && [
-                SOLUTION_SEP, h(Link, { sx: { cursor: 'pointer' }, onClick() { makeCertAndSave().then(reloadCfg).then(reloadStatus) } }, "make one"),
-                " or ", SOLUTION_SEP, cfgLink("provide adequate files")
-            ]]))
-    return h(Box, { display:'flex', gap: 2, flexDirection:'column' },
-        username && entry('', "Welcome "+username),
-        errors.length ? dontBotherWithKeys(errors.map(msg => entry('error', dontBotherWithKeys(msg))))
-            : entry('success', "Server is working"),
-        !vfs ? h(LinearProgress)
-            : !vfs.root?.children?.length && !vfs.root?.source ? entry('warning', "You have no files shared", SOLUTION_SEP, fsLink("add some"))
-                : entry('', md("Here you manage your server. There is a _separated_ interface to access your shared files: "),
-                    h(Link, { target:'frontend', href: '/' }, "Frontend interface", h(Launch, { sx: { verticalAlign: 'sub', ml: '.2em' } }))),
-        !href && entry('warning', "Frontend unreachable: ",
-            ['http','https'].map(k => k + " " + (errorMap[k] ? "is in error" : "is off")).join(', '),
-            !errors.length && [ SOLUTION_SEP, cfgLink("switch http or https on") ]
-        ),
-        plugins.find(x => x.badApi) && entry('warning', "Some plugins may be incompatible"),
-        !account?.adminActualAccess && entry('', md("You are accessing on _localhost_ where permission is not required"),
-            SOLUTION_SEP, h(InLink, { to:'accounts' }, "give admin access to an account to be able to access from other computers") ),
-        proxyWarning(cfg, status) && entry('warning', "A proxy was detected but none is configured",
-                SOLUTION_SEP, cfgLink("set the number of proxies"),
-                SOLUTION_SEP, "unless you are sure you can ", h(Button, {
-                    async onClick() {
-                        if (await confirmDialog("Go on only if you know what you are doing")
-                        && await apiCall('set_config', { values: { ignore_proxies: true } }))
-                            reloadCfg()
-                    }
-                }, "ignore this warning")),
-        status.frpDetected && entry('warning', `FRP is detected. It should not be used with "type = tcp" with HFS. Possible solutions are`,
-            h('ol',{},
-                h('li',{}, `configure FRP with type=http (best solution)`),
-                h('li',{}, md(`configure FRP to connect to HFS _not_ with 127.0.0.1 (safe, but you won't see users' IPs)`)),
-                h('li',{}, `disable "admin access for localhost" in HFS (safe, but you won't see users' IPs)`),
-            ))
-    )
-}
-
-type Color = '' | 'success' | 'warning' | 'error'
-
-function entry(color: Color, ...content: any[]) {
-    return h(Box, {
-            fontSize: 'x-large',
-            color: th => color && th.palette[color]?.main,
-        },
-        h(({ success: CheckCircle, info: Info, '': Info, warning: Warning, error: Error })[color], {
-            sx: { mb: '-3px', mr: 1 }
-        }),
-        ...content)
-}
-
-function fsLink(text=`File System page`) {
-    return h(InLink, { to:'fs' }, text)
-}
-
-function cfgLink(text=`Configuration page`) {
-    return h(InLink, { to:'configuration' }, text)
-}
-
-export function proxyWarning(cfg: any, status: any) {
-    return cfg && !cfg.proxies && !cfg.ignore_proxies && status?.proxyDetected
-}

package/admin/src/InstalledPlugins.ts

@@ -1,158 +0,0 @@
-import { apiCall, useApiList } from './api'
-import { createElement as h, Fragment } from 'react'
-import { Alert, Box, Tooltip } from '@mui/material'
-import { DataGrid } from '@mui/x-data-grid'
-import { Delete, Error, GitHub, PlayCircle, Settings, StopCircle, Upgrade } from '@mui/icons-material'
-import { IconBtn, xlate } from './misc'
-import { formDialog, toast } from './dialog'
-import _ from 'lodash'
-import { BoolField, Field, MultiSelectField, NumberField, SelectField, StringField } from '@hfs/mui-grid-form'
-import { ArrayField } from './ArrayField'
-import FileField from './FileField'
-
-export default function InstalledPlugins({ updates }: { updates?: true }) {
-    const { list, setList, error, initializing } = useApiList(updates ? 'get_plugin_updates' : 'get_plugins')
-    if (error)
-        return showError(error)
-    return h(DataGrid, {
-        rows: list.length ? list : [], // workaround for DataGrid bug causing 'no rows' message to be not displayed after 'loading' was also used
-        loading: initializing,
-        disableColumnSelector: true,
-        disableColumnMenu: true,
-        columnVisibilityModel: {
-            started: !updates,
-        },
-        localeText: updates && { noRowsLabel: "No updates available. Only online plugins are checked." },
-        columns: [
-            {
-                field: 'id',
-                headerName: "name",
-                flex: .3,
-                minWidth: 150,
-                renderCell({ row, value }) {
-                    return h(Fragment, {},
-                        value,
-                        typeof row.badApi === 'string' && h(Tooltip, { title: row.badApi, children: h(Error, { color: 'warning', sx: { ml: 1 } }) }),
-                        repoLink(row.repo),
-                    )
-                }
-            },
-            {
-                field: 'version',
-                width: 70,
-            },
-            {
-                field: 'description',
-                flex: 1,
-            },
-            {
-                field: "actions",
-                width: 120,
-                align: 'center',
-                headerAlign: 'center',
-                hideSortIcons: true,
-                disableColumnMenu: true,
-                renderCell({ row }) {
-                    const { config, id } = row
-                    if (updates)
-                        return h(UpdateButton, { id, then: () => setList(list.filter(x => x.id !== id)) })
-                    return h('div', {},
-                        h(IconBtn, row.started ? {
-                            icon: StopCircle,
-                            title: h(Box, {}, `Stop ${id}`, h('br'), `Started ` + new Date(row.started as string).toLocaleString()),
-                            color: 'success',
-                            onClick: () =>
-                                apiCall('set_plugin', { id, enabled: false }).then(() =>
-                                    toast("Plugin is stopping", h(StopCircle, { color: 'warning' })))
-                        } : {
-                            icon: PlayCircle,
-                            title: `Start ${id}`,
-                            onClick: () => startPlugin(id),
-                        }),
-                        h(IconBtn, {
-                            icon: Settings,
-                            title: "Configuration",
-                            disabled: !config && "No configuration available for this plugin",
-                            async onClick() {
-                                const pl = await apiCall('get_plugin', { id })
-                                const values = await formDialog({
-                                    title: `${id} configuration`,
-                                    fields: [ h(Box, {}, row.description), ...makeFields(config) ],
-                                    values: pl.config,
-                                    ...row.configDialog,
-                                })
-                                if (!values || _.isEqual(pl.config, values)) return
-                                await apiCall('set_plugin', { id, config: values })
-                                toast("Configuration saved")
-                            }
-                        }),
-                        h(IconBtn, {
-                            icon: Delete,
-                            title: "Uninstall",
-                            confirm: "Remove?",
-                            async onClick() {
-                                await apiCall('uninstall_plugin', { id })
-                                toast("Plugin uninstalled")
-                            }
-                        }),
-                    )
-                }
-            },
-        ]
-    })
-}
-
-function makeFields(config: any) {
-    return Object.entries(config).map(([k,o]: [string,any]) => {
-        if (!_.isPlainObject(o))
-            return o
-        let { type, defaultValue, fields, $column, $width, ...rest } = o
-        const comp = (type2comp as any)[type] as Field<any> | undefined
-        if (comp === ArrayField)
-            fields = makeFields(fields)
-        if (defaultValue !== undefined && type === 'boolean')
-            rest.placeholder = `Default value is ${JSON.stringify(defaultValue)}`
-        return { k, comp, fields, ...rest }
-    })
-}
-
-const type2comp = {
-    string: StringField,
-    number: NumberField,
-    boolean: BoolField,
-    select: SelectField,
-    multiselect: MultiSelectField,
-    array: ArrayField,
-    real_path: FileField,
-}
-
-export function repoLink(repo?: string) {
-    return repo && h(IconBtn, {
-        icon: GitHub,
-        title: "Open web page",
-        link: 'https://github.com/' + repo,
-    })
-}
-
-export function showError(error: any) {
-    return h(Alert, { severity: 'error' }, xlate(error, {
-        ENOTFOUND: "Couldn't reach github.com"
-    }))
-}
-
-export function UpdateButton({ id, then }: { id: string, then: (id:string)=>void }) {
-    return h(IconBtn, {
-        icon: Upgrade,
-        title: "Update",
-        async onClick() {
-            await apiCall('update_plugin', { id })
-            then?.(id)
-            toast("Plugin updated")
-        }
-    })
-}
-
-export function startPlugin(id: string) {
-    return apiCall('set_plugin', { id, enabled: true }).then(() =>
-        toast("Plugin is starting", h(PlayCircle, { color: 'success' })))
-}

package/admin/src/LoginRequired.ts

@@ -1,75 +0,0 @@
-import { state, useSnapState } from './state'
-import { createElement as h, Fragment, useState } from 'react'
-import { Center } from './misc'
-import { Form } from '@hfs/mui-grid-form'
-import { apiCall } from './api'
-import { srpSequence } from '@hfs/shared'
-import { Alert } from '@mui/material'
-
-export function LoginRequired({ children }: any) {
-    const { loginRequired } = useSnapState()
-    if (loginRequired)
-        return h(LoginForm)
-    return h(Fragment, {}, children)
-}
-
-function LoginForm() {
-    const [values, setValues] = useState({ username: '', password: '' })
-    const [error, setError] = useState('')
-    return h(Center, {},
-        h(Form, {
-            values,
-            set(v, k) {
-                setValues({ ...values, [k]: v })
-            },
-            fields: [
-                { k: 'username', autoComplete: 'username', autoFocus: true, required: true },
-                { k: 'password', type: 'password', autoComplete: 'current-password', required: true },
-            ],
-            addToBar: [ error && h(Alert, { severity: 'error', sx: { flex: 1 } }, error) ],
-            saveOnEnter: true,
-            save: {
-                children: "Enter",
-                startIcon: null,
-                async onClick() {
-                    try {
-                        setError('')
-                        await login(values.username, values.password)
-                    }
-                    catch(e) {
-                        setError(String(e))
-                    }
-                }
-            }
-        })
-    )
-}
-
-async function login(username: string, password: string) {
-    const res = await srpSequence(username, password, apiCall).catch(err => {
-        throw err?.code === 401 ? "Wrong username or password"
-            : err === 'trust' ? "Login aborted: server identity cannot be trusted"
-            : err?.name === 'AbortError' ? "Server didn't respond"
-            : (err?.message || "Unknown error")
-    })
-    if (!res.adminUrl)
-        throw "This account has no Admin access"
-
-    // login was successful, update state
-    state.loginRequired = false
-    sessionRefresher(res)
-}
-
-// @ts-ignore
-sessionRefresher(window.SESSION)
-
-function sessionRefresher(response: any) {
-    if (!response) return
-    const { exp, username } = response
-    state.username = username
-    if (!username || !exp) return
-    const delta = new Date(exp).getTime() - Date.now()
-    const t = Math.min(delta - 30_000, 600_000)
-    console.debug('session refresh in', Math.round(t/1000))
-    setTimeout(() => apiCall('refresh_session').then(sessionRefresher), t)
-}

package/admin/src/LogoutPage.ts

@@ -1,27 +0,0 @@
-import { createElement as h } from "react"
-import { Alert, Box, Button } from '@mui/material'
-import { apiCall, useApiEx } from './api'
-import { alertDialog } from "./dialog"
-import { useSnapState } from './state'
-
-export default function LogoutPage() {
-    const { element } = useApiEx('get_config', { only: [] }) // sort of noop, just to get the 'element' part
-    const { username } = useSnapState()
-    if (element)
-        return element
-    if (!username)
-        return h(Alert, { severity: 'info' }, "You are not logged in, because authentication is not required on localhost")
-    return h(Box, { display: 'flex', flexDirection:'column', gap: 2 },
-        "You are logged in as " + username,
-        h(Box, {},
-            h(Button, {
-                size: 'large',
-                variant: 'contained',
-                onClick() {
-                    apiCall('logout').catch(err => // we expect 401
-                        err.code !== 401 && alertDialog(err))
-                }
-            }, "Yes, I want to logout")
-        )
-    )
-}