@robota-sdk/agent-transport 3.0.0-beta.75 → 3.0.0-beta.77

package/src/tui/flows/permission-prompt-flow.ts

@@ -1,85 +0,0 @@
-import {
-  applySelectionInput,
-  getDirectionalSelectionInputAction,
-  type ISelectionFlowState,
-  type ISelectionInputKey,
-  type TSelectionInputAction,
-} from './selection-flow.js';
-
-export const PERMISSION_PROMPT_OPTIONS = [
-  'Allow [y]',
-  'Allow always (this session) [s]',
-  'Allow always (this project) [p]',
-  'Deny [n]',
-] as const;
-
-export type TPermissionPromptDecision = true | 'allow-session' | 'allow-project' | false;
-export type TPermissionPromptInputAction =
-  | TSelectionInputAction
-  | { type: 'shortcut'; index: number };
-
-export type TPermissionPromptEffect =
-  | { type: 'none' }
-  | { type: 'resolve'; decision: TPermissionPromptDecision };
-
-export function getPermissionPromptInputAction(
-  input: string,
-  key: ISelectionInputKey,
-): TPermissionPromptInputAction | undefined {
-  const action = getDirectionalSelectionInputAction({ ...key, escape: false });
-  if (action !== undefined) {
-    return action;
-  }
-  if (input === 'y' || input === '1') {
-    return { type: 'shortcut', index: 0 };
-  }
-  if (input === 's' || input === 'a' || input === '2') {
-    return { type: 'shortcut', index: 1 };
-  }
-  if (input === 'p' || input === '3') {
-    return { type: 'shortcut', index: 2 };
-  }
-  if (input === 'n' || input === 'd' || input === '4') {
-    return { type: 'shortcut', index: 3 };
-  }
-  return undefined;
-}
-
-export function applyPermissionPromptInput(
-  state: ISelectionFlowState,
-  action: TPermissionPromptInputAction,
-): { state: ISelectionFlowState; effect: TPermissionPromptEffect } {
-  if (state.resolved) {
-    return { state, effect: { type: 'none' } };
-  }
-  if (typeof action !== 'string') {
-    return resolvePermissionIndex(state, action.index);
-  }
-  const result = applySelectionInput(state, action, {
-    itemCount: PERMISSION_PROMPT_OPTIONS.length,
-  });
-  if (result.effect.type !== 'select') {
-    return { state: result.state, effect: { type: 'none' } };
-  }
-  return {
-    state: result.state,
-    effect: { type: 'resolve', decision: getPermissionDecision(result.effect.index) },
-  };
-}
-
-function getPermissionDecision(index: number): TPermissionPromptDecision {
-  if (index === 0) return true;
-  if (index === 1) return 'allow-session';
-  if (index === 2) return 'allow-project';
-  return false;
-}
-
-function resolvePermissionIndex(
-  state: ISelectionFlowState,
-  index: number,
-): { state: ISelectionFlowState; effect: TPermissionPromptEffect } {
-  return {
-    state: { ...state, selectedIndex: index, resolved: true },
-    effect: { type: 'resolve', decision: getPermissionDecision(index) },
-  };
-}

package/src/tui/flows/selection-flow.ts

