@aiwg/cockpit 2026.7.11 → 2026.7.13

package/web/src/sessionMonitor.ts

@@ -0,0 +1,72 @@
+import { useEffect, useRef } from 'react';
+import { apiRaw } from './api';
+import {
+  getSessionRegistrySnapshot,
+  updateRegistrySessionSnapshot,
+  useSessionRegistry,
+} from './sessionRegistry';
+
+interface ScreenSnapshotResponse {
+  text?: string;
+  snapshot?: string;
+  screen?: string;
+  content?: string;
+  seq?: number;
+  sequence?: number;
+  anchor_sequence?: number;
+  anchorSequence?: number;
+}
+
+export function useSessionSnapshotMonitor(refreshMs = 12_000) {
+  useSessionRegistry();
+  // Sessions whose screen endpoint returned 404 (no server-side snapshot — e.g.
+  // host-runtime PTYs). Skip them on subsequent ticks so we don't re-request a
+  // known-missing endpoint every cycle and flood the console with 404s.
+  const noScreenRef = useRef<Set<string>>(new Set());
+
+  useEffect(() => {
+    let cancelled = false;
+    let timer: number | undefined;
+    const schedule = (ms = refreshMs) => {
+      timer = window.setTimeout(tick, ms);
+    };
+    const tick = async () => {
+      if (cancelled) return;
+      if (document.hidden) {
+        schedule(refreshMs);
+        return;
+      }
+      const entries = Object.values(getSessionRegistrySnapshot().entries)
+        .filter((entry) => !entry.attached)
+        .filter((entry) => entry.metadata.has_screen !== false)
+        .filter((entry) => !noScreenRef.current.has(`${entry.instanceId}:${entry.sessionId}`));
+      await Promise.all(entries.map(async (entry) => {
+        const key = `${entry.instanceId}:${entry.sessionId}`;
+        try {
+          const res = await apiRaw(
+            `/api/instances/${encodeURIComponent(entry.instanceId)}/sessions/${encodeURIComponent(entry.sessionId)}/screen`,
+          );
+          if (!res.ok) {
+            // No server-side snapshot for this session (e.g. host PTY). Stop
+            // polling it so it doesn't re-404 every cycle.
+            if (res.status === 404) noScreenRef.current.add(key);
+            return;
+          }
+          const snapshot = (await res.json()) as ScreenSnapshotResponse;
+          const text = String(snapshot.text ?? snapshot.snapshot ?? snapshot.screen ?? snapshot.content ?? '');
+          const seq = snapshot.seq ?? snapshot.sequence ?? snapshot.anchor_sequence ?? snapshot.anchorSequence;
+          updateRegistrySessionSnapshot(entry.instanceId, entry.sessionId, text, { seq: typeof seq === 'number' ? seq : undefined });
+        } catch {
+          // Snapshot support is opportunistic. A transient network error should
+          // not break the active driven terminal or session list.
+        }
+      }));
+      if (!cancelled) schedule(refreshMs);
+    };
+    schedule(0);
+    return () => {
+      cancelled = true;
+      if (timer !== undefined) window.clearTimeout(timer);
+    };
+  }, [refreshMs]);
+}

package/web/src/sessionRegistry.test.ts

