@rynx-ai/server 0.1.0

package/dist/control-web-dist.d.ts

@@ -0,0 +1,6 @@
+import type { Context } from "koa";
+/** Absolute path to the built SPA dir, or null when it hasn't been built. */
+export declare function resolveControlWebDist(): string | null;
+/** Serve a static file from the SPA dir; missing non-asset paths fall back to
+ *  index.html (client-side routing), missing assets return 404. */
+export declare function sendSpaFile(ctx: Context, distDir: string): Promise<void>;

package/dist/control-web-dist.js

@@ -0,0 +1,63 @@
+/**
+ * Locate + serve the built control-web SPA (`@rynx-ai/control-web/dist`). Resolving
+ * the package's own `package.json` is robust across pnpm symlinks; the daemon
+ * ships control-web as a dependency so the dist is present at runtime.
+ *
+ * A tiny hand-rolled static sender (no extra dep) covers the SPA's needs:
+ * `index.html` + hashed `assets/*`, with an index.html fallback for client paths.
+ */
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { dirname, extname, join, resolve } from "node:path";
+const require = createRequire(import.meta.url);
+const CONTENT_TYPES = {
+    ".html": "text/html; charset=utf-8",
+    ".js": "text/javascript; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".svg": "image/svg+xml",
+    ".json": "application/json; charset=utf-8",
+    ".ico": "image/x-icon",
+    ".png": "image/png",
+    ".woff2": "font/woff2",
+    ".map": "application/json",
+};
+/** Absolute path to the built SPA dir, or null when it hasn't been built. */
+export function resolveControlWebDist() {
+    try {
+        const pkgJson = require.resolve("@rynx-ai/control-web/package.json");
+        const dist = join(dirname(pkgJson), "dist");
+        return existsSync(join(dist, "index.html")) ? dist : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Serve a static file from the SPA dir; missing non-asset paths fall back to
+ *  index.html (client-side routing), missing assets return 404. */
+export async function sendSpaFile(ctx, distDir) {
+    const relative = ctx.path === "/" ? "index.html" : ctx.path.replace(/^\/+/, "");
+    const target = resolve(distDir, relative);
+    if (target !== distDir && !target.startsWith(distDir + "/")) {
+        ctx.status = 403;
+        return;
+    }
+    let filePath = target;
+    let ext = extname(filePath);
+    let data = await readFile(filePath).catch(() => null);
+    if (!data) {
+        if (ext) {
+            ctx.status = 404;
+            return;
+        }
+        filePath = join(distDir, "index.html");
+        ext = ".html";
+        data = await readFile(filePath).catch(() => null);
+        if (!data) {
+            ctx.status = 404;
+            return;
+        }
+    }
+    ctx.type = CONTENT_TYPES[ext] ?? "application/octet-stream";
+    ctx.body = data;
+}

package/dist/emulator-touch-ws.d.ts

@@ -0,0 +1,8 @@
+import type { Server } from "node:http";
+import { WebSocketServer } from "ws";
+import type { ControlEmulatorDeps } from "./control-api.js";
+interface EmulatorTouchWsDeps {
+    emulator: ControlEmulatorDeps;
+}
+export declare function attachEmulatorTouchWs(server: Server, deps: EmulatorTouchWsDeps): WebSocketServer;
+export {};

package/dist/emulator-touch-ws.js

@@ -0,0 +1,87 @@
+import { WebSocketServer } from "ws";
+const EMULATOR_TOUCH_PATH = "/api/emulator/touch";
+const WS_CLOSE_BAD_REQUEST = 4400;
+const WS_CLOSE_UNAVAILABLE = 4404;
+const WS_CLOSE_INTERNAL_ERROR = 4500;
+function parseTouchPoint(data) {
+    try {
+        const parsed = JSON.parse(data.toString("utf8"));
+        if (parsed.type !== "begin" && parsed.type !== "move" && parsed.type !== "end")
+            return null;
+        if (!Number.isFinite(parsed.x) || !Number.isFinite(parsed.y))
+            return null;
+        return { type: parsed.type, x: parsed.x, y: parsed.y };
+    }
+    catch {
+        return null;
+    }
+}
+function sendText(ws, value) {
+    if (ws.readyState === ws.OPEN)
+        ws.send(JSON.stringify(value));
+}
+export function attachEmulatorTouchWs(server, deps) {
+    const wss = new WebSocketServer({ noServer: true });
+    server.on("upgrade", (req, socket, head) => {
+        let url;
+        try {
+            url = new URL(req.url ?? "", "http://localhost");
+        }
+        catch {
+            return;
+        }
+        if (url.pathname !== EMULATOR_TOUCH_PATH)
+            return;
+        wss.handleUpgrade(req, socket, head, (ws) => {
+            void handleConnection(ws, url, deps);
+        });
+    });
+    return wss;
+}
+async function handleConnection(ws, url, deps) {
+    if (!deps.emulator.liveTouch) {
+        sendText(ws, { t: "error", message: "emulator live touch API is not available on this server" });
+        ws.close(WS_CLOSE_UNAVAILABLE, "emulator live touch unavailable");
+        return;
+    }
+    const pending = [];
+    let controller = null;
+    let closed = false;
+    const close = () => {
+        closed = true;
+        controller?.close();
+        controller = null;
+    };
+    ws.on("message", (data, isBinary) => {
+        if (isBinary)
+            return;
+        const point = parseTouchPoint(data);
+        if (!point) {
+            sendText(ws, { t: "error", message: "invalid touch point" });
+            ws.close(WS_CLOSE_BAD_REQUEST, "invalid touch point");
+            return;
+        }
+        if (controller)
+            controller.send(point);
+        else
+            pending.push(point);
+    });
+    ws.on("close", close);
+    ws.on("error", close);
+    try {
+        controller = await deps.emulator.liveTouch({ device: url.searchParams.get("device") ?? undefined });
+        if (closed) {
+            controller.close();
+            controller = null;
+            return;
+        }
+        sendText(ws, { t: "opened", backend: controller.backend, device: controller.device });
+        for (const point of pending.splice(0))
+            controller.send(point);
+    }
+    catch (error) {
+        sendText(ws, { t: "error", message: error instanceof Error ? error.message : String(error) });
+        ws.close(WS_CLOSE_INTERNAL_ERROR, "emulator live touch error");
+        return;
+    }
+}

package/dist/server.d.ts

@@ -0,0 +1,66 @@
+import Koa from "koa";
+import { ConversationRuntime, type AppConfig, type ChannelFactory, type ChannelInstanceDescriptor, type SessionBus, type SessionLogStore, type SessionRegistry } from "@rynx-ai/core";
+import { RunnerManager, type CodexSessionStore } from "@rynx-ai/runtime";
+import { ChannelManager } from "./channel-manager.js";
+import { type ControlPlaneDeps } from "./control-api.js";
+export { ChannelManager } from "./channel-manager.js";
+export type { ChannelInstanceStatus } from "./channel-manager.js";
+export type { ControlPlaneDeps, StoredSessionMeta } from "./control-api.js";
+export type { ControlChannel, ControlChannelType, ControlInstanceConfig, ControlInstanceStatus, ControlAgentSummary, } from "@rynx-ai/protocol/control";
+export interface CreateAppOptions {
+    config?: AppConfig;
+    /** When present, mount the control plane (page + JSON API) beside `/health`.
+     *  `runtime`/`sessionBus`/`sessionLog`/`runnerManager` (from `startServer`'s
+     *  scope) enable the channel-agnostic `/api/sessions` agent-run endpoints. */
+    control?: {
+        manager: ChannelManager;
+        deps: ControlPlaneDeps;
+        runtime?: ConversationRuntime;
+        sessionBus?: SessionBus;
+        sessionLog?: SessionLogStore;
+        runnerManager?: RunnerManager;
+        sessionStore?: CodexSessionStore;
+    };
+}
+export interface StartServerOptions {
+    config?: AppConfig;
+    /**
+     * Legacy: channel plugins to mount as one shared-context batch. Kept for
+     * back-compat (and tests); the daemon now uses {@link loadInstances} so each
+     * instance gets its own context. Empty ⇒ a pure `/health` server.
+     */
+    channelFactories?: ChannelFactory[];
+    /** Static set of channel instances to mount, each with its own context. */
+    channelInstances?: ChannelInstanceDescriptor[];
+    /**
+     * Dynamic source of channel instance descriptors, re-read on reloads. When
+     * provided, the server mounts them via a {@link ChannelManager} (the seam the
+     * control plane drives). Takes precedence over `channelInstances`.
+     */
+    loadInstances?: () => Promise<ChannelInstanceDescriptor[]>;
+    /**
+     * Control-plane deps (config + agent-spec mutators + log tail) injected by the
+     * daemon. When present (and instances are managed), the server serves the
+     * control page + JSON API. Requires `loadInstances`/`channelInstances`.
+     */
+    control?: ControlPlaneDeps;
+    /**
+     * Durable canonical session log (the daemon injects the SQLite-backed store).
+     * Absent ⇒ channels render from the live stream without persisting.
+     */
+    sessionLog?: SessionLogStore;
+    /**
+     * Unified machine-session registry (the daemon injects the SQLite-backed store
+     * over `sessions`). Handed to mounted channels so they register an identity row
+     * per session; the control plane lists every session uniformly from it.
+     */
+    sessionRegistry?: SessionRegistry;
+}
+/**
+ * The HTTP surface is just a liveness probe for container orchestration — all
+ * agent capabilities are forwarded through the mounted channel plugins (the
+ * Lark bot reaches its server over an outbound WebSocket long connection), so
+ * no agent request / response / SSE endpoints are exposed here.
+ */
+export declare function createApp({ control }?: CreateAppOptions): Koa<Koa.DefaultState, Koa.DefaultContext>;
+export declare function startServer({ config, channelFactories, channelInstances, loadInstances, control, sessionLog, sessionRegistry, }?: StartServerOptions): Promise<import("node:http").Server<typeof import("node:http").IncomingMessage, typeof import("node:http").ServerResponse>>;

package/dist/server.js

@@ -0,0 +1,224 @@
+import { pathToFileURL } from "node:url";
+import Koa from "koa";
+import Router from "@koa/router";
+import { loadConfig, resolveRuntimeModel, ConversationRuntime, InMemorySessionBus, persistSessionEvent, } from "@rynx-ai/core";
+import { RunnerManager, FileCodexSessionStore, resolveCodexSessionStorePath, } from "@rynx-ai/runtime";
+import { ChannelManager } from "./channel-manager.js";
+import { createControlRouter } from "./control-api.js";
+import { attachEmulatorTouchWs } from "./emulator-touch-ws.js";
+import { attachTerminalWs } from "./terminal-ws.js";
+import { resolveControlWebDist, sendSpaFile } from "./control-web-dist.js";
+export { ChannelManager } from "./channel-manager.js";
+function toErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return "Unknown error";
+}
+/**
+ * The HTTP surface is just a liveness probe for container orchestration — all
+ * agent capabilities are forwarded through the mounted channel plugins (the
+ * Lark bot reaches its server over an outbound WebSocket long connection), so
+ * no agent request / response / SSE endpoints are exposed here.
+ */
+export function createApp({ control } = {}) {
+    const app = new Koa();
+    const router = new Router();
+    router.get("/health", (ctx) => {
+        ctx.body = { ok: true };
+    });
+    app.use(router.routes());
+    app.use(router.allowedMethods());
+    if (control) {
+        const controlRouter = createControlRouter(control);
+        app.use(controlRouter.routes());
+        app.use(controlRouter.allowedMethods());
+        // Serve the built control-web SPA for everything that isn't /health or /api.
+        const distDir = resolveControlWebDist();
+        app.use(async (ctx, next) => {
+            if (ctx.method !== "GET" && ctx.method !== "HEAD")
+                return next();
+            if (ctx.path === "/health" || ctx.path.startsWith("/api/"))
+                return next();
+            if (!distDir) {
+                if (ctx.path === "/") {
+                    ctx.type = "html";
+                    ctx.body =
+                        "<!doctype html><meta charset=utf-8><body style='font:14px system-ui;padding:2rem'>" +
+                            "<h1>rynx control</h1><p>The web console isn't built yet. Run " +
+                            "<code>pnpm --filter @rynx-ai/control-web build</code> and restart.</p>";
+                }
+                return next();
+            }
+            await sendSpaFile(ctx, distDir);
+        });
+    }
+    return app;
+}
+export async function startServer({ config = loadConfig(), channelFactories = [], channelInstances, loadInstances, control, sessionLog, sessionRegistry, } = {}) {
+    // One shared session store, owned here and handed to the channels via the
+    // ChannelContext (mirror index / active-session reads). Runner children open
+    // the same on-disk store for their session bindings.
+    const sessionStore = new FileCodexSessionStore(resolveCodexSessionStorePath(config));
+    // The executor + capability surface. Holds no execution backend itself: it
+    // spawns a runner child per session for turns, forwards per-thread
+    // capabilities to a runner, and answers status/model-list locally.
+    const runnerManager = new RunnerManager({
+        config,
+        sessionStore,
+        // Give runner children the control-plane URL so a claude-native
+        // PermissionRequest hook subprocess can POST approvals back to this daemon.
+        childEnv: {
+            RYNX_CONTROL_URL: `http://127.0.0.1:${config.PORT}`,
+        },
+    });
+    // One canonical event bus shared by every mounted instance, so a future
+    // observer (web console) sees every channel's turns over one fan-out.
+    const sessionBus = new InMemorySessionBus();
+    const conversationRuntime = new ConversationRuntime({
+        config,
+        executor: runnerManager,
+        // The live co-drive path (`runLive`) reads a turn's mirrored events off this bus.
+        sessionBus,
+    });
+    // codex-native single-writer: a session's persistent forwarder mirrors EVERY
+    // turn (web- AND co-driving-TUI-initiated) as canonical SessionEvents; persist
+    // + publish each so the web console's /stream renders them uniformly.
+    runnerManager.onMirror((sessionId, event) => {
+        void persistSessionEvent(sessionId, event, { sessionLog, sessionBus });
+    });
+    // claude `/clear`·`/fork` rotates to a fresh machine-session; record its meta so
+    // the console list shows it with the carried-over agent/model + a source tag.
+    // (It also surfaces via the log-merge once its first turn mirrors.)
+    runnerManager.onRotate((r) => {
+        control?.createSessionMeta({
+            id: r.to,
+            source: r.kind === "fork" ? "fork" : "clear",
+            ...(r.agent ? { agent: r.agent } : {}),
+            ...(r.model ? { model: r.model } : {}),
+            createdAt: new Date().toISOString(),
+        });
+    });
+    // New path: per-instance contexts via the ChannelManager (the daemon supplies
+    // `loadInstances`; the control plane drives live start/stop/reload).
+    const resolveInstances = loadInstances ?? (channelInstances ? async () => channelInstances : null);
+    if (resolveInstances) {
+        const manager = new ChannelManager({
+            config,
+            conversationRuntime,
+            capabilities: runnerManager,
+            sessionStore,
+            sessionLog,
+            sessionBus,
+            sessionRegistry,
+            loadInstances: resolveInstances,
+        });
+        const app = createApp({
+            config,
+            control: control
+                ? {
+                    manager,
+                    deps: control,
+                    runtime: conversationRuntime,
+                    sessionBus,
+                    sessionLog,
+                    runnerManager,
+                    sessionStore,
+                }
+                : undefined,
+        });
+        return new Promise((resolve) => {
+            const server = app.listen(config.PORT, config.HOST, () => {
+                console.log(JSON.stringify({
+                    level: config.LOG_LEVEL,
+                    msg: "Harness agent server listening",
+                    host: config.HOST,
+                    port: config.PORT,
+                    runtime: config.AGENT_RUNTIME,
+                    model: resolveRuntimeModel(config, config.AGENT_RUNTIME),
+                }));
+                void manager.startAll();
+                // Live WS bridges share this http.Server (no second port).
+                attachTerminalWs(server, { runnerManager });
+                if (control?.emulator)
+                    attachEmulatorTouchWs(server, { emulator: control.emulator });
+                server.on("close", () => {
+                    void manager.stopAll();
+                    void runnerManager.stop();
+                });
+                resolve(server);
+            });
+        });
+    }
+    // Legacy path: one shared context for all factories (unchanged behavior).
+    const channelContext = {
+        config,
+        conversationRuntime,
+        capabilities: runnerManager,
+        sessionStore,
+    };
+    // Construct each channel defensively: a plugin that throws while building
+    // (e.g. Lark with missing credentials) is isolated and logged, so one broken
+    // channel can't take down the host or its sibling channels.
+    const channels = [];
+    for (const factory of channelFactories) {
+        try {
+            channels.push(factory(channelContext));
+        }
+        catch (error) {
+            console.error(JSON.stringify({
+                level: "error",
+                type: "channel",
+                event: "construct_failed",
+                error: toErrorMessage(error),
+            }));
+        }
+    }
+    const app = createApp({ config });
+    return new Promise((resolve) => {
+        const server = app.listen(config.PORT, config.HOST, () => {
+            console.log(JSON.stringify({
+                level: config.LOG_LEVEL,
+                msg: "Harness agent server listening",
+                host: config.HOST,
+                port: config.PORT,
+                runtime: config.AGENT_RUNTIME,
+                model: resolveRuntimeModel(config, config.AGENT_RUNTIME),
+                channels: channels.map((channel) => channel.id),
+            }));
+            for (const channel of channels) {
+                void channel.start().catch((error) => {
+                    console.error(JSON.stringify({
+                        level: "error",
+                        type: "channel",
+                        channel: channel.id,
+                        event: "runtime.start_failed",
+                        error: toErrorMessage(error),
+                    }));
+                });
+            }
+            server.on("close", () => {
+                void runnerManager.stop();
+                for (const channel of channels) {
+                    void channel.stop().catch((error) => {
+                        console.error(JSON.stringify({
+                            level: "error",
+                            type: "channel",
+                            channel: channel.id,
+                            event: "runtime.stop_failed",
+                            error: toErrorMessage(error),
+                        }));
+                    });
+                }
+            });
+            resolve(server);
+        });
+    });
+}
+const entrypoint = process.argv[1];
+if (entrypoint && import.meta.url === pathToFileURL(entrypoint).href) {
+    startServer().catch((error) => {
+        console.error(error);
+        process.exitCode = 1;
+    });
+}

package/dist/terminal-ws.d.ts

@@ -0,0 +1,25 @@
+/**
+ * WebSocket bridge for the live terminal (Phase C). Attaches to the existing
+ * daemon `http.Server` via the `upgrade` event — no second port — and tunnels a
+ * browser xterm session to a per-session terminal on the runner child through
+ * {@link RunnerManager.openTerminal}.
+ *
+ * Wire protocol (mirrors omnigent's terminal attach):
+ *  - server → browser: BINARY frames = raw PTY output; TEXT frames = JSON
+ *    control (`{t:"opened",role}`, `{t:"exit"}`, `{t:"error",message}`).
+ *  - browser → server: BINARY frames = keystrokes; TEXT frames = JSON control
+ *    (`{t:"resize",cols,rows}` / `{t:"input",data}`).
+ */
+import type { Server } from "node:http";
+import type { RunnerManager } from "@rynx-ai/runtime";
+import { WebSocketServer } from "ws";
+export interface TerminalWsDeps {
+    runnerManager: RunnerManager;
+    /** Resolve a session's terminal working directory (sync). Defaults to cwd. */
+    resolveCwd?: (sessionId: string) => string | undefined;
+    /** Inner command for the pane; defaults child-side to the login shell. */
+    command?: string;
+    args?: string[];
+}
+/** Attach the terminal WS upgrade handler to a running http.Server. */
+export declare function attachTerminalWs(server: Server, deps: TerminalWsDeps): WebSocketServer;

package/dist/terminal-ws.js

@@ -0,0 +1,123 @@
+import { WebSocketServer } from "ws";
+const TERMINAL_PATH = /^\/api\/sessions\/([^/]+)\/terminal$/;
+const MAX_DIM = 1000;
+// PTY-output → WS coalescing, ported from omnigent's `_forward_pty_to_ws`
+// (ws_bridge.py): merge PTY chunks that arrive in the same tick into bounded
+// frames so a screen redraw is a few frames, not dozens. Cap each frame at
+// 64 KiB normally; drop to 2 KiB within 750 ms of user input so a post-keystroke
+// redraw stays in the browser terminal's synchronous-echo fast path (xterm falls
+// back to a laggy async write for frames over ~2 KiB). Oversize accumulations are
+// split across frames. Constants match omnigent's exactly.
+const WS_COALESCE_MAX_BYTES = 64 * 1024;
+const INTERACTIVE_WS_COALESCE_MAX_BYTES = 2048;
+const INTERACTIVE_ECHO_WINDOW_MS = 750;
+// Application WebSocket close codes, matching omnigent (ws_bridge.py). 4404 = the
+// pane's inner process exited / session gone; 4500 = bridge could not open the
+// terminal. The frontend's isUnexpectedTerminalClose auto-reconnects only on
+// transport codes (1006 etc.), so these 4xxx codes correctly land on the
+// dead-pane overlay instead of a reconnect loop. rynx's server-initiated close is
+// always "gone" (a client *detach* is client-initiated and never reaches here),
+// so omnigent's 4405 "detached" has no rynx counterpart.
+const WS_CLOSE_TERMINAL_GONE = 4404;
+const WS_CLOSE_INTERNAL_ERROR = 4500;
+/** Attach the terminal WS upgrade handler to a running http.Server. */
+export function attachTerminalWs(server, deps) {
+    const wss = new WebSocketServer({ noServer: true });
+    server.on("upgrade", (req, socket, head) => {
+        let url;
+        try {
+            url = new URL(req.url ?? "", "http://localhost");
+        }
+        catch {
+            return;
+        }
+        const match = TERMINAL_PATH.exec(url.pathname);
+        if (!match)
+            return; // Not our route — leave it for any other upgrade handler.
+        wss.handleUpgrade(req, socket, head, (ws) => {
+            handleConnection(ws, url, decodeURIComponent(match[1]), deps);
+        });
+    });
+    return wss;
+}
+function clampDim(raw, fallback) {
+    const n = raw ? Number.parseInt(raw, 10) : Number.NaN;
+    return Number.isFinite(n) && n > 0 && n <= MAX_DIM ? n : fallback;
+}
+function handleConnection(ws, url, sessionId, deps) {
+    const role = url.searchParams.get("role") === "read-only" ? "read-only" : "owner";
+    const cols = clampDim(url.searchParams.get("cols"), 80);
+    const rows = clampDim(url.searchParams.get("rows"), 24);
+    const cwd = deps.resolveCwd?.(sessionId) ?? process.cwd();
+    const term = deps.runnerManager.openTerminal(sessionId, {
+        role,
+        cwd,
+        cols,
+        rows,
+        ...(deps.command ? { command: deps.command } : {}),
+        ...(deps.args ? { args: deps.args } : {}),
+    });
+    const sendText = (obj) => {
+        if (ws.readyState === ws.OPEN)
+            ws.send(JSON.stringify(obj));
+    };
+    // Monotonic-ish stamp of the last client keystroke, so a redraw right after
+    // input takes the smaller interactive frame cap (omnigent `last_client_input_at`).
+    let lastClientInputAt = 0;
+    // Chunks buffered within the current tick, flushed coalesced on the next.
+    let pending = [];
+    let flushScheduled = false;
+    const flushOutput = () => {
+        flushScheduled = false;
+        if (ws.readyState !== ws.OPEN || pending.length === 0) {
+            pending = [];
+            return;
+        }
+        const merged = pending.length === 1 ? pending[0] : Buffer.concat(pending);
+        pending = [];
+        const limit = Date.now() - lastClientInputAt < INTERACTIVE_ECHO_WINDOW_MS
+            ? INTERACTIVE_WS_COALESCE_MAX_BYTES
+            : WS_COALESCE_MAX_BYTES;
+        for (let off = 0; off < merged.length; off += limit) {
+            ws.send(merged.subarray(off, Math.min(off + limit, merged.length)));
+        }
+    };
+    term.onData((chunk) => {
+        pending.push(Buffer.from(chunk, "utf8"));
+        if (!flushScheduled) {
+            flushScheduled = true;
+            setImmediate(flushOutput);
+        }
+    });
+    term.onExit(() => {
+        flushOutput(); // drain the pane's final bytes before the close frame
+        sendText({ t: "exit" });
+        ws.close(WS_CLOSE_TERMINAL_GONE, "terminal session ended");
+    });
+    term.ready.then((opened) => sendText({ t: "opened", role: opened.role }), (error) => {
+        sendText({ t: "error", message: error instanceof Error ? error.message : String(error) });
+        ws.close(WS_CLOSE_INTERNAL_ERROR, "terminal bridge error");
+    });
+    ws.on("message", (data, isBinary) => {
+        if (isBinary) {
+            lastClientInputAt = Date.now();
+            term.write(data.toString("utf8"));
+            return;
+        }
+        try {
+            const msg = JSON.parse(data.toString("utf8"));
+            if (msg.t === "resize" && typeof msg.cols === "number" && typeof msg.rows === "number") {
+                term.resize(msg.cols, msg.rows);
+            }
+            else if (msg.t === "input" && typeof msg.data === "string") {
+                lastClientInputAt = Date.now();
+                term.write(msg.data);
+            }
+        }
+        catch {
+            // Ignore malformed control frames.
+        }
+    });
+    ws.on("close", () => term.close());
+    ws.on("error", () => term.close());
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@rynx-ai/server",
+  "version": "0.1.0",
+  "description": "Composition root: wires the @rynx-ai/runtime host to channel plugins (injected by the daemon) and exposes a liveness HTTP probe.",
+  "type": "module",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/server.js",
+  "types": "./dist/server.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/server.d.ts",
+      "default": "./dist/server.js"
+    }
+  },
+  "dependencies": {
+    "@koa/router": "^15.4.0",
+    "koa": "^3.2.0",
+    "ws": "^8.21.0",
+    "@rynx-ai/control-web": "0.1.0",
+    "@rynx-ai/runtime": "0.1.0",
+    "@rynx-ai/core": "0.1.0",
+    "@rynx-ai/protocol": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/ws": "^8.18.1"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.json",
+    "start": "node dist/server.js",
+    "dev": "tsx watch --tsconfig ../../tsconfig.json src/server.ts"
+  }
+}