@@ -1,126 +0,0 @@
-export interface ISelectionFlowState {
-  selectedIndex: number;
-  scrollOffset: number;
-  resolved: boolean;
-}
-
-export interface ISelectionInputKey {
-  escape?: boolean;
-  return?: boolean;
-  upArrow?: boolean;
-  downArrow?: boolean;
-  leftArrow?: boolean;
-  rightArrow?: boolean;
-}
-
-export type TSelectionInputAction = 'cancel' | 'select' | 'previous' | 'next';
-
-export type TSelectionEffect =
-  | { type: 'none' }
-  | { type: 'cancel' }
-  | { type: 'select'; index: number };
-
-export interface ISelectionFlowOptions {
-  itemCount: number;
-  maxVisible?: number;
-  wrap?: boolean;
-  enabled?: boolean;
-}
-
-export function createSelectionFlowState(): ISelectionFlowState {
-  return { selectedIndex: 0, scrollOffset: 0, resolved: false };
-}
-
-export function getVerticalSelectionInputAction(
-  key: ISelectionInputKey,
-): TSelectionInputAction | undefined {
-  if (key.escape === true) return 'cancel';
-  if (key.upArrow === true) return 'previous';
-  if (key.downArrow === true) return 'next';
-  if (key.return === true) return 'select';
-  return undefined;
-}
-
-export function getDirectionalSelectionInputAction(
-  key: ISelectionInputKey,
-): TSelectionInputAction | undefined {
-  if (key.escape === true) return 'cancel';
-  if (key.leftArrow === true || key.upArrow === true) return 'previous';
-  if (key.rightArrow === true || key.downArrow === true) return 'next';
-  if (key.return === true) return 'select';
-  return undefined;
-}
-
-export function applySelectionInput(
-  state: ISelectionFlowState,
-  action: TSelectionInputAction,
-  options: ISelectionFlowOptions,
-): { state: ISelectionFlowState; effect: TSelectionEffect } {
-  if (state.resolved) {
-    return { state, effect: { type: 'none' } };
-  }
-  if (action === 'cancel') {
-    return { state: { ...state, resolved: true }, effect: { type: 'cancel' } };
-  }
-  if (options.enabled === false || options.itemCount === 0) {
-    return { state, effect: { type: 'none' } };
-  }
-  if (action === 'select') {
-    const index = clampIndex(state.selectedIndex, options.itemCount);
-    return {
-      state: { ...state, selectedIndex: index, resolved: true },
-      effect: { type: 'select', index },
-    };
-  }
-  const selectedIndex = moveSelection(state.selectedIndex, action, options);
-  const scrollOffset = resolveScrollOffset(selectedIndex, state.scrollOffset, options);
-  return { state: { ...state, selectedIndex, scrollOffset }, effect: { type: 'none' } };
-}
-
-export function normalizeSelectionState(
-  state: ISelectionFlowState,
-  options: ISelectionFlowOptions,
-): ISelectionFlowState {
-  if (options.itemCount === 0) {
-    return { ...state, selectedIndex: 0, scrollOffset: 0 };
-  }
-  const selectedIndex = clampIndex(state.selectedIndex, options.itemCount);
-  const scrollOffset = resolveScrollOffset(selectedIndex, state.scrollOffset, options);
-  if (selectedIndex === state.selectedIndex && scrollOffset === state.scrollOffset) {
-    return state;
-  }
-  return {
-    ...state,
-    selectedIndex,
-    scrollOffset,
-  };
-}
-
-function moveSelection(
-  selectedIndex: number,
-  action: TSelectionInputAction,
-  options: ISelectionFlowOptions,
-): number {
-  if (action === 'previous') {
-    if (options.wrap === true && selectedIndex === 0) return options.itemCount - 1;
-    return Math.max(0, selectedIndex - 1);
-  }
-  if (options.wrap === true && selectedIndex === options.itemCount - 1) return 0;
-  return Math.min(options.itemCount - 1, selectedIndex + 1);
-}
-
-function resolveScrollOffset(
-  selectedIndex: number,
-  scrollOffset: number,
-  options: ISelectionFlowOptions,
-): number {
-  const maxVisible = options.maxVisible ?? options.itemCount;
-  if (maxVisible <= 0) return 0;
-  if (selectedIndex < scrollOffset) return selectedIndex;
-  if (selectedIndex >= scrollOffset + maxVisible) return selectedIndex - maxVisible + 1;
-  return Math.max(0, scrollOffset);
-}
-
-function clampIndex(index: number, itemCount: number): number {
-  return Math.min(Math.max(index, 0), itemCount - 1);
-}

package/src/tui/flows/session-init-poller.ts