@@ -0,0 +1,112 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import {
+  getSessionRegistrySnapshot,
+  interactivePromptFrom,
+  markRegistrySessionViewed,
+  registryResponseNeededItems,
+  resetSessionRegistryForTest,
+  sessionRegistryKey,
+  setRegistryActiveSession,
+  subscribeSessionRegistry,
+  updateRegistrySessionSnapshot,
+  upsertRegistrySessions,
+} from './sessionRegistry';
+import type { SessionInfo } from './types';
+
+const SESSION_A: SessionInfo = {
+  id: 'sess-a',
+  instance_id: 'inst-a',
+  attach_url: 'ws://x/agents/inst-a/sessions/sess-a/attach',
+  session_name: 'terminal-a',
+};
+
+const SESSION_B: SessionInfo = {
+  id: 'sess-b',
+  instance_id: 'inst-b',
+  attach_url: 'ws://x/agents/inst-b/sessions/sess-b/attach',
+  session_name: 'terminal-b',
+};
+
+beforeEach(() => resetSessionRegistryForTest());
+
+describe('sessionRegistry', () => {
+  it('keys entries by instance/session identity and preserves existing snapshot state on metadata refresh', () => {
+    upsertRegistrySessions([SESSION_A], '2026-07-06T20:00:00.000Z');
+    updateRegistrySessionSnapshot('inst-a', 'sess-a', 'hello\n', { now: '2026-07-06T20:00:01.000Z' });
+    upsertRegistrySessions([{ ...SESSION_A, session_name: 'renamed' }], '2026-07-06T20:00:02.000Z');
+
+    const entry = getSessionRegistrySnapshot().entries[sessionRegistryKey('inst-a', 'sess-a')];
+    expect(entry.metadata.session_name).toBe('renamed');
+    expect(entry.snapshot?.text).toBe('hello\n');
+    expect(entry.unread).toBe(true);
+  });
+
+  it('tracks the active attached session without dropping background entries', () => {
+    upsertRegistrySessions([SESSION_A, SESSION_B]);
+    setRegistryActiveSession('inst-a', 'sess-a', '2026-07-06T20:01:00.000Z');
+
+    const snapshot = getSessionRegistrySnapshot();
+    expect(snapshot.activeKey).toBe('inst-a:sess-a');
+    expect(snapshot.entries['inst-a:sess-a'].attached).toBe(true);
+    expect(snapshot.entries['inst-b:sess-b'].attached).toBe(false);
+  });
+
+  it('marks background snapshot changes unread and clears unread on view', () => {
+    upsertRegistrySessions([SESSION_A]);
+    updateRegistrySessionSnapshot('inst-a', 'sess-a', 'new output\n', { now: '2026-07-06T20:02:00.000Z' });
+    expect(getSessionRegistrySnapshot().entries['inst-a:sess-a'].unread).toBe(true);
+
+    markRegistrySessionViewed('inst-a', 'sess-a');
+    expect(getSessionRegistrySnapshot().entries['inst-a:sess-a'].unread).toBe(false);
+  });
+
+  it('does not mark the actively attached session unread for its own snapshot changes', () => {
+    upsertRegistrySessions([SESSION_A]);
+    setRegistryActiveSession('inst-a', 'sess-a');
+    updateRegistrySessionSnapshot('inst-a', 'sess-a', 'driver output\n');
+
+    expect(getSessionRegistrySnapshot().entries['inst-a:sess-a'].unread).toBe(false);
+  });
+
+  it('detects response-needed prompts from snapshot tails', () => {
+    upsertRegistrySessions([SESSION_A]);
+    updateRegistrySessionSnapshot('inst-a', 'sess-a', 'Deploy to prod? [y/N]\n', { now: '2026-07-06T20:03:00.000Z' });
+
+    const response = getSessionRegistrySnapshot().entries['inst-a:sess-a'].responseNeeded;
+    expect(response).toMatchObject({
+      needed: true,
+      prompt: 'Deploy to prod? [y/N]',
+      since: '2026-07-06T20:03:00.000Z',
+      source: 'snapshot',
+    });
+  });
+
+  it('projects response-needed entries for the approvals inbox', () => {
+    upsertRegistrySessions([SESSION_A]);
+    updateRegistrySessionSnapshot('inst-a', 'sess-a', 'Deploy to prod? [y/N]\n', { now: '2026-07-06T20:03:00.000Z' });
+
+    expect(registryResponseNeededItems(getSessionRegistrySnapshot())).toEqual([{
+      id: 'pty:inst-a:sess-a',
+      instance_id: 'inst-a',
+      prompt: 'Deploy to prod? [y/N]',
+      source: 'snapshot',
+      status: 'response-needed',
+      attach_url: 'ws://x/agents/inst-a/sessions/sess-a/attach',
+    }]);
+  });
+
+  it('notifies subscribers when registry state changes', () => {
+    const listener = vi.fn();
+    const unsubscribe = subscribeSessionRegistry(listener);
+    upsertRegistrySessions([SESSION_A]);
+    unsubscribe();
+    upsertRegistrySessions([SESSION_B]);
+
+    expect(listener).toHaveBeenCalledTimes(1);
+  });
+
+  it('exports the prompt heuristic for monitor and PTY plumbing reuse', () => {
+    expect(interactivePromptFrom('Choose one\n1. yes\n2. no\n')).toContain('Choose one');
+    expect(interactivePromptFrom('plain build output\n')).toBe('');
+  });
+});

package/web/src/sessionRegistry.ts

