@rynx-ai/server 0.1.9 → 0.1.10-beta.2

package/dist/control-api.js

@@ -19,9 +19,11 @@
 import { timingSafeEqual } from "node:crypto";
 import Router from "@koa/router";
 import { agentSpecSchema, newSessionId, skillInstallRecipeSchema, } from "@rynx-ai/core";
+import { DAEMON_BROWSER_ARTIFACT_CLEAN_PATH, DAEMON_BROWSER_ARTIFACT_INSTALL_PATH, DAEMON_BROWSER_ARTIFACT_UPDATE_PATH, DAEMON_BROWSER_ARTIFACT_VERSION_PATH, DAEMON_CHROME_INSPECTION_PATH, DAEMON_CLEANUP_SESSIONS_PATH, DAEMON_SHUTDOWN_IF_IDLE_PATH, parseDaemonBrowserArtifactInstallInput, parseDaemonBrowserArtifactUpdateInput, parseDaemonChromeInspectionConfigureInput, parseDaemonCleanupSessionsInput, } from "@rynx-ai/protocol/control";
 import { DIRECT_RUNTIME_CONTROL_PATH, encodePairingCode, } from "@rynx-ai/protocol/direct-runtime";
+import { PLUGIN_INSTALL_PREPARATIONS_PATH, parsePluginInstallCommitInput, parsePluginInstallPrepareInput, } from "@rynx-ai/protocol/plugin-management";
 import { parseDaemonStatus } from "@rynx-ai/protocol/remote-runtime";
-import { materializeRemoteRuntimeSessionEvent, materializeRemoteRuntimeSessionRuntimeSnapshot, parseRemoteRuntimeRpcRequest, REMOTE_RUNTIME_RPC_MAX_FRAME_BYTES, REMOTE_RUNTIME_SESSION_MAX_PAGE_SIZE, } from "@rynx-ai/protocol/remote-runtime-rpc";
+import { materializeRemoteRuntimeSessionEvent, materializeRemoteRuntimeSessionRuntimeSnapshot, parseRemoteRuntimeRpcRequest, REMOTE_RUNTIME_RPC_MAX_FRAME_BYTES, SESSION_IMAGE_MEDIA_TYPES, SESSION_RESOURCE_MAX_IMAGE_BYTES, SESSION_RESOURCE_MAX_FILENAME_CHARS, SESSION_RESOURCE_TRANSFER_CHUNK_BYTES, REMOTE_RUNTIME_SESSION_MAX_PAGE_SIZE, } from "@rynx-ai/protocol/remote-runtime-rpc";
 import { RUNTIME_BROWSER_BOOTSTRAP_PATH, RUNTIME_BROWSER_CAPABILITY_HEADER, RUNTIME_BROWSER_MANAGEMENT_PATH_PREFIX, RUNTIME_BROWSER_RPC_PATH, RUNTIME_BROWSER_SESSION_ID_HEADER, parseRuntimeBrowserBootstrapCredential, } from "@rynx-ai/protocol/runtime-browser-bootstrap";
 import { parseRuntimeBrowserStateGetParams } from "@rynx-ai/protocol/runtime-browser";
 import { ensureCodexResumeRollout } from "@rynx-ai/runtime";
@@ -35,6 +37,15 @@ const PLUGIN_CLI_ARGS_TOTAL_MAX_BYTES = 32 * 1024;
 const PLUGIN_CLI_ARGS_MAX_COUNT = 64;
 const PLUGIN_CLI_ERROR_MAX_BYTES = 16 * 1024;
 const PLUGIN_CLI_TIMEOUT_MS = 120_000;
+const PLUGIN_INSTALL_BODY_MAX_BYTES = 16 * 1024;
+const PLUGIN_INSTALL_OPERATION_TIMEOUT_MS = 15 * 60_000;
+const PLUGIN_INSTALL_ERROR_MAX_BYTES = 16 * 1024;
+const BROWSER_ARTIFACT_BODY_MAX_BYTES = 4 * 1024;
+const BROWSER_ARTIFACT_OPERATION_TIMEOUT_MS = 15 * 60_000;
+const BROWSER_ARTIFACT_ERROR_MAX_BYTES = 16 * 1024;
+const CHROME_INSPECTION_BODY_MAX_BYTES = 16 * 1024;
+const CHROME_INSPECTION_ERROR_MAX_BYTES = 4 * 1024;
+const CLEANUP_SESSIONS_BODY_MAX_BYTES = 1 * 1024;
 const REMOTE_RUNTIME_ADMIN_BODY_MAX_BYTES = 4 * 1024;
 const RUNTIME_TARGET_PAIR_BODY_MAX_BYTES = 64 * 1024;
 const REMOTE_RUNTIME_EMULATOR_CONTROL_TIMEOUT_MS = 30_000;