@@ -1,77 +0,0 @@
-/**
- * Bounded polling helper for asynchronous session initialization.
- *
- * Distinguishes benign "not yet initialized" errors (retried until a timeout)
- * from real failures (surfaced immediately), so the TUI can show an error
- * instead of spinning forever.
- */
-
-export type TSessionInitFailure =
-  | { kind: 'timeout'; lastError: Error | undefined }
-  | { kind: 'error'; error: Error };
-
-export interface ISessionInitPollerOptions {
-  /** Throws while the session is not ready; returns normally when ready. */
-  check: () => void;
-  intervalMs: number;
-  timeoutMs: number;
-  /** Returns true when an error means "keep polling". Defaults to /not initialized/i. */
-  isBenignError?: (error: Error) => boolean;
-  onReady: () => void;
-  onFailure: (failure: TSessionInitFailure) => void;
-}
-
-export interface ISessionInitPoller {
-  start(): void;
-  stop(): void;
-}
-
-function defaultIsBenignError(error: Error): boolean {
-  return /not initialized/i.test(error.message);
-}
-
-export function createSessionInitPoller(options: ISessionInitPollerOptions): ISessionInitPoller {
-  const isBenign = options.isBenignError ?? defaultIsBenignError;
-  let timer: ReturnType<typeof setInterval> | null = null;
-  let elapsedMs = 0;
-  let lastBenignError: Error | undefined;
-
-  function stop(): void {
-    if (timer !== null) {
-      clearInterval(timer);
-      timer = null;
-    }
-  }
-
-  function tick(): void {
-    elapsedMs += options.intervalMs;
-    try {
-      options.check();
-    } catch (raw) {
-      // allow-fallback: poller's purpose is to classify and route this error, never to swallow it
-      const error = raw instanceof Error ? raw : new Error(String(raw));
-      if (!isBenign(error)) {
-        stop();
-        options.onFailure({ kind: 'error', error });
-        return;
-      }
-      lastBenignError = error;
-      if (elapsedMs >= options.timeoutMs) {
-        stop();
-        options.onFailure({ kind: 'timeout', lastError: lastBenignError });
-      }
-      return;
-    }
-    stop();
-    options.onReady();
-  }
-
-  return {
-    start(): void {
-      if (timer !== null) return;
-      elapsedMs = 0;
-      timer = setInterval(tick, options.intervalMs);
-    },
-    stop,
-  };
-}

package/src/tui/flows/text-prompt-flow.ts

@@ -1,98 +0,0 @@
-export interface ITextPromptFlowState {
-  value: string;
-  error?: string;
-  resolved: boolean;
-}
-
-export interface ITextPromptInputKey {
-  escape?: boolean;
-  return?: boolean;
-  backspace?: boolean;
-  delete?: boolean;
-  ctrl?: boolean;
-  meta?: boolean;
-}
-
-export type TTextPromptInputAction =
-  | { type: 'cancel' }
-  | { type: 'submit' }
-  | { type: 'delete' }
-  | { type: 'insert'; value: string };
-
-export type TTextPromptEffect =
-  | { type: 'none' }
-  | { type: 'cancel' }
-  | { type: 'submit'; value: string };
-
-export interface ITextPromptFlowOptions {
-  allowEmpty: boolean;
-  validate?: (value: string) => string | undefined;
-}
-
-export function createTextPromptFlowState(): ITextPromptFlowState {
-  return { value: '', resolved: false };
-}
-
-export function getTextPromptInputAction(
-  input: string,
-  key: ITextPromptInputKey,
-): TTextPromptInputAction | undefined {
-  if (key.escape === true) {
-    return { type: 'cancel' };
-  }
-  if (key.return === true) {
-    return { type: 'submit' };
-  }
-  if (key.backspace === true || key.delete === true) {
-    return { type: 'delete' };
-  }
-  if (input && key.ctrl !== true && key.meta !== true) {
-    return { type: 'insert', value: input };
-  }
-  return undefined;
-}
-
-export function applyTextPromptInput(
-  state: ITextPromptFlowState,
-  action: TTextPromptInputAction,
-  options: ITextPromptFlowOptions,
-): { state: ITextPromptFlowState; effect: TTextPromptEffect } {
-  if (state.resolved) {
-    return { state, effect: { type: 'none' } };
-  }
-  if (action.type === 'cancel') {
-    return { state: { ...state, resolved: true }, effect: { type: 'cancel' } };
-  }
-  if (action.type === 'delete') {
-    return {
-      state: { ...state, value: state.value.slice(0, -1), error: undefined },
-      effect: { type: 'none' },
-    };
-  }
-  if (action.type === 'insert') {
-    return {
-      state: { ...state, value: state.value + action.value, error: undefined },
-      effect: { type: 'none' },
-    };
-  }
-  return submitTextPromptValue(state, options);
-}
-
-function submitTextPromptValue(
-  state: ITextPromptFlowState,
-  options: ITextPromptFlowOptions,
-): { state: ITextPromptFlowState; effect: TTextPromptEffect } {
-  const trimmed = state.value.trim();
-  if (!trimmed && !options.allowEmpty) {
-    const emptyError = options.validate?.(trimmed);
-    return {
-      state: emptyError ? { ...state, error: emptyError } : state,
-      effect: { type: 'none' },
-    };
-  }
-  const error = options.validate?.(trimmed);
-  if (error !== undefined) {
-    return { state: { ...state, error }, effect: { type: 'none' } };
-  }
-  return { state: { ...state, resolved: true }, effect: { type: 'submit', value: trimmed } };
-}

