@omochi-ui/utils 0.1.1 → 0.2.0

package/dist/http.js

@@ -1,156 +0,0 @@
-import { Action } from "@omochi-ui/sdk";
-import { OutputBuffer, fenced, formatDuration } from "./output.js";
-import { readText } from "./http-body.js";
-import { UtilitySurface } from "./surface.js";
-const BODY_LIMIT = 64 * 1024;
-export class HttpWatch extends UtilitySurface {
-    options;
-    fetcher;
-    body = new OutputBuffer();
-    interval;
-    controller;
-    running = false;
-    paused = false;
-    status = "Starting…";
-    metadata = "";
-    consecutiveFailures = 0;
-    lastHealthy;
-    transition = "No previous result";
-    constructor(publisher, options) {
-        super(publisher, options.name);
-        this.options = options;
-        this.fetcher = options.fetch ?? fetch;
-    }
-    async start() {
-        await super.start();
-        void this.run();
-    }
-    build(ui) {
-        ui.text(this.name, { key: "title", variant: "h3" });
-        ui.row({ key: "controls" }, () => {
-            if (this.paused)
-                ui.button("Resume", new Action("resume").call(null), { key: "resume", variant: "primary" });
-            else
-                ui.button("Pause", new Action("pause").call(null), { key: "pause" });
-            if (!this.running)
-                ui.button("Run now", new Action("run").call(null), { key: "run" });
-        });
-        ui.text(`${this.status}${this.paused ? " · Paused" : ""}`, { key: "status" });
-        if (this.metadata)
-            ui.text(this.metadata, { key: "metadata" });
-        if (this.body.text)
-            ui.text(fenced(this.body.text, this.body.truncated), { key: "body" });
-    }
-    onAction(name) {
-        if (name === "pause" && !this.paused) {
-            this.paused = true;
-            clearTimeout(this.interval);
-            this.scheduleRender();
-        }
-        else if (name === "resume" && this.paused) {
-            this.paused = false;
-            this.scheduleRender();
-            if (!this.running)
-                void this.run();
-        }
-        else if (name === "run" && !this.running) {
-            clearTimeout(this.interval);
-            void this.run();
-        }
-    }
-    close() {
-        this.closeSurface();
-        clearTimeout(this.interval);
-        this.controller?.abort();
-        return Promise.resolve();
-    }
-    async run() {
-        if (this.running || this.closing)
-            return;
-        this.running = true;
-        this.status = "Requesting…";
-        this.scheduleRender();
-        const startedAt = performance.now();
-        const controller = new AbortController();
-        this.controller = controller;
-        const timeout = setTimeout(() => controller.abort(new Error("request timed out")), this.options.timeoutMs);
-        let healthy = false;
-        try {
-            const response = await this.fetcher(this.options.url, { signal: controller.signal, redirect: "follow" });
-            const durationMs = performance.now() - startedAt;
-            const contentType = response.headers.get("content-type") ?? "unknown";
-            const contentLength = response.headers.get("content-length");
-            const textual = isText(contentType);
-            let rawBody = "";
-            let bodyTruncated = false;
-            let expectedBodyMatched = this.options.expectBody === undefined;
-            if (textual) {
-                const read = await readText(response, BODY_LIMIT, this.options.expectBody);
-                rawBody = read.text;
-                bodyTruncated = read.truncated;
-                expectedBodyMatched = read.expectedMatched;
-                let display = rawBody;
-                if (isJson(contentType) && !bodyTruncated) {
-                    try {
-                        display = JSON.stringify(JSON.parse(rawBody), null, 2);
-                    }
-                    catch {
-                        display = `Invalid JSON response\n\n${rawBody}`;
-                    }
-                }
-                this.body.reset(display);
-                if (bodyTruncated)
-                    this.body.append("\n\n[Response body truncated]");
-            }
-            else {
-                await response.body?.cancel();
-                this.body.reset();
-            }
-            const statusMatches = response.status >= this.options.expectStatus[0] && response.status <= this.options.expectStatus[1];
-            const bodyMatches = textual && expectedBodyMatched || this.options.expectBody === undefined;
-            healthy = statusMatches && bodyMatches;
-            this.status = `${healthy ? "Healthy" : "Unhealthy"} · HTTP ${response.status} · ${formatDuration(durationMs)} · ${new Date().toISOString()}`;
-            this.metadata = [
-                `URL: ${response.url}`,
-                `Content-Type: ${contentType}`,
-                `Size: ${contentLength ? `${contentLength} bytes` : textual && !bodyTruncated ? `${Buffer.byteLength(rawBody)} bytes` : "unknown"}`,
-                `Expectation: status ${this.options.expectStatus[0]}${this.options.expectStatus[0] === this.options.expectStatus[1] ? "" : `–${this.options.expectStatus[1]}`}${this.options.expectBody === undefined ? "" : ` and body contains ${JSON.stringify(this.options.expectBody)}`}`,
-            ].join("  \n");
-        }
-        catch (error) {
-            const durationMs = performance.now() - startedAt;
-            const message = controller.signal.aborted && controller.signal.reason instanceof Error
-                ? controller.signal.reason.message
-                : error instanceof Error ? error.message : String(error);
-            this.status = `Unhealthy · ${message} · ${formatDuration(durationMs)} · ${new Date().toISOString()}`;
-            this.metadata = `URL: ${this.options.url}`;
-            this.body.reset();
-        }
-        finally {
-            clearTimeout(timeout);
-            this.controller = undefined;
-            this.running = false;
-        }
-        if (healthy)
-            this.consecutiveFailures = 0;
-        else
-            this.consecutiveFailures++;
-        if (this.lastHealthy === undefined)
-            this.transition = healthy ? "Initial result: healthy" : "Initial result: unhealthy";
-        else if (this.lastHealthy !== healthy)
-            this.transition = healthy ? "Recovered" : "Became unhealthy";
-        this.lastHealthy = healthy;
-        this.metadata += `  \nConsecutive failures: ${this.consecutiveFailures}  \nState: ${this.transition}`;
-        this.scheduleRender();
-        if (!this.paused && !this.closing)
-            this.interval = setTimeout(() => void this.run(), this.options.intervalMs);
-    }
-}
-function isJson(contentType) {
-    const mediaType = contentType.split(";", 1)[0].trim().toLowerCase();
-    return mediaType === "application/json" || mediaType.endsWith("+json");
-}
-function isText(contentType) {
-    const mediaType = contentType.split(";", 1)[0].trim().toLowerCase();
-    return mediaType.startsWith("text/") || isJson(contentType) || ["application/javascript", "application/xml", "application/x-www-form-urlencoded"].includes(mediaType) || mediaType.endsWith("+xml");
-}

