@neuralnomads/codenomad-dev 0.18.0-dev-20260716-40cee071 → 0.18.0-dev-20260720-4c50829d

package/dist/server/__tests__/remote-proxy.test.js

@@ -8,27 +8,20 @@ import { Agent, fetch } from "undici";
 import { RemoteProxySessionManager } from "../remote-proxy";
 import { resolveHttpsOptions } from "../tls";
 const sharedTempDir = fs.mkdtempSync(path.join(os.tmpdir(), "codenomad-remote-proxy-test-"));
-const sharedTls = resolveHttpsOptions({
-    enabled: true,
-    configDir: sharedTempDir,
-    host: "127.0.0.1",
-    logger: createStubLogger(),
-});
-if (!sharedTls) {
+const sharedTls = resolveHttpsOptions({ enabled: true, configDir: sharedTempDir, host: "127.0.0.1", logger: createStubLogger() });
+if (!sharedTls)
     throw new Error("Failed to generate HTTPS options for remote proxy tests");
-}
 const sharedHttpsOptions = sharedTls.httpsOptions;
 const httpsDispatcher = new Agent({ connect: { rejectUnauthorized: false } });
 const managers = new Set();
 afterEach(async () => {
-    for (const manager of managers) {
-        await disposeManager(manager);
-    }
+    for (const manager of managers)
+        await manager.shutdown().catch(() => undefined);
     managers.clear();
 });