package/src/tui/hooks/command-effect-handler.ts

@@ -1,97 +0,0 @@
-import { createSystemMessage, messageToHistoryEntry } from '@robota-sdk/agent-core';
-import { isStatusLineCommandSettingsPatch } from '@robota-sdk/agent-framework';
-
-import type { ITuiCliAdapter } from '../tui-cli-adapter.js';
-import type { IHistoryEntry, TSessionEndReason } from '@robota-sdk/agent-core';
-import type {
-  TCommandEffect,
-  TStatusLineCommandSettingsPatch,
-} from '@robota-sdk/agent-interface-transport';
-
-export interface ICommandEffectHandlerDeps {
-  addEntry: (entry: IHistoryEntry) => void;
-  requestShutdown: (reason: TSessionEndReason, message: string) => void;
-  openPluginTUI: () => void;
-  openSessionPicker: () => void;
-  openTransportTUI: () => void;
-  openAgentSwitcher: () => void;
-  renameSession: (name: string) => void;
-  applyStatusLinePatch: (patch: TStatusLineCommandSettingsPatch) => boolean;
-  cliAdapter: ITuiCliAdapter;
-}
-
-export function applyCommandEffects(
-  effects: readonly TCommandEffect[],
-  deps: ICommandEffectHandlerDeps,
-): boolean {
-  for (const effect of effects) {
-    if (effect.type === 'language-change-requested') {
-      applyLanguageEffect(effect.language, deps);
-      return true;
-    }
-    if (effect.type === 'settings-reset-requested') {
-      applySettingsResetEffect(deps);
-      return true;
-    }
-    if (effect.type === 'session-exit-requested') {
-      deps.requestShutdown(
-        effect.reason ?? 'prompt_input_exit',
-        effect.message ?? 'User requested exit',
-      );
-      return true;
-    }
-    if (effect.type === 'session-restart-requested') {
-      deps.requestShutdown(effect.reason, effect.message);
-      return true;
-    }
-    if (effect.type === 'plugin-tui-requested') {
-      deps.openPluginTUI();
-      return true;
-    }
-    if (effect.type === 'settings-tui-requested') {
-      deps.openTransportTUI();
-      return true;
-    }
-    if (effect.type === 'agent-switcher-requested') {
-      deps.openAgentSwitcher();
-      return true;
-    }
-    if (effect.type === 'session-picker-requested') {
-      deps.openSessionPicker();
-      return true;
-    }
-    if (effect.type === 'session-renamed') {
-      deps.renameSession(effect.name);
-      return true;
-    }
-    if (effect.type === 'statusline-settings-patch') {
-      if (isStatusLineCommandSettingsPatch(effect.patch)) {
-        return deps.applyStatusLinePatch(effect.patch);
-      }
-    }
-  }
-  return false;
-}
-
-function applyLanguageEffect(language: string, deps: ICommandEffectHandlerDeps): void {
-  const settingsPath = deps.cliAdapter.getUserSettingsPath();
-  const settings = deps.cliAdapter.readSettings(settingsPath);
-  settings.language = language;
-  deps.cliAdapter.writeSettings(settingsPath, settings);
-  deps.addEntry(
-    messageToHistoryEntry(createSystemMessage(`Language set to "${language}". Restarting...`)),
-  );
-  deps.requestShutdown('other', 'Language change restart');
-}
-
-function applySettingsResetEffect(deps: ICommandEffectHandlerDeps): void {
-  const settingsPath = deps.cliAdapter.getUserSettingsPath();
-  if (deps.cliAdapter.deleteSettings(settingsPath)) {
-    deps.addEntry(
-      messageToHistoryEntry(createSystemMessage(`Deleted ${settingsPath}. Exiting...`)),
-    );
-  } else {
-    deps.addEntry(messageToHistoryEntry(createSystemMessage('No user settings found.')));
-  }
-  deps.requestShutdown('other', 'Reset settings restart');
-}

