@omochi-ui/cli 0.1.1 → 0.2.0

package/dist/hub/dashboards.js

@@ -1,230 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { readFile, writeFile, rename, unlink } from 'node:fs/promises';
-import path from 'node:path';
-import { isValidNodeId, isValidServiceId } from '@omochi-ui/core';
-import { ensureConfigRoot, omochiConfigRoot, withStateLock } from '@omochi-ui/discovery';
-import { overlaps, referenceId } from '@omochi-ui/hub-ui/contracts';
-class HttpError extends Error {
-    status;
-    constructor(status, message) {
-        super(message);
-        this.status = status;
-    }
-}
-const record = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
-const text = (value, max = 200) => typeof value === 'string' && value.trim().length > 0 && value.length <= max;
-const integer = (value, min, max) => Number.isSafeInteger(value) && Number(value) >= min && Number(value) <= max;
-export function validateDashboard(value) {
-    if (!record(value) || !text(value.name) || !Array.isArray(value.panels) || value.panels.length > 200) {
-        throw new HttpError(400, 'A dashboard needs a name and at most 200 panels');
-    }
-    const panels = [];
-    const ids = new Set();
-    const references = new Set();
-    for (const p of value.panels) {
-        if (!record(p) || !text(p.id, 100) || !text(p.title) || !record(p.reference)
-            || typeof p.reference.nodeId !== 'string' || !isValidNodeId(p.reference.nodeId)
-            || typeof p.reference.serviceId !== 'string' || !isValidServiceId(p.reference.serviceId)
-            || !text(p.reference.surfaceId, 4096)
-            || !integer(p.x, 0, 11) || !integer(p.y, 0, 100000) || !integer(p.w, 1, 12) || !integer(p.h, 1, 1000)
-            || p.x + p.w > 12)
-            throw new HttpError(400, 'Invalid panel reference or grid position');
-        const panel = {
-            id: p.id, title: p.title, reference: { nodeId: p.reference.nodeId, serviceId: p.reference.serviceId, surfaceId: p.reference.surfaceId },
-            x: p.x, y: p.y, w: p.w, h: p.h,
-        };
-        const ref = referenceId(panel.reference);
-        if (ids.has(panel.id) || references.has(ref))
-            throw new HttpError(400, 'Duplicate panel or surface');
-        if (panels.some(other => overlaps(panel, other)))
-            throw new HttpError(400, 'Panels must not overlap');
-        ids.add(panel.id);
-        references.add(ref);
-        panels.push(panel);
-    }
-    return { name: value.name.trim(), panels };
-}
-/** Re-read under the mutation queue and cross-process lock; failed writes never replace the last good file. */
-export class DashboardStore {
-    root;
-    queue = Promise.resolve();
-    file;
-    constructor(root = omochiConfigRoot()) {
-        this.root = root;
-        this.file = path.join(root, 'dashboards.json');
-    }
-    async read() {
-        let raw;
-        try {
-            raw = await readFile(this.file, 'utf8');
-        }
-        catch (error) {
-            if (error.code === 'ENOENT')
-                return { version: 1, dashboards: [] };
-            throw new HttpError(503, 'Could not read dashboard storage');
-        }
-        try {
-            const data = JSON.parse(raw);
-            if (!record(data) || data.version !== 1 || !Array.isArray(data.dashboards))
-                throw new Error();
-            const ids = new Set();
-            const dashboards = data.dashboards.map((item) => {
-                if (!record(item) || !text(item.id, 100) || !integer(item.revision, 1, Number.MAX_SAFE_INTEGER) || ids.has(item.id))
-                    throw new Error();
-                ids.add(item.id);
-                return { ...validateDashboard(item), id: item.id, revision: item.revision };
-            });
-            return { version: 1, dashboards };
-        }
-        catch {
-            throw new HttpError(503, 'Dashboard storage is invalid; repair dashboards.json before saving');
-        }
-    }
-    async list() { await this.queue; return (await this.read()).dashboards; }
-    mutate(id, input, remove = false) {
-        const next = this.queue.then(async () => {
-            try {
-                await ensureConfigRoot(this.root);
-                return await withStateLock(this.file, async () => {
-                    const file = await this.read();
-                    const current = id === null ? undefined : file.dashboards.find(d => d.id === id);
-                    if (id !== null && !current)
-                        throw new HttpError(404, 'Dashboard not found');
-                    if (current && (!record(input) || input.revision !== current.revision))
-                        throw new HttpError(409, 'This dashboard changed elsewhere. Reload before saving.');
-                    const dashboard = remove ? null : {
-                        ...validateDashboard(input), id: current?.id ?? randomUUID(), revision: (current?.revision ?? 0) + 1,
-                    };
-                    file.dashboards = file.dashboards.filter(d => d.id !== id);
-                    if (dashboard)
-                        file.dashboards.push(dashboard);
-                    const temporary = path.join(this.root, `.dashboards-${randomUUID()}.tmp`);
-                    try {
-                        await writeFile(temporary, JSON.stringify(file, null, 2) + '\n', { mode: 0o600, flag: 'wx' });
-                        await rename(temporary, this.file);
-                    }
-                    finally {
-                        await unlink(temporary).catch(() => { });
-                    }
-                    return dashboard;
-                });
-            }
-            catch (error) {
-                if (error instanceof HttpError)
-                    throw error;
-                throw new HttpError(503, 'Could not save dashboard storage');
-            }
-        });
-        this.queue = next.catch(() => { });
-        return next;
-    }
-}
-async function body(request) {
-    if (request.headers['content-type']?.split(';')[0]?.trim() !== 'application/json')
-        throw new HttpError(415, 'Use application/json');
-    const chunks = [];
-    let size = 0;
-    for await (const chunk of request) {
-        size += Buffer.byteLength(chunk);
-        if (size > 1024 * 1024)
-            throw new HttpError(413, 'Dashboard request is too large');
-        chunks.push(Buffer.from(chunk));
-    }
-    try {
-        return JSON.parse(Buffer.concat(chunks).toString('utf8'));
-    }
-    catch {
-        throw new HttpError(400, 'Invalid JSON');
-    }
-}
-export function dashboardEndpoints(store, allowed) {
-    return (request, response) => {
-        const pathname = new URL(request.url ?? '/', 'http://localhost').pathname;
-        if (pathname !== '/api/dashboards' && !pathname.startsWith('/api/dashboards/'))
-            return false;
-        const send = (status, value) => {
-            response.writeHead(status, { 'Content-Type': 'application/json; charset=utf-8', 'Cache-Control': 'no-store' });
-            response.end(JSON.stringify(value));
-        };
-        if (!allowed(request.headers.origin)) {
-            send(403, { error: 'Forbidden origin' });
-            return true;
-        }
-        response.setHeader('Vary', 'Origin');
-        if (request.headers.origin)
-            response.setHeader('Access-Control-Allow-Origin', request.headers.origin);
-        if (request.method === 'OPTIONS') {
-            response.writeHead(204, { 'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS', 'Access-Control-Allow-Headers': 'Content-Type' });
-            response.end();
-            return true;
-        }
-        void (async () => {
-            const id = pathname === '/api/dashboards' ? null : decodeURIComponent(pathname.slice('/api/dashboards/'.length));
-            if (id !== null && (!id || id.includes('/')))
-                throw new HttpError(404, 'Dashboard not found');
-            if (request.method === 'GET') {
-                const dashboards = await store.list();
-                if (id === null)
-                    send(200, dashboards);
-                else {
-                    const dashboard = dashboards.find(d => d.id === id);
-                    if (!dashboard)
-                        throw new HttpError(404, 'Dashboard not found');
-                    send(200, dashboard);
-                }
-            }
-            else if (request.method === 'POST' && id === null)
-                send(201, await store.mutate(null, await body(request)));
-            else if (request.method === 'PUT' && id !== null)
-                send(200, await store.mutate(id, await body(request)));
-            else if (request.method === 'DELETE' && id !== null) {
-                await store.mutate(id, await body(request), true);
-                send(200, { deleted: true });
-            }
-            else
-                throw new HttpError(405, 'Method not allowed');
-        })().catch(error => send(error instanceof HttpError ? error.status : error instanceof URIError ? 400 : 503, { error: error instanceof HttpError ? error.message : 'Could not save dashboard' }));
-        return true;
-    };
-}
-export function validatePresets(values) {
-    const ids = new Set();
-    return values.map((value) => {
-        if (!text(value.id, 100) || ids.has(value.id))
-            throw new Error(`Invalid or duplicate dashboard preset id: ${JSON.stringify(value.id)}`);
-        ids.add(value.id);
-        return { id: value.id, ...validateDashboard(value) };
-    });
-}
-/** Read-only presets live only for the lifetime of this hub process. */
-export function presetEndpoints(presets, allowed) {
-    const validated = validatePresets(presets);
-    return (request, response) => {
-        const pathname = new URL(request.url ?? '/', 'http://localhost').pathname;
-        if (pathname !== '/api/presets')
-            return false;
-        const send = (status, value) => {
-            const headers = { 'Cache-Control': 'no-store' };
-            if (value !== undefined)
-                headers['Content-Type'] = 'application/json; charset=utf-8';
-            response.writeHead(status, headers);
-            response.end(value === undefined ? undefined : JSON.stringify(value));
-        };
-        if (!allowed(request.headers.origin)) {
-            send(403, { error: 'Forbidden origin' });
-            return true;
-        }
-        response.setHeader('Vary', 'Origin');
-        if (request.headers.origin)
-            response.setHeader('Access-Control-Allow-Origin', request.headers.origin);
-        if (request.method === 'OPTIONS') {
-            response.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS');
-            send(204);
-        }
-        else if (request.method === 'GET')
-            send(200, validated);
-        else
-            send(405, { error: 'Method not allowed' });
-        return true;
-    };
-}