@@ -0,0 +1,192 @@
+import { useSyncExternalStore } from 'react';
+import type { ResponseNeeded, SessionInfo } from './types';
+
+export interface RegistryResponseNeeded {
+  needed: boolean;
+  prompt: string;
+  since: string | null;
+  source: 'snapshot' | 'pty';
+}
+
+export interface RegistrySnapshot {
+  text: string;
+  lines: string[];
+  fetchedAt: string;
+  seq?: number;
+}
+
+export interface RegistrySessionEntry {
+  key: string;
+  instanceId: string;
+  sessionId: string;
+  metadata: SessionInfo;
+  lastOutputAt: string | null;
+  unread: boolean;
+  responseNeeded: RegistryResponseNeeded;
+  snapshot: RegistrySnapshot | null;
+  attached: boolean;
+  updatedAt: string;
+}
+
+interface RegistryState {
+  activeKey: string | null;
+  entries: Record<string, RegistrySessionEntry>;
+}
+
+type Listener = () => void;
+
+const EMPTY_RESPONSE: RegistryResponseNeeded = { needed: false, prompt: '', since: null, source: 'snapshot' };
+
+let state: RegistryState = { activeKey: null, entries: {} };
+const listeners = new Set<Listener>();
+
+export function sessionRegistryKey(instanceId: string, sessionId: string): string {
+  return `${instanceId}:${sessionId}`;
+}
+
+export function sessionRegistryKeyFor(s: Pick<SessionInfo, 'instance_id' | 'id'>): string {
+  return sessionRegistryKey(s.instance_id, s.id);
+}
+
+export function subscribeSessionRegistry(listener: Listener): () => void {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+
+export function getSessionRegistrySnapshot(): RegistryState {
+  return state;
+}
+
+export function useSessionRegistry(): RegistryState {
+  return useSyncExternalStore(subscribeSessionRegistry, getSessionRegistrySnapshot, getSessionRegistrySnapshot);
+}
+
+export function registryResponseNeededItems(registry: RegistryState): ResponseNeeded[] {
+  return Object.values(registry.entries)
+    .filter((entry) => entry.responseNeeded.needed)
+    .map((entry) => ({
+      id: `pty:${entry.key}`,
+      instance_id: entry.instanceId,
+      prompt: entry.responseNeeded.prompt,
+      source: entry.responseNeeded.source,
+      status: 'response-needed',
+      attach_url: entry.metadata.attach_url,
+    }));
+}
+
+export function resetSessionRegistryForTest() {
+  state = { activeKey: null, entries: {} };
+  emit();
+}
+
+export function upsertRegistrySessions(sessions: SessionInfo[], now = new Date().toISOString()) {
+  if (!sessions.length) return;
+  update((prev) => {
+    const entries = { ...prev.entries };
+    for (const session of sessions) {
+      const key = sessionRegistryKeyFor(session);
+      const prior = entries[key];
+      entries[key] = {
+        key,
+        instanceId: session.instance_id,
+        sessionId: session.id,
+        metadata: { ...(prior?.metadata ?? {}), ...session },
+        lastOutputAt: prior?.lastOutputAt ?? null,
+        unread: prior?.unread ?? false,
+        responseNeeded: prior?.responseNeeded ?? EMPTY_RESPONSE,
+        snapshot: prior?.snapshot ?? null,
+        attached: prior?.attached ?? false,
+        updatedAt: now,
+      };
+    }
+    return { ...prev, entries };
+  });
+}
+
+export function setRegistryActiveSession(instanceId: string | null, sessionId: string | null, now = new Date().toISOString()) {
+  const nextActiveKey = instanceId && sessionId ? sessionRegistryKey(instanceId, sessionId) : null;
+  update((prev) => {
+    const entries = { ...prev.entries };
+    for (const [key, entry] of Object.entries(entries)) {
+      if (entry.attached !== (key === nextActiveKey)) entries[key] = { ...entry, attached: key === nextActiveKey, updatedAt: now };
+    }
+    return { activeKey: nextActiveKey, entries };
+  });
+}
+
+export function markRegistrySessionViewed(instanceId: string, sessionId: string, now = new Date().toISOString()) {
+  const key = sessionRegistryKey(instanceId, sessionId);
+  updateEntry(key, (entry) => ({ ...entry, unread: false, updatedAt: now }));
+}
+
+export function updateRegistrySessionSnapshot(
+  instanceId: string,
+  sessionId: string,
+  snapshotText: string,
+  options: { seq?: number; now?: string; source?: RegistryResponseNeeded['source'] } = {},
+) {
+  const key = sessionRegistryKey(instanceId, sessionId);
+  const now = options.now ?? new Date().toISOString();
+  updateEntry(key, (entry) => {
+    const previousText = entry.snapshot?.text ?? '';
+    const text = snapshotText;
+    const changed = text !== previousText;
+    const prompt = interactivePromptFrom(text);
+    return {
+      ...entry,
+      lastOutputAt: changed ? now : entry.lastOutputAt,
+      unread: entry.attached ? false : entry.unread || changed,
+      responseNeeded: prompt
+        ? { needed: true, prompt, since: entry.responseNeeded.prompt === prompt ? entry.responseNeeded.since : now, source: options.source ?? 'snapshot' }
+        : { ...EMPTY_RESPONSE, source: options.source ?? 'snapshot' },
+      snapshot: { text, lines: tailLines(text), fetchedAt: now, seq: options.seq },
+      updatedAt: now,
+    };
+  });
+}
+
+function updateEntry(key: string, mapper: (entry: RegistrySessionEntry) => RegistrySessionEntry) {
+  update((prev) => {
+    const current = prev.entries[key];
+    if (!current) return prev;
+    return { ...prev, entries: { ...prev.entries, [key]: mapper(current) } };
+  });
+}
+
+function update(mapper: (prev: RegistryState) => RegistryState) {
+  const next = mapper(state);
+  if (next === state) return;
+  state = next;
+  emit();
+}
+
+function emit() {
+  for (const listener of listeners) listener();
+}
+
+function tailLines(text: string, maxLines = 24): string[] {
+  return text.replace(/\r/g, '\n').split('\n').filter(Boolean).slice(-maxLines);
+}
+
+function stripAnsi(text: string): string {
+  return text
+    .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, '')
+    .replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, '')
+    .replace(/\x1b[()][A-Za-z0-9]/g, '');
+}
+
+export function interactivePromptFrom(output: string): string {
+  const clean = stripAnsi(output).replace(/\r/g, '\n');
+  const lines = clean.split('\n').map((line) => line.trim()).filter(Boolean).slice(-24);
+  const text = lines.join('\n');
+  const promptPatterns = [
+    /Enter to select\b/i,
+    /(?:↑|up)\/(?:↓|down)|arrow keys|navigate/i,
+    /\bEsc to cancel\b/i,
+    /\b(?:y\/n|Y\/n|y\/N|\[y\/N\]|\[Y\/n\])\b/,
+    /\b(?:choose|select|pick) (?:one|an option|a number)\b/i,
+    /\?$/,
+  ];
+  if (!promptPatterns.some((re) => re.test(text))) return '';
+  return lines.slice(-10).join('\n').slice(0, 900);
+}