package/src/tui/hooks/command-effect-queue.ts

@@ -1,39 +0,0 @@
-import type { ICommandInteraction, TCommandEffect } from '@robota-sdk/agent-interface-transport';
-
-export type TQueuedCommandState =
-  | {
-      type: 'interaction';
-      interaction: ICommandInteraction;
-    }
-  | {
-      type: 'effects';
-      effects: readonly TCommandEffect[];
-    };
-
-export interface ICommandEffectQueue {
-  enqueueInteraction(interaction: ICommandInteraction): void;
-  enqueueEffects(effects: readonly TCommandEffect[]): void;
-  drain(): TQueuedCommandState | undefined;
-  clear(): void;
-}
-
-export class CommandEffectQueue implements ICommandEffectQueue {
-  private readonly queue: TQueuedCommandState[] = [];
-
-  enqueueInteraction(interaction: ICommandInteraction): void {
-    this.queue.push({ type: 'interaction', interaction });
-  }
-
-  enqueueEffects(effects: readonly TCommandEffect[]): void {
-    if (effects.length === 0) return;
-    this.queue.push({ type: 'effects', effects: [...effects] });
-  }
-
-  drain(): TQueuedCommandState | undefined {
-    return this.queue.shift();
-  }
-
-  clear(): void {
-    this.queue.length = 0;
-  }
-}

package/src/tui/hooks/side-effects-types.ts

@@ -1,35 +0,0 @@
-import type { ICommandEffectQueue } from './command-effect-queue.js';
-import type { IHistoryEntry } from '@robota-sdk/agent-core';
-import type { InteractiveSession } from '@robota-sdk/agent-framework';
-import type {
-  IStatusLineCommandSettings as TStatusLineSettings,
-  TCommandInteractionPrompt as TInteractivePrompt,
-} from '@robota-sdk/agent-interface-transport';
-
-export type { TInteractivePrompt, TStatusLineSettings };
-
-export interface IUseSideEffectsOptions {
-  cwd: string;
-  providerOverride?: string | undefined;
-  interactiveSession: InteractiveSession;
-  commandEffectQueue: ICommandEffectQueue;
-  addEntry: (entry: IHistoryEntry) => void;
-  baseHandleSubmit: (input: string) => Promise<void>;
-  setSessionName: (name: string) => void;
-  setStatusLineSettings: (settings: TStatusLineSettings) => void;
-  showSessionPickerOnStart?: boolean;
-  openAgentSwitcher?: () => void;
-}
-
-export interface IUseSideEffectsResult {
-  handleSubmit: (input: string) => Promise<void>;
-  pendingInteractionPrompt: TInteractivePrompt | null;
-  showPluginTUI: boolean;
-  showSessionPicker: boolean;
-  showTransportTUI: boolean;
-  setShowPluginTUI: (show: boolean) => void;
-  setShowSessionPicker: (show: boolean) => void;
-  setShowTransportTUI: (show: boolean) => void;
-  handleInteractionSubmit: (value: string) => Promise<void>;
-  handleInteractionCancel: () => void;
-}

package/src/tui/hooks/useAutocomplete.ts

