sideby 0.0.0-stage → 0.1.0

package/dist/src/panel/handler.js

@@ -0,0 +1,411 @@
+// HTTP handler for the local Panel. Mountable under any basePath; standalone and embedded use the same rules.
+import { randomBytes, timingSafeEqual } from 'node:crypto';
+import { resolveRef } from '../core/accounts.js';
+import { aliasArgs, aliasRefs } from '../core/config.js';
+import { UserError } from '../core/errors.js';
+import { planHandoff } from '../core/handoff.js';
+import { buildId, packageVersion } from '../core/version.js';
+import { renderPage } from './page.js';
+import { resolveTheme } from './theme.js';
+export const PANEL_VERSION = packageVersion();
+export const MAX_BODY_BYTES = 64 * 1024;
+/** Write requests allowed to wait behind the running one; more get 409. */
+export const MAX_QUEUED_WRITES = 4;
+const PANEL_LANGS = ['auto', 'en', 'zh'];
+function resolveLang(lang) {
+    if (lang === undefined)
+        return 'auto';
+    const found = PANEL_LANGS.find((l) => l === lang);
+    if (!found)
+        throw new TypeError('panel lang must be "auto", "en" or "zh"');
+    return found;
+}
+/** Counts of failing and warning Findings per checked Account, from the Doctor history. */
+export function healthByAccount(history) {
+    const out = new Map();
+    for (const [ref, entry] of Object.entries(history?.accounts ?? {}))
+        out.set(ref, {
+            at: entry.at,
+            fail: entry.findings.filter((f) => f.level === 'fail').length,
+            warn: entry.findings.filter((f) => f.level === 'warn').length,
+        });
+    return out;
+}
+/** Alias names per Account ref, sorted. An alias whose target matches no Account is left out. */
+export function aliasesByAccount(aliases, accounts) {
+    const out = new Map();
+    for (const [alias, target] of Object.entries(aliases ?? {})) {
+        let ref;
+        try {
+            ref = resolveRef(target, accounts).ref;
+        }
+        catch {
+            continue;
+        }
+        out.set(ref, [...(out.get(ref) ?? []), alias].sort());
+    }
+    return out;
+}
+/** The `handoff` map of the Panel state, from the statuses and Quota already read for the page. */
+export function handoffByFamily(rt, accounts, now) {
+    const out = {};
+    for (const [id, f] of rt.families) {
+        const list = accounts.filter((a) => a.family === id);
+        if (!f.readQuota || list.filter((a) => a.kind === 'subscription').length < 2)
+            continue;
+        const plan = planHandoff(id, list.map((a) => ({
+            ref: a.ref,
+            name: a.name,
+            isMain: a.isMain,
+            kind: a.kind,
+            login: a.login ?? 'unknown',
+            quota: a.quota ?? { status: 'unavailable', reason: 'unrecognized' },
+        })), now);
+        if (plan.pick && plan.hasQuota)
+            out[id] = plan.pick;
+    }
+    return out;
+}
+class HttpError extends Error {
+    status;
+    /** Machine-readable reason the page acts on, such as `bad-token`. */
+    code;
+    constructor(status, message, code) {
+        super(message);
+        this.status = status;
+        if (code)
+            this.code = code;
+    }
+}
+function normalizeBase(p) {
+    if (!p || p === '/')
+        return '';
+    const withSlash = p.startsWith('/') ? p : `/${p}`;
+    return withSlash.replace(/\/+$/, '');
+}
+function sameSecret(given, expected) {
+    const a = Buffer.from(given);
+    const b = Buffer.from(expected);
+    return a.length === b.length && timingSafeEqual(a, b);
+}
+function send(res, status, body, extra = {}) {
+    const data = JSON.stringify(body);
+    res.writeHead(status, {
+        'content-type': 'application/json; charset=utf-8',
+        'cache-control': 'no-store',
+        'x-content-type-options': 'nosniff',
+        ...extra,
+    });
+    res.end(data);
+}
+function readBody(req) {
+    const declared = Number(req.headers['content-length']);
+    if (Number.isFinite(declared) && declared > MAX_BODY_BYTES)
+        return Promise.reject(new HttpError(413, `request body over ${MAX_BODY_BYTES} bytes`));
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let size = 0;
+        let failed = false;
+        req.on('data', (c) => {
+            if (failed)
+                return;
+            size += c.length;
+            if (size > MAX_BODY_BYTES) {
+                failed = true;
+                reject(new HttpError(413, `request body over ${MAX_BODY_BYTES} bytes`));
+                return;
+            }
+            chunks.push(c);
+        });
+        req.on('error', (err) => {
+            if (!failed)
+                reject(err);
+        });
+        req.on('end', () => {
+            if (failed)
+                return;
+            const raw = Buffer.concat(chunks).toString('utf8').trim();
+            if (!raw)
+                return resolve({});
+            try {
+                const parsed = JSON.parse(raw);
+                if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
+                    return reject(new HttpError(400, 'request body must be a JSON object'));
+                resolve(parsed);
+            }
+            catch {
+                reject(new HttpError(400, 'request body is not valid JSON'));
+            }
+        });
+    });
+}
+function optString(body, key) {
+    const v = body[key];
+    if (v === undefined || v === null || v === '')
+        return undefined;
+    if (typeof v !== 'string')
+        throw new HttpError(400, `"${key}" must be a string`);
+    return v;
+}
+function optBool(body, key) {
+    const v = body[key];
+    if (v === undefined || v === null)
+        return false;
+    if (typeof v !== 'boolean')
+        throw new HttpError(400, `"${key}" must be true or false`);
+    return v;
+}
+async function accountState(rt, account, families) {
+    const errors = [];
+    const guard = async (p) => {
+        try {
+            return await p;
+        }
+        catch (err) {
+            errors.push(err.message);
+            return undefined;
+        }
+    };
+    const [status, quota, usage] = await Promise.all([
+        guard(rt.status(account)),
+        guard(rt.quota(account)),
+        guard(rt.usage(account)),
+    ]);
+    const fam = families.find((f) => f.id === account.family);
+    const base = status ?? {
+        ...account,
+        familyTitle: fam?.title ?? account.family,
+        hostInstalled: fam?.installed ?? false,
+        login: 'unknown',
+    };
+    errors.push(...(status?.problems ?? []));
+    return {
+        ...base,
+        ...(quota ? { quota } : {}),
+        ...(usage ? { usage } : {}),
+        ...(errors.length ? { error: errors.join('; ') } : {}),
+    };
+}
+async function buildState(rt, opts) {
+    const ctx = rt.readContext();
+    const [families, accounts, history, quotaSetups] = await Promise.all([
+        rt.familyInfo(),
+        rt.accounts(),
+        rt.doctorHistory(),
+        rt.quotaSetups(),
+    ]);
+    const health = healthByAccount(history);
+    const aliases = aliasesByAccount(aliasRefs(rt.config.aliases), accounts);
+    const list = await Promise.all(accounts.map(async (a) => {
+        const st = await accountState(rt, a, families);
+        const h = health.get(a.ref);
+        const names = aliases.get(a.ref);
+        const withArgs = (names ?? [])
+            .map((n) => [n, aliasArgs(rt.config.aliases?.[n])])
+            .filter(([, args]) => args.length);
+        return {
+            ...st,
+            ...(h ? { health: h } : {}),
+            ...(names ? { aliases: names } : {}),
+            ...(withArgs.length ? { aliasArgs: Object.fromEntries(withArgs) } : {}),
+        };
+    }));
+    const handoff = handoffByFamily(rt, list, ctx.now);
+    return {
+        schemaVersion: 1,
+        version: opts.version,
+        build: opts.build,
+        readOnly: opts.readOnly,
+        generatedAt: ctx.now.toISOString(),
+        families: families.map((f) => {
+            const logo = rt.families.get(f.id)?.logo;
+            return logo ? { ...f, logo } : f;
+        }),
+        accounts: list,
+        pluginErrors: rt.pluginErrors.map((e) => ({ where: e.where, message: e.message })),
+        quotaSetups,
+        ...(history ? { history } : {}),
+        ...(rt.config.aliases ? { configAliases: aliasRefs(rt.config.aliases) } : {}),
+        ...(Object.keys(handoff).length ? { handoff } : {}),
+    };
+}
+/** Runs write requests one at a time; a few may wait, the rest are told to retry. */
+function writeQueue() {
+    let tail = Promise.resolve();
+    let inFlight = 0;
+    return (fn) => {
+        if (inFlight > MAX_QUEUED_WRITES)
+            return Promise.reject(new HttpError(409, 'another change is still running; try again in a moment'));
+        inFlight++;
+        const run = tail.then(fn);
+        tail = run.catch(() => undefined);
+        return run.finally(() => {
+            inFlight--;
+        });
+    };
+}
+export function createPanelHandler(opts) {
+    const basePath = normalizeBase(opts.basePath);
+    const allowed = new Set(opts.allowedHosts.map((h) => h.toLowerCase()));
+    const readOnly = Boolean(opts.readOnly);
+    const version = opts.version ?? PANEL_VERSION;
+    const build = buildId();
+    const theme = resolveTheme(opts.theme);
+    const lang = resolveLang(opts.lang);
+    const token = randomBytes(32).toString('base64url');
+    const serial = writeQueue();
+    const getRuntime = typeof opts.runtime === 'function' ? opts.runtime : async () => opts.runtime;
+    const routes = {
+        '/api/doctor': {
+            // Only the record of the check is written, and a read-only Panel skips that (persist: false).
+            writes: () => false,
+            async run(body) {
+                const target = optString(body, 'target');
+                const rt = await getRuntime();
+                return rt.doctorWithHistory({ persist: !readOnly, ...(target ? { target } : {}) });
+            },
+        },
+        '/api/fix': {
+            async run(body) {
+                const target = optString(body, 'target');
+                const force = optBool(body, 'force');
+                const rt = await getRuntime();
+                return rt.doctorWithHistory({ fix: true, force, ...(target ? { target } : {}) });
+            },
+        },
+        '/api/accounts': {
+            async run(body) {
+                const family = optString(body, 'family');
+                const name = optString(body, 'name');
+                if (!family || !name)
+                    throw new HttpError(400, 'pick a family and enter a name');
+                const api = optBool(body, 'api');
+                const alias = optString(body, 'alias');
+                const rt = await getRuntime();
+                return rt.createAccount(family, name, { api, ...(alias ? { alias } : {}) });
+            },
+        },
+        '/api/quota/setup': {
+            writes: (body) => body.confirm === true,
+            async run(body) {
+                const family = optString(body, 'family');
+                const confirm = optBool(body, 'confirm');
+                if (!family)
+                    throw new HttpError(400, '"family" is required');
+                const rt = await getRuntime();
+                const setup = rt.quotaSetup(family);
+                const plan = confirm ? await setup.apply() : await setup.plan();
+                return { family, summary: setup.summary, plan };
+            },
+        },
+        // Undo for the setup above; the Runtime turns a teardown that throws into `{ ok: false, message }`.
+        '/api/quota/teardown': {
+            async run(body) {
+                const family = optString(body, 'family');
+                if (!family)
+                    throw new HttpError(400, '"family" is required');
+                const rt = await getRuntime();
+                return { family, result: await rt.quotaSetup(family).teardown() };
+            },
+        },
+    };
+    const handle = async (req, res) => {
+        let pathname;
+        try {
+            pathname = new URL(req.url ?? '/', 'http://x').pathname;
+        }
+        catch {
+            return false;
+        }
+        if (basePath && pathname !== basePath && !pathname.startsWith(`${basePath}/`))
+            return false;
+        const sub = pathname.slice(basePath.length) || '/';
+        try {
+            const host = (req.headers.host ?? '').toLowerCase();
+            if (!allowed.has(host))
+                throw new HttpError(403, 'host not allowed');
+            const method = req.method ?? 'GET';
+            if (method === 'GET' || method === 'HEAD') {
+                if (sub === '/' || sub === '/index.html') {
+                    const nonce = randomBytes(16).toString('base64');
+                    res.writeHead(200, {
+                        'content-type': 'text/html; charset=utf-8',
+                        'cache-control': 'no-store',
+                        'x-content-type-options': 'nosniff',
+                        'referrer-policy': 'no-referrer',
+                        'content-security-policy': [
+                            "default-src 'none'",
+                            `script-src 'nonce-${nonce}'`,
+                            `style-src 'nonce-${nonce}'`,
+                            "connect-src 'self'",
+                            "img-src 'self' data:",
+                            "base-uri 'none'",
+                            "form-action 'none'",
+                            "frame-ancestors 'self'",
+                        ].join('; '),
+                    });
+                    res.end(method === 'HEAD'
+                        ? undefined
+                        : renderPage({ basePath, token, nonce, version, build, readOnly, theme, lang }));
+                    return true;
+                }
+                if (sub === '/api/health') {
+                    send(res, 200, { app: 'sideby', version, build });
+                    return true;
+                }
+                // The page fetches a fresh token here after the server restarted (a new process, a new token).
+                // It reveals nothing a same-origin read of the page does not; a cross-site page cannot read it.
+                if (sub === '/api/session') {
+                    if (req.headers['sec-fetch-site'] === 'cross-site')
+                        throw new HttpError(403, 'origin not allowed');
+                    send(res, 200, { token });
+                    return true;
+                }
+                if (sub === '/api/state') {
+                    send(res, 200, await buildState(await getRuntime(), { version, build, readOnly }));
+                    return true;
+                }
+                if (Object.hasOwn(routes, sub))
+                    throw new HttpError(405, 'use POST');
+                throw new HttpError(404, 'not found');
+            }
+            if (method !== 'POST')
+                throw new HttpError(405, 'method not allowed');
+            const route = Object.hasOwn(routes, sub) ? routes[sub] : undefined;
+            if (!route)
+                throw new HttpError(404, 'not found');
+            const origin = req.headers.origin;
+            if (!origin || origin.toLowerCase() !== `http://${host}`)
+                throw new HttpError(403, 'origin not allowed');
+            const given = req.headers['x-sideby-token'];
+            if (typeof given !== 'string' || !sameSecret(given, token))
+                throw new HttpError(403, 'missing or wrong x-sideby-token; reload the page', 'bad-token');
+            const body = (await readBody(req));
+            if (readOnly && (route.writes?.(body) ?? true))
+                throw new HttpError(403, 'this panel is read-only');
+            // Reads that record history (doctor) also run in this queue, so overlapping checks merge in order.
+            send(res, 200, await serial(() => route.run(body)));
+            return true;
+        }
+        catch (err) {
+            if (res.headersSent) {
+                res.end();
+                return true;
+            }
+            if (err instanceof HttpError) {
+                const body = err.code ? { error: err.message, code: err.code } : { error: err.message };
+                send(res, err.status, body, err.status === 413 ? { connection: 'close' } : {});
+                if (err.status === 413)
+                    req.resume();
+            }
+            else if (err instanceof UserError) {
+                send(res, 400, err.code ? { error: err.message, code: err.code } : { error: err.message });
+            }
+            else {
+                send(res, 500, { error: err?.message || 'internal error' });
+            }
+            return true;
+        }
+    };
+    return Object.assign(handle, { token });
+}