package/dist/mcp.d.ts

@@ -1,3 +0,0 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { Publisher } from "./publisher.js";
-export declare function startMcp(publisher: Publisher, onClose: () => void): Promise<McpServer>;

package/dist/mcp.js

@@ -1,59 +0,0 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { BASIC_CATALOG } from "@omochi-ui/sdk";
-import { z } from "zod";
-const examples = {
-    publish: [
-        { version: "v0.9", createSurface: { surfaceId: "main", catalogId: BASIC_CATALOG.id, sendDataModel: true } },
-        { version: "v0.9", updateComponents: { surfaceId: "main", components: [
-                    { id: "root", component: "Column", children: ["title", "input", "submit"] },
-                    { id: "title", component: "Text", text: "What should we build?" },
-                    { id: "input", component: "TextField", label: "Request", value: { path: "/request" } },
-                    { id: "submit", component: "Button", child: "submit-label", action: { event: { name: "submit", context: { request: { path: "/request" } } } } },
-                    { id: "submit-label", component: "Text", text: "Send" },
-                ] } },
-        { version: "v0.9", updateDataModel: { surfaceId: "main", path: "/", value: { request: "" } } },
-    ],
-    update: [{ version: "v0.9", updateComponents: { surfaceId: "main", components: [{ id: "title", component: "Text", text: "Working…" }] } }],
-    delete: [{ version: "v0.9", deleteSurface: { surfaceId: "main" } }],
-};
-function result(value) {
-    return { content: [{ type: "text", text: JSON.stringify(value) }], structuredContent: { ...value } };
-}
-async function tool(work) {
-    try {
-        return result(await work());
-    }
-    catch (error) {
-        return { isError: true, content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }] };
-    }
-}
-export async function startMcp(publisher, onClose) {
-    const server = new McpServer({ name: "omochi-utils", version: "0.1.0" }, {
-        instructions: `Publish A2UI v0.9 surfaces to the local Omochi gateway. Basic Catalog: ${BASIC_CATALOG.id}. ` +
-            "Use surface-local IDs (no gateway prefixes). Surfaces live only while this process runs. " +
-            "Call read_events to receive button/form actions, then publish_messages to respond; events do not execute code. " +
-            `Examples for publish_messages({messages: ...}): ${JSON.stringify(examples)}`,
-    });
-    server.registerTool("publish_messages", {
-        description: `Publish an ordered, prevalidated batch of A2UI v0.9 createSurface/updateComponents/updateDataModel/deleteSurface messages. Basic Catalog: ${BASIC_CATALOG.id}. Example: ${JSON.stringify(examples.publish)}`,
-        inputSchema: { messages: z.array(z.record(z.string(), z.unknown())).min(1) },
-        annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: false },
-    }, ({ messages }) => tool(() => publisher.publish(messages)));
-    server.registerTool("list_surfaces", {
-        description: "List this process's service ID and currently published surface IDs.",
-        inputSchema: {},
-        annotations: { readOnlyHint: true, openWorldHint: false },
-    }, () => tool(() => publisher.list()));
-    server.registerTool("read_events", {
-        description: "Read button/form actions without consuming them. Start after=0, then use nextCursor. timeoutMs waits up to 30000ms. Latest 1000 events retained; dropped reports missing events. The original A2UI message includes action.context and optional client data model metadata.",
-        inputSchema: {
-            after: z.number().int().nonnegative().optional(),
-            timeoutMs: z.number().int().min(0).max(30_000).optional(),
-        },
-        annotations: { readOnlyHint: true, openWorldHint: false },
-    }, ({ after, timeoutMs }, extra) => tool(() => publisher.events.read(after, timeoutMs, extra.signal)));
-    server.server.onclose = onClose;
-    await server.connect(new StdioServerTransport());
-    return server;
-}

