@vantran-se/openchamber-web 2.0.2 → 2.0.4

package/server/lib/opencode/lifecycle.js

@@ -55,6 +55,132 @@ const WARMUP_REQUEST_TIMEOUT_MS = 30000;
 const MANAGED_STDERR_TAIL_MAX_BYTES = 32 * 1024;
 const HEALTH_FAILURE_DETAIL_MAX_LENGTH = 256;
 
+export const resolveOpenCodeConnectionKind = ({ runtime, configuredHost, lifecycleMode }) => {
+  if (configuredHost) return 'explicit-external';
+  if (lifecycleMode === 'managed' || runtime === 'desktop') return 'managed-owned';
+  return 'shared-local';
+};
+
+export const createOpenCodeServerComposition = ({
+  runtime,
+  configuredHost,
+  lifecycleMode,
+  createSharedRuntime,
+  createManagedPluginRuntime = () => null,
+  getManagedBaseUrl = () => null,
+  getManagedAuthHeaders = () => ({}),
+}) => {
+  const kind = resolveOpenCodeConnectionKind({ runtime, configuredHost, lifecycleMode });
+  if (kind === 'shared-local' && !createSharedRuntime) {
+    throw new Error('Shared OpenCode composition requires a shared runtime factory');
+  }
+  const sharedRuntime = kind === 'shared-local' ? createSharedRuntime() : null;
+  const managedPluginRuntime = kind === 'managed-owned' ? createManagedPluginRuntime() : null;
+  const connection = createOpenCodeConnectionAdapter({
+    kind,
+    sharedRuntime,
+    getManagedBaseUrl,
+    getManagedAuthHeaders,
+  });
+  return { kind, sharedRuntime, managedPluginRuntime, connection };
+};
+
+export const createOpenCodeRecoveryCallbacks = ({
+  resetOpenCodeRuntimeProviders,
+  rebindUpstream,
+  interruptBusySessionsAfterRestart,
+  broadcastUiNotification,
+}) => ({
+  onManagedRestarted() {
+    resetOpenCodeRuntimeProviders();
+    try {
+      rebindUpstream();
+    } catch (error) {
+      console.warn('Failed to rebind message stream after OpenCode restart:', error?.message ?? error);
+    }
+    try {
+      const { sessionIds } = interruptBusySessionsAfterRestart();
+      if (sessionIds.length === 0) return;
+      const multiple = sessionIds.length > 1;
+      broadcastUiNotification({
+        title: multiple ? 'Chats interrupted' : 'Chat interrupted',
+        body: multiple
+          ? 'OpenCode restarted during running responses. Send a message in each chat to continue.'
+          : 'OpenCode restarted during a running response. Send a message to continue.',
+        tag: 'opencode-restart-interrupted',
+        kind: 'opencode-restart-interrupted',
+        sessionId: sessionIds[0],
+      });
+    } catch (error) {
+      console.warn('Failed to reconcile sessions after OpenCode restart:', error?.message ?? error);
+    }
+  },
+  onSharedRecovered() {
+    resetOpenCodeRuntimeProviders();
+    rebindUpstream();
+  },
+});
+
+export const createOpenCodeLifecycleControls = ({
+  getKind,
+  restartLifecycle,
+  triggerLifecycleHealthCheck,
+  recoverShared,
+  onSharedRecovered,
+}) => {
+  let sharedRecoveryPromise = null;
+  const recover = () => {
+    if (!recoverShared || !onSharedRecovered) {
+      return Promise.reject(new Error('Shared OpenCode recovery is not configured'));
+    }
+    if (!sharedRecoveryPromise) {
+      sharedRecoveryPromise = Promise.resolve()
+        .then(() => recoverShared())
+        .then(() => onSharedRecovered())
+        .finally(() => {
+          sharedRecoveryPromise = null;
+        });
+    }
+    return sharedRecoveryPromise;
+  };
+
+  return {
+    restart: (...args) => (
+      getKind() === 'shared-local' ? recover() : restartLifecycle(...args)
+    ),
+    triggerHealthCheck: (...args) => {
+      if (getKind() !== 'shared-local') {
+        return triggerLifecycleHealthCheck(...args);
+      }
+      return recover().catch((error) => {
+        console.warn('Failed to recover shared OpenCode service:', error?.message ?? error);
+      });
+    },
+  };
+};
+
+export const createOpenCodeConnectionAdapter = ({
+  kind,
+  sharedRuntime = null,
+  getManagedBaseUrl = () => null,
+  getManagedAuthHeaders = () => ({}),
+}) => {
+  if (kind === 'shared-local' && !sharedRuntime) {
+    throw new Error('Shared OpenCode connection requires a shared service runtime');
+  }
+
+  return {
+    getOpenCodeConnectionKind: () => kind,
+    getOpenCodeBaseUrl: () => (
+      kind === 'shared-local' ? sharedRuntime.getBaseUrl() : getManagedBaseUrl()
+    ),
+    getOpenCodeAuthHeaders: () => (
+      kind === 'shared-local' ? sharedRuntime.getHeaders() : getManagedAuthHeaders()
+    ),
+    ownsOpenCodeProcess: () => kind === 'managed-owned',
+  };
+};
+
 const getBoundedTextTail = (value, maxBytes) => {
   const buffer = Buffer.from(String(value ?? ''));
   if (buffer.byteLength <= maxBytes) return buffer.toString();

package/server/lib/opencode/lifecycle.test.js

@@ -18,7 +18,14 @@ vi.mock('./startup-performance.js', () => ({
   recordStartupPerformance: recordStartupPerformanceMock,
 }));
 
-const { createOpenCodeLifecycleRuntime } = await import('./lifecycle.js');
+const {
+  createOpenCodeConnectionAdapter,
+  createOpenCodeLifecycleControls,
+  createOpenCodeLifecycleRuntime,
+  createOpenCodeRecoveryCallbacks,
+  createOpenCodeServerComposition,
+  resolveOpenCodeConnectionKind,
+} = await import('./lifecycle.js');
 
 const originalOpencodeBinary = process.env.OPENCODE_BINARY;
 const originalPath = process.env.PATH;
@@ -128,6 +135,226 @@ const createRuntime = (overrides = {}, stateOverrides = {}, envOverrides = {}) =
   return runtime;
 };
 
