hfs 0.26.8 → 0.27.2

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")
-        )
-    )
-}

package/admin/src/LogsPage.ts

@@ -1,75 +0,0 @@
-import { createElement as h, Fragment, useState } from 'react';
-import { Tab, Tabs } from '@mui/material'
-import { useApiList } from './api'
-import { DataGrid } from '@mui/x-data-grid'
-import { formatBytes } from '@hfs/shared'
-import { logLabels } from './ConfigPage'
-import { typedKeys } from './misc';
-
-export default function LogsPage() {
-    const [tab, setTab] = useState(0)
-    const files = typedKeys(logLabels)
-    return h(Fragment, {},
-        h(Tabs, { value: tab, onChange(ev,i){ setTab(i) } },
-            files.map(f => h(Tab, { label: logLabels[f], key: f })) ),
-        h(LogFile, { key: tab, file: files[tab] }), // without key, some state is accidentally preserved across files
-    )
-}
-
-function LogFile({ file }: { file: string }) {
-    const { list, error, connecting } = useApiList('get_log', { file }, { addId: true })
-    if (error)
-        return error
-    return h(DataGrid, {
-        loading: connecting,
-        rows: list as any,
-        componentsProps: {
-            pagination: {
-                showFirstButton: true,
-                showLastButton: true,
-            }
-        },
-        columns: [
-            {
-                field: 'ip',
-                headerName: "Address",
-                flex: 1,
-                minWidth: 100,
-                maxWidth: 400,
-            },
-            {
-                field: 'user',
-                headerName: "Username",
-                flex: 1,
-            },
-            {
-                field: 'ts',
-                headerName: "Timestamp",
-                type: 'dateTime',
-                width: 200,
-                valueFormatter: ({ value }) => new Date(value as string).toLocaleString()
-            },
-            {
-                field: 'method',
-                headerName: "Method",
-            },
-            {
-                field: 'status',
-                headerName: "Code",
-                type: 'number',
-            },
-            {
-                field: 'length',
-                headerName: "Size",
-                type: 'number',
-                valueFormatter: ({ value }) => formatBytes(value as number)
-            },
-            {
-                field: 'uri',
-                headerName: "URI",
-                flex: 2,
-                minWidth: 100,
-            },
-        ]
-    })
-}

package/admin/src/MainMenu.ts

@@ -1,74 +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, FC } from 'react';
-import { List, ListItemButton, ListItemIcon, ListItemText, Box, Typography } from '@mui/material'
-import {
-    AccountTree,
-    Extension,
-    History,
-    Logout,
-    ManageAccounts,
-    Monitor,
-    Public,
-    Settings,
-    SvgIconComponent
-} from '@mui/icons-material'
-import _ from 'lodash'
-import { NavLink } from 'react-router-dom'
-import MonitorPage from './MonitorPage'
-import ConfigPage from './ConfigPage';
-import VfsPage from './VfsPage';
-import AccountsPage from './AccountsPage';
-import HomePage from './HomePage'
-import LogoutPage from './LogoutPage';
-import LogsPage from './LogsPage';
-import { useApi } from './api'
-import PluginsPage from './PluginsPage';
-
-interface MenuEntry {
-    path: string
-    icon: SvgIconComponent
-    label?: string
-    title?: string
-    comp: FC
-}
-
-export const mainMenu: MenuEntry[] = [
-    { path: '', icon: Public, label: 'Home', title: "Admin panel", comp: HomePage },
-    { path: 'fs', icon: AccountTree, label: "Shared files", comp: VfsPage },
-    { path: 'accounts', icon: ManageAccounts, comp: AccountsPage },
-    { path: 'configuration', icon: Settings, comp: ConfigPage },
-    { path: 'monitoring', icon: Monitor, comp: MonitorPage },
-    { path: 'logs', icon: History, comp: LogsPage },
-    { path: 'plugins', icon: Extension, comp: PluginsPage },
-    { path: 'logout', icon: Logout, comp: LogoutPage }
-]
-
-let version: any // cache 'version', as it won't change at runtime, while the Drawer mechanism will unmount our menu each time
-export default function Menu({ onSelect }: { onSelect: ()=>void }) {
-    const [status] = useApi(!version && 'get_status')
-    version ||= status?.version?.replace('-', ' ')
-    return h(List, { sx:{ pr:1, bgcolor: 'primary.main', color:'primary.contrastText', minHeight: '100%', boxSizing: 'border-box' } },
-        h(Box, { display: 'flex', px: 2, py: 1, gap: 2, alignItems: 'flex-end' },
-            h(Typography, { variant:'h3' }, 'HFS'),
-            h(Box, { pb: 1, fontSize: 'small' }, version),
-        ),
-        mainMenu.map(it =>
-            h(ListItemButton, {
-                key: it.path,
-                to: it.path,
-                component: NavLink,
-                onClick: onSelect,
-                // @ts-ignore
-                style: ({ isActive }) => isActive ? { textDecoration: 'underline' } : {},
-                children: undefined, // shut up ts
-            },
-                it.icon && h(ListItemIcon, { sx:{ color: 'primary.contrastText' } }, h(it.icon)),
-                h(ListItemText, { primary: getMenuLabel(it) })
-            ) )
-    )
-}
-
-export function getMenuLabel(it: MenuEntry) {
-    return it && (it.label ?? _.capitalize(it.path))
-}

package/admin/src/MenuButton.ts

@@ -1,38 +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 React, { createElement as h, useCallback } from 'react'
-import { Button, Menu, MenuItem } from '@mui/material'
-
-interface Props { items: any[], [rest:string]:any }
-
-export default function MenuButton({ items, ...rest }: Props) {
-    const [anchorEl, setAnchorEl] = React.useState<HTMLElement>()
-    const open = Boolean(anchorEl)
-    const onClose = useCallback(() => setAnchorEl(undefined), [])
-    return h(React.Fragment, {},
-        h(Button, {
-            'aria-controls': open ? 'basic-menu' : undefined,
-            'aria-haspopup': 'true',
-            'aria-expanded': open ? 'true' : undefined,
-            onClick: (event: React.MouseEvent<HTMLButtonElement>) => {
-                setAnchorEl(event.currentTarget)
-            },
-            ...rest,
-        }),
-        h(Menu, {
-            anchorEl,
-            open,
-            onClose,
-            MenuListProps: { 'aria-labelledby': 'basic-button' },
-            children: items.map((it,idx) =>
-                h(MenuItem, {
-                    key: idx,
-                    ...it,
-                    onClick() {
-                        onClose()
-                        it.onClick?.apply(this, arguments)
-                    }
-                }) )
-        })
-    )
-}