@phreshos/node 0.1.13 → 0.1.15

package/dist/representation.js

@@ -0,0 +1,340 @@
+import { randomUUID } from "node:crypto";
+const maximumStreamQueue = 256;
+/** A connection-owned, live representation of the authoritative System model. */
+export default class SystemRepresentation {
+    connection;
+    authorization;
+    programs = new Map();
+    processes = new Map();
+    appearance;
+    listeners = new Map();
+    release = [];
+    constructor(connection) {
+        this.connection = connection;
+        const session = ownerSession(connection.session);
+        this.authorization = session.authorization;
+        this.appearance = session.linkManager.appearance.value;
+        for (const [, value] of session.authManager.programManager.programs) {
+            const program = programState(value);
+            this.programs.set(program.identity, program);
+        }
+        for (const [, value] of session.authManager.processManager.processes) {
+            const process = processState(value);
+            this.processes.set(process.identity, process);
+        }
+        this.followModel(session.linkManager.appearance.key);
+    }
+    activate() { this.connection.activate(); }
+    close() {
+        for (const stop of this.release.splice(0))
+            stop();
+        this.listeners.clear();
+    }
+    call(event, ...values) {
+        return this.connection.call(`/auth${event}`, this.authorization, ...values);
+    }
+    on(event, listener) {
+        const listeners = this.listeners.get(event) ?? new Set();
+        listeners.add(listener);
+        this.listeners.set(event, listeners);
+        return () => {
+            listeners.delete(listener);
+            if (!listeners.size)
+                this.listeners.delete(event);
+        };
+    }
+    follow(observation, listener, impossible) {
+        const subscription = randomUUID();
+        let active = true;
+        const stopEvent = this.connection.subscribe("/auth/process/followed", (received, event, value) => {
+            if (active && received === subscription && typeof event === "string")
+                listener(event, value);
+        });
+        const stopImpossible = this.connection.subscribe("/auth/process/impossible", (received, reason) => {
+            if (!active || received !== subscription)
+                return;
+            stop();
+            impossible?.(new Error(String(reason)));
+        });
+        const stop = () => {
+            if (!active)
+                return;
+            active = false;
+            stopEvent();
+            stopImpossible();
+            void this.call("/process/unfollow", subscription).catch(() => undefined);
+        };
+        void this.call("/process/follow", subscription, observation).catch(error => {
+            if (!active)
+                return;
+            stop();
+            impossible?.(exception(error));
+        });
+        return stop;
+    }
+    /** Stream one Program command through the live LinkManager connection. */
+    command(operation, subject, value, signal) {
+        const stream = randomUUID();
+        const queue = [];
+        let wake = null;
+        let ended = false;
+        let failure = null;
+        const stopOutput = this.connection.subscribe("/auth/program/command-output", (received, output) => {
+            if (received !== stream || ended)
+                return;
+            if (!record(output))
+                failure = new Error("The System returned an invalid Program command event");
+            else if (queue.length >= maximumStreamQueue)
+                failure = new Error(`System stream queue exceeded its capacity of ${maximumStreamQueue}`);
+            else
+                queue.push(output);
+            wake?.();
+            wake = null;
+        });
+        const cancel = () => { void this.call("/program/command-cancel", stream).catch(() => undefined); };
+        const abort = () => {
+            failure = abortReason(signal);
+            cancel();
+            wake?.();
+            wake = null;
+        };
+        if (signal?.aborted) {
+            failure = abortReason(signal);
+            ended = true;
+        }
+        else
+            signal?.addEventListener("abort", abort, { once: true });
+        const running = ended
+            ? Promise.resolve()
+            : this.call("/program/command", stream, operation, subject, value, "").then(() => { ended = true; wake?.(); wake = null; }, error => { failure = signal?.aborted ? abortReason(signal) : exception(error); ended = true; wake?.(); wake = null; });
+        return (async function* () {
+            try {
+                while (true) {
+                    if (queue.length) {
+                        yield queue.shift();
+                        continue;
+                    }
+                    if (failure)
+                        throw failure;
+                    if (ended)
+                        return;
+                    await new Promise(resolve => { wake = resolve; });
+                }
+            }
+            finally {
+                stopOutput();
+                signal?.removeEventListener("abort", abort);
+                if (!ended)
+                    cancel();
+                await running.catch(() => undefined);
+            }
+        })();
+    }
+    followModel(appearance) {
+        const subscribe = (event, listener) => this.release.push(this.connection.subscribe(event, listener));
+        subscribe(`property-update:${appearance}`, value => {
+            this.appearance = value;
+            this.emit("appearance", this.appearance);
+        });
+        subscribe("/auth/program/create", value => this.arriveProgram("create", value));
+        subscribe("/auth/program/install", value => this.arriveProgram("install", value));
+        subscribe("/auth/program/uninstall", (value, everything) => this.uninstallProgram(value, everything === true));
+        subscribe("/auth/program/forget", value => this.forgetProgram(value));
+        subscribe("/auth/process/created", value => this.createProcess(value));
+        subscribe("/auth/process/server-ready", identity => this.serverReady(identity));
+        subscribe("/auth/process/server-start", (identity, value) => this.changeEndpoint(identity, "server", value));
+        subscribe("/auth/process/server-stop", (identity, value) => this.changeEndpoint(identity, "server", value, false));
+        subscribe("/auth/process/client-start", (identity, value) => this.changeEndpoint(identity, "client", value));
+        subscribe("/auth/process/client-stop", (identity, value) => this.changeEndpoint(identity, "client", value, false));
+        subscribe("/auth/process/client-access", (identity, value) => this.changeEndpoint(identity, "client", value));
+        subscribe("/auth/process/exited", (value, code, signal) => this.exitProcess(value, code, signal));
+        for (const event of ["move", "resize", "geometry", "change-title", "raise", "minimize"]) {
+            subscribe(`/auth/process/${event}`, value => this.changeWindow(event, value));
+        }
+    }
+    arriveProgram(event, value) {
+        const program = programState(value);
+        this.programs.set(program.identity, program);
+        this.emit(`program:${program.reference}:change`, program);
+        this.emit(`program:${event}`, program);
+    }
+    uninstallProgram(value, everything) {
+        const program = programState(value);
+        this.programs.set(program.identity, program);
+        this.emit(`program:${program.reference}:change`, program);
+        this.emit(`program:${program.reference}:uninstall`, everything);
+        this.emit("program:uninstall", program, everything);
+    }
+    forgetProgram(value) {
+        if (typeof value !== "string")
+            return;
+        const program = this.programs.get(value);
+        if (!program)
+            return;
+        this.programs.delete(value);
+        this.emit(`program:${program.reference}:forget`);
+        this.emit("program:forget", program);
+    }
+    createProcess(value) {
+        const process = processState(value);
+        this.processes.set(process.identity, process);
+        this.emit("process:create", process);
+        this.emit(`program:${process.program}:process:create`, process);
+    }
+    serverReady(value) {
+        if (typeof value !== "string")
+            return;
+        const process = this.processes.get(value);
+        if (!process?.server)
+            return;
+        process.server.ready = true;
+        this.emit(`endpoint:${process.reference}:server:ready`);
+    }
+    changeEndpoint(identity, endpoint, value, running = true) {
+        if (typeof identity !== "string")
+            return;
+        const current = this.processes.get(identity);
+        if (!current)
+            return;
+        const incoming = processState(value);
+        current.server = incoming.server;
+        current.client = incoming.client;
+        this.emit(`endpoint:${current.reference}:${endpoint}:${running ? "start" : "stop"}`);
+        this.emit(`process:${current.reference}:change`, current);
+    }
+    exitProcess(value, code, signal) {
+        const received = processState(value);
+        const process = this.processes.get(received.identity) ?? received;
+        this.processes.delete(process.identity);
+        const exit = {
+            status: typeof signal === "string" ? "signaled" : "exited",
+            code: typeof code === "number" ? code : null,
+            signal: typeof signal === "string" ? signal : null
+        };
+        this.emit(`process:${process.reference}:exit`, exit);
+        this.emit("process:exit", process, exit);
+        this.emit(`program:${process.program}:process:exit`, process, exit);
+    }
+    changeWindow(event, value) {
+        if (!record(value) || typeof value.identity !== "string" || !record(value.window))
+            return;
+        const process = this.processes.get(value.identity);
+        if (!process?.client)
+            return;
+        process.client.window = windowState(value.window);
+        this.emit(`window:${process.identity}:${camel(event)}`, windowMessage(event, process));
+        this.emit(`process:${process.reference}:change`, process);
+    }
+    emit(event, ...values) {
+        for (const listener of this.listeners.get(event) ?? [])
+            listener(...values);
+    }
+}
+function ownerSession(value) {
+    if (!record(value) || typeof value.authorization !== "string")
+        throw new Error("The System Gateway returned an invalid owner session");
+    const linkManager = value.linkManager;
+    const authManager = value.authManager;
+    if (!record(linkManager) || !record(linkManager.appearance) || typeof linkManager.appearance.key !== "string")
+        throw new Error("The System Gateway returned invalid Appearance state");
+    if (!record(authManager) || !record(authManager.programManager) || !record(authManager.processManager))
+        throw new Error("The System Gateway returned an invalid System state");
+    const programs = authManager.programManager.programs;
+    const processes = authManager.processManager.processes;
+    if (!Array.isArray(programs) || !Array.isArray(processes))
+        throw new Error("The System Gateway returned invalid domain collections");
+    return {
+        authorization: value.authorization,
+        linkManager: { appearance: { key: linkManager.appearance.key, value: linkManager.appearance.value } },
+        authManager: {
+            programManager: { programs: programs },
+            processManager: { processes: processes }
+        }
+    };
+}
+function programState(value) {
+    if (!record(value) || typeof value.reference !== "string" || typeof value.identity !== "string" || typeof value.assetId !== "string" || typeof value.name !== "string") {
+        throw new Error("The System returned an invalid Program");
+    }
+    return {
+        reference: value.reference,
+        identity: value.identity,
+        assetId: value.assetId,
+        installed: value.installed === true,
+        name: value.name,
+        version: typeof value.version === "string" ? value.version : null,
+        description: typeof value.description === "string" ? value.description : null,
+        hasAgent: value.hasAgent === true,
+        server: value.server,
+        client: value.client
+    };
+}
+function processState(value) {
+    const identity = processIdentityState(value);
+    const source = value;
+    return {
+        ...identity,
+        server: record(source.server) ? { ready: source.server.ready === true, service: source.server.service === true } : null,
+        client: record(source.client) ? {
+            service: source.client.service === true,
+            sameOrigin: source.client.sameOrigin === true,
+            window: windowState(source.client.window)
+        } : null
+    };
+}
+/** Read the immutable facts needed to retain one Process handle. */
+export function processIdentityState(value) {
+    if (!record(value) || typeof value.reference !== "string" || typeof value.identity !== "string" || !record(value.options)) {
+        throw new Error("The System returned an invalid Process");
+    }
+    const program = typeof value.program === "string"
+        ? value.program
+        : record(value.program) && typeof value.program.identity === "string"
+            ? value.program.identity
+            : null;
+    const startedAt = value.startedAt instanceof Date ? value.startedAt : new Date(String(value.startedAt));
+    if (program === null)
+        throw new Error("The System returned an invalid Process owner");
+    if (Number.isNaN(startedAt.getTime()))
+        throw new Error("The System returned an invalid Process start time");
+    return {
+        reference: value.reference,
+        identity: value.identity,
+        name: typeof value.name === "string" ? value.name : null,
+        program,
+        options: value.options,
+        startedAt
+    };
+}
+function windowState(value) {
+    if (!record(value) || typeof value.title !== "string" || typeof value.location !== "string" || typeof value.depth !== "number" || typeof value.minimized !== "boolean") {
+        throw new Error("The System returned an invalid Window");
+    }
+    return {
+        title: value.title,
+        position: value.position,
+        size: value.size,
+        depth: value.depth,
+        minimized: value.minimized,
+        layer: value.layer,
+        location: value.location
+    };
+}
+function windowMessage(event, process) {
+    const window = process.client.window;
+    if (event === "move")
+        return window.position;
+    if (event === "resize")
+        return window.size;
+    if (event === "geometry")
+        return { position: window.position, size: window.size };
+    if (event === "change-title")
+        return window.title;
+    if (event === "minimize")
+        return window.minimized;
+    return true;
+}
+function camel(value) { return value === "change-title" ? "changeTitle" : value; }
+function record(value) { return value !== null && typeof value === "object" && !Array.isArray(value); }
+function exception(error) { return error instanceof Error ? error : new Error(String(error)); }
+function abortReason(signal) { return signal.reason instanceof Error ? signal.reason : new Error("The operation was cancelled"); }

package/dist/system.d.ts

@@ -14,6 +14,7 @@ export declare class System implements CoreSystem {
     readonly process: SystemProcess;
     readonly uploads: SystemUploads;
     fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+    websocket(url: string | URL, protocols?: string | string[]): Promise<WebSocket>;
     shell(command: string, options?: ShellOptions): AsyncGenerator<import("@phreshos/core").ShellEvent, void, void>;
     private constructor();
     /** Connect to the System selected by argument, environment, or owner default. */