@omochi-ui/utils 0.0.0-stage → 0.1.0

package/dist/surface.js

@@ -0,0 +1,51 @@
+import { BASIC_CATALOG, Reconciler, UI } from "@omochi-ui/sdk";
+export class UtilitySurface {
+    publisher;
+    name;
+    reconciler = new Reconciler();
+    closing = false;
+    unsubscribe;
+    timer;
+    constructor(publisher, name) {
+        this.publisher = publisher;
+        this.name = name;
+        this.unsubscribe = publisher.onAction((message) => this.receiveAction(message));
+    }
+    async start() { await this.render(); }
+    onAction(_name) { }
+    scheduleRender() {
+        if (this.timer || this.closing)
+            return;
+        this.timer = setTimeout(() => {
+            this.timer = undefined;
+            void this.render().catch((error) => {
+                if (!this.closing)
+                    process.stderr.write(`surface render: ${String(error)}\n`);
+            });
+        }, 50);
+    }
+    async render() {
+        if (this.closing)
+            return;
+        const ui = new UI("main", BASIC_CATALOG);
+        this.build(ui);
+        const messages = this.reconciler.render(ui.build());
+        if (messages.length)
+            await this.publisher.publish(messages);
+    }
+    closeSurface() {
+        if (this.closing)
+            return;
+        this.closing = true;
+        this.unsubscribe();
+        clearTimeout(this.timer);
+    }
+    receiveAction(message) {
+        const action = message.action;
+        if (!action || typeof action !== "object" || Array.isArray(action))
+            return;
+        if (action.surfaceId !== "main" || typeof action.name !== "string")
+            return;
+        this.onAction(action.name);
+    }
+}

package/dist/tail.d.ts

@@ -0,0 +1,25 @@
+import type { UI } from "@omochi-ui/sdk";
+import { Publisher } from "./publisher.js";
+import { UtilitySurface } from "./surface.js";
+export interface TailOptions {
+    path: string;
+    lines: number;
+    name: string;
+}
+export declare class FileTail extends UtilitySurface {
+    private readonly options;
+    private readonly output;
+    private decoder;
+    private identity?;
+    private position;
+    private seenFile;
+    private status;
+    private pollTimer?;
+    constructor(publisher: Publisher, options: TailOptions);
+    start(): Promise<void>;
+    protected build(ui: UI): void;
+    close(): Promise<void>;
+    private poll;
+    private readInitial;
+    private readRange;
+}

package/dist/tail.js

