@aiwg/cockpit 2026.7.11 → 2026.7.13

package/web/src/components/Library.tsx

@@ -29,7 +29,7 @@ export function Library({ session, setComposer, goSessions }: { session: Session
   };
   const use = (a: LibraryAsset) => {
     const cmd = capRef(a.type, a.name.replace(/\.(md|markdown|ya?ml|json)$/i, ''));
-    if (!(session.isController && session.sendInput(cmd))) setComposer(cmd);
+    if (!(session.isController && session.state.target && session.sendInput(cmd, session.state.target))) setComposer(cmd);
     goSessions();
   };
 

package/web/src/components/Sessions.test.tsx

@@ -1,7 +1,8 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { render, screen, waitFor, fireEvent, cleanup, within } from '@testing-library/react';
+import { render, screen, waitFor, fireEvent, cleanup, within, act } from '@testing-library/react';
 import { Sessions } from './Sessions';
 import type { SessionApi } from '../useSession';
+import { resetSessionRegistryForTest, updateRegistrySessionSnapshot } from '../sessionRegistry';
 
 const INSTANCE = {
   id: 'inst-1',
@@ -21,10 +22,40 @@ const INSTANCE_NEXT = {
   id: 'inst-2',
   launch_context: { name: 'docker-two', loadout: 'agentic-dev' },
 };
+const STALE_INSTANCE = {
+  ...INSTANCE,
+  id: 'stale-docker',
+  agent_ready: false,
+  launch_context: { name: 'stale-docker', loadout: 'agentic-dev' },
+  session_backends: [{
+    mode: 'managed',
+    backend: 'tmux',
+    available: false,
+    drive: true,
+    keyframe: true,
+    reason: 'container is running but the agent has not registered; PTY sessions are not ready',
+  }],
+};
+const STALE_VM_INSTANCE = {
+  ...STALE_INSTANCE,
+  id: 'stale-vm',
+  runtime: 'vm',
+  runtime_posture: { kind: 'vm', isolation: 'strong', label: 'VM / hardware boundary' },
+  launch_context: { name: 'stale-vm', loadout: 'agentic-dev' },
+  session_backends: [{
+    mode: 'managed',
+    backend: 'tmux',
+    available: false,
+    drive: true,
+    keyframe: true,
+    reason: 'VM is running but the agent has not registered; PTY sessions are not ready',
+  }],
+};
 
-function stubSession(): SessionApi {
+function stubSession(state: Partial<SessionApi['state']> = {}): SessionApi {
+  const nextState = { attached: true, role: 'controller', url: 'ws://x/agents/inst-1/sessions/sess-1/attach', ...state };
   return {
-    state: { attached: true, role: 'controller', url: 'ws://x/agents/inst-1/sessions/sess-1/attach' },
+    state: nextState,
     responseNeeded: { needed: false, prompt: '', since: null, source: 'pty' },
     attach: vi.fn(),
     detach: vi.fn(),
@@ -32,12 +63,13 @@ function stubSession(): SessionApi {
     requestKeyframe: vi.fn(),
     sendInput: vi.fn(),
     openTerminal: vi.fn(),
-    isController: true,
+    isController: nextState.role === 'controller',
   } as unknown as SessionApi;
 }
 
 beforeEach(() => {
   (window as unknown as { __COCKPIT_TOKEN__: string }).__COCKPIT_TOKEN__ = 'test-token';
+  resetSessionRegistryForTest();
   vi.spyOn(window, 'confirm').mockReturnValue(true);
 });
 
@@ -74,11 +106,11 @@ describe('Sessions', () => {
       expect.stringContaining('/api/instances/inst-1/sessions/sess-1'),
       expect.objectContaining({ method: 'DELETE' }),
     ));
-    expect(session.detach).toHaveBeenCalled();
+    await waitFor(() => expect(session.detach).toHaveBeenCalled());
   });
 
   it('refreshes stale recovered inventory and stops offering dead session attach URLs', async () => {
-    const session = stubSession();
+    const session = stubSession({ attached: false, role: null, url: null });
     const inventories = [
       { instances: [INSTANCE] },
       { instances: [INSTANCE_NEXT] },
@@ -121,6 +153,56 @@ describe('Sessions', () => {
     expect(await within(nav).findByTitle('sess-new')).toBeTruthy();
   });
 
+  it('keeps a stale running container visible with reconnect guidance', async () => {
+    const session = stubSession({ attached: false, role: null, url: null });
+    const fetchMock = vi.fn(async (input: RequestInfo | URL, init?: RequestInit) => {
+      const url = String(input);
+      if (url.includes('/api/inventory')) return jsonResponse({ instances: [STALE_INSTANCE] });
+      if (url.includes('/api/sessions?instance=stale-docker')) return jsonResponse({ sessions: [] });
+      if (url.includes('/api/instances/stale-docker/reconnect') && init?.method === 'POST') {
+        return jsonResponse({ state: 'reconnecting' });
+      }
+      return new Response('{}', { status: 404 });
+    });
+    globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+    render(<Sessions session={session} composer="" setComposer={() => {}} onRequestStart={() => {}} refreshMs={60_000} />);
+
+    const nav = screen.getByLabelText('Instances and sessions');
+    expect(await within(nav).findByText('stale-docker')).toBeTruthy();
+    expect(await screen.findByText(/agent is unreachable while the runtime is still running/i)).toBeTruthy();
+    fireEvent.click(screen.getByRole('button', { name: 'Reconnect' }));
+    await waitFor(() => expect(fetchMock).toHaveBeenCalledWith(
+      expect.stringContaining('/api/instances/stale-docker/reconnect'),
+      expect.objectContaining({ method: 'POST' }),
+    ));
+  });
+
+  it('keeps a stale running VM visible with reconnect guidance (#1778)', async () => {
+    const session = stubSession({ attached: false, role: null, url: null });
+    const fetchMock = vi.fn(async (input: RequestInfo | URL, init?: RequestInit) => {
+      const url = String(input);
+      if (url.includes('/api/inventory')) return jsonResponse({ instances: [STALE_VM_INSTANCE] });
+      if (url.includes('/api/sessions?instance=stale-vm')) return jsonResponse({ sessions: [] });
+      if (url.includes('/api/instances/stale-vm/reconnect') && init?.method === 'POST') {
+        return jsonResponse({ state: 'reconnecting' });
+      }
+      return new Response('{}', { status: 404 });
+    });
+    globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+    render(<Sessions session={session} composer="" setComposer={() => {}} onRequestStart={() => {}} refreshMs={60_000} />);
+
+    const nav = screen.getByLabelText('Instances and sessions');
+    expect(await within(nav).findByText('stale-vm')).toBeTruthy();
+    expect(await screen.findByText(/agent is unreachable while the runtime is still running/i)).toBeTruthy();
+    fireEvent.click(screen.getByRole('button', { name: 'Reconnect' }));
+    await waitFor(() => expect(fetchMock).toHaveBeenCalledWith(
+      expect.stringContaining('/api/instances/stale-vm/reconnect'),
+      expect.objectContaining({ method: 'POST' }),
+    ));
+  });
+
   it('keeps controller posture when a different session is selected while driving (#1670)', async () => {
     const session = stubSession(); // currently attached to .../sessions/sess-1/attach as controller
     const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
@@ -139,7 +221,109 @@ describe('Sessions', () => {
     fireEvent.click(sessBtn);
     // Selecting a not-yet-attached session should not silently downgrade an
     // operator who is already driving another session.
-    expect(session.attach).toHaveBeenCalledWith('ws://x/agents/inst-1/sessions/sess-2/attach', false, 'controller');
+    expect(session.attach).toHaveBeenCalledWith('ws://x/agents/inst-1/sessions/sess-2/attach', false, 'controller', { instanceId: 'inst-1', sessionId: 'sess-2' });
+  });
+
+  it('does not detach the live session when browsing another instance (#1739)', async () => {
+    const session = stubSession();
+    const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
+      const url = String(input);
+      if (url.includes('/api/inventory')) return jsonResponse({ instances: [INSTANCE, INSTANCE_NEXT] });
+      if (url.includes('instance=inst-1')) return jsonResponse({
+        sessions: [{ id: 'sess-1', session_name: 'terminal-main', instance_id: 'inst-1', attach_url: 'ws://x/agents/inst-1/sessions/sess-1/attach', mode: 'managed', backend: 'tmux' }],
+      });
+      if (url.includes('instance=inst-2')) return jsonResponse({
+        sessions: [{ id: 'sess-2', session_name: 'terminal-other', instance_id: 'inst-2', attach_url: 'ws://x/agents/inst-2/sessions/sess-2/attach', mode: 'managed', backend: 'tmux' }],
+      });
+      return new Response('{}', { status: 404 });
+    });
+    globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+    render(<Sessions session={session} composer="" setComposer={() => {}} onRequestStart={() => {}} />);
+
+    expect((await screen.findAllByTitle('sess-1')).length).toBeGreaterThan(0);
+    fireEvent.click(await screen.findByText('docker-two'));
+    expect((await screen.findAllByText('terminal-other')).length).toBeGreaterThan(0);
+
+    expect(session.detach).not.toHaveBeenCalled();
+  });
+
+  it('treats the instance/session pair as live identity when attach URLs diverge (#1741)', async () => {
+    const session = stubSession({ url: 'ws://executor-a/agents/inst-1/sessions/sess-1/attach?from=create' });
+    const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
+      const url = String(input);
+      if (url.includes('/api/inventory')) return jsonResponse({ instances: [INSTANCE] });
+      if (url.includes('/api/sessions?instance=')) return jsonResponse({
+        sessions: [{
+          id: 'sess-1',
+          session_name: 'terminal-main',
+          instance_id: 'inst-1',
+          attach_url: 'ws://executor-b/agents/inst-1/sessions/sess-1/attach',
+          mode: 'managed',
+          backend: 'tmux',
+        }],
+      });
+      return new Response('{}', { status: 404 });
+    });
+    globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+    render(<Sessions session={session} composer="" setComposer={() => {}} onRequestStart={() => {}} />);
+
+    const nav = screen.getByLabelText('Instances and sessions');
+    expect(await within(nav).findByTitle('Attached here')).toBeTruthy();
+    expect(session.detach).not.toHaveBeenCalled();
+  });
+
+  it('ignores stale session-list responses after switching instances (#1740)', async () => {
+    const session = stubSession({ attached: false, role: null, url: null });
+    let resolveInst1: (value: Response) => void = () => {};
+    const inst1Sessions = new Promise<Response>((resolve) => { resolveInst1 = resolve; });
+    const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
+      const url = String(input);
+      if (url.includes('/api/inventory')) return jsonResponse({ instances: [INSTANCE, INSTANCE_NEXT] });
+      if (url.includes('instance=inst-1')) return inst1Sessions;
+      if (url.includes('instance=inst-2')) return jsonResponse({
+        sessions: [{ id: 'sess-2', session_name: 'terminal-two', instance_id: 'inst-2', attach_url: 'ws://x/agents/inst-2/sessions/sess-2/attach', mode: 'managed', backend: 'tmux' }],
+      });
+      return new Response('{}', { status: 404 });
+    });
+    globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+    render(<Sessions session={session} composer="" setComposer={() => {}} onRequestStart={() => {}} refreshMs={60_000} />);
+
+    fireEvent.click(await screen.findByText('docker-two'));
+    const nav = screen.getByLabelText('Instances and sessions');
+    expect(await within(nav).findByTitle('sess-2')).toBeTruthy();
+
+    resolveInst1(jsonResponse({
+      sessions: [{ id: 'sess-1', session_name: 'terminal-one', instance_id: 'inst-1', attach_url: 'ws://x/agents/inst-1/sessions/sess-1/attach', mode: 'managed', backend: 'tmux' }],
+    }));
+
+    await waitFor(() => expect(within(nav).queryByText('terminal-one')).toBeNull());
+    expect(within(nav).getByText('terminal-two')).toBeTruthy();
+  });
+
+  it('requires two consecutive missing polls before detaching the attached session (#1740)', async () => {
+    const session = stubSession();
+    const sessionResponses = [
+      [{ id: 'sess-1', session_name: 'terminal-main', instance_id: 'inst-1', attach_url: 'ws://x/agents/inst-1/sessions/sess-1/attach', mode: 'managed', backend: 'tmux' }],
+      [{ id: 'sess-1', session_name: 'terminal-main', instance_id: 'inst-1', attach_url: 'ws://x/agents/inst-1/sessions/sess-1/attach', mode: 'managed', backend: 'tmux' }],
+      [{ id: 'sess-other', session_name: 'terminal-other', instance_id: 'inst-1', attach_url: 'ws://x/agents/inst-1/sessions/sess-other/attach', mode: 'managed', backend: 'tmux' }],
+      [{ id: 'sess-other', session_name: 'terminal-other', instance_id: 'inst-1', attach_url: 'ws://x/agents/inst-1/sessions/sess-other/attach', mode: 'managed', backend: 'tmux' }],
+    ];
+    const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
+      const url = String(input);
+      if (url.includes('/api/inventory')) return jsonResponse({ instances: [INSTANCE] });
+      if (url.includes('/api/sessions?instance=')) return jsonResponse({ sessions: sessionResponses.shift() ?? sessionResponses[sessionResponses.length - 1] ?? [] });
+      return new Response('{}', { status: 404 });
+    });
+    globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+    render(<Sessions session={session} composer="" setComposer={() => {}} onRequestStart={() => {}} refreshMs={250} />);
+    expect(await screen.findByTitle('sess-other')).toBeTruthy();
+    expect(session.detach).not.toHaveBeenCalled();
+
+    await waitFor(() => expect(session.detach).toHaveBeenCalledTimes(1), { timeout: 1_200 });
   });
 
   it('reattaches with replay instead of downgrading when re-selecting the session already attached', async () => {
@@ -160,7 +344,7 @@ describe('Sessions', () => {
     // Clicking the session we already drive replays/reasserts controller; it
     // must not downgrade us back to observer.
     expect(session.attach).not.toHaveBeenCalled();
-    expect(session.replay).toHaveBeenCalledWith('ws://x/agents/inst-1/sessions/sess-1/attach', 'controller');
+    expect(session.replay).toHaveBeenCalledWith('ws://x/agents/inst-1/sessions/sess-1/attach', 'controller', { instanceId: 'inst-1', sessionId: 'sess-1' });
   });
 
   it('distinguishes sessions by name + backend + viewer count in the nav (#1670)', async () => {
@@ -170,8 +354,8 @@ describe('Sessions', () => {
       if (url.includes('/api/inventory')) return jsonResponse({ instances: [INSTANCE] });
       if (url.includes('/api/sessions?instance=')) return jsonResponse({
         sessions: [
-          { id: 'sess-a', session_name: 'terminal-alpha', instance_id: 'inst-1', attach_url: 'ws://x/agents/inst-1/sessions/sess-a/attach', mode: 'managed', backend: 'tmux', controllers: 1, observers: 1 },
-          { id: 'sess-b', session_name: 'terminal-beta', instance_id: 'inst-1', attach_url: 'ws://x/agents/inst-1/sessions/sess-b/attach', mode: 'direct', backend: 'native', members: 0 },
+          { id: 'sess-a', session_name: 'terminal-alpha', instance_id: 'inst-1', attach_url: 'ws://x/agents/inst-1/sessions/sess-a/attach', session_class: 'managed', session_backend: 'tmux', membership: { controllers: ['c1'], observers: ['o1'], attachment_count: 2 } },
+          { id: 'sess-b', session_name: 'terminal-beta', instance_id: 'inst-1', attach_url: 'ws://x/agents/inst-1/sessions/sess-b/attach', session_class: 'direct', session_backend: 'native', membership: { controllers: [], observers: [], attachment_count: 0 } },
         ],
       });
       return new Response('{}', { status: 404 });
@@ -191,6 +375,60 @@ describe('Sessions', () => {
     // sess-a has a controller connected → it carries the ctrl badge; sess-b does not.
     expect(within(nav).getByTitle('A controller is connected')).toBeTruthy();
   });
+
+  it('shows registry unread and response-needed badges and clears unread on view', async () => {
+    const session = stubSession({ attached: false, role: null, url: null });
+    const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
+      const url = String(input);
+      if (url.includes('/api/inventory')) return jsonResponse({ instances: [INSTANCE] });
+      if (url.includes('/api/sessions?instance=')) return jsonResponse({
+        sessions: [
+          { id: 'sess-a', session_name: 'terminal-alpha', instance_id: 'inst-1', attach_url: 'ws://x/agents/inst-1/sessions/sess-a/attach', session_class: 'managed', session_backend: 'tmux' },
+          { id: 'sess-b', session_name: 'terminal-beta', instance_id: 'inst-1', attach_url: 'ws://x/agents/inst-1/sessions/sess-b/attach', session_class: 'managed', session_backend: 'tmux' },
+        ],
+      });
+      return new Response('{}', { status: 404 });
+    });
+    globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+    render(<Sessions session={session} composer="" setComposer={() => {}} onRequestStart={() => {}} />);
+
+    const nav = screen.getByLabelText('Instances and sessions');
+    const beta = await within(nav).findByTitle('sess-b');
+    act(() => updateRegistrySessionSnapshot('inst-1', 'sess-b', 'Deploy to prod? [y/N]\n'));
+
+    expect(await within(nav).findByTitle('Unread output')).toBeTruthy();
+    expect(within(nav).getByTitle('Response needed')).toBeTruthy();
+
+    fireEvent.click(beta);
+    await waitFor(() => expect(within(nav).queryByTitle('Unread output')).toBeNull());
+    expect(within(nav).getByTitle('Response needed')).toBeTruthy();
+  });
+
+  it('omits viewer counts when the session source does not provide membership fields (#1745)', async () => {
+    const session = stubSession();
+    const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
+      const url = String(input);
+      if (url.includes('/api/inventory')) return jsonResponse({ instances: [INSTANCE] });
+      if (url.includes('/api/sessions?instance=')) return jsonResponse({
+        sessions: [
+          { id: 'sess-bare', session_name: 'terminal-bare', instance_id: 'inst-1', attach_url: 'ws://x/agents/inst-1/sessions/sess-bare/attach', session_class: 'managed', session_backend: 'tmux' },
+          { id: 'sess-rich', session_name: 'terminal-rich', instance_id: 'inst-1', attach_url: 'ws://x/agents/inst-1/sessions/sess-rich/attach', session_class: 'managed', session_backend: 'tmux', membership: { controllers: ['c1'], observers: ['o1'], attachment_count: 2 } },
+        ],
+      });
+      return new Response('{}', { status: 404 });
+    });
+    globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+    render(<Sessions session={session} composer="" setComposer={() => {}} onRequestStart={() => {}} />);
+
+    await screen.findByText('terminal-rich');
+    const nav = screen.getByLabelText('Instances and sessions');
+    expect(within(nav).getAllByText('managed/tmux')).toHaveLength(1);
+    expect(within(nav).getByText('managed/tmux · 2 viewers')).toBeTruthy();
+    expect(within(nav).getByTitle('A controller is connected')).toBeTruthy();
+    expect(within(nav).queryByText('0 viewers')).toBeNull();
+  });
 });
 
 function jsonResponse(body: unknown): Response {