omkit 0.8.2 → 0.8.4

package/dist/cli/ui/app.js

@@ -5,6 +5,17 @@ import { RunModel } from "../../output/RunModel.js";
 import { OmList } from "./views/OmList.js";
 import { RunView } from "./views/RunView.js";
 import { Spinner } from "./Spinner.js";
+/**
+ * How often the run screen redraws while the log streams in.
+ *
+ * An Ink frame costs ~25ms at minimum and grows with the milestone tail, so redrawing per log
+ * entry caps the app at roughly 40 entries/second — far under what a build, a test suite, or a
+ * dev server emits. The app then falls permanently behind: `settled` is the *last* message on
+ * the channel, so it only arrives once every backlogged entry has been drawn, and the run looks
+ * hung long after the child has finished. Folding into the model is cheap; drawing is not, so
+ * the two run at different rates.
+ */
+const REDRAW_MS = 80;
 /** The interactive app: discover → list/search → run → live milestones + prompts. */
 export function App({ client, onExit, oms: initialOms, }) {
     const { exit } = useApp();
@@ -21,6 +32,16 @@ export function App({ client, onExit, oms: initialOms, }) {
     const sessionRef = useRef(null);
     const verdictRef = useRef(undefined);
     const tearingRef = useRef(false);
+    const redrawTimer = useRef(undefined);
+    const stopRedraw = () => {
+        if (redrawTimer.current === undefined)
+            return;
+        clearInterval(redrawTimer.current);
+        redrawTimer.current = undefined;
+    };
+    // The redraw timer holds the event loop open, so it must not outlive the app — an unmount
+    // for any reason other than the run settling would otherwise keep the CLI from exiting.
+    useEffect(() => stopRedraw, []);
     useEffect(() => {
         if (initialOms)
             return; // provided by the caller's pre-flight discovery
@@ -37,17 +58,34 @@ export function App({ client, onExit, oms: initialOms, }) {
         const model = new RunModel();
         const s = client.run(om.file);
         sessionRef.current = s;
-        s.on("log", (entry) => {
-            model.apply(entry);
+        // Every entry lands in the model immediately; the screen catches up on its own cadence.
+        // `dirty` keeps an idle run from redrawing over nothing — see REDRAW_MS for why the two
+        // are separated at all.
+        let dirty = false;
+        const redraw = () => {
+            if (!dirty)
+                return;
+            dirty = false;
             setLines(model.milestones());
             setStatus(model.summary());
+        };
+        redrawTimer.current = setInterval(redraw, REDRAW_MS);
+        s.on("log", (entry) => {
+            model.apply(entry);
+            dirty = true;
+        });
+        // A prompt blocks the child until it's answered, so it must not wait for the next tick —
+        // and the milestones that led to it are the context the question is read in.
+        s.on("prompt", (req) => {
+            redraw();
+            setPrompt(req);
         });
-        s.on("prompt", (req) => setPrompt(req));
         // The child gave up on the prompt (timed out or torn down). Withdraw its box so a stale,
         // unanswerable prompt doesn't linger — but only if it's still the one on screen, so a late
         // withdrawal can't clobber a fresh prompt.
         s.on("promptDone", (id) => setPrompt((p) => (p?.id === id ? undefined : p)));
         s.on("settled", (v) => {
+            redraw(); // the run's closing milestones, before its verdict
             setVerdict(v);
             setPrompt(undefined);
         });
@@ -57,6 +95,8 @@ export function App({ client, onExit, oms: initialOms, }) {
         // so it can print the durable summary block, and unmount. Without this a self-completing run
         // would show its verdict line but never exit or render the summary.
         void s.result.then((v) => {
+            stopRedraw();
+            redraw(); // last pass: whatever arrived since the final tick
             verdictRef.current = v;
             setVerdict(v);
             onExit?.(v);

package/dist/client/channel.d.ts

@@ -5,6 +5,11 @@ export interface Transport {
     send(message: SupervisorMessage): void;
     onMessage(handler: (message: ChildMessage) => void): void;
     onClose(handler: (code: number | null) => void): void;
+    /**
+     * Whatever the child printed outside the channel, for a close that never reached `settled`.
+     * Read only on that path — a run that reports for itself needs no second account.
+     */
+    diagnostics?(): string[];
 }
 /**
  * Turn a child transport into a {@link RunSession}: fan `log`/`prompt`/`prompt-done` child

package/dist/client/channel.js

@@ -35,8 +35,15 @@ export function createChannel(transport) {
         }
     });
     transport.onClose(() => {
-        if (!settled)
-            resolveResult({ ok: false, folder: "", summary: [] });
+        if (settled)
+            return;
+        // The child died before it could report: there is no run folder and no summary of its own.
+        // What it printed on its way out — a module that failed to load, a crash during import — is
+        // the only account of why, so it stands in as the summary. Without it the frontend shows a
+        // bare "✗ failed" and the reason is lost with the process.
+        const output = transport.diagnostics?.() ?? [];
+        const summary = output.length ? ["the run ended before it could report:", ...output] : [];
+        resolveResult({ ok: false, folder: "", summary });
     });
     return {
         on(event, handler) {

package/dist/client/runner.js

@@ -18,6 +18,30 @@ export function inspectArgs(inspect) {
         return [];
     return [`--inspect=${inspect.port}`];
 }
+/**
+ * How much of a child's raw output to keep. Enough for a module-resolution failure or a stack
+ * trace, small enough that a run which prints megabytes still costs nothing to supervise.
+ */
+const TAIL_BYTES = 8 * 1024;
+/**
+ * Drain a child's raw streams while keeping the last {@link TAIL_BYTES} of them. Attaching a
+ * `data` handler is what puts each stream in flowing mode — that, not the tail, is what stops
+ * the child wedging on a full pipe. Returns a reader for the kept lines, oldest first; stdout
+ * and stderr share one buffer so a message split across them stays in order.
+ */
+function keepTail(...streams) {
+    let text = "";
+    for (const stream of streams) {
+        stream?.setEncoding("utf8");
+        stream?.on("data", (chunk) => {
+            text = (text + chunk).slice(-TAIL_BYTES);
+        });
+    }
+    return () => text
+        .split("\n")
+        .map((line) => line.replace(/\r$/, "").trimEnd())
+        .filter((line) => line !== "");
+}
 /**
  * Fork `omFile` as a supervised child: the `tsx` loader runs the TypeScript directly,
  * `OMKIT_SUPERVISED=1` flips the child into channel mode (see core/interaction.ts), and its
@@ -38,10 +62,19 @@ export function runOm(omFile, opts = {}) {
         env: { ...process.env, OMKIT_SUPERVISED: "1", ...opts.env },
         stdio: ["ignore", "pipe", "pipe", "ipc"],
     });
+    // Piped, not read: nothing in the supervisor consumes these streams, so once the OS pipe
+    // buffer fills (~64 KB) the child blocks on its next write — permanently, since the only
+    // thing the supervisor ever reads is the IPC channel. `patch-console` swaps the console
+    // methods but not `process.stdout.write`, so any direct write in an om (or in a library it
+    // uses) lands here and wedges the run before it can settle. Draining is what keeps the child
+    // moving; the tail is kept because a child that dies before the channel opens has nowhere
+    // else to say why (see the Transport's `diagnostics`).
+    const tail = keepTail(child.stdout, child.stderr);
     const transport = {
         send: (message) => void child.send(message),
         onMessage: (handler) => void child.on("message", (m) => handler(m)),
         onClose: (handler) => void child.on("close", (code) => handler(code)),
+        diagnostics: tail,
     };
     const session = createChannel(transport);
     // When the run settles, the child has already written its logs and reaped its process tree —

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omkit",
-  "version": "0.8.2",
+  "version": "0.8.4",
   "description": "A tiny runtime for developer workflows: typed actions that pass runtime capabilities and emit typed events, under one run and one shared log. The operational/runtime layer to tskb's knowledge layer.",
   "type": "module",
   "main": "./dist/index.js",