package/dist/output.d.ts

@@ -1,10 +0,0 @@
-export declare class OutputBuffer {
-    private value;
-    private wasTruncated;
-    get text(): string;
-    get truncated(): boolean;
-    reset(value?: string): void;
-    append(chunk: string): void;
-}
-export declare function fenced(text: string, truncated?: boolean): string;
-export declare function formatDuration(milliseconds: number): string;

package/dist/output.js

@@ -1,35 +0,0 @@
-const OUTPUT_LIMIT = 64 * 1024;
-export class OutputBuffer {
-    value = "";
-    wasTruncated = false;
-    get text() { return this.value; }
-    get truncated() { return this.wasTruncated; }
-    reset(value = "") {
-        this.value = "";
-        this.wasTruncated = false;
-        this.append(value);
-    }
-    append(chunk) {
-        const bytes = Buffer.from(this.value + chunk);
-        if (bytes.length <= OUTPUT_LIMIT) {
-            this.value += chunk;
-            return;
-        }
-        let start = bytes.length - OUTPUT_LIMIT;
-        while (start < bytes.length && (bytes[start] & 0xc0) === 0x80)
-            start++;
-        this.value = bytes.subarray(start).toString("utf8");
-        this.wasTruncated = true;
-    }
-}
-export function fenced(text, truncated = false) {
-    const fence = "`".repeat(Math.max(3, ...[...text.matchAll(/`+/g)].map((match) => match[0].length + 1)));
-    return `${truncated ? "Earlier output truncated.\n\n" : ""}${fence}\n${text}\n${fence}`;
-}
-export function formatDuration(milliseconds) {
-    if (milliseconds < 1000)
-        return `${Math.round(milliseconds)} ms`;
-    if (milliseconds < 60_000)
-        return `${(milliseconds / 1000).toFixed(milliseconds < 10_000 ? 2 : 1)} s`;
-    return `${(milliseconds / 60_000).toFixed(1)} min`;
-}

package/dist/process.d.ts

@@ -1,32 +0,0 @@
-import { type UI } from "@omochi-ui/sdk";
-import { Publisher } from "./publisher.js";
-import { UtilitySurface } from "./surface.js";
-export type RestartPolicy = "never" | "on-failure" | "always";
-export interface ProcessOptions {
-    command: string[];
-    cwd?: string;
-    name: string;
-    restart: RestartPolicy;
-    restartDelayMs: number;
-}
-export declare class CommandProcess extends UtilitySurface {
-    private readonly options;
-    private readonly output;
-    private readonly runner;
-    private running;
-    private status;
-    private restartCount;
-    private suppressRestart;
-    private restartTimer?;
-    private control;
-    private closePromise?;
-    constructor(publisher: Publisher, options: ProcessOptions);
-    protected build(ui: UI): void;
-    protected onAction(name: string): void;
-    close(): Promise<void>;
-    private enqueue;
-    private launch;
-    private stop;
-    private restart;
-    private exited;
-}

package/dist/process.js

@@ -1,115 +0,0 @@
-import { Action } from "@omochi-ui/sdk";
-import { ManagedCommand, describeResult } from "./command.js";
-import { OutputBuffer, fenced } from "./output.js";
-import { UtilitySurface } from "./surface.js";
-export class CommandProcess extends UtilitySurface {
-    options;
-    output = new OutputBuffer();
-    runner;
-    running = false;
-    status = "Stopped";
-    restartCount = 0;
-    suppressRestart = false;
-    restartTimer;
-    control = Promise.resolve();
-    closePromise;
-    constructor(publisher, options) {
-        super(publisher, options.name);
-        this.options = options;
-        this.runner = new ManagedCommand({
-            command: options.command,
-            cwd: options.cwd,
-            onData: (chunk) => {
-                this.output.append(chunk);
-                this.scheduleRender();
-            },
-        });
-    }
-    build(ui) {
-        ui.text(this.name, { key: "title", variant: "h3" });
-        ui.row({ key: "controls" }, () => {
-            if (this.running) {
-                ui.button("Stop", new Action("stop").call(null), { key: "stop" });
-                ui.button("Restart", new Action("restart").call(null), { key: "restart", variant: "primary" });
-            }
-            else {
-                ui.button("Start", new Action("start").call(null), { key: "start", variant: "primary" });
-            }
-        });
-        ui.text(`${this.status} · automatic restarts: ${this.restartCount}`, { key: "status" });
-        ui.text(fenced(this.output.text, this.output.truncated), { key: "output" });
-    }
-    onAction(name) {
-        if (name === "start")
-            this.enqueue(async () => this.launch(false));
-        if (name === "stop")
-            this.enqueue(() => this.stop());
-        if (name === "restart")
-            this.enqueue(() => this.restart());
-    }
-    close() {
-        if (this.closePromise)
-            return this.closePromise;
-        this.closeSurface();
-        this.suppressRestart = true;
-        clearTimeout(this.restartTimer);
-        this.closePromise = (async () => {
-            await this.control;
-            await this.runner.close();
-        })();
-        return this.closePromise;
-    }
-    enqueue(operation) {
-        this.control = this.control.then(operation).catch((error) => {
-            this.status = `Control failed: ${error instanceof Error ? error.message : String(error)}`;
-            this.scheduleRender();
-        });
-    }
-    launch(automatic) {
-        if (this.running || this.closing)
-            return;
-        clearTimeout(this.restartTimer);
-        this.suppressRestart = false;
-        this.running = true;
-        if (automatic)
-            this.restartCount++;
-        this.output.append(`\n--- ${automatic ? "Automatically restarted" : "Started"} at ${new Date().toISOString()} ---\n`);
-        this.status = "Running…";
-        this.scheduleRender();
-        void this.runner.start().then((result) => this.exited(result));
-    }
-    async stop() {
-        this.suppressRestart = true;
-        clearTimeout(this.restartTimer);
-        if (this.running)
-            await this.runner.stop();
-        this.status = "Stopped";
-        this.scheduleRender();
-    }
-    async restart() {
-        this.suppressRestart = true;
-        clearTimeout(this.restartTimer);
-        if (this.running)
-            await this.runner.stop();
-        this.suppressRestart = false;
-        this.launch(false);
-    }
-    exited(result) {
-        this.running = false;
-        const description = describeResult(result);
-        this.output.append(`\n--- ${description} at ${new Date().toISOString()} ---\n`);
-        this.status = description;
-        this.scheduleRender();
-        if (this.closing || this.suppressRestart || !shouldRestart(this.options.restart, result))
-            return;
-        this.status = `${description} · restarting soon…`;
-        this.restartTimer = setTimeout(() => this.launch(true), this.options.restartDelayMs);
-    }
-}
-function shouldRestart(policy, result) {
-    if (policy === "never")
-        return false;
-    if (policy === "always")
-        return true;
-    return Boolean(result.error || result.signal || result.code !== 0);
-}

package/dist/publisher.d.ts

@@ -1,31 +0,0 @@
-import type { JsonObject } from "@omochi-ui/sdk";
-import { UnixSocketServerTransport, type UnixSocketServerTransportOptions } from "@omochi-ui/sdk/node";
-import { EventBuffer } from "./events.js";
-export type PublisherOptions = Omit<UnixSocketServerTransportOptions, "serviceId"> & {
-    serviceId?: string;
-};
-export declare class Publisher {
-    readonly serviceId: string;
-    readonly transport: UnixSocketServerTransport;
-    readonly events: EventBuffer;
-    private snapshot;
-    private queue;
-    private closing;
-    private closePromise?;
-    private readonly receiver;
-    private readonly listeners;
-    private constructor();
-    static open(options?: PublisherOptions): Promise<Publisher>;
-    onAction(listener: (message: JsonObject) => void): () => void;
-    list(): {
-        serviceId: string;
-        surfaceIds: string[];
-    };
-    publish(messages: unknown[]): Promise<{
-        accepted: number;
-        serviceId: string;
-        surfaceIds: string[];
-    }>;
-    close(): Promise<void>;
-    private receive;
-}

package/dist/publisher.js

@@ -1,101 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { A2uiSnapshot } from "@omochi-ui/core";
-import { UnixSocketServerTransport } from "@omochi-ui/sdk/node";
-import { EventBuffer } from "./events.js";
-export class Publisher {
-    serviceId;
-    transport;
-    events = new EventBuffer();
-    snapshot = new A2uiSnapshot();
-    queue = Promise.resolve();
-    closing = false;
-    closePromise;
-    receiver;
-    listeners = new Set();
-    constructor(options) {
-        this.serviceId = options.serviceId ?? `utils-${randomUUID()}`;
-        this.transport = new UnixSocketServerTransport({ ...options, serviceId: this.serviceId });
-        this.receiver = this.receive();
-        // Startup failure is reported by open(); don't leave a second rejected promise.
-        void this.receiver.catch(() => undefined);
-    }
-    static async open(options = {}) {
-        const publisher = new Publisher(options);
-        try {
-            await publisher.transport.ready;
-            return publisher;
-        }
-        catch (error) {
-            await publisher.close();
-            throw error;
-        }
-    }
-    onAction(listener) {
-        this.listeners.add(listener);
-        return () => { this.listeners.delete(listener); };
-    }
-    list() {
-        const surfaceIds = this.snapshot.messages().flatMap((message) => "createSurface" in message ? [message.createSurface.surfaceId] : []);
-        return { serviceId: this.serviceId, surfaceIds };
-    }
-    publish(messages) {
-        const batch = structuredClone(messages);
-        const work = this.queue.then(async () => {
-            if (this.closing)
-                throw new Error("publisher is closed");
-            if (!batch.length)
-                throw new Error("messages must not be empty");
-            // Validate against a disposable snapshot so a bad batch cannot partly publish.
-            const candidate = new A2uiSnapshot();
-            for (const message of this.snapshot.messages())
-                candidate.apply(message);
-            for (const [index, message] of batch.entries()) {
-                try {
-                    assertSafeDataPath(message);
-                    candidate.apply(message);
-                }
-                catch (error) {
-                    throw new Error(`messages[${index}]: ${error instanceof Error ? error.message : String(error)}`);
-                }
-            }
-            for (const message of batch)
-                await this.transport.send(message);
-            this.snapshot = candidate;
-            return { accepted: batch.length, ...this.list() };
-        });
-        this.queue = work.catch(() => undefined);
-        return work;
-    }
-    close() {
-        if (this.closePromise)
-            return this.closePromise;
-        this.closing = true;
-        this.events.close();
-        this.closePromise = (async () => {
-            await this.queue;
-            await this.transport.close();
-            await this.receiver.catch(() => undefined);
-        })();
-        return this.closePromise;
-    }
-    async receive() {
-        for await (const message of this.transport) {
-            if (this.closing)
-                break;
-            this.events.push(message);
-            for (const listener of this.listeners)
-                listener(message);
-        }
-    }
-}
-// Snapshot traversal must not follow JavaScript prototype properties from raw input.
-function assertSafeDataPath(message) {
-    if (!message || typeof message !== "object" || !("updateDataModel" in message))
-        return;
-    const update = message.updateDataModel;
-    if (!update || typeof update !== "object" || !("path" in update) || typeof update.path !== "string")
-        return;
-    const parts = update.path.split("/").map((part) => part.replaceAll("~1", "/").replaceAll("~0", "~"));
-    if (parts.some((part) => ["__proto__", "constructor", "prototype"].includes(part)))
-        throw new Error("unsafe data model path");
-}

package/dist/stream.d.ts

@@ -1,18 +0,0 @@
-import type { Readable } from "node:stream";
-import type { UI } from "@omochi-ui/sdk";
-import { Publisher } from "./publisher.js";
-import { UtilitySurface } from "./surface.js";
-export interface StreamOptions {
-    name: string;
-    input?: Readable;
-}
-export declare class InputStream extends UtilitySurface {
-    private readonly output;
-    private readonly input;
-    private status;
-    constructor(publisher: Publisher, options: StreamOptions);
-    start(): Promise<void>;
-    protected build(ui: UI): void;
-    close(): Promise<void>;
-    private consume;
-}

package/dist/stream.js

@@ -1,46 +0,0 @@
-import { OutputBuffer, fenced } from "./output.js";
-import { UtilitySurface } from "./surface.js";
-export class InputStream extends UtilitySurface {
-    output = new OutputBuffer();
-    input;
-    status = "Reading input…";
-    constructor(publisher, options) {
-        super(publisher, options.name);
-        this.input = options.input ?? process.stdin;
-    }
-    async start() {
-        await super.start();
-        void this.consume();
-    }
-    build(ui) {
-        ui.text(this.name, { key: "title", variant: "h3" });
-        ui.text(this.status, { key: "status" });
-        ui.text(fenced(this.output.text, this.output.truncated), { key: "output" });
-    }
-    close() {
-        this.closeSurface();
-        this.input.pause();
-        return Promise.resolve();
-    }
-    async consume() {
-        this.input.setEncoding("utf8");
-        try {
-            for await (const chunk of this.input) {
-                if (this.closing)
-                    break;
-                this.output.append(String(chunk));
-                this.scheduleRender();
-            }
-            if (!this.closing) {
-                this.status = "Input closed";
-                this.scheduleRender();
-            }
-        }
-        catch (error) {
-            if (!this.closing) {
-                this.status = `Input error: ${error instanceof Error ? error.message : String(error)}`;
-                this.scheduleRender();
-            }
-        }
-    }
-}

package/dist/surface.d.ts

@@ -1,18 +0,0 @@
-import { Reconciler, UI } from "@omochi-ui/sdk";
-import { Publisher } from "./publisher.js";
-export declare abstract class UtilitySurface {
-    protected readonly publisher: Publisher;
-    protected readonly name: string;
-    protected readonly reconciler: Reconciler;
-    protected closing: boolean;
-    private readonly unsubscribe;
-    private timer?;
-    constructor(publisher: Publisher, name: string);
-    start(): Promise<void>;
-    protected abstract build(ui: UI): void;
-    protected onAction(_name: string): void;
-    protected scheduleRender(): void;
-    protected render(): Promise<void>;
-    protected closeSurface(): void;
-    private receiveAction;
-}