@vantran-se/openchamber-web 2.0.2 → 2.0.4

package/server/lib/opencode/shared-service-runtime.js

@@ -0,0 +1,155 @@
+import { access } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+import { Service } from '@opencode/client/service';
+import { z } from 'zod';
+
+import { isSupportedOpenCodeVersion, readOpenCodeInfo } from './compatibility.js';
+
+const endpointSchema = z.object({
+  url: z.string(),
+  auth: z.object({
+    type: z.literal('basic'),
+    username: z.string(),
+    password: z.string(),
+  }).optional(),
+});
+
+const createConnectionError = (code, message, details = {}, cause) => {
+  const error = new Error(message, cause === undefined ? undefined : { cause });
+  error.code = code;
+  Object.assign(error, details);
+  return error;
+};
+
+const unavailableError = (message, cause) => createConnectionError(
+  'OPENCODE_SERVICE_UNAVAILABLE',
+  message,
+  {},
+  cause,
+);
+
+const normalizeEndpoint = (endpoint) => {
+  const parsed = endpointSchema.safeParse(endpoint);
+  if (!parsed.success) {
+    throw unavailableError('OpenCode shared service did not return an endpoint');
+  }
+
+  let url;
+  try {
+    url = new URL(parsed.data.url);
+  } catch (cause) {
+    throw unavailableError('OpenCode shared service returned an invalid URL', cause);
+  }
+  if ((url.protocol !== 'http:' && url.protocol !== 'https:') || !url.hostname) {
+    throw unavailableError('OpenCode shared service returned an unsupported URL');
+  }
+
+  return { ...parsed.data, url: url.origin };
+};
+
+const defaultRegistrationFile = () => join(
+  process.env.XDG_STATE_HOME ?? join(homedir(), '.local', 'state'),
+  'opencode',
+  'service.json',
+);
+
+const registrationExists = async (options = {}) => {
+  try {
+    await access(options.file ?? defaultRegistrationFile());
+    return true;
+  } catch (error) {
+    if (error?.code === 'ENOENT') return false;
+    throw error;
+  }
+};
+
+export const createSharedOpenCodeServiceRuntime = ({
+  service = Service,
+  fetchImpl = fetch,
+  ensureOptions,
+  readInfo = readOpenCodeInfo,
+  isSupportedVersion = isSupportedOpenCodeVersion,
+  hasRegistration = registrationExists,
+}) => {
+  let activeConnection = null;
+
+  const resolveEndpoint = async () => {
+    let discovered;
+    try {
+      discovered = await service.discover(ensureOptions);
+    } catch (cause) {
+      throw unavailableError('Could not discover the OpenCode shared service', cause);
+    }
+    if (discovered) return normalizeEndpoint(discovered);
+
+    try {
+      if (await hasRegistration(ensureOptions)) {
+        throw unavailableError(
+          'An incompatible or unhealthy OpenCode shared service is already registered',
+        );
+      }
+    } catch (cause) {
+      if (cause?.code === 'OPENCODE_SERVICE_UNAVAILABLE') throw cause;
+      throw unavailableError('Could not inspect the OpenCode shared service registration', cause);
+    }
+    try {
+      return normalizeEndpoint(await service.ensure(ensureOptions));
+    } catch (cause) {
+      if (cause?.code === 'OPENCODE_SERVICE_UNAVAILABLE') throw cause;
+      throw unavailableError('Could not start the OpenCode shared service', cause);
+    }
+  };
+
+  const probe = async (endpoint) => {
+    let headers;
+    try {
+      headers = { ...(service.headers(endpoint) ?? {}) };
+    } catch (cause) {
+      throw unavailableError('Could not authenticate with the OpenCode shared service', cause);
+    }
+    let info;
+    try {
+      const response = await fetchImpl(new URL('/api/info', endpoint.url), {
+        headers: { Accept: 'application/json', ...headers },
+      });
+      info = await readInfo(response);
+    } catch (cause) {
+      throw unavailableError('Could not reach the OpenCode shared service', cause);
+    }
+    if (!info) {
+      throw unavailableError('OpenCode shared service did not return valid service information');
+    }
+    if (!isSupportedVersion(info.version)) {
+      throw createConnectionError(
+        'OPENCODE_INCOMPATIBLE',
+        `OpenCode shared service version ${info.version} is incompatible`,
+        { foundVersion: info.version },
+      );
+    }
+
+    return {
+      kind: 'shared-local',
+      endpoint,
+      version: info.version,
+    };
+  };
+
+  const establishConnection = async () => {
+    const replacement = await probe(await resolveEndpoint());
+    activeConnection = replacement;
+    return replacement;
+  };
+
+  return {
+    connect: establishConnection,
+    recover: establishConnection,
+    getConnection: () => activeConnection,
+    getBaseUrl: () => activeConnection?.endpoint.url ?? null,
+    getHeaders: () => activeConnection ? { ...(service.headers(activeConnection.endpoint) ?? {}) } : {},
+    dispose: async () => {
+      activeConnection = null;
+    },
+  };
+};

