@robota-sdk/agent-ui-terminal 3.0.0-beta.82 → 3.0.0-beta.84

package/src/__tests__/session-picker.test.tsx

@@ -0,0 +1,93 @@
+import { render } from 'ink-testing-library';
+import React from 'react';
+import { describe, expect, it } from 'vitest';
+
+import SessionPicker from '../SessionPicker.js';
+import { shortSessionId } from '../short-session-id.js';
+
+import type {
+  IResumableSessionSummary,
+  ISessionListingEntry,
+} from '@robota-sdk/agent-interface-session';
+
+function summary(id: string, name?: string): IResumableSessionSummary {
+  return {
+    id,
+    cwd: '/w',
+    updatedAt: '2026-09-26T10:00:00.000Z',
+    messageCount: 2,
+    preview: '',
+    ...(name !== undefined ? { name } : {}),
+  };
+}
+
+describe('session ids on screen', () => {
+  it('shortens an id to the part that tells sessions apart, not the prefix they share', () => {
+    expect(shortSessionId('session_07d291bc-4d43-4d26-9375-7d8ca0e60e6f')).toBe('07d291bc');
+    expect(shortSessionId('session_1773862349776_rnecma5lu')).toBe('17738623');
+    expect(shortSessionId('host-session-id')).toBe('host-ses');
+    expect(shortSessionId('session_')).toBe('session_');
+  });
+
+  it('lists unnamed sessions by distinct ids, and named ones by name', () => {
+    const view = render(
+      <SessionPicker
+        sessions={[
+          summary('session_07d291bc-4d43-4d26-9375-7d8ca0e60e6f'),
+          summary('session_15f05245-1f06-4375-8f29-db19e622afdd'),
+          summary('session_aaaaaaaa-0000-0000-0000-000000000000', 'auth work'),
+        ]}
+        onSelect={() => undefined}
+        onCancel={() => undefined}
+      />,
+    );
+    const frame = view.lastFrame() ?? '';
+    expect(frame).toContain('07d291bc');
+    expect(frame).toContain('15f05245');
+    expect(frame).toContain('auth work');
+    expect(frame).not.toMatch(/session_\s/);
+    view.unmount();
+  });
+});
+
+describe('live sessions in the picker (#3189)', () => {
+  function entry(id: string, name: string, extra: Partial<ISessionListingEntry>): ISessionListingEntry {
+    return { ...summary(id, name), ...extra };
+  }
+
+  it('marks a session the host runs now, and how many clients are on it', () => {
+    const view = render(
+      <SessionPicker
+        sessions={[
+          entry('session_a', 'busy one', { live: true, clients: 2 }),
+          entry('session_b', 'solo one', { live: true, clients: 1 }),
+          entry('session_c', 'stored one', { live: false, clients: 0 }),
+        ]}
+        onSelect={() => undefined}
+        onCancel={() => undefined}
+      />,
+    );
+    const lines = (view.lastFrame() ?? '').split('\n');
+    const lineOf = (name: string): string => lines.find((line) => line.includes(name)) ?? '';
+    expect(lineOf('busy one')).toContain('● live · 2 clients');
+    expect(lineOf('solo one')).toContain('● live · 1 client');
+    expect(lineOf('solo one')).not.toContain('1 clients');
+    expect(lineOf('stored one')).not.toContain('live');
+    expect(lineOf('stored one')).not.toContain('client');
+    view.unmount();
+  });
+
+  it('shows neither for an older host, which sends neither', () => {
+    const view = render(
+      <SessionPicker
+        sessions={[summary('session_a', 'plain')]}
+        onSelect={() => undefined}
+        onCancel={() => undefined}
+      />,
+    );
+    const frame = view.lastFrame() ?? '';
+    expect(frame).not.toContain('live');
+    expect(frame).not.toContain('client');
+    view.unmount();
+  });
+});

package/src/__tests__/status-bar.test.tsx

@@ -47,6 +47,14 @@ describe('StatusBar', () => {
     }
   });
 