-after(() => {
+after(async () => {
     fs.rmSync(sharedTempDir, { recursive: true, force: true });
-    httpsDispatcher.close().catch(() => { });
+    await httpsDispatcher.destroy().catch(() => { });
 });
 describe("RemoteProxySessionManager", () => {
     it("blocks proxying before activation and keeps bootstrap tokens scoped per session", async () => {
@@ -66,8 +59,7 @@ describe("RemoteProxySessionManager", () => {
             const requestUrl = req.url ?? "";
             if (requestUrl === "/base/redirect") {
                 res.writeHead(302, { location: "/base/after?ok=1" });
-                res.end();
-                return;
+                return res.end();
             }
             res.writeHead(200, { "content-type": "text/plain" });
             res.end(requestUrl);
@@ -95,13 +87,11 @@ describe("RemoteProxySessionManager", () => {
                     "content-type": "text/plain",
                     "set-cookie": "session=abc123; Path=/; Secure; HttpOnly; Domain=127.0.0.1",
                 });
-                res.end("ok");
-                return;
+                return res.end("ok");
             }
             if (requestUrl === "/base/whoami") {
                 res.writeHead(200, { "content-type": "text/plain" });
-                res.end(req.headers.cookie ?? "");
-                return;
+                return res.end(req.headers.cookie ?? "");
             }
             res.writeHead(404, { "content-type": "text/plain" });
             res.end(requestUrl);
@@ -116,7 +106,7 @@ describe("RemoteProxySessionManager", () => {
             const session3 = await createSession(manager, `${upstreamBaseUrl}/base`);
             const internalSessions = manager.sessions;
             const internalCleanup = manager.cleanupExpiredSessions;
-            internalSessions.get(session3.sessionId).lastAccessAt = Date.now() - 31 * 60000;
+            internalSessions.get(session3.sessionId).lastAccessAt = Date.now() - 31 * 60_000;
             await internalCleanup.call(manager);
             assert.equal(internalSessions.has(session3.sessionId), false);
             assert.equal(await manager.deleteSession(session3.sessionId), false);
@@ -139,7 +129,7 @@ describe("RemoteProxySessionManager", () => {
     });
     it("waits for in-flight idle cleanup during shutdown", async () => {
         await withUpstreamServer(async (upstreamBaseUrl) => {
-            const manager = createSessionManager({ disposalTimeoutMs: 1000 });
+            const manager = createSessionManager({ disposalTimeoutMs: 1_000 });
             const session = await createSession(manager, `${upstreamBaseUrl}/base`);
             const internalSession = manager.sessions.get(session.sessionId);
             const closeGate = deferred();
@@ -148,9 +138,8 @@ describe("RemoteProxySessionManager", () => {
                 await closeGate.promise;
                 return originalClose();
             };
-            internalSession.lastAccessAt = Date.now() - 31 * 60000;
+            internalSession.lastAccessAt = Date.now() - 31 * 60_000;
             const cleanup = manager.cleanupExpiredSessions();
-            assert.equal(manager.pendingDisposals.size, 1);
             let shutdownSettled = false;
             const shutdown = manager.shutdown().then(() => {
                 shutdownSettled = true;
@@ -160,7 +149,7 @@ describe("RemoteProxySessionManager", () => {
             closeGate.resolve();
             await cleanup;
             await shutdown;
-            assert.equal(manager.pendingDisposals.size, 0);
+            assert.equal(manager.disposals.size, 0);
         }, (_req, res) => {
             res.writeHead(200).end("ok");
         });
@@ -177,12 +166,11 @@ describe("RemoteProxySessionManager", () => {
                 new Promise((_resolve, reject) => setTimeout(() => reject(new Error("shutdown stalled")), 500)),
             ]);
             assert.equal(manager.sessions.size, 0);
-            assert.equal(manager.pendingDisposals.size, 0);
+            assert.equal(manager.disposals.size, 0);
         }, (req, res) => {
             if (req.url === "/base/events") {
                 res.writeHead(200, { "content-type": "text/event-stream" });
-                res.write("data: connected\n\n");
-                return;
+                return void res.write("data: connected\n\n");
             }
             res.writeHead(200).end("ok");
         });
@@ -193,12 +181,18 @@ describe("RemoteProxySessionManager", () => {
             const session = await createSession(manager, `${upstreamBaseUrl}/base`);
             const internalSession = manager.sessions.get(session.sessionId);
             const originalClose = internalSession.app.close.bind(internalSession.app);
+            let failClose = true;
             internalSession.app.close = async () => {
                 await originalClose();
-                throw new Error("close failed");
+                if (failClose) {
+                    failClose = false;
+                    throw new Error("close failed");
+                }
             };
             await assert.rejects(manager.deleteSession(session.sessionId), /Remote proxy disposal failed/);
-            await assert.rejects(manager.shutdown(), /Remote proxy shutdown failed/);
+            // A completed deletion failure predating shutdown must not poison it.
+            await manager.shutdown();
+            assert.equal(manager.sessions.size, 0);
         }, (_req, res) => {
             res.writeHead(200).end("ok");
         });
@@ -210,31 +204,58 @@ describe("RemoteProxySessionManager", () => {
             const shutdown = manager.shutdown();
             await assert.rejects(creation, /shutting down/);
             await shutdown;
-            assert.equal(manager.pendingCreations.size, 0);
+            assert.equal(manager.creations.size, 0);
             assert.equal(manager.sessions.size, 0);
             await assert.rejects(manager.createSession(`${upstreamBaseUrl}/base`, false), /shutting down/);
         }, (_req, res) => {
             res.writeHead(200).end("ok");
         });
     });
+    it("coalesces shutdown, retains current disposal failures, and gives every session its own agent", async () => {
+        await withUpstreamServer(async (upstreamBaseUrl) => {
+            const manager = createSessionManager();
+            const verified = await manager.createSession(`${upstreamBaseUrl}/verified`, false);
+            const insecure = await manager.createSession(`${upstreamBaseUrl}/insecure`, true);
+            const sessions = manager.sessions;
+            assert.ok(sessions.get(verified.sessionId).dispatcher instanceof Agent);
+            assert.ok(sessions.get(insecure.sessionId).dispatcher instanceof Agent);
+            assert.notStrictEqual(sessions.get(verified.sessionId).dispatcher, sessions.get(insecure.sessionId).dispatcher);
+            const closeGate = deferred();
+            const originalClose = sessions.get(verified.sessionId).app.close.bind(sessions.get(verified.sessionId).app);
+            let failClose = true;
+            sessions.get(verified.sessionId).app.close = async () => {
+                await closeGate.promise;
+                await originalClose();
+                if (failClose) {
+                    failClose = false;
+                    throw new Error("current close failed");
+                }
+            };
+            const disposal = manager.deleteSession(verified.sessionId);
+            const first = manager.shutdown();
+            const concurrent = manager.shutdown();
+            assert.strictEqual(first, concurrent);
+            closeGate.resolve();
+            await assert.rejects(disposal, /Remote proxy disposal failed/);
+            await assert.rejects(first, (error) => error instanceof AggregateError && error.errors.some((cause) => cause instanceof AggregateError && cause.errors.some((nested) => /current close failed/.test(String(nested)))));
+            await manager.shutdown();
+            assert.equal(sessions.size, 0);
+        }, (_req, res) => {
+            res.writeHead(200).end("ok");
+        });
+    });
 });
 function createSessionManager(options = {}) {
     const manager = new RemoteProxySessionManager({
-        authManager: {
-            isLoopbackRequest: () => true,
-        },
-        logger: createStubLogger(),
-        httpsOptions: sharedHttpsOptions,
-        ...options,
+        authManager: { isLoopbackRequest: () => true },
+        logger: createStubLogger(), httpsOptions: sharedHttpsOptions, ...options,
     });
     managers.add(manager);
     return manager;
 }
 function deferred() {
     let resolve;
-    const promise = new Promise((resolvePromise) => {
-        resolve = resolvePromise;
-    });
+    const promise = new Promise((resolvePromise) => { resolve = resolvePromise; });
     return { promise, resolve };
 }
 async function createSession(manager, baseUrl) {
@@ -253,34 +274,28 @@ async function activateSession(session) {
         headers: { "content-type": "application/json" },
         body: JSON.stringify({ token: session.token }),
     });
-    if (!response.ok) {
+    if (!response.ok)
         return false;
-    }
     const body = (await response.json());
     return body.ok === true;
 }
 function getSetCookie(response) {
     const values = response.headers.getSetCookie?.();
-    if (Array.isArray(values) && values.length > 0) {
+    if (Array.isArray(values) && values.length > 0)
         return values;
-    }
     const fallback = response.headers.get("set-cookie");
     return fallback ? [fallback] : [];
 }
 async function proxyFetch(url, init) {
     return fetch(url, { dispatcher: httpsDispatcher, ...init });
 }
-async function disposeManager(manager) {
-    await manager.shutdown().catch(() => undefined);
-}
 async function withUpstreamServer(callback, handler) {
     const server = http.createServer(handler);
     await new Promise((resolve) => server.listen(0, "127.0.0.1", () => resolve()));
     try {
         const address = server.address();
-        if (!address || typeof address === "string") {
+        if (!address || typeof address === "string")
             throw new Error("Failed to resolve upstream server address");
-        }
         await callback(`http://127.0.0.1:${address.port}`);
     }
     finally {
@@ -288,13 +303,6 @@ async function withUpstreamServer(callback, handler) {
     }
 }
 function createStubLogger() {
-    const logger = {
-        info() { },
-        warn() { },
-        error() { },
-        child() {
-            return logger;
-        },
-    };
+    const logger = { info() { }, warn() { }, error() { }, child() { return logger; } };
     return logger;
 }

package/dist/server/http-server.js

@@ -19,16 +19,16 @@ import { registerBackgroundProcessRoutes } from "./routes/background-processes";
 import { registerYoloRoutes } from "./routes/yolo";
 import { registerWorktreeRoutes } from "./routes/worktrees";
 import { registerSpeechRoutes } from "./routes/speech";
+import { registerOpenCodeUpdateRoutes } from "./routes/opencode-update";
 import { registerRemoteServerRoutes } from "./routes/remote-servers";
 import { registerRemoteProxyRoutes } from "./routes/remote-proxy";
 import { registerSideCarRoutes } from "./routes/sidecars";
 import { registerPreviewRoutes } from "./routes/previews";
 import { registerUsageRoutes } from "./routes/usage";
 import { BackgroundProcessManager } from "../background-processes/manager";
-import { AutoAcceptManager } from "../permissions/auto-accept-manager";
-import { createOpencodePermissionReplier } from "../permissions/opencode-replier";
 import { registerAuthRoutes } from "./routes/auth";
 import { sendUnauthorized, wantsHtml } from "../auth/http-auth";
+import { createOpenCodeUpdateService } from "../opencode-update/service";
 export function createHttpServer(deps) {
     // Fastify's type-level RawServer inference gets noisy when toggling HTTP vs HTTPS.
     // We keep the runtime behavior correct and cast the instance to a generic FastifyInstance.
@@ -59,7 +59,7 @@ export function createHttpServer(deps) {
     });
     app.addHook("onResponse", (request, reply, done) => {
         const meta = request.__logMeta;
-        const durationMs = meta ? Number((process.hrtime.bigint() - meta.start) / BigInt(1000000)) : undefined;
+        const durationMs = meta ? Number((process.hrtime.bigint() - meta.start) / BigInt(1_000_000)) : undefined;
         const base = {
             method: request.method,
             url: request.url,
@@ -135,15 +135,6 @@ export function createHttpServer(deps) {
         eventBus: deps.eventBus,
         logger: deps.logger.child({ component: "background-processes" }),
     });
-    const yoloManager = new AutoAcceptManager({
-        eventBus: deps.eventBus,
-        logger: deps.logger.child({ component: "yolo" }),
-        replier: createOpencodePermissionReplier({
-            workspaceManager: deps.workspaceManager,
-            logger: deps.logger.child({ component: "yolo" }),
-        }),
-    });
-    yoloManager.start();
     registerAuthRoutes(app, { authManager: deps.authManager });
     app.addHook("preHandler", (request, reply, done) => {
         const rawUrl = request.raw.url ?? request.url;
@@ -205,6 +196,10 @@ export function createHttpServer(deps) {
     });
     registerWorkspaceRoutes(app, { workspaceManager: deps.workspaceManager });
     registerSettingsRoutes(app, { settings: deps.settings, logger: apiLogger });
+    registerOpenCodeUpdateRoutes(app, {
+        service: createOpenCodeUpdateService(deps.settings, deps.workspaceManager),
+        logger: apiLogger,
+    });
     registerFilesystemRoutes(app, { fileSystemBrowser: deps.fileSystemBrowser });
     registerConfigFileRoutes(app);
     registerMetaRoutes(app, { serverMeta: deps.serverMeta });
@@ -214,7 +209,10 @@ export function createHttpServer(deps) {
         logger: sseLogger,
         connectionManager: deps.clientConnectionManager,
     });
-    registerWorktreeRoutes(app, { workspaceManager: deps.workspaceManager });
+    registerWorktreeRoutes(app, {
+        workspaceManager: deps.workspaceManager,
+        sessionMetadataPersistence: deps.sessionMetadataPersistence,
+    });
     registerStorageRoutes(app, {
         instanceStore: deps.instanceStore,
         eventBus: deps.eventBus,
@@ -246,7 +244,7 @@ export function createHttpServer(deps) {
         voiceModeManager: deps.voiceModeManager,
     });
     registerBackgroundProcessRoutes(app, { backgroundProcessManager });
-    registerYoloRoutes(app, { yoloManager });
+    registerYoloRoutes(app, { yoloManager: deps.yoloManager });
     registerInstanceProxyRoutes(app, { workspaceManager: deps.workspaceManager, logger: proxyLogger });
     if (deps.uiDevServerUrl) {
         setupDevProxy(app, deps.uiDevServerUrl, deps.authManager, deps.previewManager, proxyLogger);
@@ -302,7 +300,6 @@ export function createHttpServer(deps) {
             return { port: actualPort, url: serverUrl, displayHost };
         },
         stop: () => {
-            yoloManager.stop();
             closeSseClients();
             return app.close();
         },

package/dist/server/remote-proxy.js

@@ -6,36 +6,23 @@ import { Agent, fetch } from "undici";
 const LOOPBACK_HOST = "127.0.0.1";
 const BOOTSTRAP_PAGE_PATH = "/__codenomad/auth/token";
 const BOOTSTRAP_EXCHANGE_PATH = "/__codenomad/api/auth/token";
-const SESSION_IDLE_TTL_MS = 30 * 60000;
-const SESSION_DISPOSAL_TIMEOUT_MS = 5000;
+const SESSION_IDLE_TTL_MS = 30 * 60_000;
+const SESSION_DISPOSAL_TIMEOUT_MS = 5_000;
 export class RemoteProxySessionManager {
     constructor(options) {
         this.options = options;
         this.sessions = new Map();
-        this.pendingCreations = new Set();
-        this.pendingDisposals = new Set();
-        this.disposalFailures = [];
+        this.creations = new Set();
+        this.disposals = new Set();
+        this.sessionDisposals = new Map();
         this.shuttingDown = false;
-        this.disposalTimeoutMs = Math.max(1, options.disposalTimeoutMs ?? SESSION_DISPOSAL_TIMEOUT_MS);
-        this.cleanupTimer = setInterval(() => {
-            void this.cleanupExpiredSessions().catch((error) => {
-                this.options.logger.error({ err: error }, "Failed to dispose expired remote proxy session");
-            });
-        }, 60000);
+        this.cleanupTimer = setInterval(() => void this.cleanupExpiredSessions().catch((error) => this.options.logger.error({ err: error }, "Failed to dispose expired remote proxy session")), 60_000);
         this.cleanupTimer.unref();
     }
     async createSession(baseUrl, skipTlsVerify) {
-        if (this.shuttingDown) {
+        if (this.shuttingDown)
             throw new Error("Remote proxy session manager is shutting down");
-        }
-        const creation = this.createSessionInternal(baseUrl, skipTlsVerify);
-        this.pendingCreations.add(creation);
-        try {
-            return await creation;
-        }
-        finally {
-            this.pendingCreations.delete(creation);
-        }
+        return this.track(this.creations, this.createSessionInternal(baseUrl, skipTlsVerify));
     }
     async createSessionInternal(baseUrl, skipTlsVerify) {
         if (!this.options.httpsOptions) {
@@ -79,7 +66,7 @@ export class RemoteProxySessionManager {
             session.lastAccessAt = Date.now();
             reply.send({ ok: true });
         });
-        app.all("/*", async (request, reply) => {
+        const handleProxyRequest = async (request, reply) => {
             if (!session) {
                 reply.code(503).send({ error: "Remote proxy session is unavailable" });
                 return;
@@ -90,78 +77,64 @@ export class RemoteProxySessionManager {
             }
             session.lastAccessAt = Date.now();
             await proxyRequest({ request, reply, session, logger: this.options.logger });
-        });
-        app.setNotFoundHandler(async (request, reply) => {
-            if (!session) {
-                reply.code(503).send({ error: "Remote proxy session is unavailable" });
-                return;
-            }
-            if (!session.activated) {
-                reply.code(403).send({ error: "Remote proxy session is not activated" });
-                return;
-            }
-            session.lastAccessAt = Date.now();
-            await proxyRequest({ request, reply, session, logger: this.options.logger });
-        });
+        };
+        app.all("/*", handleProxyRequest);
+        app.setNotFoundHandler(handleProxyRequest);
         const addressInfo = await app.listen({ host: LOOPBACK_HOST, port: 0 });
-        if (this.shuttingDown) {
-            abortController.abort();
-            try {
-                await this.disposeResources(app, dispatcher);
-            }
-            catch (error) {
-                this.disposalFailures.push(error);
-                throw error;
-            }
-            throw new Error("Remote proxy session manager is shutting down");
-        }
         const address = new URL(addressInfo);
         const localBaseUrl = new URL(`https://${LOOPBACK_HOST}:${address.port}`);
         const entryUrl = new URL(targetBaseUrl.pathname || "/", localBaseUrl);
         const returnTo = buildReturnToTarget(entryUrl);
+        const bootstrapUrl = `${localBaseUrl.origin}${BOOTSTRAP_PAGE_PATH}?returnTo=${encodeURIComponent(returnTo)}#${encodeURIComponent(bootstrapToken)}`;
         session = {
             id: sessionId,
             bootstrapToken,
             targetBaseUrl,
-            skipTlsVerify,
             localBaseUrl,
-            entryUrl,
-            bootstrapUrl: `${localBaseUrl.origin}${BOOTSTRAP_PAGE_PATH}?returnTo=${encodeURIComponent(returnTo)}#${encodeURIComponent(bootstrapToken)}`,
             activated: false,
             cookiePrefix: `cnrp_${randomBytes(6).toString("hex")}_`,
             app,
             dispatcher,
             abortController,
-            createdAt: Date.now(),
             lastAccessAt: Date.now(),
         };
         this.sessions.set(sessionId, session);
+        if (this.shuttingDown) {
+            await this.disposeSession(sessionId);
+            throw new Error("Remote proxy session manager is shutting down");
+        }
         this.options.logger.info({ sessionId, targetBaseUrl: targetBaseUrl.toString(), localBaseUrl: localBaseUrl.toString() }, "Created remote proxy session");
-        return { sessionId, windowUrl: session.bootstrapUrl };
+        return { sessionId, windowUrl: bootstrapUrl };
     }
     async deleteSession(sessionId) {
         return this.disposeSession(sessionId);
     }
-    async shutdown() {
+    shutdown() {
+        if (this.shutdownPromise)
+            return this.shutdownPromise;
         this.shuttingDown = true;
         clearInterval(this.cleanupTimer);
-        const disposals = new Set(this.pendingDisposals);
-        await Promise.allSettled(Array.from(this.pendingCreations));
-        for (const sessionId of this.sessions.keys())
-            disposals.add(this.disposeSession(sessionId));
-        while (this.pendingDisposals.size > 0) {
-            const pending = Array.from(this.pendingDisposals);
-            for (const disposal of pending)
+        const shutdown = this.drainShutdown();
+        this.shutdownPromise = shutdown;
+        void shutdown.finally(() => {
+            if (this.shutdownPromise === shutdown)
+                this.shutdownPromise = undefined;
+        }).catch(() => undefined);
+        return shutdown;
+    }
+    async drainShutdown() {
+        const disposals = new Set(this.disposals);
+        while (this.creations.size > 0) {
+            await Promise.allSettled([...this.creations]);
+            for (const disposal of this.disposals)
                 disposals.add(disposal);
-            await Promise.allSettled(pending);
         }
-        const results = await Promise.allSettled(disposals);
-        const failures = [
-            ...this.disposalFailures,
-            ...results.flatMap((result) => result.status === "rejected" ? [result.reason] : []),
-        ];
-        if (failures.length > 0)
-            throw createDisposalError("Remote proxy shutdown failed", failures);
+        const pendingResults = await Promise.allSettled(disposals);
+        const results = await Promise.allSettled(Array.from(this.sessions.keys(), (id) => this.disposeSession(id)));
+        const failures = [...pendingResults, ...results]
+            .flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+        if (failures.length)
+            throw new AggregateError(failures, "Remote proxy shutdown failed");
     }
     async cleanupExpiredSessions() {
         const now = Date.now();
@@ -173,48 +146,45 @@ export class RemoteProxySessionManager {
         }
     }
     disposeSession(sessionId) {
+        const pending = this.sessionDisposals.get(sessionId);
+        if (pending)
+            return pending;
         const session = this.sessions.get(sessionId);
-        if (!session) {
+        if (!session)
             return Promise.resolve(false);
-        }
-        this.sessions.delete(sessionId);
         session.abortController.abort();
-        const disposal = this.disposeResources(session.app, session.dispatcher)
-            .then(() => {
+        const disposal = this.trackDisposal(this.disposeResources(session.app, session.dispatcher).then(() => {
+            if (this.sessions.get(sessionId) === session)
+                this.sessions.delete(sessionId);
             this.options.logger.info({ sessionId }, "Disposed remote proxy session");
             return true;
-        })
-            .catch((error) => {
-            this.disposalFailures.push(error);
-            throw error;
-        });
-        this.pendingDisposals.add(disposal);
-        void disposal.then(() => this.pendingDisposals.delete(disposal), () => this.pendingDisposals.delete(disposal));
+        }));
+        this.sessionDisposals.set(sessionId, disposal);
+        void disposal.finally(() => {
+            if (this.sessionDisposals.get(sessionId) === disposal)
+                this.sessionDisposals.delete(sessionId);
+        }).catch(() => undefined);
         return disposal;
     }
     async disposeResources(app, dispatcher) {
         app.server.closeAllConnections?.();
-        const disposal = Promise.allSettled([app.close(), dispatcher.destroy()]);
-        let timeout;
-        const deadline = new Promise((_resolve, reject) => {
-            timeout = setTimeout(() => reject(new Error(`Remote proxy disposal timed out after ${this.disposalTimeoutMs}ms`)), this.disposalTimeoutMs);
-            timeout.unref();
-        });
-        try {
-            const results = await Promise.race([disposal, deadline]);
-            const failures = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
-            if (failures.length > 0)
-                throw createDisposalError("Remote proxy disposal failed", failures);
-        }
-        finally {
-            if (timeout)
-                clearTimeout(timeout);
-        }
+        const results = await Promise.race([
+            Promise.allSettled([app.close(), dispatcher?.destroy()]),
+            new Promise((_resolve, reject) => AbortSignal.timeout(Math.max(1, this.options.disposalTimeoutMs ?? SESSION_DISPOSAL_TIMEOUT_MS)).addEventListener("abort", () => reject(new Error("Remote proxy disposal timed out")))),
+        ]);
+        const failures = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+        if (failures.length)
+            throw new AggregateError(failures, "Remote proxy disposal failed");
+    }
+    track(operations, operation) {
+        operations.add(operation);
+        void operation.finally(() => operations.delete(operation)).catch(() => undefined);
+        return operation;
+    }
+    trackDisposal(operation) {
+        return this.track(this.disposals, operation);
     }
 }
-function createDisposalError(message, failures) {
-    return Object.assign(new Error(message), { failures });
-}
 function normalizeBaseUrl(input) {
     const parsed = new URL(input.trim());
     if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {

package/dist/server/routes/opencode-update.js

@@ -0,0 +1,37 @@
+import { OpenCodeUpdateError } from "../../opencode-update/service";
+function statusCode(error) {
+    if (error.code === "no_ready_instance")
+        return 409;
+    if (error.code === "binary_unavailable")
+        return 422;
+    return 502;
+}
+function requestError(error, fallback) {
+    if (error instanceof OpenCodeUpdateError)
+        return { status: statusCode(error), code: error.code };
+    return { status: 500, code: fallback };
+}
+export function registerOpenCodeUpdateRoutes(app, deps) {
+    app.get("/api/opencode/update", async (_request, reply) => {
+        try {
+            return await deps.service.getStatus();
+        }
+        catch (error) {
+            deps.logger.warn({ err: error }, "Failed to check OpenCode update status");
+            const failure = requestError(error, "update_check_failed");
+            reply.code(failure.status);
+            return { error: failure.code };
+        }
+    });
+    app.post("/api/opencode/update", async (_request, reply) => {
+        try {
+            return await deps.service.upgrade();
+        }
+        catch (error) {
+            deps.logger.warn({ err: error }, "Failed to update OpenCode");
+            const failure = requestError(error, "upgrade_failed");
+            reply.code(failure.status);
+            return { success: false, error: failure.code };
+        }
+    });
+}

package/dist/server/routes/opencode-update.test.js

@@ -0,0 +1,34 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import Fastify from "fastify";
+import { registerOpenCodeUpdateRoutes } from "./opencode-update";
+test("does not pass request-controlled binary paths to the update service", async () => {
+    const calls = [];
+    const service = {
+        getStatus: async (...args) => {
+            calls.push({ method: "status", args });
+            return {
+                currentVersion: "1.0.0",
+                latestVersion: "1.1.0",
+                updateAvailable: true,
+                canUpgrade: true,
+            };
+        },
+        upgrade: async (...args) => {
+            calls.push({ method: "upgrade", args });
+            return { success: true, version: "1.1.0" };
+        },
+    };
+    const app = Fastify();
+    registerOpenCodeUpdateRoutes(app, {
+        service,
+        logger: { warn() { } },
+    });
+    await app.inject({ method: "GET", url: "/api/opencode/update?binary=untrusted.cmd" });
+    await app.inject({ method: "POST", url: "/api/opencode/update", payload: { binary: "untrusted.cmd" } });
+    assert.deepEqual(calls, [
+        { method: "status", args: [] },
+        { method: "upgrade", args: [] },
+    ]);
+    await app.close();
+});

package/dist/server/routes/remote-servers.js

@@ -4,7 +4,7 @@ const ProbeSchema = z.object({
     baseUrl: z.string().min(1),
     skipTlsVerify: z.boolean().optional(),
 });
-const PROBE_TIMEOUT_MS = 8000;
+const PROBE_TIMEOUT_MS = 8_000;
 export function registerRemoteServerRoutes(app, deps) {
     app.post("/api/remote-servers/probe", async (request, reply) => {
         try {