package/server/lib/opencode/shared-service-runtime.test.js

@@ -0,0 +1,180 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { createSharedOpenCodeServiceRuntime } from './shared-service-runtime.js';
+
+const endpointA = {
+  url: 'http://127.0.0.1:4096',
+  auth: { type: 'basic', username: 'opencode', password: 'original' },
+};
+const endpointB = {
+  url: 'http://127.0.0.1:5096',
+  auth: { type: 'basic', username: 'opencode', password: 'replacement' },
+};
+
+const createRuntime = ({
+  discover = vi.fn().mockResolvedValue(endpointA),
+  ensure = vi.fn(),
+  stop = vi.fn(),
+  headers = vi.fn((endpoint) => endpoint.auth
+    ? { authorization: `Basic ${endpoint.auth.password}` }
+    : undefined),
+  fetchImpl = vi.fn().mockResolvedValue(Response.json({ version: '2.0.15' })),
+  infoVersion,
+  readInfo = async (response) => infoVersion === undefined
+    ? response.json()
+    : { version: infoVersion },
+  isSupportedVersion = (version) => version === '2.0.15',
+  ensureOptions = { command: ['opencode', 'serve', '--service'] },
+  hasRegistration = vi.fn().mockResolvedValue(false),
+} = {}) => createSharedOpenCodeServiceRuntime({
+  service: { discover, ensure, stop, headers },
+  fetchImpl,
+  ensureOptions,
+  readInfo,
+  isSupportedVersion,
+  hasRegistration,
+});
+
+describe('shared OpenCode service runtime', () => {
+  it('uses a compatible discovered service without ensuring another one', async () => {
+    const discover = vi.fn().mockResolvedValue(endpointA);
+    const ensure = vi.fn();
+    const runtime = createRuntime({ discover, ensure, infoVersion: '2.0.15' });
+
+    await expect(runtime.connect()).resolves.toMatchObject({
+      kind: 'shared-local',
+      endpoint: endpointA,
+      version: '2.0.15',
+    });
+    expect(ensure).not.toHaveBeenCalled();
+  });
+
+  it('rejects an incompatible discovered service without replacing it', async () => {
+    const discover = vi.fn().mockResolvedValue(endpointA);
+    const ensure = vi.fn();
+    const runtime = createRuntime({ discover, ensure, infoVersion: '1.99.0' });
+
+    await expect(runtime.connect()).rejects.toMatchObject({
+      code: 'OPENCODE_INCOMPATIBLE',
+      foundVersion: '1.99.0',
+    });
+    expect(ensure).not.toHaveBeenCalled();
+  });
+
+  it('refuses to ensure when discovery hides an existing incompatible or unhealthy registration', async () => {
+    const discover = vi.fn().mockResolvedValue(undefined);
+    const ensure = vi.fn();
+    const runtime = createRuntime({
+      discover,
+      ensure,
+      hasRegistration: vi.fn().mockResolvedValue(true),
+    });
+
+    await expect(runtime.connect()).rejects.toMatchObject({
+      code: 'OPENCODE_SERVICE_UNAVAILABLE',
+    });
+    expect(ensure).not.toHaveBeenCalled();
+  });
+
+  it('ensures a service only when discovery returns no endpoint', async () => {
+    const discover = vi.fn().mockResolvedValue(undefined);
+    const ensure = vi.fn().mockResolvedValue(endpointA);
+    const runtime = createRuntime({ discover, ensure, infoVersion: '2.0.15' });
+
+    await expect(runtime.connect()).resolves.toMatchObject({ endpoint: endpointA });
+    expect(ensure).toHaveBeenCalledTimes(1);
+  });
+
+  it('refreshes URL and auth when recovery discovers a replacement endpoint', async () => {
+    const discover = vi.fn()
+      .mockResolvedValueOnce(endpointA)
+      .mockResolvedValueOnce(endpointB);
+    const runtime = createRuntime({ discover, infoVersion: '2.0.15' });
+
+    await runtime.connect();
+    await runtime.recover();
+
+    expect(runtime.getBaseUrl()).toBe(endpointB.url);
+    expect(runtime.getHeaders()).toEqual({ authorization: 'Basic replacement' });
+  });
+
+  it('keeps the active connection when a replacement is incompatible', async () => {
+    const discover = vi.fn()
+      .mockResolvedValueOnce(endpointA)
+      .mockResolvedValueOnce(endpointB);
+    const readInfo = vi.fn()
+      .mockResolvedValueOnce({ version: '2.0.15' })
+      .mockResolvedValueOnce({ version: '1.99.0' });
+    const runtime = createRuntime({ discover, readInfo });
+
+    await runtime.connect();
+    await expect(runtime.recover()).rejects.toMatchObject({ code: 'OPENCODE_INCOMPATIBLE' });
+
+    expect(runtime.getBaseUrl()).toBe(endpointA.url);
+    expect(runtime.getHeaders()).toEqual({ authorization: 'Basic original' });
+  });
+
+  it('dispose does not stop the shared service', async () => {
+    const stop = vi.fn();
+    const runtime = createRuntime({ stop, infoVersion: '2.0.15' });
+    await runtime.connect();
+    await runtime.dispose();
+    expect(stop).not.toHaveBeenCalled();
+    expect(runtime.getConnection()).toBeNull();
+  });
+
+  it.each([
+    [undefined],
+    [{}],
+    [{ url: '' }],
+    [{ url: 'file:///tmp/opencode.sock' }],
+    [{ url: 'not a url' }],
+  ])('rejects a malformed endpoint (%j)', async (endpoint) => {
+    const runtime = createRuntime({ discover: vi.fn().mockResolvedValue(endpoint) });
+
+    await expect(runtime.connect()).rejects.toMatchObject({ code: 'OPENCODE_SERVICE_UNAVAILABLE' });
+  });
+
+  it('reports an authenticated service as unavailable when /api/info returns 401', async () => {
+    const runtime = createRuntime({
+      fetchImpl: vi.fn().mockResolvedValue(new Response(null, { status: 401 })),
+      readInfo: async () => null,
+    });
+
+    await expect(runtime.connect()).rejects.toMatchObject({ code: 'OPENCODE_SERVICE_UNAVAILABLE' });
+  });
+
+  it('reports discovery failures as unavailable without ensuring a replacement', async () => {
+    const ensure = vi.fn();
+    const runtime = createRuntime({
+      discover: vi.fn().mockRejectedValue(new Error('registration unavailable')),
+      ensure,
+    });
+
+    await expect(runtime.connect()).rejects.toMatchObject({ code: 'OPENCODE_SERVICE_UNAVAILABLE' });
+    expect(ensure).not.toHaveBeenCalled();
+  });
+
+  it('reports an unreachable discovered endpoint as unavailable without ensuring a replacement', async () => {
+    const ensure = vi.fn();
+    const runtime = createRuntime({
+      ensure,
+      fetchImpl: vi.fn().mockRejectedValue(new Error('connection refused')),
+    });
+
+    await expect(runtime.connect()).rejects.toMatchObject({ code: 'OPENCODE_SERVICE_UNAVAILABLE' });
+    expect(ensure).not.toHaveBeenCalled();
+  });
+
+  it('uses empty headers when Service.headers returns undefined', async () => {
+    const fetchImpl = vi.fn().mockResolvedValue(Response.json({ version: '2.0.15' }));
+    const runtime = createRuntime({ headers: vi.fn().mockReturnValue(undefined), fetchImpl });
+
+    await runtime.connect();
+
+    expect(runtime.getHeaders()).toEqual({});
+    expect(fetchImpl).toHaveBeenCalledWith(new URL(`${endpointA.url}/api/info`), {
+      headers: { Accept: 'application/json' },
+    });
+  });
+});

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