@@ -63,8 +74,69 @@ const RUNTIME_BROWSER_RPC_METHODS = new Set([
     "browser.page.reload",
 ]);
 export function createControlRouter(opts) {
-    const { manager, deps, runtime, sessionBus, sessionLog, runnerManager, sessionStore, pluginRuntimeStatus, pluginRuntimeReload, pluginRuntimeEnsure, daemonManagement, remoteRuntime, remoteRuntimeAdmin, runtimeTargetControl, runtimeConnectionResolver, sessionEmulators, shutdownSignal, sessionRuntimeIndex = new SessionRuntimeIndex(), sessionLifecycle, runtimeLocalBrowser, providerClis, } = opts;
+    const { manager, deps, runtime, sessionBus, sessionLog, runnerManager, sessionStore, pluginRuntimeStatus, pluginRuntimeReload, pluginRuntimeEnsure, daemonManagement, remoteRuntime, remoteRuntimeAdmin, runtimeTargetControl, runtimeWebAccess, runtimeConnectionResolver, localSessionResources, sessionEmulators, shutdownSignal, sessionRuntimeIndex = new SessionRuntimeIndex(), sessionLifecycle, runtimeLocalBrowser, providerClis, } = opts;
     const router = new Router();
+    const mutateBrowserArtifact = async (ctx, operation) => {
+        const host = daemonManagement?.browserArtifacts;
+        if (!host || !isConfiguredDaemonManagement(daemonManagement)) {
+            return notFound(ctx, "Browser artifact management is not configured");
+        }
+        if (!authorizeLoopbackManagementRequest(ctx, daemonManagement.managementToken))
+            return;
+        if (!ctx.is("application/json")) {
+            ctx.status = 415;
+            ctx.body = { error: `Browser ${operation} requires application/json` };
+            return;
+        }
+        let body;
+        try {
+            body = await readBoundedJson(ctx, BROWSER_ARTIFACT_BODY_MAX_BYTES);
+        }
+        catch (error) {
+            if (error instanceof RequestBodyTooLargeError) {
+                ctx.status = 413;
+                ctx.body = { error: error.message };
+                return;
+            }
+            return bad(ctx, error instanceof Error ? error.message : String(error));
+        }
+        let installInput;
+        let updateInput;
+        try {
+            if (operation === "install") {
+                installInput = parseDaemonBrowserArtifactInstallInput(body);
+            }
+            else {
+                updateInput = parseDaemonBrowserArtifactUpdateInput(body);
+            }
+        }
+        catch (error) {
+            return bad(ctx, error instanceof Error ? error.message : String(error));
+        }
+        const invocation = browserArtifactInvocationAbortScope(ctx, shutdownSignal);
+        try {
+            ctx.set("Cache-Control", "no-store");
+            ctx.body = operation === "install"
+                ? await host.install(installInput, { signal: invocation.signal })
+                : await host.update(updateInput, { signal: invocation.signal });
+        }
+        catch (error) {
+            if (!ctx.res.destroyed) {
+                ctx.status = invocation.signal.aborted
+                    ? invocation.signal.reason instanceof Error &&
+                        invocation.signal.reason.name === "TimeoutError"
+                        ? 504
+                        : 499
+                    : 409;
+                ctx.body = {
+                    error: boundedUtf8(error instanceof Error ? error.message : String(error), BROWSER_ARTIFACT_ERROR_MAX_BYTES),
+                };
+            }
+        }
+        finally {
+            invocation.dispose();
+        }
+    };
     /** The instance (if any) bound to a channel — used to reload after a config change. */
     const instanceForChannel = (channelId) => deps.listInstancesConfig().find((i) => i.channelId === channelId);
     const listRuntimeTargets = async (ctx) => {
@@ -103,7 +175,10 @@ export function createControlRouter(opts) {
             return;
         }
         if (!Object.hasOwn(body, "offer") ||
-            Object.keys(body).some((key) => key !== "offer" && key !== "displayName")) {
+            Object.keys(body).some((key) => key !== "offer" &&
+                key !== "displayName" &&
+                key !== "replaceExisting" &&
+                key !== "expectedDaemonId")) {
             ctx.status = 400;
             ctx.body = { error: "invalid_offer" };
             return;
@@ -114,10 +189,28 @@ export function createControlRouter(opts) {
             ctx.body = { error: "invalid_target" };
             return;
         }
+        const replaceExisting = body.replaceExisting;
+        if (replaceExisting !== undefined && typeof replaceExisting !== "boolean") {
+            ctx.status = 400;
+            ctx.body = { error: "invalid_target" };
+            return;
+        }
+        const expectedDaemonId = body.expectedDaemonId;
+        if (replaceExisting === true
+            ? !isRuntimeTargetSelector(expectedDaemonId) || expectedDaemonId === "local"
+            : expectedDaemonId !== undefined) {
+            ctx.status = 400;
+            ctx.body = { error: "invalid_target" };
+            return;
+        }
         try {
             const result = await runtimeTargetControl.pair({
                 offer: body.offer,
                 ...(displayName === undefined ? {} : { displayName }),
+                ...(replaceExisting === undefined ? {} : { replaceExisting }),
+                ...(replaceExisting === true
+                    ? { expectedDaemonId: expectedDaemonId }
+                    : {}),
             });
             ctx.set("Cache-Control", "no-store");
             ctx.body = redactRuntimeTargetPairResult(result);
@@ -245,11 +338,32 @@ export function createControlRouter(opts) {
             ctx.body = { error: error instanceof Error ? error.message : String(error) };
         }
     };
+    const deleteRevokedRuntimeAccess = (ctx) => {
+        ctx.set("Cache-Control", "no-store");
+        if (!remoteRuntimeAdmin) {
+            return notFound(ctx, "Remote Runtime administration is not configured");
+        }
+        if (!/^[A-Za-z0-9][A-Za-z0-9._~-]{0,255}$/.test(ctx.params.grantId)) {
+            return bad(ctx, "invalid Remote Runtime grant id");
+        }
+        try {
+            const result = remoteRuntimeAdmin.deleteRevokedClientGrant(ctx.params.grantId);
+            if (!result.deleted) {
+                return notFound(ctx, "Remote Runtime client grant not found or still active");
+            }
+            ctx.body = result;
+        }
+        catch (error) {
+            ctx.status = 409;
+            ctx.body = { error: error instanceof Error ? error.message : String(error) };
+        }
+    };
     const authorizePublicRuntimeTargetRequest = (ctx, options = {}) => {
         ctx.set("Cache-Control", "no-store");
         const failure = authorizeRuntimeWebRequest(ctx.req, {
             mutation: options.mutation,
             capability: ctx.get(RUNTIME_WEB_CAPABILITY_HEADER),
+            access: runtimeWebAccess,
         });
         if (!failure)
             return true;
@@ -306,6 +420,11 @@ export function createControlRouter(opts) {
             revokeRuntimeAccess(ctx);
         }
     });
+    router.delete("/api/runtime-server/access/:grantId/record", (ctx) => {
+        if (authorizePublicRuntimeTargetRequest(ctx, { mutation: true })) {
+            deleteRevokedRuntimeAccess(ctx);
+        }
+    });
     router.get("/api/internal/runtimes", async (ctx) => {
         if (authorizeInternalRuntimeTargetRequest(ctx))
             await listRuntimeTargets(ctx);
@@ -361,7 +480,9 @@ export function createControlRouter(opts) {
         }
         let lease;
         try {
-            lease = await runtimeConnectionResolver.acquire(selector);
+            lease = shutdownSignal
+                ? await runtimeConnectionResolver.acquire(selector, { signal: shutdownSignal })
+                : await runtimeConnectionResolver.acquire(selector);
             if (lease.target.selector !== selector ||
                 !isRuntimeTargetSelector(lease.target.daemonId)) {
                 throw new Error("Runtime resolver returned a mismatched target");
@@ -378,6 +499,7 @@ export function createControlRouter(opts) {
         }
         try {
             const result = await lease.call(method, validatedParams, {
+                ...(shutdownSignal ? { signal: shutdownSignal } : {}),
                 timeoutMs: remoteRuntimeRpcTimeoutMs(method, validatedParams),
             });
             ctx.set("Cache-Control", "no-store");
@@ -594,9 +716,309 @@ export function createControlRouter(opts) {
         const body = await readRuntimeBody(ctx);
         if (!body)
             return;
-        if (!acceptRuntimeBodyKeys(ctx, body, ["message"]))
+        if (!acceptRuntimeBodyKeys(ctx, body, ["message", "content", "clientMessageId"]))
             return;
         const outcome = await runtimeCall(ctx, "session.message.send", {
+            sessionId: ctx.params.id,
+            ...(body.message === undefined ? {} : { message: body.message }),
+            ...(body.content === undefined
+                ? {}
+                : {
+                    content: body.content,
+                }),
+            ...(body.clientMessageId === undefined
+                ? {}
+                : { clientMessageId: body.clientMessageId }),
+        });
+        if (outcome.ok)
+            ctx.body = outcome.result;
+    };
+    const runtimeSessionResourcePolicy = async (ctx) => {
+        if (ctx.params.selector === "local" && localSessionResources) {
+            try {
+                ctx.set("Cache-Control", "no-store");
+                ctx.body = await localSessionResources.resourcePolicy(ctx.params.id);
+            }
+            catch (error) {
+                runtimeTargetHostError(ctx, error);
+            }
+            return;
+        }
+        const outcome = await runtimeCall(ctx, "session.resource.policy.get", {
+            sessionId: ctx.params.id,
+        });
+        if (outcome.ok)
+            ctx.body = outcome.result;
+    };
+    const runtimeSessionResourceUpload = async (ctx) => {
+        const uploadStarted = performance.now();
+        const mediaType = ctx.get("content-type").split(";", 1)[0]?.trim();
+        const clientUploadId = ctx.get("x-rynx-upload-id").trim();
+        const encodedFilename = ctx.get("x-rynx-filename").trim();
+        let filename = "";
+        try {
+            filename = decodeURIComponent(encodedFilename);
+        }
+        catch {
+            ctx.status = 400;
+            ctx.body = { error: "invalid_filename" };
+            return;
+        }
+        if (!mediaType ||
+            !SESSION_IMAGE_MEDIA_TYPES.includes(mediaType) ||
+            !clientUploadId ||
+            !filename ||
+            filename.length > SESSION_RESOURCE_MAX_FILENAME_CHARS) {
+            ctx.status = 400;
+            ctx.body = { error: "invalid_resource_upload" };
+            return;
+        }
+        let bytes;
+        const bodyReadStarted = performance.now();
+        try {
+            bytes = await readBoundedBinary(ctx, SESSION_RESOURCE_MAX_IMAGE_BYTES);
+        }
+        catch (error) {
+            ctx.status = error instanceof RequestBodyTooLargeError ? 413 : 400;
+            ctx.body = {
+                error: error instanceof RequestBodyTooLargeError
+                    ? "request_too_large"
+                    : "invalid_resource_upload",
+            };
+            return;
+        }
+        if (bytes.byteLength === 0) {
+            ctx.status = 400;
+            ctx.body = { error: "empty_resource" };
+            return;
+        }
+        const sessionId = ctx.params.id;
+        const local = ctx.params.selector === "local" ? localSessionResources : undefined;
+        const lease = local ? undefined : await acquireRuntimeLease(ctx);
+        if (!local && !lease)
+            return;
+        const timings = new Map([
+            ["body", performance.now() - bodyReadStarted],
+        ]);
+        const timed = async (name, operation) => {
+            const started = performance.now();
+            try {
+                return await operation();
+            }
+            finally {
+                timings.set(name, (timings.get(name) ?? 0) + performance.now() - started);
+            }
+        };
+        const policy = () => timed("policy", () => local
+            ? local.resourcePolicy(sessionId)
+            : lease.call("session.resource.policy.get", { sessionId }, { timeoutMs: REMOTE_RUNTIME_SESSION_TIMEOUT_MS }));
+        const begin = () => timed("begin", () => local
+            ? local.beginResourceUpload({
+                sessionId,
+                clientUploadId,
+                filename,
+                mediaType,
+                byteLength: bytes.byteLength,
+            })
+            : lease.call("session.resource.upload.begin", {
+                sessionId,
+                clientUploadId,
+                filename,
+                mediaType,
+                byteLength: bytes.byteLength,
+            }, { timeoutMs: REMOTE_RUNTIME_SESSION_TIMEOUT_MS }));
+        const writeChunk = (uploadId, offset, data) => timed("chunks", () => local
+            ? local.writeResourceUploadChunk({ sessionId, uploadId, offset, data })
+            : lease.call("session.resource.upload.chunk", { sessionId, uploadId, offset, data }, { timeoutMs: REMOTE_RUNTIME_SESSION_TIMEOUT_MS }));
+        const commit = (uploadId) => timed("commit", () => local
+            ? local.commitResourceUpload({ sessionId, uploadId })
+            : lease.call("session.resource.upload.commit", { sessionId, uploadId }, { timeoutMs: REMOTE_RUNTIME_SESSION_TIMEOUT_MS }));
+        try {
+            const resourcePolicy = await policy();
+            if (!resourcePolicy.enabled ||
+                !resourcePolicy.mediaTypes.includes(mediaType) ||
+                bytes.byteLength > resourcePolicy.maxImageBytes) {
+                ctx.status = 413;
+                ctx.body = { error: "resource_policy_rejected" };
+                return;
+            }
+            const begun = await begin();
+            if (begun.complete && begun.resource) {
+                ctx.set("Cache-Control", "no-store");
+                ctx.body = { resource: begun.resource };
+                return;
+            }
+            if (begun.offset < 0 || begun.offset > bytes.byteLength) {
+                throw runtimeProtocolError("Runtime Session resource upload offset is invalid");
+            }
+            let offset = begun.offset;
+            while (offset < bytes.byteLength) {
+                const chunk = bytes.subarray(offset, Math.min(offset + SESSION_RESOURCE_TRANSFER_CHUNK_BYTES, bytes.byteLength));
+                const written = await writeChunk(begun.uploadId, offset, chunk.toString("base64"));
+                if (written.offset <= offset || written.offset > bytes.byteLength) {
+                    throw runtimeProtocolError("Runtime Session resource upload did not advance");
+                }
+                offset = written.offset;
+            }
+            const committed = await commit(begun.uploadId);
+            if (committed.resource.resourceId !== begun.resourceId ||
+                committed.resource.mediaType !== mediaType ||
+                committed.resource.byteLength !== bytes.byteLength) {
+                throw runtimeProtocolError("Runtime Session resource upload identity changed");
+            }
+            ctx.status = 201;
+            ctx.set("Cache-Control", "no-store");
+            ctx.body = committed;
+        }
+        catch (error) {
+            runtimeTargetHostError(ctx, error);
+        }
+        finally {
+            lease?.release();
+            const totalDuration = performance.now() - uploadStarted;
+            timings.set("total", totalDuration);
+            ctx.set("Server-Timing", [...timings.entries()]
+                .map(([name, duration]) => `${name};dur=${duration.toFixed(1)}`)
+                .join(", "));
+            if (totalDuration >= 1_000) {
+                console.warn(JSON.stringify({
+                    level: "warn",
+                    event: "session.resource.upload.slow",
+                    selector: ctx.params.selector,
+                    sessionId,
+                    byteLength: bytes.byteLength,
+                    status: ctx.status,
+                    timings: Object.fromEntries([...timings.entries()].map(([name, duration]) => [
+                        name,
+                        Math.round(duration),
+                    ])),
+                }));
+            }
+        }
+    };
+    const runtimeSessionResourceMetadata = async (ctx) => {
+        if (ctx.params.selector === "local" && localSessionResources) {
+            try {
+                const result = await localSessionResources.getResource({
+                    sessionId: ctx.params.id,
+                    resourceId: ctx.params.resourceId,
+                });
+                if (result.resource.resourceId !== ctx.params.resourceId) {
+                    throw runtimeProtocolError("Runtime Session resource identity changed");
+                }
+                ctx.set("Cache-Control", "no-store");
+                ctx.body = result;
+            }
+            catch (error) {
+                runtimeTargetHostError(ctx, error);
+            }
+            return;
+        }
+        const outcome = await runtimeCall(ctx, "session.resource.get", {
+            sessionId: ctx.params.id,
+            resourceId: ctx.params.resourceId,
+        });
+        if (!outcome.ok)
+            return;
+        if (outcome.result.resource.resourceId !== ctx.params.resourceId) {
+            runtimeTargetHostError(ctx, runtimeProtocolError("Runtime Session resource identity changed"));
+            return;
+        }
+        ctx.body = outcome.result;
+    };
+    const runtimeSessionResourceContent = async (ctx) => {
+        const sessionId = ctx.params.id;
+        const resourceId = ctx.params.resourceId;
+        const local = ctx.params.selector === "local" ? localSessionResources : undefined;
+        const lease = local ? undefined : await acquireRuntimeLease(ctx);
+        if (!local && !lease)
+            return;
+        try {
+            const { resource } = local
+                ? await local.getResource({ sessionId, resourceId })
+                : await lease.call("session.resource.get", { sessionId, resourceId }, { timeoutMs: REMOTE_RUNTIME_SESSION_TIMEOUT_MS });
+            if (resource.resourceId !== resourceId) {
+                throw runtimeProtocolError("Runtime Session resource identity changed");
+            }
+            const etag = `"sha256-${resource.sha256}"`;
+            ctx.set("Cache-Control", "private, max-age=0, must-revalidate");
+            ctx.set("ETag", etag);
+            if (ctx.get("if-none-match").split(",").map((value) => value.trim()).includes(etag)) {
+                ctx.status = 304;
+                return;
+            }
+            const chunks = [];
+            let offset = 0;
+            while (offset < (resource.byteLength ?? 0)) {
+                const result = local
+                    ? await local.readResource({
+                        sessionId,
+                        resourceId,
+                        offset,
+                        length: SESSION_RESOURCE_TRANSFER_CHUNK_BYTES,
+                    })
+                    : await lease.call("session.resource.read", {
+                        sessionId,
+                        resourceId,
+                        offset,
+                        length: SESSION_RESOURCE_TRANSFER_CHUNK_BYTES,
+                    }, { timeoutMs: REMOTE_RUNTIME_SESSION_TIMEOUT_MS });
+                const chunk = Buffer.from(result.data, "base64");
+                if (result.offset !== offset + chunk.byteLength || (!result.eof && chunk.byteLength === 0)) {
+                    throw runtimeProtocolError("Runtime Session resource read did not advance");
+                }
+                chunks.push(chunk);
+                offset = result.offset;
+                if (result.eof)
+                    break;
+            }
+            const body = Buffer.concat(chunks);
+            if (body.byteLength !== resource.byteLength) {
+                throw runtimeProtocolError("Runtime Session resource length changed");
+            }
+            ctx.set("Content-Security-Policy", "default-src 'none'; sandbox");
+            ctx.set("Cross-Origin-Resource-Policy", "same-origin");
+            ctx.set("X-Content-Type-Options", "nosniff");
+            ctx.set("Content-Disposition", "inline");
+            ctx.type = resource.mediaType;
+            ctx.length = body.byteLength;
+            ctx.body = body;
+        }
+        catch (error) {
+            runtimeTargetHostError(ctx, error);
+        }
+        finally {
+            lease?.release();
+        }
+    };
+    const runtimeSessionResourceDelete = async (ctx) => {
+        if (ctx.params.selector === "local" && localSessionResources) {
+            try {
+                ctx.set("Cache-Control", "no-store");
+                ctx.body = await localSessionResources.deleteResource({
+                    sessionId: ctx.params.id,
+                    resourceId: ctx.params.resourceId,
+                });
+            }
+            catch (error) {
+                runtimeTargetHostError(ctx, error);
+            }
+            return;
+        }
+        const outcome = await runtimeCall(ctx, "session.resource.delete", {
+            sessionId: ctx.params.id,
+            resourceId: ctx.params.resourceId,
+        });
+        if (outcome.ok)
+            ctx.body = outcome.result;
+    };
+    const runtimeSessionMessageEnqueue = async (ctx) => {
+        const body = await readRuntimeBody(ctx);
+        if (!body)
+            return;
+        if (!acceptRuntimeBodyKeys(ctx, body, ["message"]))
+            return;
+        const outcome = await runtimeCall(ctx, "session.message.enqueue", {
             sessionId: ctx.params.id,
             message: body.message,
         });
@@ -1208,6 +1630,12 @@ export function createControlRouter(opts) {
     router.get("/api/runtimes/:selector/sessions/:id/stream", publicRuntimeRead(runtimeSessionStream));
     router.post("/api/runtimes/:selector/sessions/:id/interrupt", publicRuntimeMutation(runtimeSessionInterrupt));
     router.post("/api/runtimes/:selector/sessions/:id/messages", publicRuntimeMutation(runtimeSessionMessage));
+    router.get("/api/runtimes/:selector/sessions/:id/resources/policy", publicRuntimeRead(runtimeSessionResourcePolicy));
+    router.post("/api/runtimes/:selector/sessions/:id/resources", publicRuntimeMutation(runtimeSessionResourceUpload));
+    router.get("/api/runtimes/:selector/sessions/:id/resources/:resourceId", publicRuntimeRead(runtimeSessionResourceMetadata));
+    router.get("/api/runtimes/:selector/sessions/:id/resources/:resourceId/content", publicRuntimeRead(runtimeSessionResourceContent));
+    router.delete("/api/runtimes/:selector/sessions/:id/resources/:resourceId", publicRuntimeMutation(runtimeSessionResourceDelete));
+    router.post("/api/runtimes/:selector/sessions/:id/messages/queue", publicRuntimeMutation(runtimeSessionMessageEnqueue));
     router.post("/api/runtimes/:selector/sessions/:id/terminal/start", publicRuntimeMutation(runtimeSessionTerminalStart));
     router.post("/api/runtimes/:selector/sessions/:id/interactions/:interactionId/resolve", publicRuntimeMutation(runtimeSessionResolveInteraction));
     router.delete("/api/runtimes/:selector/sessions/:id", publicRuntimeMutation(runtimeSessionDelete));
@@ -1374,7 +1802,11 @@ export function createControlRouter(opts) {
     router.get("/api/meta", (ctx) => {
         const meta = {
             channelTypes: deps.listChannelTypes().map((t) => t.type),
+            ...(daemonManagement?.buildStatus
+                ? { daemonBuild: daemonManagement.buildStatus() }
+                : {}),
         };
+        ctx.set("Cache-Control", "no-store");
         ctx.body = meta;
     });
     router.get("/api/plugin-runtime", (ctx) => {
@@ -1398,6 +1830,148 @@ export function createControlRouter(opts) {
             return;
         ctx.body = encodeDaemonStatus(remoteRuntime.status());
     });
+    router.post(DAEMON_SHUTDOWN_IF_IDLE_PATH, (ctx) => {
+        if (!isConfiguredDaemonManagement(daemonManagement) ||
+            !daemonManagement.shutdownIfIdle) {
+            return notFound(ctx, "daemon shutdown management is not configured");
+        }
+        if (!authorizeLoopbackManagementRequest(ctx, daemonManagement.managementToken))
+            return;
+        const result = daemonManagement.shutdownIfIdle();
+        ctx.set("Cache-Control", "no-store");
+        ctx.status = result.outcome === "accepted" ? 202 : 409;
+        ctx.body = result;
+    });
+    router.post(DAEMON_BROWSER_ARTIFACT_INSTALL_PATH, async (ctx) => {
+        await mutateBrowserArtifact(ctx, "install");
+    });
+    router.post(DAEMON_BROWSER_ARTIFACT_UPDATE_PATH, async (ctx) => {
+        await mutateBrowserArtifact(ctx, "update");
+    });
+    router.get(DAEMON_BROWSER_ARTIFACT_VERSION_PATH, (ctx) => {
+        const host = daemonManagement?.browserArtifacts;
+        if (!host || !isConfiguredDaemonManagement(daemonManagement)) {
+            return notFound(ctx, "Browser artifact management is not configured");
+        }
+        if (!authorizeLoopbackManagementRequest(ctx, daemonManagement.managementToken))
+            return;
+        try {
+            ctx.set("Cache-Control", "no-store");
+            ctx.body = host.version();
+        }
+        catch (error) {
+            ctx.status = 409;
+            ctx.body = {
+                error: boundedUtf8(error instanceof Error ? error.message : String(error), BROWSER_ARTIFACT_ERROR_MAX_BYTES),
+            };
+        }
+    });
+    router.post(DAEMON_BROWSER_ARTIFACT_CLEAN_PATH, (ctx) => {
+        const host = daemonManagement?.browserArtifacts;
+        if (!host || !isConfiguredDaemonManagement(daemonManagement)) {
+            return notFound(ctx, "Browser artifact management is not configured");
+        }
+        if (!authorizeLoopbackManagementRequest(ctx, daemonManagement.managementToken))
+            return;
+        try {
+            ctx.set("Cache-Control", "no-store");
+            ctx.body = host.clean();
+        }
+        catch (error) {
+            ctx.status = 409;
+            ctx.body = {
+                error: boundedUtf8(error instanceof Error ? error.message : String(error), BROWSER_ARTIFACT_ERROR_MAX_BYTES),
+            };
+        }
+    });
+    router.get(DAEMON_CHROME_INSPECTION_PATH, async (ctx) => {
+        const host = daemonManagement?.chromeInspection;
+        if (!host || !isConfiguredDaemonManagement(daemonManagement)) {
+            return notFound(ctx, "Chrome inspection management is not configured");
+        }
+        if (!authorizeLoopbackManagementRequest(ctx, daemonManagement.managementToken))
+            return;
+        try {
+            ctx.set("Cache-Control", "no-store");
+            ctx.body = await host.status();
+        }
+        catch (error) {
+            ctx.status = 409;
+            ctx.body = {
+                error: boundedUtf8(error instanceof Error ? error.message : String(error), CHROME_INSPECTION_ERROR_MAX_BYTES),
+            };
+        }
+    });
+    router.put(DAEMON_CHROME_INSPECTION_PATH, async (ctx) => {
+        const host = daemonManagement?.chromeInspection;
+        if (!host || !isConfiguredDaemonManagement(daemonManagement)) {
+            return notFound(ctx, "Chrome inspection management is not configured");
+        }
+        if (!authorizeLoopbackManagementRequest(ctx, daemonManagement.managementToken))
+            return;
+        if (!ctx.is("application/json")) {
+            ctx.status = 415;
+            ctx.body = { error: "Chrome inspection configuration requires application/json" };
+            return;
+        }
+        let input;
+        try {
+            input = parseDaemonChromeInspectionConfigureInput(await readBoundedJson(ctx, CHROME_INSPECTION_BODY_MAX_BYTES));
+        }
+        catch (error) {
+            if (error instanceof RequestBodyTooLargeError) {
+                ctx.status = 413;
+                ctx.body = { error: error.message };
+                return;
+            }
+            return bad(ctx, error instanceof Error ? error.message : String(error));
+        }
+        try {
+            ctx.set("Cache-Control", "no-store");
+            ctx.body = await host.configure(input);
+        }
+        catch (error) {
+            ctx.status = 409;
+            ctx.body = {
+                error: boundedUtf8(error instanceof Error ? error.message : String(error), CHROME_INSPECTION_ERROR_MAX_BYTES),
+            };
+        }
+    });
+    router.post(DAEMON_CLEANUP_SESSIONS_PATH, async (ctx) => {
+        const host = daemonManagement?.maintenance;
+        if (!host || !isConfiguredDaemonManagement(daemonManagement)) {
+            return notFound(ctx, "daemon maintenance is not configured");
+        }
+        if (!authorizeLoopbackManagementRequest(ctx, daemonManagement.managementToken))
+            return;
+        if (!ctx.is("application/json")) {
+            ctx.status = 415;
+            ctx.body = { error: "Session cleanup requires application/json" };
+            return;
+        }
+        let input;
+        try {
+            input = parseDaemonCleanupSessionsInput(await readBoundedJson(ctx, CLEANUP_SESSIONS_BODY_MAX_BYTES));
+        }
+        catch (error) {
+            if (error instanceof RequestBodyTooLargeError) {
+                ctx.status = 413;
+                ctx.body = { error: error.message };
+                return;
+            }
+            return bad(ctx, error instanceof Error ? error.message : String(error));
+        }
+        try {
+            ctx.set("Cache-Control", "no-store");
+            ctx.body = host.cleanupSessions(input);
+        }
+        catch (error) {
+            ctx.status = 409;
+            ctx.body = {
+                error: boundedUtf8(error instanceof Error ? error.message : String(error), BROWSER_ARTIFACT_ERROR_MAX_BYTES),
+            };
+        }
+    });
     router.post("/api/internal/remote-runtime/pairing-offers", async (ctx) => {
         if (!remoteRuntimeAdmin || !isConfiguredDaemonManagement(daemonManagement)) {
             return notFound(ctx, "Remote Runtime administration is not configured");
@@ -1422,6 +1996,165 @@ export function createControlRouter(opts) {
             return;
         revokeRuntimeAccess(ctx);
     });
+    router.delete("/api/internal/remote-runtime/clients/:grantId/record", (ctx) => {
+        if (!remoteRuntimeAdmin || !isConfiguredDaemonManagement(daemonManagement)) {
+            return notFound(ctx, "Remote Runtime administration is not configured");
+        }
+        if (!authorizeLoopbackManagementRequest(ctx, daemonManagement.managementToken))
+            return;
+        deleteRevokedRuntimeAccess(ctx);
+    });
+    router.get("/api/internal/plugins", async (ctx) => {
+        if (!isConfiguredDaemonManagement(daemonManagement) ||
+            !daemonManagement.pluginManagement) {
+            return notFound(ctx, "plugin management is not configured");
+        }
+        if (!authorizeLoopbackManagementRequest(ctx, daemonManagement.managementToken))
+            return;
+        ctx.set("Cache-Control", "no-store");
+        ctx.body = await daemonManagement.pluginManagement.listPlugins();
+    });
+    router.post(PLUGIN_INSTALL_PREPARATIONS_PATH, async (ctx) => {
+        if (!isConfiguredDaemonManagement(daemonManagement) ||
+            !daemonManagement.pluginManagement) {
+            return notFound(ctx, "plugin management is not configured");
+        }
+        if (!authorizeLoopbackManagementRequest(ctx, daemonManagement.managementToken))
+            return;
+        if (!ctx.is("application/json")) {
+            ctx.status = 415;
+            ctx.body = { error: "plugin installation preparation requires application/json" };
+            return;
+        }
+        let input;
+        try {
+            input = parsePluginInstallPrepareInput(await readBoundedJson(ctx, PLUGIN_INSTALL_BODY_MAX_BYTES));
+        }
+        catch (error) {
+            if (error instanceof RequestBodyTooLargeError) {
+                ctx.status = 413;
+                ctx.body = { error: error.message };
+                return;
+            }
+            return bad(ctx, error instanceof Error ? error.message : String(error));
+        }
+        const invocation = pluginInstallInvocationAbortScope(ctx, shutdownSignal);
+        try {
+            ctx.set("Cache-Control", "no-store");
+            ctx.status = 201;
+            ctx.body = await daemonManagement.pluginManagement.prepareInstallation(input, { signal: invocation.signal });
+        }
+        catch (error) {
+            if (!ctx.res.destroyed) {
+                ctx.status = invocation.signal.aborted
+                    ? invocation.signal.reason instanceof Error &&
+                        invocation.signal.reason.name === "TimeoutError"
+                        ? 504
+                        : 499
+                    : 409;
+                ctx.body = {
+                    error: boundedUtf8(error instanceof Error ? error.message : String(error), PLUGIN_INSTALL_ERROR_MAX_BYTES),
+                };
+            }
+        }
+        finally {
+            invocation.dispose();
+        }
+    });
+    router.post(`${PLUGIN_INSTALL_PREPARATIONS_PATH}/:token/commit`, async (ctx) => {
+        if (!isConfiguredDaemonManagement(daemonManagement) ||
+            !daemonManagement.pluginManagement) {
+            return notFound(ctx, "plugin management is not configured");
+        }
+        if (!authorizeLoopbackManagementRequest(ctx, daemonManagement.managementToken))
+            return;
+        const token = ctx.params.token;
+        if (!/^[A-Za-z0-9_-]{32,128}$/.test(token)) {
+            return bad(ctx, "invalid plugin preparation token");
+        }
+        if (!ctx.is("application/json")) {
+            ctx.status = 415;
+            ctx.body = { error: "plugin installation commit requires application/json" };
+            return;
+        }
+        let input;
+        try {
+            input = parsePluginInstallCommitInput(await readBoundedJson(ctx, PLUGIN_INSTALL_BODY_MAX_BYTES));
+        }
+        catch (error) {
+            if (error instanceof RequestBodyTooLargeError) {
+                ctx.status = 413;
+                ctx.body = { error: error.message };
+                return;
+            }
+            return bad(ctx, error instanceof Error ? error.message : String(error));
+        }
+        const invocation = pluginInstallInvocationAbortScope(ctx, shutdownSignal);
+        try {
+            ctx.set("Cache-Control", "no-store");
+            ctx.body = await daemonManagement.pluginManagement.commitInstallation(token, input, { signal: invocation.signal });
+        }
+        catch (error) {
+            if (!ctx.res.destroyed) {
+                ctx.status = invocation.signal.aborted
+                    ? invocation.signal.reason instanceof Error &&
+                        invocation.signal.reason.name === "TimeoutError"
+                        ? 504
+                        : 499
+                    : 409;
+                ctx.body = {
+                    error: boundedUtf8(error instanceof Error ? error.message : String(error), PLUGIN_INSTALL_ERROR_MAX_BYTES),
+                };
+            }
+        }
+        finally {
+            invocation.dispose();
+        }
+    });
+    router.delete(`${PLUGIN_INSTALL_PREPARATIONS_PATH}/:token`, async (ctx) => {
+        if (!isConfiguredDaemonManagement(daemonManagement) ||
+            !daemonManagement.pluginManagement) {
+            return notFound(ctx, "plugin management is not configured");
+        }
+        if (!authorizeLoopbackManagementRequest(ctx, daemonManagement.managementToken))
+            return;
+        const token = ctx.params.token;
+        if (!/^[A-Za-z0-9_-]{32,128}$/.test(token)) {
+            return bad(ctx, "invalid plugin preparation token");
+        }
+        const cancelled = await daemonManagement.pluginManagement.cancelPreparation(token);
+        ctx.set("Cache-Control", "no-store");
+        ctx.body = { cancelled };
+    });
+    router.post("/api/internal/plugins/:pluginId/enable", async (ctx) => {
+        await updateManagedPluginState(ctx, true);
+    });
+    router.post("/api/internal/plugins/:pluginId/disable", async (ctx) => {
+        await updateManagedPluginState(ctx, false);
+    });
+    router.delete("/api/internal/plugins/:pluginId", async (ctx) => {
+        if (!isConfiguredDaemonManagement(daemonManagement) ||
+            !daemonManagement.pluginManagement) {
+            return notFound(ctx, "plugin management is not configured");
+        }
+        if (!authorizeLoopbackManagementRequest(ctx, daemonManagement.managementToken))
+            return;
+        const pluginId = ctx.params.pluginId;
+        if (!/^[a-z][a-z0-9-]{0,62}$/.test(pluginId)) {
+            return bad(ctx, "invalid plugin id");
+        }
+        try {
+            const uninstalled = await daemonManagement.pluginManagement.uninstallPlugin(pluginId);
+            if (!uninstalled)
+                return notFound(ctx, `plugin "${pluginId}" not found`);
+            ctx.set("Cache-Control", "no-store");
+            ctx.body = { uninstalled: true, pluginId };
+        }
+        catch (error) {
+            ctx.status = 409;
+            ctx.body = { error: error instanceof Error ? error.message : String(error) };
+        }
+    });
     router.post("/api/internal/plugins/:pluginId/cli", async (ctx) => {
         if (!isConfiguredDaemonManagement(daemonManagement)) {
             return notFound(ctx, "daemon management is not configured");
@@ -1472,6 +2205,33 @@ export function createControlRouter(opts) {
             invocation.dispose();
         }
     });
+    async function updateManagedPluginState(ctx, enabled) {
+        if (!isConfiguredDaemonManagement(daemonManagement) ||
+            !daemonManagement.pluginManagement) {
+            notFound(ctx, "plugin management is not configured");
+            return;
+        }
+        if (!authorizeLoopbackManagementRequest(ctx, daemonManagement.managementToken))
+            return;
+        const pluginId = ctx.params.pluginId;
+        if (!/^[a-z][a-z0-9-]{0,62}$/.test(pluginId)) {
+            bad(ctx, "invalid plugin id");
+            return;
+        }
+        try {
+            const plugin = await daemonManagement.pluginManagement.setPluginEnabled(pluginId, enabled);
+            if (!plugin) {
+                notFound(ctx, `plugin "${pluginId}" not found`);
+                return;
+            }
+            ctx.set("Cache-Control", "no-store");
+            ctx.body = { plugin };
+        }
+        catch (error) {
+            ctx.status = 409;
+            ctx.body = { error: error instanceof Error ? error.message : String(error) };
+        }
+    }
     router.post("/api/internal/plugin-runtimes/:pluginId/reload", async (ctx) => {
         if (!pluginRuntimeReload || !isConfiguredDaemonManagement(daemonManagement)) {
             return notFound(ctx, "plugin runtime management is not configured");
@@ -2124,7 +2884,7 @@ export function createControlRouter(opts) {
             // when the rollout already exists (the normal single-machine case). The bound
             // thread record is fetched directly — `bound` above is null for console
             // sessions, but a console session still resumes a stored codex thread.
-            if (liveRuntime === "codex" && sessionLog) {
+            if ((liveRuntime === "codex" || liveRuntime === "traex") && sessionLog) {
                 const codexRecord = await sessionStore?.get(id);
                 if (codexRecord?.codexSessionId) {
                     ensureCodexResumeRollout({
@@ -2132,6 +2892,7 @@ export function createControlRouter(opts) {
                         // the SAME id the runner child gets via `RYNX_RUNNER_SESSION`, so the
                         // synthesized rollout lands where that session's app-server reads.
                         sessionId: id,
+                        runtime: liveRuntime,
                         threadId: codexRecord.codexSessionId,
                         cwd: codexRecord.cwd ?? process.cwd(),
                         items: await sessionLog.snapshot(id),
@@ -2553,18 +3314,27 @@ function isConfiguredDaemonManagement(value) {
     return bytes >= 32 && bytes <= 256;
 }
 function pluginCliInvocationAbortScope(ctx, shutdownSignal) {
+    return managementInvocationAbortScope(ctx, shutdownSignal, PLUGIN_CLI_TIMEOUT_MS, "plugin CLI invocation");
+}
+function pluginInstallInvocationAbortScope(ctx, shutdownSignal) {
+    return managementInvocationAbortScope(ctx, shutdownSignal, PLUGIN_INSTALL_OPERATION_TIMEOUT_MS, "plugin installation operation");
+}
+function browserArtifactInvocationAbortScope(ctx, shutdownSignal) {
+    return managementInvocationAbortScope(ctx, shutdownSignal, BROWSER_ARTIFACT_OPERATION_TIMEOUT_MS, "Browser artifact operation");
+}
+function managementInvocationAbortScope(ctx, shutdownSignal, timeoutMs, label) {
     const controller = new AbortController();
     const abort = (reason) => {
         if (!controller.signal.aborted)
             controller.abort(reason);
     };
-    const onRequestAborted = () => abort(namedError("plugin CLI request aborted", "AbortError"));
+    const onRequestAborted = () => abort(namedError(`${label} request aborted`, "AbortError"));
     const onResponseClose = () => {
         if (!ctx.res.writableEnded)
-            abort(namedError("plugin CLI client disconnected", "AbortError"));
+            abort(namedError(`${label} client disconnected`, "AbortError"));
     };
     const onShutdown = () => abort(shutdownSignal?.reason ?? namedError("daemon is shutting down", "AbortError"));
-    const timeout = setTimeout(() => abort(namedError("plugin CLI invocation timed out", "TimeoutError")), PLUGIN_CLI_TIMEOUT_MS);
+    const timeout = setTimeout(() => abort(namedError(`${label} timed out`, "TimeoutError")), timeoutMs);
     timeout.unref?.();
     ctx.req.once("aborted", onRequestAborted);
     ctx.res.once("close", onResponseClose);
@@ -2751,6 +3521,8 @@ function runtimeLocalBrowserError(ctx, error) {
 function runtimeTargetHttpStatus(code) {
     switch (code) {
         case "invalid_offer":
+        case "offer_expired":
+        case "offer_rejected":
         case "invalid_target":
         case "invalid_request":
             return 400;
@@ -2802,6 +3574,34 @@ function publicRuntimeStreamError(error) {
 }
 class RequestBodyTooLargeError extends Error {
 }
+async function readBoundedBinary(ctx, maxBytes) {
+    const declaredLength = Number(ctx.get("content-length"));
+    if (Number.isFinite(declaredLength) && declaredLength > maxBytes) {
+        throw new RequestBodyTooLargeError(`request body exceeds ${maxBytes} bytes`);
+    }
+    const chunks = [];
+    let bytes = 0;
+    let tooLarge = false;
+    await new Promise((resolve, reject) => {
+        ctx.req.on("data", (chunk) => {
+            const data = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            bytes += data.byteLength;
+            if (bytes > maxBytes) {
+                tooLarge = true;
+                chunks.length = 0;
+                return;
+            }
+            if (!tooLarge)
+                chunks.push(data);
+        });
+        ctx.req.once("end", resolve);
+        ctx.req.once("error", reject);
+    });
+    if (tooLarge) {
+        throw new RequestBodyTooLargeError(`request body exceeds ${maxBytes} bytes`);
+    }
+    return Buffer.concat(chunks, bytes);
+}
 async function readBoundedJson(ctx, maxBytes) {
     const declaredLength = Number(ctx.get("content-length"));
     if (Number.isFinite(declaredLength) && declaredLength > maxBytes) {