+  it('says an observing terminal is read only, and nothing of the kind otherwise', () => {
+    const observing = render(<StatusBar {...baseProps} readOnly />);
+    expect(observing.lastFrame()).toContain('Observing — read only');
+    observing.unmount();
+    const driving = render(<StatusBar {...baseProps} />);
+    expect(driving.lastFrame()).not.toContain('Observing');
+  });
+
   it('renders session name when provided', () => {
     const { lastFrame } = render(<StatusBar {...baseProps} sessionName="my-feature" />);
     const frame = lastFrame()!;

package/src/__tests__/tui-channel-init-failure.test.ts

@@ -1,4 +1,8 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { afterAll, afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import type { IAIProvider } from '@robota-sdk/agent-core';
 
 vi.mock('@robota-sdk/agent-framework', async (importOriginal) => {
@@ -32,6 +36,10 @@ vi.mock('@robota-sdk/agent-framework', async (importOriginal) => {
 
 import { TuiInteractionChannel } from '../TuiInteractionChannel.js';
 
+/** The session's working directory: private to this run, never a fixed name under /tmp. */
+const PROJECT_DIR = mkdtempSync(join(tmpdir(), 'robota-tui-init-failure-'));
+afterAll(() => rmSync(PROJECT_DIR, { recursive: true, force: true }));
+
 describe('TuiInteractionChannel init failure surfacing', () => {
   beforeEach(() => {
     vi.useFakeTimers();
@@ -43,7 +51,7 @@ describe('TuiInteractionChannel init failure surfacing', () => {
 
   it('TC-05: a real init error records a session-init-error entry and sets error state', async () => {
     const channel = new TuiInteractionChannel({
-      cwd: '/tmp/project',
+      cwd: PROJECT_DIR,
       provider: {} as IAIProvider,
     });
     await channel.start();

package/src/__tests__/tui-interaction-queues.test.ts

@@ -136,4 +136,14 @@ describe('TuiPermissionQueue', () => {
     queue.current?.resolve(true);
     await expect(second).resolves.toBe(true);
   });
+
+  it('issue #3288 §1: carries the requester onto the current entry', async () => {
+    const queue = new TuiPermissionQueue(vi.fn());
+    const requester = { kind: 'background-agent' as const, label: 'general-purpose', taskId: 'agent_1' };
+    const pending = queue.enqueue('Glob', { pattern: '**/*' }, 'permission-1', false, undefined, requester);
+
+    expect(queue.current?.requester).toEqual(requester);
+    queue.current?.resolve(false);
+    await expect(pending).resolves.toBe(false);
+  });
 });

package/src/__tests__/tui-state-manager.test.ts

@@ -71,6 +71,37 @@ describe('TuiStateManager', () => {
     expect(mgr.activeTools[0]!.result).toBe('success');
   });
 
+  it('#3288: two parallel same-named calls are attributed by executionId, not by name+running order', () => {
+    const mgr = new TuiStateManager();
+    mgr.onToolStart({ toolName: 'Read', firstArg: 'a.ts', isRunning: true, executionId: 'exec-a' });
+    mgr.onToolStart({ toolName: 'Read', firstArg: 'b.ts', isRunning: true, executionId: 'exec-b' });
+    // The FIRST-started call (a.ts) finishes first, while the SECOND (b.ts) is still running.
+    // `findLastIndex` by name+running alone would pick the most-recently-STARTED entry (b.ts) —
+    // the wrong one — because it is still running and sits last in the array.
+    mgr.onToolEnd({
+      toolName: 'Read',
+      firstArg: 'a.ts',
+      isRunning: false,
+      result: 'success',
+      executionId: 'exec-a',
+    });
+    const a = mgr.activeTools.find((t) => t.executionId === 'exec-a');
+    const b = mgr.activeTools.find((t) => t.executionId === 'exec-b');
+    expect(a?.isRunning).toBe(false);
+    expect(a?.firstArg).toBe('a.ts');
+    expect(b?.isRunning).toBe(true);
+    expect(b?.firstArg).toBe('b.ts');
+
+    mgr.onToolEnd({
+      toolName: 'Read',
+      firstArg: 'b.ts',
+      isRunning: false,
+      result: 'success',
+      executionId: 'exec-b',
+    });
+    expect(mgr.activeTools.every((t) => !t.isRunning)).toBe(true);
+  });
+
   it('clears tools on thinking=true (next execution start)', () => {
     const mgr = new TuiStateManager();
     mgr.onToolStart({ toolName: 'Read', firstArg: '', isRunning: true });