package/web/src/styles.css

@@ -38,13 +38,29 @@ code { font:13px ui-monospace, monospace; color:var(--muted); }
 .badge.isolation-strong, .badge.trust-secure, .badge.daemon-available, .badge.daemon-detected { border-color:var(--ok); color:var(--ok); }
 .badge.isolation-unknown, .badge.trust-unknown, .badge.daemon-unavailable { border-color:var(--idle); color:var(--muted); }
 .cell-note { color:var(--muted); font-size:12px; margin-top:3px; max-width:260px; }
+.inventory-table { table-layout:fixed; }
+.inventory-table th, .inventory-table td { vertical-align:top; }
+.inventory-table th:nth-child(1), .inventory-table td:nth-child(1) { width:17%; }
+.inventory-table th:nth-child(2), .inventory-table td:nth-child(2) { width:15%; }
+.inventory-table th:nth-child(3), .inventory-table td:nth-child(3) { width:13%; }
+.inventory-table th:nth-child(4), .inventory-table td:nth-child(4) { width:11%; }
+.inventory-table th:nth-child(5), .inventory-table td:nth-child(5) { width:13%; }
+.inventory-table th:nth-child(6), .inventory-table td:nth-child(6) { width:7%; }
+.inventory-table th:nth-child(7), .inventory-table td:nth-child(7) { width:6%; }
+.inventory-table th:nth-child(8), .inventory-table td:nth-child(8) { width:18%; }
+.inventory-table .badge { max-width:100%; white-space:normal; line-height:1.35; }
+.inventory-table code { display:block; overflow:hidden; text-overflow:ellipsis; white-space:nowrap; }
+.inventory-table .cell-note { max-width:100%; overflow-wrap:anywhere; line-height:1.4; }
+.runtime-cell .cell-note, .daemon-cell .cell-note { display:-webkit-box; -webkit-box-orient:vertical; -webkit-line-clamp:2; overflow:hidden; }
 .state { display:inline-flex; align-items:center; gap:7px; }
 .dot { width:8px; height:8px; border-radius:50%; flex:0 0 auto; background:var(--idle); }