package/dist/src/panel/i18n.d.ts

@@ -0,0 +1,287 @@
+export type PanelLang = 'en' | 'zh';
+declare const en: {
+    'top.tagline': string;
+    'top.refresh': string;
+    'top.loading': string;
+    'top.refreshing': string;
+    'top.updated': string;
+    'top.updatedTitle': string;
+    'top.language': string;
+    'foot.text': string;
+    'acct.title': string;
+    'theme.system': string;
+    'theme.light': string;
+    'theme.dark': string;
+    'err.noAnswer': string;
+    'err.session': string;
+    'err.expired': string;
+    'err.server': string;
+    'conn.lost': string;
+    'load.failed': string;
+    'load.failedShort': string;
+    'btn.copy': string;
+    'btn.copyText': string;
+    'btn.retry': string;
+    'btn.close': string;
+    'btn.cancel': string;
+    'btn.done': string;
+    'time.justNow': string;
+    'time.minAgo': string;
+    'time.hAgo': string;
+    'time.dAgo': string;
+    'time.in': string;
+    'toast.dismiss': string;
+    'toast.copied': string;
+    'toast.copyFailed': string;
+    'toast.reconnected': string;
+    'toast.refreshed': string;
+    'toast.updated': string;
+    'toast.refreshFailed': string;
+    'toast.checkOk': string;
+    'toast.checkFound': string;
+    'toast.checkFailed': string;
+    'toast.show': string;
+    'toast.created': string;
+    'toast.createdProblems': string;
+    'toast.quotaOn': string;
+    'toast.quotaOff': string;
+    'toast.undo': string;
+    'toast.undoFailed': string;
+    'toast.undoMissing': string;
+    'tip.label': string;
+    'tip.api.term': string;
+    'tip.api.body': string;
+    'tip.shared.term': string;
+    'tip.shared.body': string;
+    'tip.drift.term': string;
+    'tip.drift.body': string;
+    'tip.quotaOff.term': string;
+    'tip.quotaOff.body': string;
+    'tip.quotaOff.cli': string;
+    'tip.age.term': string;
+    'tip.age.body': string;
+    'stat.accounts': string;
+    'stat.families.one': string;
+    'stat.families.other': string;
+    'stat.api.one': string;
+    'stat.api.other': string;
+    'stat.attention': string;
+    'stat.attentionOn': string;
+    'stat.attentionOff': string;
+    'stat.btnLabel': string;
+    'stat.allClear': string;
+    'stat.tokens': string;
+    'stat.sessions.one': string;
+    'stat.sessions.other': string;
+    'stat.nextReset': string;
+    'stat.noQuota': string;
+    'need.error.one': string;
+    'need.error.other': string;
+    'need.health-fail.one': string;
+    'need.health-fail.other': string;
+    'need.signed-out.one': string;
+    'need.signed-out.other': string;
+    'need.not-installed.one': string;
+    'need.not-installed.other': string;
+    'need.quota-high.one': string;
+    'need.quota-high.other': string;
+    'need.health-warn.one': string;
+    'need.health-warn.other': string;
+    'tb.search': string;
+    'tb.searchPh': string;
+    'tb.family': string;
+    'tb.allFamilies': string;
+    'tb.sort': string;
+    'sort.pressure': string;
+    'sort.name': string;
+    'sort.recent': string;
+    'tb.quota': string;
+    'tb.used': string;
+    'tb.left': string;
+    'tb.view': string;
+    'tb.list': string;
+    'tb.cards': string;
+    'tb.hideEmails': string;
+    'tb.showEmails': string;
+    'tb.segLabel': string;
+    'tb.new': string;
+    'count.accounts.one': string;
+    'count.accounts.other': string;
+    'count.filtered': string;
+    'filter.none': string;
+    'filter.noneQuery': string;
+    'filter.noneBody': string;
+    'filter.clear': string;
+    'group.expand': string;
+    'group.collapse': string;
+    'group.toggle': string;
+    'group.attention.one': string;
+    'group.attention.other': string;
+    'acct.alias': string;
+    'acct.aliasArgs': string;
+    'acct.api': string;
+    'acct.model': string;
+    'acct.signedOut': string;
+    'acct.signInHint': string;
+    'acct.signedOutLabel': string;
+    'acct.next': string;
+    'acct.nextHint': string;
+    'acct.nextLabel': string;
+    'acct.notInstalled': string;
+    'acct.readError': string;
+    'acct.installHost': string;
+    'acct.installIt': string;
+    'quota.pctUsed': string;
+    'quota.pctLeft': string;
+    'quota.meterUsed': string;
+    'quota.meterLeft': string;
+    'quota.resetsAt': string;
+    'quota.resetPassed': string;
+    'quota.resetNoData': string;
+    'quota.dataFrom': string;
+    'quota.asOf': string;
+    'quota.noWindows': string;
+    'quota.off': string;
+    'quota.turnOnFamily': string;
+    'quota.turnOnFamilyNote': string;
+    'quota.turnOnFamilyLabel': string;
+    'quota.blocked': string;
+    'quota.api': string;
+    'quota.noSession': string;
+    'quota.noSessionHint': string;
+    'quota.noSource': string;
+    'quota.unrecognized': string;
+    'quota.unavailable': string;
+    'quota.unitUsed': string;
+    'quota.unitLeft': string;
+    'quota.resetShort': string;
+    'quota.missing': string;
+    'quota.waiting': string;
+    'col.account': string;
+    'col.used': string;
+    'col.left': string;
+    'col.tokens': string;
+    'col.last': string;
+    'col.health': string;
+    'usage.tokens': string;
+    'usage.cache': string;
+    'usage.sessions.one': string;
+    'usage.sessions.other': string;
+    'usage.detail': string;
+    'usage.none': string;
+    'usage.noSource': string;
+    'usage.unreadable': string;
+    'usage.sparkLabel': string;
+    'last.title': string;
+    'last.unknown': string;
+    'health.title': string;
+    'health.intro': string;
+    'health.lead': string;
+    'health.sharedTerm': string;
+    'health.driftTerm': string;
+    'health.more.one': string;
+    'health.more.other': string;
+    'health.run': string;
+    'health.running': string;
+    'health.fixing': string;
+    'health.checking': string;
+    'health.waiting': string;
+    'health.last': string;
+    'health.never': string;
+    'health.error': string;
+    'health.notChecked': string;
+    'health.ok': string;
+    'health.issues.one': string;
+    'health.issues.other': string;
+    'health.warnings.one': string;
+    'health.warnings.other': string;
+    'health.filterHint': string;
+    'health.chipLabel': string;
+    'health.only': string;
+    'health.filtered': string;
+    'health.checkThis': string;
+    'health.showAll': string;
+    'health.autoFix': string;
+    'health.from': string;
+    'health.allGood': string;
+    'health.refGood': string;
+    'health.allGoodSub': string;
+    'health.refNever': string;
+    'fix.all': string;
+    'fix.hintAction': string;
+    'fix.off': string;
+    'fix.whyNoCheck': string;
+    'fix.whyManual': string;
+    'fix.whyNothing': string;
+    'fix.result': string;
+    'fix.nothing': string;
+    'menu.title': string;
+    'menu.label': string;
+    'menu.copyRun': string;
+    'menu.copyAlias': string;
+    'menu.copyLogin': string;
+    'menu.copyDir': string;
+    'menu.copyEmail': string;
+    'menu.check': string;
+    'menu.like': string;
+    'nf.title': string;
+    'nf.intro': string;
+    'nf.tool': string;
+    'nf.accounts.one': string;
+    'nf.accounts.other': string;
+    'nf.runOnce': string;
+    'nf.notInstalled': string;
+    'nf.name': string;
+    'nf.namePh': string;
+    'nf.api': string;
+    'nf.apiHint': string;
+    'nf.dir': string;
+    'nf.launch': string;
+    'nf.create': string;
+    'nf.suggested': string;
+    'nf.refusedApi': string;
+    'nf.creating': string;
+    'nf.mainTaken': string;
+    'nf.badName': string;
+    'nf.exists': string;
+    'nf.enterName': string;
+    'nf.noReady': string;
+    'nf.created': string;
+    'nf.createdProblems': string;
+    'nf.next': string;
+    'nf.fillIn': string;
+    'nf.another': string;
+    'nf.alias': string;
+    'nf.optional': string;
+    'nf.aliasPh': string;
+    'nf.aliasHint': string;
+    'nf.aliasSuggested': string;
+    'nf.aliasBad': string;
+    'nf.aliasReserved': string;
+    'nf.aliasTaken': string;
+    'nf.or': string;
+    'nf.aliasNewShell': string;
+    'nf.aliasNotAdded': string;
+    'nf.shellFileUpdated': string;
+    'nf.shellFileSame': string;
+    'qs.title': string;
+    'qs.preparing': string;
+    'qs.changes': string;
+    'qs.undoHint': string;
+    'qs.apply': string;
+    'qs.applying': string;
+    'qs.alreadyOn': string;
+    'empty.title': string;
+    'empty.body': string;
+    'empty.runOnce': string;
+    'empty.install': string;
+    'empty.noFamilies': string;
+    'empty.create': string;
+    'banner.readOnly': string;
+    'banner.plugins.one': string;
+    'banner.plugins.other': string;
+    'banner.pluginsHint': string;
+};
+export type MessageKey = keyof typeof en;
+export declare const MESSAGES: Record<PanelLang, Record<string, string>>;
+export {};