@@ -0,0 +1,130 @@
+import { open, stat } from "node:fs/promises";
+import { StringDecoder } from "node:string_decoder";
+import { OutputBuffer, fenced } from "./output.js";
+import { UtilitySurface } from "./surface.js";
+const READ_LIMIT = 64 * 1024;
+const POLL_INTERVAL = 500;
+export class FileTail extends UtilitySurface {
+    options;
+    output = new OutputBuffer();
+    decoder = new StringDecoder("utf8");
+    identity;
+    position = 0;
+    seenFile = false;
+    status = "Waiting for file…";
+    pollTimer;
+    constructor(publisher, options) {
+        super(publisher, options.name);
+        this.options = options;
+    }
+    async start() {
+        await super.start();
+        void this.poll();
+    }
+    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();
+        clearTimeout(this.pollTimer);
+        return Promise.resolve();
+    }
+    async poll() {
+        if (this.closing)
+            return;
+        try {
+            const info = await stat(this.options.path);
+            if (!info.isFile())
+                throw new Error("path is not a regular file");
+            const identity = `${info.dev}:${info.ino}`;
+            if (identity !== this.identity) {
+                if (this.seenFile)
+                    this.output.append(`\n--- File replaced at ${new Date().toISOString()} ---\n`);
+                await this.readInitial(info.size);
+                this.identity = identity;
+                this.seenFile = true;
+            }
+            else if (info.size < this.position) {
+                this.output.append(`\n--- File truncated at ${new Date().toISOString()} ---\n`);
+                await this.readInitial(info.size);
+            }
+            else if (info.size > this.position) {
+                await this.readRange(this.position, info.size);
+            }
+            this.status = `Following ${this.options.path} · ${new Date().toISOString()}`;
+            this.scheduleRender();
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === "ENOENT") {
+                if (this.identity !== undefined)
+                    this.output.append(`\n--- File missing; waiting for replacement ---\n`);
+                this.identity = undefined;
+                this.position = 0;
+                this.decoder = new StringDecoder("utf8");
+                this.status = `Waiting for ${this.options.path}…`;
+            }
+            else {
+                this.status = `Tail error: ${error instanceof Error ? error.message : String(error)}`;
+            }
+            this.scheduleRender();
+        }
+        finally {
+            if (!this.closing)
+                this.pollTimer = setTimeout(() => void this.poll(), POLL_INTERVAL);
+        }
+    }
+    async readInitial(size) {
+        this.decoder = new StringDecoder("utf8");
+        const start = Math.max(0, size - READ_LIMIT);
+        const bytes = await readBytes(this.options.path, start, size - start);
+        let offset = 0;
+        if (start > 0)
+            while (offset < bytes.length && (bytes[offset] & 0xc0) === 0x80)
+                offset++;
+        const decoded = this.decoder.write(bytes.subarray(offset));
+        const lines = decoded.split("\n");
+        const selected = lines.slice(Math.max(0, lines.length - this.options.lines - (decoded.endsWith("\n") ? 1 : 0))).join("\n");
+        if (!this.seenFile)
+            this.output.reset(selected);
+        else
+            this.output.append(selected);
+        this.position = size;
+    }
+    async readRange(start, end) {
+        let effectiveStart = start;
+        if (end - start > READ_LIMIT) {
+            effectiveStart = end - READ_LIMIT;
+            this.output.append("\n--- Earlier appended data skipped ---\n");
+            this.decoder = new StringDecoder("utf8");
+        }
+        const bytes = await readBytes(this.options.path, effectiveStart, end - effectiveStart);
+        let offset = 0;
+        if (effectiveStart !== start)
+            while (offset < bytes.length && (bytes[offset] & 0xc0) === 0x80)
+                offset++;
+        this.output.append(this.decoder.write(bytes.subarray(offset)));
+        this.position = end;
+    }
+}
+async function readBytes(filePath, position, length) {
+    if (length <= 0)
+        return Buffer.alloc(0);
+    const handle = await open(filePath, "r");
+    try {
+        const buffer = Buffer.alloc(length);
+        let offset = 0;
+        while (offset < length) {
+            const { bytesRead } = await handle.read(buffer, offset, length - offset, position + offset);
+            if (!bytesRead)
+                break;
+            offset += bytesRead;
+        }
+        return buffer.subarray(0, offset);
+    }
+    finally {
+        await handle.close();
+    }
+}

package/dist/watch.d.ts

@@ -0,0 +1,37 @@
+import { type UI } from "@omochi-ui/sdk";
+import { Publisher } from "./publisher.js";
+import { UtilitySurface } from "./surface.js";
+export interface WatchOptions {
+    command: string[];
+    cwd?: string;
+    name: string;
+    intervalMs: number;
+    timeoutMs?: number;
+    diff: boolean;
+    onChange: boolean;
+    history?: number;
+}
+export declare class CommandWatch extends UtilitySurface {
+    private readonly options;
+    private readonly current;
+    private readonly runner;
+    private readonly entries;
+    private interval?;
+    private running;
+    private paused;
+    private status;
+    private displayedOutput;
+    private displayedTruncated;
+    private difference;
+    private differencePlaceholder;
+    private differenceTruncated;
+    private previousOutput?;
+    private previousKey?;
+    private closePromise?;
+    constructor(publisher: Publisher, options: WatchOptions);
+    start(): Promise<void>;
+    protected build(ui: UI): void;
+    protected onAction(name: string): void;
+    close(): Promise<void>;
+    private run;
+}

package/dist/watch.js

