@robota-sdk/agent-ui-terminal 3.0.0-beta.83 → 3.0.0-beta.85

package/src/__tests__/pty/trust-prompt.ptytest.ts

@@ -0,0 +1,134 @@
+/**
+ * Issue #3268 — an interactive start in an untrusted repository asks whether to trust it, on the
+ * BUILT binary in a real PTY. A yes records the grant and starts Trusted, so the next start does not
+ * ask; a no starts Restricted and records nothing, so the next start asks again.
+ *
+ * Runs under `test:pty` against the built CLI (`pnpm --filter @robota-sdk/agent-cli build` first).
+ */
+
+import { execFileSync } from 'node:child_process';
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  realpathSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { afterEach, describe, expect, it } from 'vitest';
+
+import { spawnTui } from './pty-driver.js';
+
+import type { IPtySession } from './pty-driver.js';
+
+const WAIT_MS = 20_000;
+const CASE_TIMEOUT_MS = 120_000;
+const QUESTION = /Trust this folder\? \[y\/N\]/;
+const READY = /Type a message or \/help/;
+
+interface IFixture {
+  readonly root: string;
+  readonly home: string;
+  readonly repo: string;
+}
+
+function makeFixture(): IFixture {
+  const root = realpathSync(mkdtempSync(join(tmpdir(), 'robota-trust-prompt-')));
+  const home = join(root, 'home');
+  const repo = join(root, 'repo');
+  mkdirSync(join(home, '.robota'), { recursive: true });
+  // Skip the first-run welcome and provider setup: neither is what this scenario observes.
+  writeFileSync(join(home, '.robota', 'onboarded'), new Date().toISOString(), 'utf8');
+  writeFileSync(
+    join(home, '.robota', 'settings.json'),
+    JSON.stringify({
+      currentProvider: 'anthropic',
+      providers: {
+        anthropic: { type: 'anthropic', model: 'claude-test-model', apiKey: 'pty-dummy-key' },
+      },
+    }),
+    'utf8',
+  );
+  execFileSync('git', ['init', '-q', repo]);
+  return { root, home, repo };
+}
+
+function trustedGrants(fixture: IFixture): number {
+  const store = join(fixture.home, '.robota', 'workspace-trust.json');
+  if (!existsSync(store)) return 0;
+  const parsed = JSON.parse(readFileSync(store, 'utf8')) as { grants: { state: string }[] };
+  return parsed.grants.filter((grant) => grant.state === 'trusted').length;
+}
+
+async function answerAndExit(session: IPtySession, answer: 'y' | 'n'): Promise<void> {
+  await session.waitFor(QUESTION, WAIT_MS);
+  await session.sendKeys(answer);
+  await session.pressEnter();
+  await session.waitFor(READY, WAIT_MS);
+  await session.sendKeys('/exit');
+  await session.pressEnter();
+  await session.waitFor(/Exit the session\?/, WAIT_MS);
+  await session.pressEnter();
+  await session.expectExit(WAIT_MS);
+}
+
+describe('the trust question at an interactive start (issue #3268)', () => {
+  let fixture: IFixture | undefined;
+  let session: IPtySession | undefined;
+
+  afterEach(async () => {
+    await session?.disposeAsync();
+    session = undefined;
+    if (fixture) rmSync(fixture.root, { recursive: true, force: true });
+    fixture = undefined;
+  });
+
+  it(
+    'a yes records the grant, and the next start is Trusted without asking',
+    async () => {
+      fixture = makeFixture();
+      session = spawnTui({ projectDir: fixture.repo, homeDir: fixture.home });
+      await answerAndExit(session, 'y');
+      expect(trustedGrants(fixture)).toBe(1);
+
+      session = spawnTui({ projectDir: fixture.repo, homeDir: fixture.home });
+      await session.waitFor(READY, WAIT_MS);
+      expect(session.snapshot()).not.toMatch(QUESTION);
+    },
+    CASE_TIMEOUT_MS,
+  );
+
+  it.each([
+    ['--safe-mode', ['--safe-mode']],
+    // A resumed or continued session keeps the store it was saved in, so it is not asked.
+    ['--continue', ['--continue']],
+  ])(
+    'does not ask with %s',
+    async (_case, args) => {
+      fixture = makeFixture();
+      session = spawnTui({ projectDir: fixture.repo, homeDir: fixture.home, args: [...args] });
+      await session.waitFor(READY, WAIT_MS);
+      expect(session.snapshot()).not.toMatch(QUESTION);
+      expect(trustedGrants(fixture)).toBe(0);
+    },
+    CASE_TIMEOUT_MS,
+  );
+
+  it(
+    'a no starts Restricted, records nothing, and the next start asks again',
+    async () => {
+      fixture = makeFixture();
+      session = spawnTui({ projectDir: fixture.repo, homeDir: fixture.home });
+      await answerAndExit(session, 'n');
+      expect(trustedGrants(fixture)).toBe(0);
+
+      session = spawnTui({ projectDir: fixture.repo, homeDir: fixture.home });
+      await session.waitFor(QUESTION, WAIT_MS);
+    },
+    CASE_TIMEOUT_MS,
+  );
+});

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 });