@@ -13,18 +13,20 @@ export const createGracefulShutdownRuntime = (dependencies) => {
     contextObligatoryRuntime,
     messageQueueRuntime,
     scheduledTasksRuntime,
+    globalEventHub,
     getHealthCheckInterval,
     clearHealthCheckInterval,
     getTerminalRuntime,
     setTerminalRuntime,
     getMessageStreamRuntime,
     setMessageStreamRuntime,
-    shouldSkipOpenCodeStop,
+    getOpenCodeConnectionKind,
     getOpenCodePort,
     getOpenCodeProcess,
     setOpenCodeProcess,
     killProcessOnPort,
     waitForPortRelease,
+    disposeSharedOpenCodeService,
     getServer,
     getUiAuthController,
     setUiAuthController,
@@ -66,7 +68,9 @@ export const createGracefulShutdownRuntime = (dependencies) => {
     beginGuestServiceShutdown();
     syncToHmrState();
     console.log('Starting graceful shutdown...');
-    const exitProcess = typeof options.exitProcess === 'boolean' ? options.exitProcess : getExitOnShutdown();
+    const exitProcess = options.exitProcess === true || options.exitProcess === false
+      ? options.exitProcess
+      : getExitOnShutdown();
 
     // Both embedded stop() and daemon exits use this sequence. Close admission
     // synchronously above, then stop viewers before draining their services.
@@ -77,6 +81,7 @@ export const createGracefulShutdownRuntime = (dependencies) => {
       () => getRelayService()?.stop(),
       () => getDictationRuntime()?.stop(),
       () => openCodeWatcherRuntime.stop(),
+      () => globalEventHub.stop(),
       () => sessionRuntime.dispose(),
       () => sessionAssistRuntime?.stop?.(),
       () => sessionGoalRuntime?.stop?.(),
@@ -118,7 +123,8 @@ export const createGracefulShutdownRuntime = (dependencies) => {
       }
     }
 
-    if (!shouldSkipOpenCodeStop()) {
+    const connectionKind = getOpenCodeConnectionKind();
+    if (connectionKind === 'managed-owned') {
       const portToKill = getOpenCodePort();
       const openCodeProcess = getOpenCodeProcess();
 
@@ -136,8 +142,8 @@ export const createGracefulShutdownRuntime = (dependencies) => {
       if (!(await waitForPortRelease(portToKill, 5000))) {
         console.warn(`Timed out waiting for OpenCode port ${portToKill} to be released during shutdown`);
       }
-    } else {
-      console.log('Skipping OpenCode shutdown (external server)');
+    } else if (connectionKind === 'shared-local') {
+      await disposeSharedOpenCodeService();
     }
 
     const server = getServer();

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

@@ -16,18 +16,20 @@ const createRuntime = (server, overrides = {}) => {
     openCodeWatcherRuntime: { stop: vi.fn() },
     sessionRuntime: { dispose: vi.fn() },
     scheduledTasksRuntime: { stop: vi.fn() },
+    globalEventHub: { stop: vi.fn() },
     getHealthCheckInterval: () => null,
     clearHealthCheckInterval: vi.fn(),
     getTerminalRuntime: () => null,
     setTerminalRuntime: vi.fn(),
     getMessageStreamRuntime: () => null,
     setMessageStreamRuntime: vi.fn(),
-    shouldSkipOpenCodeStop: () => true,
+    getOpenCodeConnectionKind: () => 'explicit-external',
     getOpenCodePort: () => null,
     getOpenCodeProcess: () => null,
     setOpenCodeProcess: vi.fn(),
     killProcessOnPort: vi.fn(),
     waitForPortRelease: vi.fn(async () => true),
+    disposeSharedOpenCodeService: vi.fn(async () => {}),
     getServer: () => server,
     getUiAuthController: () => null,
     setUiAuthController: vi.fn(),
@@ -151,7 +153,7 @@ describe('graceful shutdown runtime', () => {
         throw new Error('fixture cleanup failure');
       },
       getTerminalRuntime: () => ({ shutdown: terminalShutdown }),
-      shouldSkipOpenCodeStop: () => false,
+      getOpenCodeConnectionKind: () => 'managed-owned',
       getOpenCodeProcess: () => ({ close: processClose }),
     });
     await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
@@ -187,6 +189,70 @@ describe('graceful shutdown runtime', () => {
     }
   });
 
+  it('only managed-owned closes and kills OpenCode before waiting for its port', async () => {
+    const close = vi.fn(async () => {});
+    const killProcessOnPort = vi.fn();
+    const waitForPortRelease = vi.fn(async () => true);
+    const disposeSharedOpenCodeService = vi.fn(async () => {});
+    const runtime = createRuntime(null, {
+      getOpenCodeConnectionKind: () => 'managed-owned',
+      getOpenCodePort: () => 4096,
+      getOpenCodeProcess: () => ({ close }),
+      killProcessOnPort,
+      waitForPortRelease,
+      disposeSharedOpenCodeService,
+    });
+
+    await runtime.gracefulShutdown({ exitProcess: false });
+
+    expect(close).toHaveBeenCalledOnce();
+    expect(killProcessOnPort).toHaveBeenCalledWith(4096);
+    expect(waitForPortRelease).toHaveBeenCalledWith(4096, 5000);
+    expect(disposeSharedOpenCodeService).not.toHaveBeenCalled();
+  });
+
+  it('shared-local disposes connection state without touching the shared service process', async () => {
+    const close = vi.fn();
+    const killProcessOnPort = vi.fn();
+    const waitForPortRelease = vi.fn();
+    const disposeSharedOpenCodeService = vi.fn(async () => {});
+    const runtime = createRuntime(null, {
+      getOpenCodeConnectionKind: () => 'shared-local',
+      getOpenCodeProcess: () => ({ close }),
+      killProcessOnPort,
+      waitForPortRelease,
+      disposeSharedOpenCodeService,
+    });
+
+    await runtime.gracefulShutdown({ exitProcess: false });
+
+    expect(disposeSharedOpenCodeService).toHaveBeenCalledOnce();
+    expect(close).not.toHaveBeenCalled();
+    expect(killProcessOnPort).not.toHaveBeenCalled();
+    expect(waitForPortRelease).not.toHaveBeenCalled();
+  });
+
+  it('explicit-external leaves OpenCode and shared state untouched', async () => {
+    const close = vi.fn();
+    const killProcessOnPort = vi.fn();
+    const waitForPortRelease = vi.fn();
+    const disposeSharedOpenCodeService = vi.fn();
+    const runtime = createRuntime(null, {
+      getOpenCodeConnectionKind: () => 'explicit-external',
+      getOpenCodeProcess: () => ({ close }),
+      killProcessOnPort,
+      waitForPortRelease,
+      disposeSharedOpenCodeService,
+    });
+
+    await runtime.gracefulShutdown({ exitProcess: false });
+
+    expect(close).not.toHaveBeenCalled();
+    expect(killProcessOnPort).not.toHaveBeenCalled();
+    expect(waitForPortRelease).not.toHaveBeenCalled();
+    expect(disposeSharedOpenCodeService).not.toHaveBeenCalled();
+  });
+
   it('stops guest services during shutdown', async () => {
     const server = {
       close: vi.fn((callback) => {
@@ -255,6 +321,15 @@ describe('graceful shutdown runtime', () => {
     expect(vi.getTimerCount()).toBe(0);
   });
 
+  it('stops the application-owned global event hub during embedded shutdown', async () => {
+    const globalEventHub = { stop: vi.fn() };
+    const runtime = createRuntime(null, { globalEventHub });
+
+    await runtime.gracefulShutdown({ exitProcess: false });
+
+    expect(globalEventHub.stop).toHaveBeenCalledOnce();
+  });
+
   it('isolates failed viewer and relay cleanup and still drains guests and exits', async () => {
     const stop = vi.fn(() => { throw new Error('stop failed'); });
     const stopAllGuestServices = vi.fn(async () => {});

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

@@ -34,7 +34,6 @@ export const createStartupPipelineRuntime = (dependencies) => {
       terminalRebindWindowMs,
       terminalMaxRebindsPerWindow,
       setupProxy,
-      scheduleOpenCodeApiDetection,
       bootstrapOpenCodeAtStartup,
       staticRoutesRuntime,
       process,
@@ -132,13 +131,15 @@ export const createStartupPipelineRuntime = (dependencies) => {
       bindHost,
       startupTunnelRequest,
       onTunnelReady,
+      afterListening: async ({ activePort }) => {
+        tunnelRuntimeContext.setActivePort(activePort);
+        await bootstrapOpenCodeAtStartup();
+      },
     });
     recordStartupPerformance('web.listener.ready', {
       durationMs: performance.now() - pipelineStartedAt,
     });
-    tunnelRuntimeContext.setActivePort(startupResult.activePort);
-    scheduleOpenCodeApiDetection();
-    void bootstrapOpenCodeAtStartup();
+
 
     serverStartupRuntime.attachProcessHandlers({ attachSignals });
 

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

@@ -3,23 +3,27 @@ import { describe, expect, it, vi } from 'vitest';
 import { createStartupPipelineRuntime } from './startup-pipeline-runtime.js';
 
 describe('startup pipeline runtime', () => {
-  it('publishes the listening port before bootstrapping managed OpenCode', async () => {
+  it('publishes the listening port before awaiting OpenCode bootstrap', async () => {
     const order = [];
+    let releaseBootstrap;
+    const bootstrapGate = new Promise((resolve) => { releaseBootstrap = resolve; });
     const runtime = createStartupPipelineRuntime({
       createTerminalRuntime: () => ({}),
       createDictationRuntime: () => ({}),
       createMessageStreamWsRuntime: () => ({}),
       createServerStartupRuntime: () => ({
         resolveBindHost: () => '127.0.0.1',
-        startListeningAndMaybeTunnel: async () => {
+        startListeningAndMaybeTunnel: async ({ afterListening }) => {
           order.push('listen');
+          await afterListening({ activePort: 3901, bindHost: '127.0.0.1' });
+          order.push('ready');
           return { activePort: 3901 };
         },
         attachProcessHandlers: vi.fn(),
       }),
     });
 
-    await runtime.run({
+    const run = runtime.run({
       app: {},
       setupProxy: vi.fn(),
       staticRoutesRuntime: { registerStaticRoutes: vi.fn() },
@@ -27,14 +31,21 @@ describe('startup pipeline runtime', () => {
       tunnelRuntimeContext: {
         setActivePort: (port) => order.push(`port:${port}`),
       },
-      scheduleOpenCodeApiDetection: () => order.push('detect'),
-      bootstrapOpenCodeAtStartup: () => order.push('bootstrap'),
+      bootstrapOpenCodeAtStartup: async () => {
+        order.push('bootstrap');
+        await bootstrapGate;
+      },
       process: {},
       crypto: {},
-      server: {},
+      server: { close: (callback) => callback() },
       attachSignals: false,
     });
 
-    expect(order).toEqual(['listen', 'port:3901', 'detect', 'bootstrap']);
+    await Promise.resolve();
+    expect(order).toEqual(['listen', 'port:3901', 'bootstrap']);
+    releaseBootstrap();
+    await run;
+
+    expect(order).toEqual(['listen', 'port:3901', 'bootstrap', 'ready']);
   });
 });

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

@@ -3,6 +3,21 @@ import { afterEach, describe, expect, it, vi } from 'vitest';
 import { createGlobalMessageStreamHub } from '../event-stream/global-hub.js';
 import { createOpenCodeWatcherRuntime } from './watcher.js';
 
+async function waitForAssertion(assertion) {
+  const deadline = Date.now() + 1000;
+  let lastError;
+  while (Date.now() < deadline) {
+    try {
+      assertion();
+      return;
+    } catch (error) {
+      lastError = error;
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+  }
+  throw lastError;
+}
+
 function createSseResponse({ blocks = [], signal, holdOpen = false }) {
   const encoder = new TextEncoder();
   let index = 0;
@@ -189,6 +204,45 @@ describe('createOpenCodeWatcherRuntime', () => {
     });
   });
 
+  it('keeps its shared subscription across a hub rebind', async () => {
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+    let generation = 0;
+    const payloads = [];
+    const globalEventHub = createGlobalMessageStreamHub({
+      buildOpenCodeUrl: () => `http://127.0.0.1:${generation === 0 ? 4096 : 5096}/api/event`,
+      getOpenCodeAuthHeaders: () => ({ Authorization: generation === 0 ? 'Basic first' : 'Basic second' }),
+      upstreamReconnectDelayMs: 60_000,
+      fetchImpl: async (_url, options) => createSseResponse({
+        signal: options.signal,
+        holdOpen: true,
+        blocks: [generation === 0
+          ? 'data: {"id":"evt-1","type":"server.connected","data":{}}\n\n'
+          : 'data: {"id":"evt-2","type":"session.renamed","location":{"directory":"/tmp/project"},"data":{"sessionID":"ses_1","title":"Recovered"}}\n\n'],
+      }),
+    });
+    const watcher = createOpenCodeWatcherRuntime({
+      waitForOpenCodePort: async () => {},
+      buildOpenCodeUrl: () => '',
+      getOpenCodeAuthHeaders: () => ({}),
+      globalEventHub,
+      onPayload: (payload) => payloads.push(payload),
+    });
+
+    try {
+      await watcher.start();
+      await waitForAssertion(() => expect(payloads.map((payload) => payload.type)).toContain('server.connected'));
+      generation = 1;
+      globalEventHub.rebind();
+      await waitForAssertion(() => expect(payloads).toContainEqual(expect.objectContaining({
+        type: 'session.updated',
+        properties: expect.objectContaining({ sessionID: 'ses_1' }),
+      })));
+    } finally {
+      watcher.stop();
+      globalEventHub.stop();
+    }
+  });
+
   it('does not stop a shared global event hub when the watcher stops', async () => {
     const events = new Set();
     const statuses = new Set();