package/dist/hub/gateway-supervisor.d.ts

@@ -1,19 +0,0 @@
-export interface GatewaySupervisor {
-    /** True when this hub started the gateway and is therefore responsible for it. */
-    readonly spawned: boolean;
-    close(): Promise<void>;
-}
-export interface SuperviseOptions {
-    /** Overridden in tests; defaults to this CLI's own `gateway` command. */
-    command?: string[];
-    startTimeoutMs?: number;
-}
-/**
- * Makes sure a gateway is listening on this machine.
- *
- * A gateway already there is reused and left running, because it is not ours to stop and
- * other hubs may be attached to it. Only a socket that refuses a connection is removed,
- * and only then is a gateway started — a live socket is never unlinked, so two hubs
- * racing to start end up sharing the winner's gateway instead of destroying it.
- */
-export declare function superviseLocalGateway(socketPath: string, options?: SuperviseOptions): Promise<GatewaySupervisor>;

package/dist/hub/gateway-supervisor.js

@@ -1,75 +0,0 @@
-import { spawn } from 'node:child_process';
-import { once } from 'node:events';
-import { rm } from 'node:fs/promises';
-import process from 'node:process';
-import { fileURLToPath } from 'node:url';
-import { probeGateway } from '@omochi-ui/discovery';
-const START_TIMEOUT_MS = 10000;
-const POLL_MS = 50;
-/**
- * How long to let a child report that it lost the race.
- *
- * The winner starts listening before the loser's bind fails, so a probe can succeed
- * while our own child is still on its way out. Waiting for that exit is what makes
- * `spawned` mean "this hub owns the gateway" rather than "this hub tried".
- */
-const EXIT_GRACE_MS = 250;
-const idle = { spawned: false, close: async () => { } };
-function gatewayCommand() {
-    // `dist/hub/gateway-supervisor.js` sits one directory below `dist/cli.js`.
-    return [process.execPath, fileURLToPath(new URL('../cli.js', import.meta.url)), 'gateway'];
-}
-async function waitForGateway(socketPath, deadline, child) {
-    while (Date.now() < deadline) {
-        if (await probeGateway({ kind: 'unix', socketPath }))
-            return true;
-        // A child that exited lost the race for the socket, or failed outright; either way
-        // the next probe decides, because the winner is already listening.
-        if (child && child.exitCode !== null)
-            return (await probeGateway({ kind: 'unix', socketPath })) !== null;
-        await new Promise((resolveDelay) => setTimeout(resolveDelay, POLL_MS));
-    }
-    return false;
-}
-/**
- * Makes sure a gateway is listening on this machine.
- *
- * A gateway already there is reused and left running, because it is not ours to stop and
- * other hubs may be attached to it. Only a socket that refuses a connection is removed,
- * and only then is a gateway started — a live socket is never unlinked, so two hubs
- * racing to start end up sharing the winner's gateway instead of destroying it.
- */
-export async function superviseLocalGateway(socketPath, options = {}) {
-    if (await probeGateway({ kind: 'unix', socketPath }))
-        return idle;
-    // Nothing answered, so any socket file here is left over from a gateway that died.
-    await rm(socketPath, { force: true });
-    const command = options.command ?? gatewayCommand();
-    const child = spawn(command[0], command.slice(1), { stdio: ['ignore', 'ignore', 'inherit'] });
-    child.unref();
-    const deadline = Date.now() + (options.startTimeoutMs ?? START_TIMEOUT_MS);
-    if (!(await waitForGateway(socketPath, deadline, child))) {
-        if (child.exitCode === null)
-            child.kill('SIGTERM');
-        throw new Error(`the gateway did not start on ${socketPath}`);
-    }
-    if (child.exitCode === null) {
-        await Promise.race([
-            once(child, 'exit'),
-            new Promise((resolveGrace) => setTimeout(resolveGrace, EXIT_GRACE_MS)),
-        ]);
-    }
-    // Losing the race is normal: another hub bound the socket first and owns that process.
-    if (child.exitCode !== null)
-        return idle;
-    return {
-        // Reported live, so a gateway that dies later is never mistaken for ours to stop.
-        get spawned() {
-            return child.exitCode === null;
-        },
-        async close() {
-            if (child.exitCode === null)
-                child.kill('SIGTERM');
-        },
-    };
-}