package/src/__tests__/wire-tui-channel.test.ts

@@ -306,6 +306,18 @@ describe('WireTuiChannel', () => {
     await channel.stop();
   });
 
+  it('issue #3288 §1: carries a background agent requester onto the shown permission request', async () => {
+    const { channel, link } = await attached();
+    const requester = { kind: 'background-agent' as const, label: 'general-purpose', taskId: 'agent_1' };
+    link.push({
+      type: 'permission_request',
+      event: { id: 'p1', toolName: 'Glob', toolArgs: { pattern: '**/*' }, requester },
+    });
+    expect(channel.getSnapshot().permissionRequest).toMatchObject({ toolName: 'Glob', requester });
+    channel.getSnapshot().permissionRequest?.resolve(false);
+    await channel.stop();
+  });
+
   it('answers an ask through resolveUserAction as ask-response', async () => {
     const { channel, link } = await attached();
     link.sent.length = 0;

package/src/index.ts

@@ -8,6 +8,8 @@ export type {
   ISupervisedAttachRequest,
   ISupervisedViewRow,
   ISupervisedSessionViewProps,
+  ISupervisedStartTrustQuestion,
+  TSupervisedStartTrustChoice,
   TSupervisedViewExit,
 } from './SupervisedSessionView.js';
 export { TuiInteractionChannel } from './TuiInteractionChannel.js';

package/src/tui-interaction-queues.ts

@@ -1,6 +1,9 @@
 import type { IPendingPermissionRequest } from './types.js';
 import type { IActionRequest, TActionResponse, TToolArgs } from '@robota-sdk/agent-core';
-import type { TPermissionResultValue } from '@robota-sdk/agent-interface-session';
+import type {
+  TPermissionRequester,
+  TPermissionResultValue,
+} from '@robota-sdk/agent-interface-session';
 
 interface IUserActionQueueEntry {
   presentedRequest: IActionRequest;
@@ -13,6 +16,8 @@ interface IPermissionQueueEntry {
   toolArgs: TToolArgs;
   canPersistProjectPermission?: boolean;
   requestedByPeer?: string;
+  /** Issue #3288 §1: a background agent's own request, forwarded to the person. */
+  requester?: TPermissionRequester;
   resolve: (result: TPermissionResultValue) => void;
   id?: string;
 }
@@ -96,6 +101,7 @@ export class TuiPermissionQueue {
     id?: string,
     canPersistProjectPermission?: boolean,
     requestedByPeer?: string,
+    requester?: TPermissionRequester,
   ): Promise<TPermissionResultValue> {
     return new Promise<TPermissionResultValue>((resolve) => {
       this.entries.push({
@@ -105,6 +111,7 @@ export class TuiPermissionQueue {
         ...(id !== undefined ? { id } : {}),
         ...(canPersistProjectPermission !== undefined ? { canPersistProjectPermission } : {}),
         ...(requestedByPeer !== undefined ? { requestedByPeer } : {}),
+        ...(requester !== undefined ? { requester } : {}),
       });
       this.processNext();
     });
@@ -149,6 +156,7 @@ export class TuiPermissionQueue {
         ? { canPersistProjectPermission: next.canPersistProjectPermission }
         : {}),
       ...(next.requestedByPeer !== undefined ? { requestedByPeer: next.requestedByPeer } : {}),
+      ...(next.requester !== undefined ? { requester: next.requester } : {}),
       resolve: (result) => {
         if (this.entries[0] !== next) return;
         this.entries.shift();

package/src/tui-session-event-projector.ts

@@ -13,6 +13,7 @@ import type {
   IExecutionResult,
   IInteractiveSessionEvents,
   TInteractiveEventName,
+  TPermissionRequester,
   TPermissionResultValue,
 } from '@robota-sdk/agent-interface-session';
 
@@ -25,6 +26,8 @@ export interface ITuiSessionEventProjectorOptions {
     id: string,
     canPersistProjectPermission?: boolean,
     requestedByPeer?: string,
+    /** Issue #3288 §1: a background agent's own request, forwarded to the person. */
+    requester?: TPermissionRequester,
   ) => Promise<TPermissionResultValue>;
   askUser: (request: IActionRequest, id: string) => Promise<TActionResponse>;
   dismissPrompt: (id: string) => void;
@@ -86,6 +89,7 @@ export class TuiSessionEventProjector {
       toolArgs,
       canPersistProjectPermission,
       requesterDriverId,
+      requester,
     }) => {
       attention?.onNeedsInput();
       // A peer turn's ask names the peer, printed only as a plain identifier.
@@ -93,7 +97,14 @@ export class TuiSessionEventProjector {
         ? printablePeerDriver(requesterDriverId)
         : undefined;
       void this.options
-        .requestPermission(toolName, toolArgs, id, canPersistProjectPermission, requestedByPeer)
+        .requestPermission(
+          toolName,
+          toolArgs,
+          id,
+          canPersistProjectPermission,
+          requestedByPeer,
+          requester,
+        )
         .then((result) => session.resolvePermission(id, result))
         .catch(() => session.resolvePermission(id, false));
     };

package/src/tui-state-manager.ts

@@ -130,8 +130,14 @@ export class TuiStateManager {
   };
 
   onToolEnd = (state: IToolState): void => {
-    // findLastIndex: when same tool runs concurrently, match the most recently started instance
-    const idx = this.activeTools.findLastIndex((t) => t.toolName === state.toolName && t.isRunning);
+    // #3288: attribute by executionId first — two same-named parallel calls can finish out of
+    // start order, and `findLastIndex` by name alone would close the wrong (most recently
+    // started, not most recently finished) running entry. Fall back to the name+running-order
+    // heuristic only when the event carries no executionId (legacy fixtures / old hosts).
+    const idx =
+      state.executionId !== undefined
+        ? this.activeTools.findIndex((t) => t.executionId === state.executionId && t.isRunning)
+        : this.activeTools.findLastIndex((t) => t.toolName === state.toolName && t.isRunning);
     if (idx !== -1) {
       const updated = [...this.activeTools];
       updated[idx] = state;

package/src/types.ts

@@ -1,7 +1,7 @@
 /** UI-layer permission types for the Ink TUI */
 
 import type { TToolArgs } from '@robota-sdk/agent-core';
-import type { TPermissionResultValue } from '@robota-sdk/agent-interface-session';
+import type { TPermissionRequester, TPermissionResultValue } from '@robota-sdk/agent-interface-session';
 
 /**
  * Permission result: true (allow once), false (deny), 'allow-session' (remember for session),
@@ -15,5 +15,7 @@ export interface IPendingPermissionRequest {
   canPersistProjectPermission?: boolean;
   /** The peer session whose message this call serves, when a peer turn asked. */
   requestedByPeer?: string;
+  /** Issue #3288 §1: a background agent's own request, forwarded to the person. */
+  requester?: TPermissionRequester;
   resolve: (result: TPermissionResult) => void;
 }

package/src/wire-tui-channel.ts

@@ -730,6 +730,7 @@ export class WireTuiChannel implements ITuiAppChannelPort {
         event.id,
         event.canPersistProjectPermission,
         requestedByPeer,
+        event.requester,
       )
       .then((result) =>
         this.answer(generation, event.id, { type: 'permission-response', id: event.id, result }),