@3minapi/cli 0.0.0-stage → 0.22.1

package/dist/modules/dashboard/data.js

@@ -0,0 +1,565 @@
+import { closeSync, existsSync, openSync, readdirSync, readSync, statSync } from 'node:fs';
+import { hostname } from 'node:os';
+import path from 'node:path';
+import { WORKER_LOG_DIR, builtinResultsName } from "../../core/domain/index.js";
+import { ControlDb } from "../../core/control-db.js";
+import { readRunner } from "../../core/host/runner-lock.js";
+import { hostUsage } from "../../core/host/usage.js";
+import { findLastRecord, parseRecord, readIfExists, tailLines } from "../../core/log-read.js";
+import { channelDir, listAllLogFiles, listChannelFiles } from "../../core/logger.js";
+import { utcDate } from "../../core/time.js";
+import { HOST_META } from "../workers/builtin/host-identity.js";
+import { ResultStore, resultsDbBytes, resultsDbPath } from "../workers/results/store.js";
+import { parseSettings } from "../workers/repeat-scheduler.js";
+import { workerFiles } from "../workers/workers.js";
+export const RANGES = ['today', '7d', '30d'];
+export const RUN_RANGES = [...RANGES, 'all'];
+export const RUN_STATES = ['completed', 'failed', 'cancelled', 'running', 'superseded'];
+export function rangeStart(range, now) {
+    if (range === 'all')
+        return null;
+    const d = new Date(now);
+    const midnight = new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime();
+    if (range === 'today')
+        return midnight;
+    const days = range === '7d' ? 6 : 29;
+    const start = new Date(midnight);
+    start.setDate(start.getDate() - days);
+    return start.getTime();
+}
+function runState(state) {
+    return state === 'received' ? 'running' : state;
+}
+function withControl(src, fn, fallback) {
+    const db = ControlDb.openReadOnly(src.dataDir);
+    if (!db)
+        return fallback;
+    try {
+        return fn(db);
+    }
+    finally {
+        db.close();
+    }
+}
+function withResults(src, fn, fallback) {
+    if (!src.projectRoot)
+        return fallback;
+    const store = ResultStore.openReadOnly(src.projectRoot);
+    if (!store)
+        return fallback;
+    try {
+        return fn(store);
+    }
+    finally {
+        store.close();
+    }
+}
+export function encodeCursor(c) {
+    return `${c.at}.${c.taskId}`;
+}
+export function decodeCursor(raw) {
+    if (!raw)
+        return null;
+    const m = /^(\d{1,16})\.(.+)$/.exec(raw);
+    return m ? { at: Number(m[1]), taskId: m[2] } : null;
+}
+function toRun(task, result, savedRuns = null) {
+    const t = task ?? null;
+    const r = result ?? null;
+    const repeat = parseSettings(t?.repeat);
+    return {
+        task_id: (t?.task_id ?? r?.task_id),
+        worker: (t?.worker ?? r?.worker),
+        state: runState(t?.state ?? r.status),
+        at: t?.received_at ?? Date.parse(r.created_at),
+        started_at: t?.started_at ?? null,
+        finished_at: t?.finished_at ?? null,
+        duration_ms: t?.started_at != null && t.finished_at != null ? t.finished_at - t.started_at : null,
+        delivery_attempt: t?.delivery_attempt ?? null,
+        run_count: t?.run_count ?? null,
+        last_error: t?.last_error ?? null,
+        bytes: r?.bytes ?? null,
+        reply: r?.reply ?? null,
+        source: r?.source ?? null,
+        in: t && r ? 'both' : t ? 'control' : 'results',
+        repeat: repeat
+            ? { interval_seconds: repeat.interval_seconds, max_runs: repeat.max_runs ?? null }
+            : null,
+        runs: t?.runs ?? null,
+        failed: t?.failed ?? null,
+        last_run_at: t?.last_run_at ?? null,
+        next_at: t?.next_at ?? null,
+        saved_runs: savedRuns
+    };
+}
+export function isRepeat(run) {
+    return run.repeat !== null || (run.saved_runs ?? 0) > 1;
+}
+const RESULT_ONLY_BATCH = 500;
+export function listRuns(src, filter, limit, after = null) {
+    const since = rangeStart(filter.range, src.now());
+    const states = filter.state === undefined
+        ? undefined
+        : filter.state === 'running'
+            ? ['received', 'running']
+            : [filter.state];
+    const fetch = limit + 1;
+    const tasks = withControl(src, (db) => db.listTasks({
+        ...(since !== null ? { since } : {}),
+        ...(filter.worker !== undefined ? { worker: filter.worker } : {}),
+        ...(states ? { states } : {}),
+        ...(after ? { after } : {})
+    }, fetch), []);
+    const boundary = tasks.length === fetch ? tasks[tasks.length - 1].received_at : null;
+    const fromResults = filter.state === undefined || filter.state === 'completed' || filter.state === 'failed';
+    const resultOnly = fromResults ? findResultOnly(src, filter, since, after, boundary, fetch) : [];
+    const { paired, counts } = withResults(src, (store) => ({
+        paired: store.rowsByIds(tasks.map((t) => t.task_id)),
+        counts: store.runCounts([...tasks.map((t) => t.task_id), ...resultOnly.map((r) => r.task_id)])
+    }), { paired: [], counts: new Map() });
+    const resultById = new Map(paired.map((r) => [r.task_id, r]));
+    const saved = (id) => counts.get(id)?.runs ?? null;
+    const merged = [
+        ...tasks.map((t) => toRun(t, resultById.get(t.task_id), saved(t.task_id))),
+        ...resultOnly.map((r) => toRun(undefined, r, saved(r.task_id)))
+    ]
+        .filter((run) => filter.state === undefined || run.state === filter.state)
+        .filter((run) => !after || before(run, after))
+        .sort((a, b) => b.at - a.at || a.task_id.localeCompare(b.task_id));
+    const runs = merged.slice(0, limit);
+    const last = runs.at(-1);
+    return {
+        runs,
+        next: merged.length > limit && last ? { at: last.at, taskId: last.task_id } : null
+    };
+}
+function findResultOnly(src, filter, since, after, boundary, max) {
+    const store = src.projectRoot ? ResultStore.openReadOnly(src.projectRoot) : null;
+    if (!store)
+        return [];
+    const db = ControlDb.openReadOnly(src.dataDir);
+    try {
+        const out = [];
+        let cursor = after
+            ? { createdAt: new Date(after.at).toISOString(), taskId: after.taskId }
+            : undefined;
+        for (;;) {
+            const batch = store.list({
+                ...(since !== null ? { since: new Date(since).toISOString() } : {}),
+                ...(filter.worker !== undefined ? { worker: filter.worker } : {}),
+                ...(filter.state === 'completed' || filter.state === 'failed'
+                    ? { status: filter.state }
+                    : {}),
+                ...(cursor ? { after: cursor } : {}),
+                latestRunOnly: true
+            }, RESULT_ONLY_BATCH);
+            const known = new Set(db ? db.tasksByIds(batch.map((r) => r.task_id)).map((t) => t.task_id) : []);
+            for (const r of batch) {
+                if (boundary !== null && Date.parse(r.created_at) < boundary)
+                    return out;
+                if (known.has(r.task_id))
+                    continue;
+                out.push(r);
+                if (out.length >= max)
+                    return out;
+            }
+            if (batch.length < RESULT_ONLY_BATCH)
+                return out;
+            const last = batch[batch.length - 1];
+            cursor = { createdAt: last.created_at, taskId: last.task_id };
+        }
+    }
+    finally {
+        db?.close();
+        store.close();
+    }
+}
+function before(run, c) {
+    return run.at < c.at || (run.at === c.at && run.task_id > c.taskId);
+}
+export function runDetail(src, taskId) {
+    const task = withControl(src, (db) => db.getTask(taskId), null);
+    const found = withResults(src, (store) => store.snapshot(() => {
+        const latest = store.rowsByIds([taskId])[0] ?? null;
+        const saved = store.runCounts([taskId]).get(taskId)?.runs ?? 0;
+        if (!task && !latest)
+            return null;
+        const run = toRun(task ?? undefined, latest ?? undefined, saved || null);
+        return { run, result: latest && !isRepeat(run) ? store.get(taskId) : null };
+    }), undefined);
+    if (found === null)
+        return null;
+    if (found === undefined)
+        return task ? { run: toRun(task, undefined, null), result: null } : null;
+    return found;
+}
+export const RUNS_DETAIL_PAGE = 50;
+export const PREVIEW_MAX_BYTES = 64 * 1024;
+export const PREVIEW_CHARS = 120;
+export function repeatRuns(src, taskId, runsBefore) {
+    const found = withResults(src, (store) => store.snapshot(() => ({
+        page: store.runPreviews(taskId, RUNS_DETAIL_PAGE + 1, runsBefore, PREVIEW_MAX_BYTES),
+        total: store.runCounts([taskId]).get(taskId)?.runs ?? 0
+    })), { page: [], total: 0 });
+    const runs = found.page.slice(0, RUNS_DETAIL_PAGE).map(({ payload, ...row }) => ({
+        ...row,
+        preview: payload === null ? null : previewOf(row.status, payload),
+        large: payload === null
+    }));
+    return {
+        runs,
+        runsNext: found.page.length > RUNS_DETAIL_PAGE ? (runs.at(-1)?.run_no ?? null) : null,
+        total: found.total
+    };
+}
+export function previewOf(status, payload) {
+    let text = payload;
+    if (status === 'failed') {
+        try {
+            const v = JSON.parse(payload);
+            const message = v !== null && typeof v === 'object' ? v.message : undefined;
+            if (typeof message === 'string')
+                text = message.split('\n')[0];
+        }
+        catch {
+        }
+    }
+    const cut = text.length > PREVIEW_CHARS * 4;
+    text = (cut ? text.slice(0, PREVIEW_CHARS * 4) : text).replace(/\s+/g, ' ').trim();
+    if (text.length <= PREVIEW_CHARS)
+        return cut ? `${text}…` : text;
+    const end = /[\uD800-\uDBFF]/.test(text[PREVIEW_CHARS - 1]) ? PREVIEW_CHARS - 1 : PREVIEW_CHARS;
+    return `${text.slice(0, end)}…`;
+}
+export function runOfTask(src, run, runNo) {
+    const found = withResults(src, (store) => store.snapshot(() => ({
+        result: store.get(run.task_id, runNo),
+        prevRow: store.runs(run.task_id, 1, runNo)[0] ?? null,
+        next: store.nextRunNo(run.task_id, runNo)
+    })), {
+        result: null,
+        prevRow: null,
+        next: null
+    });
+    const savedAt = found.result ? Date.parse(found.result.created_at) : src.now();
+    return {
+        result: found.result,
+        prev: found.prevRow?.run_no ?? null,
+        next: found.next,
+        from: runLogStart(run, runNo, savedAt, found.prevRow)
+    };
+}
+function runLogStart(run, runNo, savedAt, prev) {
+    let start;
+    if (prev)
+        start = Date.parse(prev.created_at);
+    else if (runNo === 1 && run.in !== 'results')
+        start = run.at - RUN_LOG_MARGIN_MS;
+    else if (run.repeat)
+        start = savedAt - run.repeat.interval_seconds * 1000;
+    else
+        start = savedAt - TASK_LOG_MARGIN_MS;
+    return Math.max(start, savedAt - TASK_LOG_MAX_SPAN_MS);
+}
+const HISTORY_WORKERS_TTL_MS = 60_000;
+const historyWorkers = new Map();
+export function knownWorkers(src) {
+    const names = new Set();
+    const now = src.now();
+    let cached = historyWorkers.get(src.dataDir);
+    if (!cached || now - cached.at >= HISTORY_WORKERS_TTL_MS) {
+        cached = { at: now, names: withControl(src, (db) => db.distinctWorkers(), []) };
+        if (cached.names.length > 0)
+            historyWorkers.set(src.dataDir, cached);
+    }
+    for (const name of cached.names)
+        names.add(name);
+    for (const name of workerFilesIfAny(src.workersDir)?.keys() ?? [])
+        names.add(name);
+    return [...names].sort();
+}
+const HOST_NAME_TTL_MS = 60_000;
+const hostNames = new Map();
+export function hostName(src) {
+    const now = src.now();
+    const cached = hostNames.get(src.dataDir);
+    if (cached && now - cached.at < HOST_NAME_TTL_MS)
+        return cached.name;
+    let name = null;
+    try {
+        name = withControl(src, (db) => db.getMeta(HOST_META.name), null);
+    }
+    catch {
+    }
+    if (name) {
+        hostNames.set(src.dataDir, { at: now, name });
+        return name;
+    }
+    return hostname();
+}
+function emptyCounts() {
+    return { total: 0, completed: 0, failed: 0, cancelled: 0, running: 0, superseded: 0 };
+}
+function add(c, state, n) {
+    c.total += n;
+    c[runState(state)] += n;
+}
+export function overview(src, range) {
+    const now = src.now();
+    const since = rangeStart(range, now);
+    const unit = range === 'today' ? 'hour' : 'day';
+    const totals = emptyCounts();
+    const workers = new Map();
+    const buckets = new Map(bucketKeys(since, now, unit).map((k) => [k, emptyCounts()]));
+    const fromDb = withControl(src, (db) => {
+        for (const r of db.countGrouped(since, unit)) {
+            add(totals, r.state, r.n);
+            if (!workers.has(r.worker))
+                workers.set(r.worker, emptyCounts());
+            add(workers.get(r.worker), r.state, r.n);
+            if (!buckets.has(r.bucket))
+                buckets.set(r.bucket, emptyCounts());
+            add(buckets.get(r.bucket), r.state, r.n);
+        }
+        const usage = hostUsage(db, src.logsDir);
+        return {
+            recentFailures: db.listTasks({ since, states: ['failed'] }, 8),
+            lastResponse: db.getQuota(),
+            stop: db.getStop(),
+            end: db.getEnd(),
+            host: { id: db.getMeta(HOST_META.id), name: db.getMeta(HOST_META.name) },
+            usage
+        };
+    }, null);
+    const logs = logUsage(src.logsDir);
+    const dataBytes = src.projectRoot ? resultsDbBytes(src.projectRoot) : null;
+    const results = withResults(src, (store) => store.usage().count, 0);
+    return {
+        range,
+        since,
+        totals,
+        byWorker: [...workers]
+            .map(([worker, c]) => ({ worker, ...c }))
+            .sort((a, b) => b.total - a.total || a.worker.localeCompare(b.worker)),
+        trend: {
+            unit,
+            buckets: [...buckets]
+                .sort(([a], [b]) => a.localeCompare(b))
+                .map(([bucket, c]) => ({ bucket, ...c }))
+        },
+        recentFailures: fromDb?.recentFailures ?? [],
+        runner: readRunner(src.dataDir),
+        lastResponse: fromDb?.lastResponse ?? null,
+        stop: fromDb?.stop ?? null,
+        end: fromDb?.end ?? null,
+        host: fromDb?.host ?? { id: null, name: null },
+        disk: {
+            controlDb: fromDb?.usage.controlDb
+                ? {
+                    file: fromDb.usage.controlDb.file,
+                    bytes: fromDb.usage.controlDb.bytes,
+                    tasks: fromDb.usage.controlDb.tasks
+                }
+                : null,
+            dataDb: src.projectRoot && dataBytes !== null
+                ? { file: resultsDbPath(src.projectRoot), bytes: dataBytes, results }
+                : null,
+            logs
+        },
+        hasControlDb: fromDb !== null
+    };
+}
+function bucketKeys(since, now, unit) {
+    const keys = [];
+    const d = new Date(since);
+    const pad = (n) => String(n).padStart(2, '0');
+    while (d.getTime() <= now) {
+        const day = `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+        keys.push(unit === 'day' ? day : `${day} ${pad(d.getHours())}`);
+        if (unit === 'day')
+            d.setDate(d.getDate() + 1);
+        else
+            d.setHours(d.getHours() + 1);
+    }
+    return keys;
+}
+function logUsage(logsDir) {
+    const files = listAllLogFiles(logsDir);
+    return { dir: logsDir, bytes: files.reduce((n, f) => n + f.size, 0), files: files.length };
+}
+export function workersView(src) {
+    const lastSync = readLastSync(src.logsDir);
+    const hostId = withControl(src, (db) => db.getMeta(HOST_META.id), null);
+    const builtin = hostId ? builtinResultsName(hostId) : null;
+    if (!src.workersDir)
+        return { dir: null, dirMissing: true, error: null, files: [], lastSync, builtin };
+    let map;
+    try {
+        map = workerFilesIfAny(src.workersDir);
+    }
+    catch (err) {
+        return {
+            dir: src.workersDir,
+            dirMissing: false,
+            error: err.message,
+            files: [],
+            lastSync,
+            builtin
+        };
+    }
+    if (!map)
+        return { dir: src.workersDir, dirMissing: true, error: null, files: [], lastSync, builtin };
+    const files = [...map].map(([name, list]) => ({
+        name,
+        files: list.map((file) => {
+            const st = statSync(file, { throwIfNoEntry: false });
+            return { file, bytes: st?.size ?? 0, modifiedAt: st?.mtimeMs ?? 0 };
+        })
+    }));
+    return { dir: src.workersDir, dirMissing: false, error: null, files, lastSync, builtin };
+}
+export const SYNC_SCAN_MAX_BYTES = 64 * 1024 * 1024;
+function readLastSync(logsDir) {
+    const record = findLastRecord(channelDir(logsDir, null), (r) => r.body === 'workers synced' || r.body === 'workers resynced', { maxBytes: SYNC_SCAN_MAX_BYTES, contains: 'workers ' });
+    if (!record)
+        return null;
+    const a = record.attributes ?? {};
+    const pairs = (value, key) => new Map((Array.isArray(value) ? value : [])
+        .filter((v) => v !== null && typeof v === 'object')
+        .map((v) => [String(v.name), String(v[key])]));
+    return {
+        at: Date.parse(record.timestamp),
+        event: record.body,
+        results: pairs(a.workers, 'result'),
+        rejected: pairs(a.rejected, 'code'),
+        local: Array.isArray(a.local)
+            ? new Map(a.local
+                .filter((w) => w !== null && typeof w === 'object')
+                .map((w) => [String(w.name), w]))
+            : null
+    };
+}
+function workerFilesIfAny(dir) {
+    if (!dir || !existsSync(dir))
+        return null;
+    return workerFiles(dir);
+}
+export const CODE_MAX_BYTES = 512 * 1024;
+export function workerSource(src, name) {
+    const files = workerFilesIfAny(src.workersDir)?.get(name);
+    if (!files)
+        return null;
+    return files.map((file) => {
+        const buf = readFileHead(file, CODE_MAX_BYTES + 1);
+        const truncated = buf.length > CODE_MAX_BYTES;
+        return {
+            file,
+            text: buf.subarray(0, CODE_MAX_BYTES).toString('utf8'),
+            truncated,
+            bytes: statSync(file, { throwIfNoEntry: false })?.size ?? buf.length
+        };
+    });
+}
+function readFileHead(file, max) {
+    const fd = openSync(file, 'r');
+    try {
+        const buf = Buffer.alloc(max);
+        const n = readSync(fd, buf, 0, max, 0);
+        return buf.subarray(0, n);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+export const LOG_LEVELS = ['debug', 'info', 'warn', 'error'];
+export function logChannels(src) {
+    const names = new Set();
+    const workerLogs = path.join(src.logsDir, WORKER_LOG_DIR);
+    if (existsSync(workerLogs)) {
+        for (const e of readdirSync(workerLogs, { withFileTypes: true })) {
+            if (e.isDirectory())
+                names.add(e.name);
+        }
+    }
+    for (const name of workerFilesIfAny(src.workersDir)?.keys() ?? [])
+        names.add(name);
+    return [...names].sort();
+}
+export const LOG_SCAN_MAX_BYTES = 32 * 1024 * 1024;
+export function readLog(src, channel, opts) {
+    const dir = channelDir(src.logsDir, channel);
+    const min = opts.minLevel ? LOG_LEVELS.indexOf(opts.minLevel) : 0;
+    if (min <= 0) {
+        return { lines: tailLines(dir, opts.lines).map((l) => toLine(l, channel)), truncated: false };
+    }
+    const out = [];
+    let scanned = 0;
+    for (const f of listChannelFiles(dir).reverse()) {
+        if (scanned >= LOG_SCAN_MAX_BYTES)
+            return { lines: out.reverse(), truncated: true };
+        const text = readIfExists(f.file);
+        if (text === null)
+            continue;
+        scanned += f.size;
+        const lines = text.split('\n');
+        for (let i = lines.length - 1; i >= 0 && out.length < opts.lines; i--) {
+            const record = parseRecord(lines[i]);
+            if (record && levelOf(record) >= min)
+                out.push({ record, raw: null, channel });
+        }
+        if (out.length >= opts.lines)
+            break;
+    }
+    return { lines: out.reverse(), truncated: false };
+}
+function levelOf(record) {
+    const level = LOG_LEVELS.indexOf(record.severity_text);
+    return level === -1 ? LOG_LEVELS.length : level;
+}
+function toLine(line, channel) {
+    const record = parseRecord(line);
+    return record ? { record, raw: null, channel } : { record: null, raw: line, channel };
+}
+const TASK_LOG_MARGIN_MS = 10 * 60_000;
+const TASK_LOG_MAX_SPAN_MS = 24 * 60 * 60 * 1000;
+export function taskLog(src, run) {
+    const to = (run.finished_at ?? (run.state === 'running' ? src.now() : run.at)) + TASK_LOG_MARGIN_MS;
+    const from = Math.max(run.at - TASK_LOG_MARGIN_MS, to - TASK_LOG_MAX_SPAN_MS);
+    return scanTaskLines(src, run, from, to, () => true);
+}
+export const RUN_LOG_MARGIN_MS = 5_000;
+export function runLog(src, run, runNo, from, savedAt) {
+    const to = savedAt + RUN_LOG_MARGIN_MS;
+    return scanTaskLines(src, run, from, to, (record) => {
+        const n = record.attributes?.run_no;
+        if (typeof n === 'number')
+            return n === runNo;
+        const at = Date.parse(record.timestamp);
+        return at > from && at <= to;
+    });
+}
+function scanTaskLines(src, run, from, to, keep) {
+    const first = utcDate(from);
+    const last = utcDate(to);
+    const lines = [];
+    let files = 0;
+    for (const channel of [null, run.worker]) {
+        for (const f of listChannelFiles(channelDir(src.logsDir, channel))) {
+            if (f.date < first || f.date > last)
+                continue;
+            const text = readIfExists(f.file);
+            if (text === null)
+                continue;
+            files++;
+            for (const line of text.split('\n')) {
+                if (!line.includes(run.task_id))
+                    continue;
+                const record = parseRecord(line);
+                if (record?.attributes?.task_id === run.task_id && keep(record))
+                    lines.push({ record, raw: null, channel });
+            }
+        }
+    }
+    lines.sort((a, b) => (a.record?.timestamp ?? '').localeCompare(b.record?.timestamp ?? ''));
+    return { lines, deleted: files === 0 };
+}

package/dist/modules/dashboard/guard.js

@@ -0,0 +1,75 @@
+import { createHash, timingSafeEqual } from 'node:crypto';
+import { hostname, networkInterfaces } from 'node:os';
+const LOOPBACK_NAMES = ['127.0.0.1', 'localhost', '[::1]'];
+export function allowedHosts(port, scope = {}) {
+    const names = scope.lan ? [...LOOPBACK_NAMES, ...(scope.lanNames ?? lanNames)()] : LOOPBACK_NAMES;
+    return names.map((name) => `${name.toLowerCase()}:${port}`);
+}
+export function isRemoteViewer(req, port) {
+    if (!allowedHosts(port).includes((req.host ?? '').toLowerCase()))
+        return true;
+    return !isLoopbackAddress(req.remoteAddress);
+}
+function isLoopbackAddress(address) {
+    if (!address)
+        return false;
+    const v4 = address.toLowerCase().replace(/^::ffff:/, '');
+    return v4 === '::1' || /^127\.\d+\.\d+\.\d+$/.test(v4);
+}
+export function lanNames() {
+    const names = new Set();
+    for (const addrs of Object.values(networkInterfaces())) {
+        for (const a of addrs ?? [])
+            if (a.family === 'IPv4' && !a.internal)
+                names.add(a.address);
+    }
+    const host = hostname().toLowerCase();
+    if (host) {
+        names.add(host);
+        names.add(host.endsWith('.local') ? host : `${host}.local`);
+    }
+    return [...names];
+}
+export function checkRequest(req, port, scope = {}) {
+    const host = (req.host ?? '').toLowerCase();
+    if (!allowedHosts(port, scope).includes(host)) {
+        return {
+            status: 403,
+            message: scope.lan
+                ? "Host header must be this PC's address or name"
+                : 'Host header must be 127.0.0.1 or localhost'
+        };
+    }
+    if (req.origin !== undefined && req.origin.toLowerCase() !== `http://${host}`) {
+        return { status: 403, message: 'requests from other web pages are not accepted' };
+    }
+    const site = req.secFetchSite;
+    if (site !== undefined && site !== 'none' && site !== 'same-origin') {
+        return { status: 403, message: 'requests from other web pages are not accepted' };
+    }
+    if (req.method !== 'GET' && req.method !== 'HEAD') {
+        return { status: 405, message: 'the dashboard is read-only — use GET' };
+    }
+    return null;
+}
+export function cookieName(port) {
+    return `tm_dashboard_${port}`;
+}
+export function readCookie(header, name) {
+    if (!header)
+        return undefined;
+    for (const part of header.split(';')) {
+        const i = part.indexOf('=');
+        if (i !== -1 && part.slice(0, i).trim() === name)
+            return part.slice(i + 1).trim();
+    }
+    return undefined;
+}
+export function tokenMatches(given, token) {
+    if (!given)
+        return false;
+    return timingSafeEqual(sha256(given), sha256(token));
+}
+function sha256(value) {
+    return createHash('sha256').update(value).digest();
+}