@@ -1,87 +0,0 @@
-/**
- * Slash command autocomplete hook.
- * Extracted from InputArea.tsx for single-responsibility.
- */
-
-import React, { useState, useMemo } from 'react';
-
-import type { CommandRegistry } from '@robota-sdk/agent-framework';
-import type { ICommand } from '@robota-sdk/agent-interface-transport';
-
-/** Parse input to determine autocomplete state */
-function parseSlashInput(value: string): {
-  isSlash: boolean;
-  parentCommand: string;
-  filter: string;
-} {
-  if (!value.startsWith('/')) return { isSlash: false, parentCommand: '', filter: '' };
-  const afterSlash = value.slice(1);
-  const spaceIndex = afterSlash.indexOf(' ');
-  if (spaceIndex === -1) return { isSlash: true, parentCommand: '', filter: afterSlash };
-  const parent = afterSlash.slice(0, spaceIndex);
-  const rest = afterSlash.slice(spaceIndex + 1);
-  return { isSlash: true, parentCommand: parent, filter: rest };
-}
-
-/** Hook: manage autocomplete state */
-export function useAutocomplete(
-  value: string,
-  registry: CommandRegistry | undefined,
-): {
-  showPopup: boolean;
-  filteredCommands: ICommand[];
-  selectedIndex: number;
-  setSelectedIndex: React.Dispatch<React.SetStateAction<number>>;
-  isSubcommandMode: boolean;
-  setShowPopup: React.Dispatch<React.SetStateAction<boolean>>;
-} {
-  const [selectedIndex, setSelectedIndex] = useState(0);
-  const [dismissed, setDismissed] = useState(false);
-
-  // Reset dismissed when input changes
-  const prevValueRef = React.useRef(value);
-  if (prevValueRef.current !== value) {
-    prevValueRef.current = value;
-    if (dismissed) setDismissed(false);
-  }
-
-  const parsed = parseSlashInput(value);
-  const isSubcommandMode = parsed.isSlash && parsed.parentCommand.length > 0;
-
-  const filteredCommands = useMemo(() => {
-    if (!registry || !parsed.isSlash || dismissed) return [];
-    if (isSubcommandMode) {
-      const subs = registry.getSubcommands(parsed.parentCommand);
-      if (subs.length === 0) return [];
-      if (!parsed.filter) return subs;
-      const lower = parsed.filter.toLowerCase();
-      return subs.filter((c) => c.name.toLowerCase().startsWith(lower));
-    }
-    return registry.getCommands(parsed.filter);
-  }, [registry, parsed.isSlash, parsed.parentCommand, parsed.filter, dismissed, isSubcommandMode]);
-
-  const showPopup = parsed.isSlash && filteredCommands.length > 0 && !dismissed;
-
-  // Clamp selectedIndex
-  if (selectedIndex >= filteredCommands.length && filteredCommands.length > 0) {
-    setSelectedIndex(filteredCommands.length - 1);
-  }
-
-  return {
-    showPopup,
-    filteredCommands,
-    selectedIndex,
-    setSelectedIndex,
-    isSubcommandMode,
-    setShowPopup: (val) => {
-      if (typeof val === 'function') {
-        setDismissed((prev) => {
-          const nextVal = (val as (prev: boolean) => boolean)(!prev);
-          return !nextVal;
-        });
-      } else {
-        setDismissed(!val);
-      }
-    },
-  };
-}

package/src/tui/hooks/usePluginCallbacks.ts

@@ -1,31 +0,0 @@
-/**
- * Hook: returns a no-op ICommandPluginAdapter for when no plugin adapter is provided.
- *
- * In normal usage, App receives commandHostAdapters.plugin from the CLI (agent-cli), which
- * constructs the real adapter. This fallback exists only for test environments where no adapter
- * is injected.
- */
-
-import { useMemo } from 'react';
-
-import type { ICommandPluginAdapter } from '@robota-sdk/agent-interface-transport';
-
-function createNoOpPluginAdapter(): ICommandPluginAdapter {
-  return {
-    listInstalled: async () => [],
-    listAvailablePlugins: async () => [],
-    install: async () => undefined,
-    uninstall: async () => undefined,
-    enable: async () => undefined,
-    disable: async () => undefined,
-    marketplaceAdd: async () => '',
-    marketplaceRemove: async () => undefined,
-    marketplaceUpdate: async () => undefined,
-    marketplaceList: async () => [],
-    reloadPlugins: async () => ({ loadedPluginCount: 0 }),
-  };
-}
-
-export function usePluginCallbacks(_cwd: string): ICommandPluginAdapter {
-  return useMemo(() => createNoOpPluginAdapter(), []);
-}