@neuralnomads/codenomad-dev 0.18.0-dev-20260716-40cee071 → 0.18.0-dev-20260718-8f6aa44b

package/dist/auth/manager.js

@@ -26,7 +26,7 @@ export class AuthManager {
             password: init.password,
             allowBootstrapWithoutPassword: init.generateToken,
         });
-        this.tokenManager = init.generateToken ? new TokenManager(60000) : null;
+        this.tokenManager = init.generateToken ? new TokenManager(60_000) : null;
     }
     isAuthEnabled() {
         return this.authEnabled;

package/dist/filesystem/__tests__/search-cache.test.js

@@ -7,7 +7,7 @@ describe("workspace search cache", () => {
     });
     it("expires cached candidates after the TTL", () => {
         const workspacePath = "/tmp/workspace";
-        const startTime = 1000;
+        const startTime = 1_000;
         refreshWorkspaceCandidates(workspacePath, () => [createEntry("file-a")], startTime);
         const beforeExpiry = getWorkspaceCandidates(workspacePath, startTime + WORKSPACE_CANDIDATE_CACHE_TTL_MS - 1);
         assert.ok(beforeExpiry);
@@ -18,12 +18,12 @@ describe("workspace search cache", () => {
     });
     it("replaces cached entries when manually refreshed", () => {
         const workspacePath = "/tmp/workspace";
-        refreshWorkspaceCandidates(workspacePath, () => [createEntry("file-a")], 5000);
-        const initial = getWorkspaceCandidates(workspacePath, 5001);
+        refreshWorkspaceCandidates(workspacePath, () => [createEntry("file-a")], 5_000);
+        const initial = getWorkspaceCandidates(workspacePath, 5_001);
         assert.ok(initial);
         assert.equal(initial[0].name, "file-a");
-        refreshWorkspaceCandidates(workspacePath, () => [createEntry("file-b")], 6000);
-        const refreshed = getWorkspaceCandidates(workspacePath, 6001);
+        refreshWorkspaceCandidates(workspacePath, () => [createEntry("file-b")], 6_000);
+        const refreshed = getWorkspaceCandidates(workspacePath, 6_001);
         assert.ok(refreshed);
         assert.equal(refreshed[0].name, "file-b");
     });

package/dist/filesystem/search-cache.js

@@ -1,5 +1,5 @@
 import path from "path";
-export const WORKSPACE_CANDIDATE_CACHE_TTL_MS = 30000;
+export const WORKSPACE_CANDIDATE_CACHE_TTL_MS = 30_000;
 const workspaceCandidateCache = new Map();
 export function getWorkspaceCandidates(rootDir, now = Date.now()) {
     const key = normalizeKey(rootDir);

package/dist/index.js

@@ -41,10 +41,29 @@ const DEFAULT_HOST = "127.0.0.1";
 const DEFAULT_CONFIG_PATH = "~/.config/codenomad/config.json";
 const DEFAULT_HTTPS_PORT = 9898;
 const DEFAULT_HTTP_PORT = 9899;
+export const STDIN_SHUTDOWN_COMMAND = "codenomad:shutdown";
 export function installShutdownSignalHandlers(source, shutdown) {
     source.on("SIGINT", () => void shutdown("SIGINT"));
     source.on("SIGTERM", () => void shutdown("SIGTERM"));
 }
+export function installShutdownStdinHandler(source, shutdown) {
+    let buffer = "";
+    let requested = false;
+    const onData = (chunk) => {
+        if (requested)
+            return;
+        buffer += chunk.toString();
+        const lines = buffer.split(/\r?\n/);
+        buffer = lines.pop() ?? "";
+        if (!lines.some((line) => line.trim() === STDIN_SHUTDOWN_COMMAND))
+            return;
+        requested = true;
+        source.off?.("data", onData);
+        source.destroy?.();
+        void shutdown("stdin");
+    };
+    source.on("data", onData);
+}
 function parseCliOptions(argv) {
     const program = new Command()
         .name("codenomad")
@@ -431,6 +450,11 @@ async function main() {
     }
     const shutdown = createServerShutdownHandler({
         logger,
+        holdAfterFailure: () => new Promise(() => { setInterval(() => undefined, 60_000); }),
+        setExitCode: (code) => {
+            process.stdin.destroy();
+            process.exitCode = code;
+        },
         shutdown: () => orchestrateServerShutdown({
             stopInstanceEventBridge: () => instanceEventBridge.shutdown(),
             stopSidecars: () => sidecarManager.shutdown(),
@@ -451,6 +475,7 @@ async function main() {
         }, logger),
     });
     installShutdownSignalHandlers(process, shutdown);
+    installShutdownStdinHandler(process.stdin, shutdown);
 }
 if (path.resolve(process.argv[1] ?? "") === __filename) {
     main().catch((error) => {

package/dist/index.test.js

@@ -1,6 +1,8 @@
 import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import { once } from "node:events";
 import { describe, it } from "node:test";
-import { installShutdownSignalHandlers } from "./index";
+import { installShutdownSignalHandlers, installShutdownStdinHandler, STDIN_SHUTDOWN_COMMAND } from "./index";
 import { createServerShutdownHandler } from "./shutdown";
 describe("CLI shutdown signal registration", () => {
     it("routes a second process signal to forced nonzero escalation", async () => {
@@ -10,23 +12,51 @@ describe("CLI shutdown signal registration", () => {
             finishCleanup = resolve;
         });
         const exits = [];
+        let handled;
         const shutdown = createServerShutdownHandler({
             shutdown: () => cleanup,
-            logger: {
-                info: () => undefined,
-                warn: () => undefined,
-                error: () => undefined,
-            },
+            logger: { info() { }, warn() { }, error() { } },
             forceExit: (code) => exits.push(code),
             setExitCode: () => undefined,
+            reportStatus: () => undefined,
         });
-        installShutdownSignalHandlers({
-            on: (signal, listener) => listeners.set(signal, listener),
-        }, shutdown);
+        installShutdownSignalHandlers({ on: (signal, listener) => listeners.set(signal, listener) }, (signal) => (handled = shutdown(signal)));
         listeners.get("SIGINT")?.();
         listeners.get("SIGTERM")?.();
         assert.deepEqual(exits, [1]);
         finishCleanup();
-        await cleanup;
+        await handled;
+    });
+    it("coalesces chunked and repeated stdin shutdown commands through the same handler", async () => {
+        const listeners = new Map();
+        const triggers = [];
+        let destroys = 0;
+        const source = {
+            on: (event, listener) => listeners.set(event, listener),
+            off: (event, listener) => {
+                if (listeners.get(event) === listener)
+                    listeners.delete(event);
+            },
+            destroy: () => { destroys++; },
+        };
+        installShutdownStdinHandler(source, async (trigger) => { triggers.push(trigger); });
+        const listener = listeners.get("data");
+        listener(STDIN_SHUTDOWN_COMMAND.slice(0, 8));
+        listener(`${STDIN_SHUTDOWN_COMMAND.slice(8)}\n${STDIN_SHUTDOWN_COMMAND}\n`);
+        listener(`${STDIN_SHUTDOWN_COMMAND}\n`);
+        await Promise.resolve();
+        assert.deepEqual(triggers, ["stdin"]);
+        assert.equal(destroys, 1);
+        assert.equal(listeners.has("data"), false);
+    });
+    it("allows a real piped process to exit naturally after the shutdown command", { timeout: 5_000 }, async () => {
+        const moduleUrl = new URL("./index.ts", import.meta.url).href;
+        const child = spawn(process.execPath, ["--import", "tsx", "--input-type=module", "-e", `
+      import { installShutdownStdinHandler } from ${JSON.stringify(moduleUrl)}
+      installShutdownStdinHandler(process.stdin, async () => { process.exitCode = 0 })
+    `], { stdio: ["pipe", "ignore", "inherit"] });
+        child.stdin.end(`${STDIN_SHUTDOWN_COMMAND}\n`);
+        const [code] = await once(child, "exit");
+        assert.equal(code, 0);
     });
 });

package/dist/opencode-update/service.js

@@ -0,0 +1,150 @@
+import { fetch } from "undici";
+import { BinaryResolver } from "../settings/binaries";
+import { createInstanceClient } from "../workspaces/instance-client";
+import { probeBinaryVersion } from "../workspaces/spawn";
+import { compareVersionStrings, stripTagPrefix } from "../releases/release-monitor";
+const OPENCODE_LATEST_URL = "https://registry.npmjs.org/opencode-ai/latest";
+const LATEST_VERSION_CACHE_MS = 5 * 60_000;
+const UPGRADE_TIMEOUT_MS = 10 * 60_000;
+const inFlightUpgrades = new Map();
+export class OpenCodeUpdateError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "OpenCodeUpdateError";
+    }
+}
+export class OpenCodeUpdateService {
+    constructor(deps) {
+        this.deps = deps;
+        this.latestVersionCache = null;
+    }
+    async getStatus() {
+        const binary = this.deps.resolveBinary();
+        const currentVersion = this.readCurrentVersion(binary.path);
+        let latestVersion;
+        try {
+            latestVersion = await this.readLatestVersion();
+        }
+        catch (error) {
+            if (!(error instanceof OpenCodeUpdateError) || error.code !== "update_check_failed")
+                throw error;
+            return {
+                currentVersion,
+                latestVersion: null,
+                updateAvailable: null,
+                canUpgrade: false,
+                checkError: "update_check_failed",
+            };
+        }
+        const updateAvailable = compareVersionStrings(latestVersion, currentVersion) > 0;
+        const readyInstanceId = this.deps.findReadyInstanceId(binary.path);
+        return {
+            currentVersion,
+            latestVersion,
+            updateAvailable,
+            canUpgrade: updateAvailable && Boolean(readyInstanceId),
+        };
+    }
+    upgrade() {
+        const binary = this.deps.resolveBinary();
+        const existing = inFlightUpgrades.get(binary.path);
+        if (existing)
+            return existing;
+        const pending = this.performUpgrade(binary).finally(() => {
+            if (inFlightUpgrades.get(binary.path) === pending)
+                inFlightUpgrades.delete(binary.path);
+        });
+        inFlightUpgrades.set(binary.path, pending);
+        return pending;
+    }
+    async performUpgrade(binary) {
+        const currentVersion = this.readCurrentVersion(binary.path);
+        const latestVersion = await this.readLatestVersion();
+        if (compareVersionStrings(latestVersion, currentVersion) <= 0) {
+            return { success: true, version: currentVersion };
+        }
+        const instanceId = this.deps.findReadyInstanceId(binary.path);
+        if (!instanceId) {
+            throw new OpenCodeUpdateError("no_ready_instance", "No running OpenCode instance uses the configured binary");
+        }
+        try {
+            const result = await this.deps.upgradeInstance(instanceId, latestVersion);
+            if (!result.success) {
+                throw new OpenCodeUpdateError("upgrade_failed", result.error);
+            }
+            const installedVersion = this.readCurrentVersion(binary.path);
+            if (compareVersionStrings(installedVersion, latestVersion) !== 0) {
+                throw new OpenCodeUpdateError("upgrade_verification_failed", `OpenCode reported ${result.version}, but the configured binary is still ${installedVersion}`);
+            }
+            return { success: true, version: installedVersion };
+        }
+        catch (error) {
+            if (error instanceof OpenCodeUpdateError)
+                throw error;
+            throw new OpenCodeUpdateError("upgrade_failed", error instanceof Error ? error.message : "OpenCode upgrade failed");
+        }
+    }
+    readCurrentVersion(binaryPath) {
+        if (process.platform === "win32" && /["\r\n]/.test(binaryPath)) {
+            throw new OpenCodeUpdateError("binary_unavailable", "The configured OpenCode binary path is invalid");
+        }
+        const result = this.deps.probeBinary(binaryPath);
+        const version = stripTagPrefix(result.version);
+        if (!result.valid || !version) {
+            throw new OpenCodeUpdateError("binary_unavailable", result.error ?? "Unable to read OpenCode version");
+        }
+        return version;
+    }
+    async readLatestVersion() {
+        const now = (this.deps.now ?? Date.now)();
+        if (this.latestVersionCache && this.latestVersionCache.expiresAt > now) {
+            return this.latestVersionCache.version;
+        }
+        try {
+            const version = stripTagPrefix(await this.deps.fetchLatestVersion());
+            if (!version || !/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(version)) {
+                throw new Error("OpenCode registry returned an invalid version");
+            }
+            this.latestVersionCache = { version, expiresAt: now + LATEST_VERSION_CACHE_MS };
+            return version;
+        }
+        catch (error) {
+            throw new OpenCodeUpdateError("update_check_failed", error instanceof Error ? error.message : "Unable to check the latest OpenCode version");
+        }
+    }
+}
+export async function fetchLatestOpenCodeVersion() {
+    const response = await fetch(OPENCODE_LATEST_URL, {
+        headers: { Accept: "application/json", "User-Agent": "CodeNomad-CLI" },
+        signal: AbortSignal.timeout(10_000),
+    });
+    if (!response.ok) {
+        throw new Error(`OpenCode registry responded with ${response.status}`);
+    }
+    const payload = (await response.json());
+    if (typeof payload.version !== "string") {
+        throw new Error("OpenCode registry response did not include a version");
+    }
+    return payload.version;
+}
+export function createOpenCodeUpdateService(settings, workspaceManager) {
+    const binaryResolver = new BinaryResolver(settings);
+    return new OpenCodeUpdateService({
+        resolveBinary: () => {
+            const binary = binaryResolver.resolveDefault();
+            return { ...binary, path: workspaceManager.resolveBinaryPath(binary.path) };
+        },
+        probeBinary: probeBinaryVersion,
+        findReadyInstanceId: (binaryPath) => workspaceManager.findReadyInstanceIdByBinary(binaryPath),
+        fetchLatestVersion: fetchLatestOpenCodeVersion,
+        upgradeInstance: async (instanceId, target) => {
+            const client = createInstanceClient(workspaceManager, instanceId, { timeoutMs: UPGRADE_TIMEOUT_MS });
+            if (!client) {
+                throw new OpenCodeUpdateError("no_ready_instance", "OpenCode instance is not ready");
+            }
+            const { data } = await client.global.upgrade({ target }, { throwOnError: true });
+            return data;
+        },
+    });
+}

package/dist/opencode-update/service.test.js

@@ -0,0 +1,107 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { OpenCodeUpdateError, OpenCodeUpdateService } from "./service";
+function createDeps(overrides = {}) {
+    let currentVersion = "1.0.0";
+    return {
+        resolveBinary: () => ({ path: "opencode", label: "OpenCode" }),
+        probeBinary: () => ({ valid: true, version: currentVersion }),
+        findReadyInstanceId: () => "workspace-1",
+        fetchLatestVersion: async () => "1.1.0",
+        upgradeInstance: async (_instanceId, target) => {
+            currentVersion = target;
+            return { success: true, version: target };
+        },
+        ...overrides,
+    };
+}
+test("reports an available update and caches the latest version", async () => {
+    let checks = 0;
+    const service = new OpenCodeUpdateService(createDeps({
+        fetchLatestVersion: async () => {
+            checks += 1;
+            return "1.1.0";
+        },
+    }));
+    assert.deepEqual(await service.getStatus(), {
+        currentVersion: "1.0.0",
+        latestVersion: "1.1.0",
+        updateAvailable: true,
+        canUpgrade: true,
+    });
+    await service.getStatus();
+    assert.equal(checks, 1);
+});
+test("keeps the update visible when no matching instance is ready", async () => {
+    const service = new OpenCodeUpdateService(createDeps({ findReadyInstanceId: () => undefined }));
+    assert.deepEqual(await service.getStatus(), {
+        currentVersion: "1.0.0",
+        latestVersion: "1.1.0",
+        updateAvailable: true,
+        canUpgrade: false,
+    });
+});
+test("preserves the installed version when the registry check fails", async () => {
+    const service = new OpenCodeUpdateService(createDeps({
+        fetchLatestVersion: async () => {
+            throw new Error("registry unavailable");
+        },
+    }));
+    assert.deepEqual(await service.getStatus(), {
+        currentVersion: "1.0.0",
+        latestVersion: null,
+        updateAvailable: null,
+        canUpgrade: false,
+        checkError: "update_check_failed",
+    });
+});
+test("upgrades through the matching OpenCode instance to the advertised version", async () => {
+    const calls = [];
+    let currentVersion = "1.0.0";
+    const service = new OpenCodeUpdateService(createDeps({
+        probeBinary: () => ({ valid: true, version: currentVersion }),
+        upgradeInstance: async (instanceId, target) => {
+            calls.push({ instanceId, target });
+            currentVersion = target;
+            return { success: true, version: target };
+        },
+    }));
+    assert.deepEqual(await service.upgrade(), { success: true, version: "1.1.0" });
+    assert.deepEqual(calls, [{ instanceId: "workspace-1", target: "1.1.0" }]);
+});
+test("rejects success when the configured binary was not updated", async () => {
+    const service = new OpenCodeUpdateService(createDeps({
+        probeBinary: () => ({ valid: true, version: "1.0.0" }),
+        upgradeInstance: async (_instanceId, target) => ({ success: true, version: target }),
+    }));
+    await assert.rejects(() => service.upgrade(), (error) => error instanceof OpenCodeUpdateError && error.code === "upgrade_verification_failed");
+});
+test("joins concurrent upgrades for the same binary", async () => {
+    let currentVersion = "1.0.0";
+    let upgrades = 0;
+    let finishUpgrade;
+    const gate = new Promise((resolve) => {
+        finishUpgrade = resolve;
+    });
+    const service = new OpenCodeUpdateService(createDeps({
+        probeBinary: () => ({ valid: true, version: currentVersion }),
+        upgradeInstance: async (_instanceId, target) => {
+            upgrades += 1;
+            await gate;
+            currentVersion = target;
+            return { success: true, version: target };
+        },
+    }));
+    const first = service.upgrade();
+    const second = service.upgrade();
+    finishUpgrade?.();
+    assert.deepEqual(await Promise.all([first, second]), [
+        { success: true, version: "1.1.0" },
+        { success: true, version: "1.1.0" },
+    ]);
+    assert.equal(upgrades, 1);
+});
+test("rejects an upgrade when no matching OpenCode instance is running", async () => {
+    const service = new OpenCodeUpdateService(createDeps({ findReadyInstanceId: () => undefined }));
+    await assert.rejects(() => service.upgrade(), (error) => error instanceof OpenCodeUpdateError && error.code === "no_ready_instance");
+});

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;
 }