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

package/src/TuiInteractionChannel.ts

@@ -6,16 +6,13 @@
  */
 
 import { createSystemMessage, messageToHistoryEntry } from '@robota-sdk/agent-core';
-import {
-  CommandRegistry,
-  buildRuntimeSession,
-  generateSessionName,
-} from '@robota-sdk/agent-framework';
+import { CommandRegistry, buildRuntimeSession } from '@robota-sdk/agent-framework';
 
 import { AttentionCoordinator } from './attention/attention-coordinator.js';
 import { MS_PER_SECOND } from './attention/time-units.js';
 import { createSessionInitPoller } from './flows/session-init-poller.js';
 import { applySystemCommandResult } from './hooks/command-result-handler.js';
+import { parseSlashCommandInput } from './slash-command-input.js';
 import {
   TuiChannelLifecycleCoordinator,
   TuiChannelStartRollbackError,
@@ -24,6 +21,7 @@ import { TuiPermissionQueue, TuiUserActionQueue } from './tui-interaction-queues
 import { TuiSessionEventProjector } from './tui-session-event-projector.js';
 import { buildTuiSessionOptions } from './tui-session-options.js';
 import { TuiStateManager } from './tui-state-manager.js';
+import { WAITING_LOOP_STOP_REASON, waitingLoopStopNotice } from './waiting-loop-stop-notice.js';
 
 import type { IAttentionSource } from './attention/attention-tracker.js';
 import type { ISessionInitPoller, TSessionInitFailure } from './flows/session-init-poller.js';
@@ -78,7 +76,6 @@ export class TuiInteractionChannel implements ITuiAppChannelPort {
   availableCommands: ICommandInfo[] = [];
   sessionName: string | undefined;
 
-  private autoNameTriggered = false;
   private initPoller: ISessionInitPoller | null = null;
 
   /** TERM-002: the App registers its Ink suspend/resume hooks into this controller. */
@@ -103,14 +100,21 @@ export class TuiInteractionChannel implements ITuiAppChannelPort {
       session: this.interactiveSession,
       manager: this.stateManager,
       ...(this.attention ? { attention: this.attention } : {}),
-      onUserMessage: (content) => this.handleAutoNaming(content),
-      requestPermission: (toolName, toolArgs, id, canPersistProjectPermission, requestedByPeer) =>
+      requestPermission: (
+        toolName,
+        toolArgs,
+        id,
+        canPersistProjectPermission,
+        requestedByPeer,
+        requester,
+      ) =>
         this.permissions.enqueue(
           toolName,
           toolArgs,
           id,
           canPersistProjectPermission,
           requestedByPeer,
+          requester,
         ),
       askUser: (request, id) => this.askUser(request, id),
       dismissPrompt: (id) => this.dismissPromptById(id),
@@ -324,34 +328,11 @@ export class TuiInteractionChannel implements ITuiAppChannelPort {
     this.stateManager.setPendingPrompt(null);
   }
 
+  /** Esc on an idle prompt: the session decides which waiting loop, if any, stops. */
   async stopWaitingSelfPacedLoop(): Promise<void> {
-    const waiting = this.interactiveSession
-      .listSelfPacedLoops()
-      .filter((loop) => loop.phase === 'waiting');
-    if (waiting.length === 0) return;
-    if (waiting.length > 1) {
-      this.addEntry(
-        messageToHistoryEntry(
-          createSystemMessage(
-            'Several self-paced loops are waiting. Use /loop list and /loop stop <id> to choose one.',
-          ),
-        ),
-      );
-      return;
-    }
-    const loopId = waiting[0]!.loopId;
-    try {
-      await this.interactiveSession.stopSelfPacedLoop(loopId, 'Loop stopped by Esc');
-      this.addEntry(messageToHistoryEntry(createSystemMessage(`Loop ${loopId} stopped by Esc.`)));
-    } catch (error) {
-      this.addEntry(
-        messageToHistoryEntry(
-          createSystemMessage(
-            `Could not stop loop ${loopId}: ${error instanceof Error ? error.message : String(error)}`,
-          ),
-        ),
-      );
-    }
+    const outcome = await this.interactiveSession.stopWaitingSelfPacedLoop(WAITING_LOOP_STOP_REASON);
+    const notice = waitingLoopStopNotice(outcome);
+    if (notice !== undefined) this.addEntry(messageToHistoryEntry(createSystemMessage(notice)));
   }
 
   async shutdown(options?: { reason?: TSessionEndReason; timeoutMs?: number }): Promise<void> {
@@ -407,9 +388,7 @@ export class TuiInteractionChannel implements ITuiAppChannelPort {
   }
 
   private async handleSlashCommand(input: string): Promise<void> {
-    const parts = input.slice(1).split(/\s+/);
-    const cmd = parts[0]?.toLowerCase() ?? '';
-    const args = parts.slice(1).join(' ');
+    const { name: cmd, args } = parseSlashCommandInput(input);
 
     const result = await this.interactiveSession.executeCommand(cmd, args);
     if (result) {
@@ -463,22 +442,6 @@ export class TuiInteractionChannel implements ITuiAppChannelPort {
     this.permissions.cancelAll();
   }
 
-  private handleAutoNaming(content: string): void {
-    if (this.autoNameTriggered) return;
-    if (this.opts.sessionName || this.interactiveSession.getName()) return;
-    this.autoNameTriggered = true;
-    generateSessionName(this.opts.provider, content)
-      .then((name) => {
-        this.interactiveSession.setName(name);
-        this.sessionName = name;
-        this.opts.onAutoNamed?.(name);
-        this.onChange?.();
-      })
-      .catch(() => {
-        this.autoNameTriggered = false;
-      });
-  }
-
   private syncRestoredHistory(): void {
     if (this.stateManager.history.length === 0) {
       const restored = this.interactiveSession.getFullHistory();

package/src/__tests__/SupervisedSessionView-render.test.tsx

@@ -21,4 +21,32 @@ describe('production supervised view renderer', () => {
     expect(wrapper.props.children.props.onOpenPr).toBe(onOpenPr);
     expect(wrapper.props.children.props.filteredByPr).toBe(true);
   });
+
+  it('returns the attach the user confirmed so the host can run it and come back', async () => {
+    vi.mocked(render).mockClear();
+    let exitView: () => void = () => undefined;
+    vi.mocked(render).mockImplementationOnce(() => ({
+      waitUntilExit: () => new Promise<void>((resolve) => { exitView = resolve; }),
+      unmount: () => undefined,
+    }) as never);
+    const ended = renderSupervisedSessionView({ loadRows: async () => [], screenReader: false });
+    const wrapper = vi.mocked(render).mock.calls[0]?.[0] as React.ReactElement<{
+      children: React.ReactElement<{ onAttach?: (request: unknown) => void }>;
+    }>;
+    wrapper.props.children.props.onAttach?.({ id: 'x', generation: 'g', mode: 'observe', groupByDirectory: true });
+    exitView();
+    expect(await ended).toEqual({ kind: 'attach', id: 'x', generation: 'g', mode: 'observe', groupByDirectory: true });
+  });
+
+  it('prints the screen-reader line only when asked to announce', async () => {
+    const out = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+    try {
+      await renderSupervisedSessionView({ loadRows: async () => [], screenReader: true, screenReaderChannel: 'flag', announce: false });
+      expect(out.mock.calls.map(([text]) => String(text)).join('')).not.toContain('Screen reader mode');
+      await renderSupervisedSessionView({ loadRows: async () => [], screenReader: true, screenReaderChannel: 'flag' });
+      expect(out.mock.calls.map(([text]) => String(text)).join('')).toContain('Screen reader mode: on via flag');
+    } finally {
+      out.mockRestore();
+    }
+  });
 });