@@ -0,0 +1,130 @@
+import { Action } from "@omochi-ui/sdk";
+import { createTwoFilesPatch } from "diff";
+import { ManagedCommand, describeResult } from "./command.js";
+import { OutputBuffer, fenced, formatDuration } from "./output.js";
+import { UtilitySurface } from "./surface.js";
+export class CommandWatch extends UtilitySurface {
+    options;
+    current = new OutputBuffer();
+    runner;
+    entries = [];
+    interval;
+    running = false;
+    paused = false;
+    status = "Starting…";
+    displayedOutput = "";
+    displayedTruncated = false;
+    difference = "";
+    differencePlaceholder = "No previous run.";
+    differenceTruncated = false;
+    previousOutput;
+    previousKey;
+    closePromise;
+    constructor(publisher, options) {
+        super(publisher, options.name);
+        this.options = options;
+        this.runner = new ManagedCommand({
+            command: options.command,
+            cwd: options.cwd,
+            onData: (chunk) => {
+                this.current.append(chunk);
+                if (!options.onChange) {
+                    this.displayedOutput = this.current.text;
+                    this.displayedTruncated = this.current.truncated;
+                    this.scheduleRender();
+                }
+            },
+        });
+    }
+    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" });
+        ui.text(fenced(this.displayedOutput, this.displayedTruncated), { key: "output" });
+        if (this.options.diff) {
+            ui.text("Changes since previous run", { key: "diff-title", variant: "h4" });
+            ui.text(fenced(this.difference || this.differencePlaceholder, this.differenceTruncated), { key: "diff" });
+        }
+        if (this.options.history && this.entries.length) {
+            ui.text("History", { key: "history-title", variant: "h4" });
+            ui.text(this.entries.map((entry) => `- ${entry.at} · ${entry.result} · ${formatDuration(entry.durationMs)} · ${entry.changed ? "changed" : "unchanged"}`).join("\n"), { key: "history" });
+        }
+    }
+    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() {
+        if (this.closePromise)
+            return this.closePromise;
+        this.closeSurface();
+        clearTimeout(this.interval);
+        this.closePromise = this.runner.close();
+        return this.closePromise;
+    }
+    async run() {
+        if (this.running || this.closing)
+            return;
+        this.running = true;
+        this.current.reset();
+        if (!this.options.onChange) {
+            this.status = "Running…";
+            this.displayedOutput = "";
+            this.displayedTruncated = false;
+            this.scheduleRender();
+        }
+        const result = await this.runner.start(this.options.timeoutMs);
+        const output = this.current.text;
+        const key = `${resultKey(result)}\0${output}`;
+        const changed = this.previousKey === undefined || key !== this.previousKey;
+        const difference = new OutputBuffer();
+        const hadPrevious = this.previousOutput !== undefined;
+        difference.reset(hadPrevious ? createTwoFilesPatch("previous", "current", this.previousOutput, output, "", "", { context: 3 }) : "");
+        this.difference = difference.text;
+        this.differenceTruncated = difference.truncated;
+        this.differencePlaceholder = hadPrevious ? "No changes." : "No previous run.";
+        this.previousOutput = output;
+        this.previousKey = key;
+        this.running = false;
+        this.status = `${describeResult(result)} · ${formatDuration(result.durationMs)} · ${new Date().toISOString()}`;
+        if (this.options.history !== undefined && this.options.history > 0) {
+            this.entries.push({ at: new Date().toISOString(), durationMs: result.durationMs, result: describeResult(result), changed });
+            if (this.entries.length > this.options.history)
+                this.entries.splice(0, this.entries.length - this.options.history);
+        }
+        if (!this.options.onChange || changed) {
+            this.displayedOutput = output;
+            this.displayedTruncated = this.current.truncated;
+            this.scheduleRender();
+        }
+        if (!this.paused && !this.closing)
+            this.interval = setTimeout(() => void this.run(), this.options.intervalMs);
+    }
+}
+function resultKey(result) {
+    return result.error ? `error:${result.error.message}` : result.timedOut ? "timeout" : result.signal ? `signal:${result.signal}` : `code:${result.code}`;
+}

package/package.json

@@ -1,6 +1,37 @@
 {
   "name": "@omochi-ui/utils",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "engines": {
+    "bun": ">=1.4.3"
+  },
+  "description": "Publish development utilities and agent-created A2UI surfaces to Omochi",
+  "license": "Apache-2.0",
+  "type": "module",
+  "bin": {
+    "omochi-utils": "./bin/omochi-utils.js"
+  },
+  "files": [
+    "bin",
+    "dist"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.31.0",
+    "diff": "^9.0.0",
+    "@omochi-ui/core": "0.1.0",
+    "@omochi-ui/sdk": "0.1.0",
+    "zod": "^4.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/k-kozika/omochi.git",
+    "directory": "packages/utils"
+  },
+  "homepage": "https://github.com/k-kozika/omochi#readme",
+  "bugs": {
+    "url": "https://github.com/k-kozika/omochi/issues"
+  }
+}