package/dist/hub/hub.d.ts

@@ -1,41 +0,0 @@
-import { type GatewayLocator, type NodeIdentity, type TrustStore } from '@omochi-ui/discovery';
-import type { DashboardPreset } from '@omochi-ui/hub-ui/contracts';
-export interface HubOptions {
-    host?: string;
-    port?: number;
-    allowOrigins?: string[];
-    /** Where to look for gateways. Defaults to the gateway on this machine. */
-    gateways?: GatewayLocator[];
-    /** The local gateway's socket; defaults to `<runtime root>/gateway.sock`. */
-    gatewaySocket?: string;
-    /** Start a local gateway when none is listening. Defaults to true. */
-    autoGateway?: boolean;
-    /** Where the persisted identity and pinned peers live; defaults to the config root. */
-    configRoot?: string;
-    /** Overrides this hub's identity and trust store; mainly useful in tests. */
-    identity?: NodeIdentity;
-    trust?: TrustStore;
-    /** Also look for gateways on the local link. Off by default. */
-    discoverLan?: boolean;
-    /** Read-only dashboard compositions exposed for this hub process only. */
-    presets?: DashboardPreset[];
-}
-export interface HubHandle {
-    readonly url: string;
-    readonly httpUrl: string;
-    /** How many gateways are currently connected. */
-    readonly nodeCount: number;
-    close(): Promise<void>;
-}
-/**
- * Aggregates every reachable gateway into one A2UI stream.
- *
- * The hub knows nothing about manifests, runtime directories, or application sockets:
- * a gateway owns all of that, and the hub only ever speaks the gateway contract. That is
- * what lets a gateway on another machine join on exactly the same terms as the local one.
- *
- * Surfaces arrive namespaced by service id and are re-namespaced as
- * `<nodeId>~<serviceId>/<surfaceId>`, so two machines running the same service stay
- * distinct all the way out to the renderer.
- */
-export declare function startHub(options?: HubOptions): Promise<HubHandle>;