+describe('OpenCode connection composition', () => {
+  it('selects shared-local for Web without an explicit host', () => {
+    expect(resolveOpenCodeConnectionKind({ runtime: 'web', configuredHost: null })).toBe('shared-local');
+  });
+
+  it('selects explicit-external when a host is configured', () => {
+    expect(resolveOpenCodeConnectionKind({
+      runtime: 'web',
+      configuredHost: { origin: 'https://opencode.example.com', port: 443 },
+    })).toBe('explicit-external');
+  });
+
+  it('keeps Desktop on the managed-owned lifecycle', () => {
+    expect(resolveOpenCodeConnectionKind({ runtime: 'desktop', configuredHost: null })).toBe('managed-owned');
+  });
+
+  it('gives an explicit host priority over the Desktop managed lifecycle', () => {
+    expect(resolveOpenCodeConnectionKind({
+      runtime: 'desktop',
+      configuredHost: { origin: 'https://opencode.example.com', port: 443 },
+    })).toBe('explicit-external');
+  });
+
+  it('keeps an embedded managed override on the managed-owned lifecycle', () => {
+    expect(resolveOpenCodeConnectionKind({
+      runtime: 'web',
+      configuredHost: null,
+      lifecycleMode: 'managed',
+    })).toBe('managed-owned');
+  });
+
+  it('requires a shared runtime factory for shared-local composition', () => {
+    expect(() => createOpenCodeServerComposition({
+      runtime: 'web',
+      configuredHost: null,
+    })).toThrow('Shared OpenCode composition requires a shared runtime factory');
+  });
+
+  it('creates shared and managed-only runtimes only for their owning connection kind', () => {
+    const sharedRuntime = { getBaseUrl: () => null, getHeaders: () => ({}) };
+    const managedPluginRuntime = { buildManagedChildEnv: () => ({}) };
+    const createSharedRuntime = vi.fn(() => sharedRuntime);
+    const createManagedPluginRuntime = vi.fn(() => managedPluginRuntime);
+
+    const shared = createOpenCodeServerComposition({
+      runtime: 'web',
+      configuredHost: null,
+      createSharedRuntime,
+      createManagedPluginRuntime,
+    });
+    const external = createOpenCodeServerComposition({
+      runtime: 'web',
+      configuredHost: { origin: 'https://opencode.example.com', port: 443 },
+      createSharedRuntime,
+      createManagedPluginRuntime,
+    });
+    const desktop = createOpenCodeServerComposition({
+      runtime: 'desktop',
+      configuredHost: null,
+      createSharedRuntime,
+      createManagedPluginRuntime,
+    });
+
+    expect(shared.sharedRuntime).toBe(sharedRuntime);
+    expect(shared.managedPluginRuntime).toBeNull();
+    expect(external.sharedRuntime).toBeNull();
+    expect(external.managedPluginRuntime).toBeNull();
+    expect(desktop.sharedRuntime).toBeNull();
+    expect(desktop.managedPluginRuntime).toBe(managedPluginRuntime);
+    expect(createSharedRuntime).toHaveBeenCalledTimes(1);
+    expect(createManagedPluginRuntime).toHaveBeenCalledTimes(1);
+  });
+
+  it('recovers the shared service through the production callback without interrupting sessions', async () => {
+    const restartManaged = vi.fn(async () => {});
+    const triggerManagedHealthCheck = vi.fn(async () => {});
+    const recoverShared = vi.fn(async () => {});
+    const resetOpenCodeRuntimeProviders = vi.fn();
+    const rebindUpstream = vi.fn();
+    const interruptBusySessionsAfterRestart = vi.fn(() => ({ sessionIds: [] }));
+    const broadcastUiNotification = vi.fn();
+    const callbacks = createOpenCodeRecoveryCallbacks({
+      resetOpenCodeRuntimeProviders,
+      rebindUpstream,
+      interruptBusySessionsAfterRestart,
+      broadcastUiNotification,
+    });
+    const shared = createOpenCodeLifecycleControls({
+      getKind: () => 'shared-local',
+      restartLifecycle: restartManaged,
+      triggerLifecycleHealthCheck: triggerManagedHealthCheck,
+      recoverShared,
+      onSharedRecovered: callbacks.onSharedRecovered,
+    });
+
+    await shared.restart('manual');
+
+    expect(recoverShared).toHaveBeenCalledOnce();
+    expect(resetOpenCodeRuntimeProviders).toHaveBeenCalledOnce();
+    expect(rebindUpstream).toHaveBeenCalledOnce();
+    expect(recoverShared.mock.invocationCallOrder[0]).toBeLessThan(rebindUpstream.mock.invocationCallOrder[0]);
+    expect(interruptBusySessionsAfterRestart).not.toHaveBeenCalled();
+    expect(broadcastUiNotification).not.toHaveBeenCalled();
+    expect(restartManaged).not.toHaveBeenCalled();
+    expect(triggerManagedHealthCheck).not.toHaveBeenCalled();
+  });
+
+  it('keeps managed restart interruption behavior in the production callback', () => {
+    const resetOpenCodeRuntimeProviders = vi.fn();
+    const rebindUpstream = vi.fn();
+    const interruptBusySessionsAfterRestart = vi.fn(() => ({ sessionIds: ['session-1'] }));
+    const broadcastUiNotification = vi.fn();
+    const callbacks = createOpenCodeRecoveryCallbacks({
+      resetOpenCodeRuntimeProviders,
+      rebindUpstream,
+      interruptBusySessionsAfterRestart,
+      broadcastUiNotification,
+    });
+
+    callbacks.onManagedRestarted();
+
+    expect(resetOpenCodeRuntimeProviders).toHaveBeenCalledOnce();
+    expect(rebindUpstream).toHaveBeenCalledOnce();
+    expect(interruptBusySessionsAfterRestart).toHaveBeenCalledOnce();
+    expect(broadcastUiNotification).toHaveBeenCalledWith(expect.objectContaining({
+      kind: 'opencode-restart-interrupted',
+      sessionId: 'session-1',
+    }));
+  });
+
+  it('shares concurrent shared recovery attempts', async () => {
+    let finishRecovery;
+    const recoverShared = vi.fn(() => new Promise((resolve) => {
+      finishRecovery = resolve;
+    }));
+    const onSharedRecovered = vi.fn(async () => {});
+    const shared = createOpenCodeLifecycleControls({
+      getKind: () => 'shared-local',
+      restartLifecycle: vi.fn(),
+      triggerLifecycleHealthCheck: vi.fn(),
+      recoverShared,
+      onSharedRecovered,
+    });
+
+    const first = shared.triggerHealthCheck();
+    const second = shared.triggerHealthCheck();
+    await vi.waitFor(() => expect(recoverShared).toHaveBeenCalledOnce());
+    finishRecovery();
+    await Promise.all([first, second]);
+
+    expect(recoverShared).toHaveBeenCalledOnce();
+    expect(onSharedRecovered).toHaveBeenCalledOnce();
+  });
+
+  it('contains shared health recovery failures and permits a later retry', async () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const recoverShared = vi.fn()
+      .mockRejectedValueOnce(new Error('service unavailable'))
+      .mockResolvedValueOnce(undefined);
+    const onSharedRecovered = vi.fn(async () => {});
+    const shared = createOpenCodeLifecycleControls({
+      getKind: () => 'shared-local',
+      restartLifecycle: vi.fn(),
+      triggerLifecycleHealthCheck: vi.fn(),
+      recoverShared,
+      onSharedRecovered,
+    });
+
+    await expect(shared.triggerHealthCheck()).resolves.toBeUndefined();
+    await expect(shared.restart()).resolves.toBeUndefined();
+
+    expect(recoverShared).toHaveBeenCalledTimes(2);
+    expect(onSharedRecovered).toHaveBeenCalledOnce();
+  });
+
+  it('preserves managed lifecycle controls', async () => {
+    const restartManaged = vi.fn(async () => {});
+    const triggerManagedHealthCheck = vi.fn(async () => {});
+    const managed = createOpenCodeLifecycleControls({
+      getKind: () => 'managed-owned',
+      restartLifecycle: restartManaged,
+      triggerLifecycleHealthCheck: triggerManagedHealthCheck,
+    });
+
+    await managed.restart('manual');
+    await managed.triggerHealthCheck();
+
+    expect(restartManaged).toHaveBeenCalledWith('manual');
+    expect(triggerManagedHealthCheck).toHaveBeenCalledTimes(1);
+  });
+
+  it('requires a shared runtime for shared-local composition', () => {
+    expect(() => createOpenCodeConnectionAdapter({ kind: 'shared-local' })).toThrow(
+      'Shared OpenCode connection requires a shared service runtime',
+    );
+  });
+
+  it('reads shared URL and auth from the shared runtime at call time without owning its process', () => {
+    let baseUrl = 'http://127.0.0.1:4096';
+    let headers = { authorization: 'Basic first' };
+    const adapter = createOpenCodeConnectionAdapter({
+      kind: 'shared-local',
+      sharedRuntime: {
+        getBaseUrl: () => baseUrl,
+        getHeaders: () => ({ ...headers }),
+      },
+    });
+
+    expect(adapter.getOpenCodeConnectionKind()).toBe('shared-local');
+    expect(adapter.getOpenCodeBaseUrl()).toBe('http://127.0.0.1:4096');
+    expect(adapter.getOpenCodeAuthHeaders()).toEqual({ authorization: 'Basic first' });
+    expect(adapter.ownsOpenCodeProcess()).toBe(false);
+
+    baseUrl = 'http://127.0.0.1:5096';
+    headers = { authorization: 'Basic replacement' };
+    expect(adapter.getOpenCodeBaseUrl()).toBe('http://127.0.0.1:5096');
+    expect(adapter.getOpenCodeAuthHeaders()).toEqual({ authorization: 'Basic replacement' });
+  });
+});
+
 describe('OpenCode lifecycle', () => {
   it('uses the resolved binary directly on startup and managed restart without an env override', async () => {
     delete process.env.OPENCODE_BINARY;

package/server/lib/opencode/network-runtime.js

@@ -2,10 +2,18 @@ import { readOpenCodeInfo, isSupportedOpenCodeVersion } from './compatibility.js
 export const createOpenCodeNetworkRuntime = (deps) => {
   const {
     state,
-    getOpenCodeAuthHeaders,
+    getOpenCodeBaseUrl,
+    getOpenCodeAuthHeaders: readOpenCodeAuthHeaders,
     configuredOpenCodeHostname = '127.0.0.1',
   } = deps;
 
+  const getOpenCodeAuthHeaders = () => Object.fromEntries(
+    Object.entries(readOpenCodeAuthHeaders?.() ?? {}).map(([key, value]) => [
+      key.toLowerCase() === 'authorization' ? 'Authorization' : key,
+      value,
+    ]),
+  );
+
   const resolveConnectHostname = () => {
     const raw = typeof configuredOpenCodeHostname === 'string' ? configuredOpenCodeHostname.trim() : '';
     const hostname = raw || '127.0.0.1';
@@ -83,14 +91,14 @@ export const createOpenCodeNetworkRuntime = (deps) => {
   };
 
   const buildOpenCodeUrl = (path, prefixOverride) => {
-    if (!state.openCodePort) {
-      throw new Error('OpenCode port is not available');
+    const base = getOpenCodeBaseUrl?.() ?? state.openCodeBaseUrl;
+    if (!base && !state.openCodePort) {
+      throw new Error('OpenCode endpoint is not available');
     }
     const normalizedPath = path.startsWith('/') ? path : `/${path}`;
-    const prefix = normalizeApiPrefix(prefixOverride !== undefined ? prefixOverride : '');
-    const fullPath = `${prefix}${normalizedPath}`;
-    const base = state.openCodeBaseUrl ?? `http://${resolveConnectHostname()}:${state.openCodePort}`;
-    return `${base}${fullPath}`;
+    const prefix = normalizeApiPrefix(prefixOverride ?? '');
+    const fallback = `http://${resolveConnectHostname()}:${state.openCodePort}`;
+    return `${String(base ?? fallback).replace(/\/+$/, '')}${prefix}${normalizedPath}`;
   };
 
   const detectOpenCodeApiPrefix = () => {
@@ -107,6 +115,7 @@ export const createOpenCodeNetworkRuntime = (deps) => {
 
   return {
     waitForReady,
+    getOpenCodeAuthHeaders,
     normalizeApiPrefix,
     setDetectedOpenCodeApiPrefix,
     buildOpenCodeUrl,

package/server/lib/opencode/network-runtime.test.js

@@ -13,7 +13,8 @@ const createRuntime = (overrides = {}) => createOpenCodeNetworkRuntime({
     openCodeApiDetectionTimer: null,
     ...overrides.state,
   },
-  getOpenCodeAuthHeaders: () => ({}),
+  getOpenCodeBaseUrl: overrides.getOpenCodeBaseUrl,
+  getOpenCodeAuthHeaders: overrides.getOpenCodeAuthHeaders ?? (() => ({})),
   configuredOpenCodeHostname: overrides.configuredOpenCodeHostname,
 });
 
@@ -48,6 +49,33 @@ describe('OpenCode network runtime', () => {
     expect(runtime.buildOpenCodeUrl('/provider')).toBe('http://remote.example:4096/provider');
   });
 
+  it('builds each request from the current shared-service base URL', () => {
+    let baseUrl = 'http://127.0.0.1:4096';
+    const runtime = createRuntime({
+      state: { openCodePort: null },
+      getOpenCodeBaseUrl: () => baseUrl,
+    });
+
+    expect(runtime.buildOpenCodeUrl('/api/session')).toBe('http://127.0.0.1:4096/api/session');
+    baseUrl = 'http://127.0.0.1:5096/';
+    expect(runtime.buildOpenCodeUrl('/api/session')).toBe('http://127.0.0.1:5096/api/session');
+  });
+
+  it('normalizes current service auth without dropping additional headers', () => {
+    let headers = { authorization: 'Basic first', 'x-service-header': 'one' };
+    const runtime = createRuntime({ getOpenCodeAuthHeaders: () => headers });
+
+    expect(runtime.getOpenCodeAuthHeaders()).toEqual({
+      Authorization: 'Basic first',
+      'x-service-header': 'one',
+    });
+    headers = { authorization: 'Basic replacement', 'x-service-header': 'two' };
+    expect(runtime.getOpenCodeAuthHeaders()).toEqual({
+      Authorization: 'Basic replacement',
+      'x-service-header': 'two',
+    });
+  });
+
   it('normalizes wildcard and IPv6 OpenCode bind hosts for local connects', () => {
     expect(createRuntime({ configuredOpenCodeHostname: '0.0.0.0' }).buildOpenCodeUrl('/provider'))
       .toBe('http://127.0.0.1:4096/provider');

package/server/lib/opencode/proxy.js

@@ -477,18 +477,15 @@ export const registerOpenCodeProxy = (app, deps) => {
   const resolveProxyTarget = () => {
     const runtimeState = getRuntime();
 
-    // `buildOpenCodeUrl` throws while the port is unknown, and the port is
-    // nulled on several runtime paths (health-check failure, failed restart),
-    // not just cold start. Checking first keeps a degraded OpenCode from
-    // making every proxied request pay for a thrown-and-caught exception.
-    if (runtimeState.openCodePort) {
-      try {
-        const resolved = normalizeProxyTarget(buildOpenCodeUrl('/', ''));
-        if (resolved) {
-          return resolved;
-        }
-      } catch {
+    // The shared-service endpoint can remain authoritative even when it has no
+    // explicit port (for example, HTTPS on its default port). Resolve it before
+    // consulting the legacy runtime snapshot.
+    try {
+      const resolved = normalizeProxyTarget(buildOpenCodeUrl('/', ''));
+      if (resolved) {
+        return resolved;
       }
+    } catch {
     }
 
     const externalBase = normalizeProxyTarget(runtimeState.openCodeBaseUrl);
@@ -973,10 +970,14 @@ export const registerOpenCodeProxy = (app, deps) => {
     router: () => resolveProxyTarget(),
     on: {
       proxyReq: (proxyReq, req) => {
-        // Inject OpenCode auth headers
+        // The proxy middleware starts with browser headers. Never let an
+        // OpenChamber client credential reach OpenCode, even when the active
+        // OpenCode connection itself has no authorization header.
+        proxyReq.removeHeader('authorization');
         const authHeaders = getOpenCodeAuthHeaders();
-        if (authHeaders.Authorization) {
-          proxyReq.setHeader('Authorization', authHeaders.Authorization);
+        for (const [key, value] of Object.entries(authHeaders)) {
+          proxyReq.removeHeader(key);
+          proxyReq.setHeader(key, value);
         }
 
         if (req.headers?.['x-opencode-directory-encoding'] === 'uri') {

package/server/lib/opencode/server-startup-runtime.js

@@ -31,6 +31,7 @@ export const createServerStartupRuntime = (dependencies) => {
     bindHost,
     startupTunnelRequest,
     onTunnelReady,
+    afterListening,
   }) => {
     let activePort = port;
 
@@ -45,6 +46,30 @@ export const createServerStartupRuntime = (dependencies) => {
         try {
           const addressInfo = server.address();
           activePort = typeof addressInfo === 'object' && addressInfo ? addressInfo.port : port;
+          try {
+            await afterListening?.({ activePort, bindHost });
+          } catch (error) {
+            if (typeof process.send === 'function' && process.connected) {
+              const startupError = {
+                type: 'openchamber:error',
+                code: error?.code || 'WEB_STARTUP_ERROR',
+                message: error instanceof Error ? error.message : String(error),
+              };
+              if (error?.url) startupError.url = error.url;
+              await new Promise((resolveStartupError) => {
+                try {
+                  process.send(startupError, () => resolveStartupError());
+                } catch {
+                  resolveStartupError();
+                }
+              });
+            }
+            await new Promise((resolveClose) => {
+              server.close(() => resolveClose());
+              server.closeAllConnections?.();
+            });
+            throw error;
+          }
 
           if (typeof process.send === 'function') {
             if (!process.connected) {

package/server/lib/opencode/server-startup-runtime.test.js

@@ -1,4 +1,4 @@
-import { describe, expect, test } from 'bun:test';
+import { describe, expect, test, mock } from 'bun:test';
 import { EventEmitter } from 'node:events';
 import { createServerStartupRuntime } from './server-startup-runtime.js';
 
@@ -7,6 +7,72 @@ import { createServerStartupRuntime } from './server-startup-runtime.js';
  * on a single uncaught exception turned every stray socket error into "the
  * instance is unreachable until restarted". Only a sustained storm shuts down.
  */
+describe('server startup readiness', () => {
+  test('reports daemon ready only after listener-dependent startup finishes', async () => {
+    const order = [];
+    const fakeProcess = {
+      connected: true,
+      send: mock((message, callback) => {
+        order.push(message.type);
+        callback();
+      }),
+    };
+    const server = new EventEmitter();
+    server.address = () => ({ port: 3901 });
+    server.listen = (_port, _host, callback) => callback();
+    const runtime = createServerStartupRuntime({
+      process: fakeProcess,
+      crypto: {},
+      server,
+      readSettingsFromDiskMigrated: async () => ({}),
+      tunnelAuthController: {},
+    });
+
+    await runtime.startListeningAndMaybeTunnel({
+      port: 0,
+      bindHost: '127.0.0.1',
+      afterListening: async () => order.push('prepared'),
+    });
+
+    expect(order).toEqual(['prepared', 'openchamber:ready']);
+  });
+
+  test('closes the listener and reports startup failure when listener-dependent startup fails', async () => {
+    const sent = [];
+    const fakeProcess = {
+      connected: true,
+      send: mock((message, callback) => {
+        sent.push(message);
+        callback();
+      }),
+    };
+    const server = new EventEmitter();
+    server.address = () => ({ port: 3901 });
+    server.listen = (_port, _host, callback) => callback();
+    server.close = mock((callback) => callback());
+    server.closeAllConnections = mock(() => {});
+    const runtime = createServerStartupRuntime({ process: fakeProcess, crypto: {}, server });
+    const startupError = Object.assign(new Error('shared service rejected'), {
+      code: 'OPENCODE_INCOMPATIBLE',
+    });
+
+    await expect(runtime.startListeningAndMaybeTunnel({
+      port: 0,
+      bindHost: '127.0.0.1',
+      afterListening: async () => { throw startupError; },
+    })).rejects.toBe(startupError);
+
+    expect(server.close).toHaveBeenCalledTimes(1);
+    expect(server.closeAllConnections).toHaveBeenCalledTimes(1);
+    expect(sent).toEqual([expect.objectContaining({
+      type: 'openchamber:error',
+      code: 'OPENCODE_INCOMPATIBLE',
+    })]);
+    expect(sent).not.toContainEqual(expect.objectContaining({ type: 'openchamber:ready' }));
+  });
+
+});
+
 describe('uncaught exception policy', () => {
   const setup = () => {
     const fakeProcess = new EventEmitter();