-.state.running .dot, .state.working .dot { background:var(--ok); } .state.provisioning .dot { background:var(--warn); }
+.state.running .dot, .state.working .dot { background:var(--ok); } .state.provisioning .dot, .state.degraded .dot { background:var(--warn); }
 .empty { color:var(--muted); padding:22px; } .err { color:var(--err); padding:12px 0; }
 .controls { display:flex; gap:10px; align-items:center; flex-wrap:wrap; margin-bottom:14px; }
 .controls label { color:var(--muted); font-size:13px; }
-.manage-actions { white-space:nowrap; display:flex; gap:8px; align-items:center; }
+.manage-actions { white-space:nowrap; display:flex; gap:8px; align-items:flex-start; justify-content:flex-start; }
+.inventory-table .manage-actions button { min-width:74px; min-height:38px; padding-inline:10px; }
+.inventory-table .manage-actions .cta { min-width:92px; }
 .section-toolbar { display:flex; align-items:flex-end; justify-content:space-between; gap:14px; flex-wrap:wrap; margin-bottom:14px; }
 .section-toolbar h2 { margin:0; font-size:20px; }
 .empty-state { display:grid; gap:10px; justify-items:start; border:1px solid var(--line); border-radius:8px; padding:18px; background:var(--panel); }
@@ -329,6 +345,8 @@ code { font:13px ui-monospace, monospace; color:var(--muted); }
 .nav-session-meta { font-size:11px; color:var(--muted); }
 .nav-session .badge { padding:0 6px; font-size:10px; }
 .nav-session .live-dot { border-color:var(--ok); color:var(--ok); }
+.nav-session .unread { border-color:var(--accent2); color:var(--accent2); }
+.nav-session .response { border-color:var(--warn); color:var(--warn); }
 .nav-session-end { align-self:center; padding:4px 9px; color:var(--muted); border-color:transparent; background:none; line-height:1; }
 .nav-session-end:hover:not(:disabled) { border-color:var(--err); color:var(--err); }
 .nav-new-session { margin-top:6px; align-self:flex-start; }

package/web/src/types.ts

@@ -35,7 +35,29 @@ export interface Instance {
   session_backends: SessionBackend[];
 }
 export interface RunningTask { instance_id: string; task_id: string; state: string; tenant: string; runtime_posture?: RuntimePosture; transport?: TransportPosture }
-export interface SessionInfo { id: string; instance_id: string; seq?: number; members?: number; has_controller?: boolean; attach_url: string; mode?: 'direct' | 'managed'; backend?: string; session_name?: string; sessionName?: string; session_class?: string; session_backend?: string; role_policy?: string; replay?: boolean; keyframe?: boolean; controllers?: number; observers?: number }
+// Session model mirrors the agentic-sandbox v2 SessionEntry (management/src/http/sessions.rs,
+// released in v2026.7.2). Cockpit consumes the v2 objects directly — no flat-field
+// translation. `id` is the Cockpit primary key, set from the v2 `session_id`; `attach_url`
+// is the data-plane URL the Bridge resolves. membership/liveness are the v2 sub-objects.
+export interface SessionMembership { controllers: string[]; observers: string[]; attachment_count: number }
+export interface SessionLiveness { agent_connected: boolean; has_screen: boolean; replay_newest_seq?: number | null; max_client_lag: number }
+export interface SessionInfo {
+  id: string;
+  session_id?: string;
+  instance_id: string;
+  agent_id?: string;
+  session_name?: string;
+  session_type?: string;
+  session_backend?: string;
+  session_class?: string;
+  attach_url: string;
+  pty_ws_url?: string;
+  has_screen?: boolean;
+  role_policy?: string;
+  default_role?: string;
+  membership?: SessionMembership;
+  liveness?: SessionLiveness;
+}
 export interface Approval { id: string; instance_id: string; prompt: string; risk: string; status: string }
 export interface ResponseNeeded { id: string; instance_id: string; prompt: string; source: string; status: string; attach_url?: string | null }
 export interface MissionAuditEvent { event?: string; ts?: string; missionId?: string; mission_id?: string; objective?: string; [key: string]: unknown }