@navios/commander-tui 1.2.0 → 1.4.0

package/src/services/logger.ts

@@ -42,6 +42,7 @@ export class ScreenLoggerInstance implements LoggerService {
       typeof options.screen === 'string'
         ? {
             name: options.screen,
+            static: true,
           }
         : options.screen,
     )
@@ -51,7 +52,12 @@ export class ScreenLoggerInstance implements LoggerService {
   }
 
   private isLevelEnabled(level: LogLevel): boolean {
-    return this.enabledLevels.has(level)
+    // Check local logger levels first
+    if (!this.enabledLevels.has(level)) {
+      return false
+    }
+    // Then check global levels via ScreenManager
+    return this.screen.isLogLevelEnabled(level)
   }
 
   // ============================================

package/src/services/readline_prompt.ts

@@ -0,0 +1,194 @@
+import * as readline from 'node:readline'
+
+import type {
+  ChoicePromptData,
+  ConfirmPromptData,
+  InputPromptData,
+  MultiChoicePromptData,
+  PromptData,
+} from '../types/index.ts'
+
+/**
+ * Readline-based prompt service for stdout mode.
+ * Provides basic interactive prompts when TUI adapter is not available.
+ */
+export class ReadlinePromptService {
+  private rl: readline.Interface | null = null
+  private promptQueue: Array<{
+    prompt: PromptData
+    resolve: (value: string | boolean | string[]) => void
+  }> = []
+  private isProcessing = false
+
+  private ensureInterface(): readline.Interface {
+    if (!this.rl) {
+      this.rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      })
+    }
+    return this.rl
+  }
+
+  /**
+   * Handle a prompt interactively via readline.
+   * Prompts are queued and processed sequentially.
+   */
+  async handlePrompt(prompt: PromptData): Promise<string | boolean | string[]> {
+    return new Promise((resolve) => {
+      this.promptQueue.push({ prompt, resolve })
+      this.processQueue()
+    })
+  }
+
+  private async processQueue(): Promise<void> {
+    if (this.isProcessing || this.promptQueue.length === 0) return
+
+    this.isProcessing = true
+
+    while (this.promptQueue.length > 0) {
+      const { prompt, resolve } = this.promptQueue.shift()!
+      const result = await this.processPrompt(prompt)
+      resolve(result)
+    }
+
+    this.isProcessing = false
+  }
+
+  private async processPrompt(prompt: PromptData): Promise<string | boolean | string[]> {
+    switch (prompt.type) {
+      case 'choice':
+        return this.handleChoice(prompt)
+      case 'confirm':
+        return this.handleConfirm(prompt)
+      case 'input':
+        return this.handleInput(prompt)
+      case 'multiChoice':
+        return this.handleMultiChoice(prompt)
+    }
+  }
+
+  private async handleChoice(prompt: ChoicePromptData): Promise<string> {
+    const rl = this.ensureInterface()
+
+    // Display question and choices
+    console.log(`\n${prompt.question}`)
+    prompt.choices.forEach((choice, index) => {
+      const isDefault = choice.value === prompt.defaultChoice
+      const marker = isDefault ? '*' : ' '
+      const inputHint = choice.input ? ' (allows custom input)' : ''
+      console.log(`  ${marker} ${index + 1}. ${choice.label}${inputHint}`)
+    })
+
+    return new Promise((resolve) => {
+      rl.question('Enter number (or press Enter for default): ', (answer) => {
+        const trimmed = answer.trim()
+        if (!trimmed) {
+          resolve(prompt.defaultChoice)
+          return
+        }
+
+        const num = parseInt(trimmed, 10)
+        if (num >= 1 && num <= prompt.choices.length) {
+          const choice = prompt.choices[num - 1]
+          if (choice.input) {
+            // If choice allows input, ask for it
+            rl.question(`Enter value for "${choice.label}": `, (inputValue) => {
+              resolve(inputValue.trim() || choice.value)
+            })
+          } else {
+            resolve(choice.value)
+          }
+        } else {
+          resolve(prompt.defaultChoice)
+        }
+      })
+    })
+  }
+
+  private async handleConfirm(prompt: ConfirmPromptData): Promise<boolean> {
+    const rl = this.ensureInterface()
+    const defaultText = prompt.defaultValue ? 'Y/n' : 'y/N'
+
+    return new Promise((resolve) => {
+      rl.question(`${prompt.question} [${defaultText}]: `, (answer) => {
+        const trimmed = answer.trim().toLowerCase()
+        if (!trimmed) {
+          resolve(prompt.defaultValue)
+          return
+        }
+        resolve(trimmed === 'y' || trimmed === 'yes')
+      })
+    })
+  }
+
+  private async handleInput(prompt: InputPromptData): Promise<string> {
+    const rl = this.ensureInterface()
+    const defaultHint = prompt.defaultValue ? ` (default: ${prompt.defaultValue})` : ''
+    const placeholderHint = prompt.placeholder ? ` [${prompt.placeholder}]` : ''
+
+    return new Promise((resolve) => {
+      rl.question(`${prompt.question}${placeholderHint}${defaultHint}: `, (answer) => {
+        resolve(answer.trim() || prompt.defaultValue)
+      })
+    })
+  }
+
+  private async handleMultiChoice(prompt: MultiChoicePromptData): Promise<string[]> {
+    const rl = this.ensureInterface()
+
+    // Display question and choices
+    console.log(`\n${prompt.question}`)
+    console.log(`(Select ${prompt.minSelect}-${prompt.maxSelect} options, enter comma-separated numbers)`)
+    prompt.choices.forEach((choice, index) => {
+      const selected = prompt.selectedIndices.has(index) ? '[x]' : '[ ]'
+      console.log(`  ${selected} ${index + 1}. ${choice.label}`)
+    })
+
+    return new Promise((resolve) => {
+      rl.question('Enter numbers (e.g., 1,3,5): ', (answer) => {
+        const trimmed = answer.trim()
+        if (!trimmed) {
+          // Return default selections
+          resolve(
+            prompt.choices.filter((_, i) => prompt.selectedIndices.has(i)).map((c) => c.value),
+          )
+          return
+        }
+
+        const indices = trimmed
+          .split(',')
+          .map((s) => parseInt(s.trim(), 10) - 1)
+          .filter((n) => n >= 0 && n < prompt.choices.length)
+
+        // Validate selection count
+        if (indices.length < prompt.minSelect) {
+          console.log(`Minimum ${prompt.minSelect} selections required. Using defaults.`)
+          resolve(
+            prompt.choices.filter((_, i) => prompt.selectedIndices.has(i)).map((c) => c.value),
+          )
+          return
+        }
+
+        if (indices.length > prompt.maxSelect) {
+          console.log(`Maximum ${prompt.maxSelect} selections allowed. Taking first ${prompt.maxSelect}.`)
+          indices.splice(prompt.maxSelect)
+        }
+
+        resolve(indices.map((i) => prompt.choices[i].value))
+      })
+    })
+  }
+
+  /**
+   * Cleanup readline interface
+   */
+  destroy(): void {
+    if (this.rl) {
+      this.rl.close()
+      this.rl = null
+    }
+    this.promptQueue = []
+    this.isProcessing = false
+  }
+}

package/src/services/screen.ts

@@ -1,4 +1,11 @@
+import { EventEmitter } from 'node:events'
+
+import type { LogLevel } from '@navios/core'
+
+import { getPromptDefaultValue, printSingleMessage } from '../utils/index.ts'
+
 import type { ScreenOptions } from '../schemas/index.ts'
+import { RenderMode } from '../types/index.ts'
 import type {
   ChoicePromptData,
   ConfirmPromptData,
@@ -8,10 +15,11 @@ import type {
   MultiChoicePromptData,
   ProgressMessageData,
   PromptData,
+  ScreenEventMap,
   ScreenStatus,
 } from '../types/index.ts'
 
-import type { ScreenManager } from './screen_manager.tsx'
+import type { ScreenManagerInstance } from './screen_manager.ts'
 
 interface PendingPrompt {
   data: PromptData
@@ -19,7 +27,7 @@ interface PendingPrompt {
   timeoutId?: ReturnType<typeof setTimeout>
 }
 
-export class ScreenInstance {
+export class ScreenInstance extends EventEmitter<ScreenEventMap> {
   private id: string
   private name: string
   private icon?: string
@@ -27,8 +35,7 @@ export class ScreenInstance {
   private status: ScreenStatus = 'waiting'
   private hidden: boolean = false
   private messages: MessageData[] = []
-  private manager: ScreenManager | null = null
-  private changeListeners: Set<() => void> = new Set()
+  private manager: ScreenManagerInstance | null = null
   private printFn: ((messages: MessageData[], name: string, isError: boolean) => void) | null = null
   private hasPrinted: boolean = false
   private version: number = 0
@@ -38,6 +45,7 @@ export class ScreenInstance {
   private activePrompt: PendingPrompt | null = null
 
   constructor(id: string, options: ScreenOptions) {
+    super()
     this.id = id
     this.name = options.name
     this.icon = options.icon
@@ -59,7 +67,7 @@ export class ScreenInstance {
   /**
    * Internal: Set the manager reference
    */
-  _setManager(manager: ScreenManager): void {
+  _setManager(manager: ScreenManagerInstance): void {
     this.manager = manager
   }
 
@@ -88,7 +96,7 @@ export class ScreenInstance {
 
   setBadgeCount(count: number): this {
     this.badgeCount = count
-    this.notifyChange()
+    this.emit('badge:changed', count)
     return this
   }
 
@@ -99,7 +107,7 @@ export class ScreenInstance {
   setHidden(hidden: boolean): this {
     this.hidden = hidden
     this.manager?.onScreenVisibilityChanged(this)
-    this.notifyChange()
+    this.emit('visibility:changed', hidden)
     return this
   }
 
@@ -116,7 +124,18 @@ export class ScreenInstance {
   }
 
   /**
-   * Set screen status. When success/fail and TUI is not bound, prints to stdout/stderr
+   * Check if a log level is enabled globally via the ScreenManager.
+   * Returns true if no manager is set or if the level is allowed.
+   */
+  isLogLevelEnabled(level: LogLevel): boolean {
+    if (!this.manager) {
+      return true
+    }
+    return this.manager.isLogLevelEnabled(level)
+  }
+
+  /**
+   * Set screen status. When success/fail and not in TUI mode, prints to stdout/stderr
    */
   setStatus(status: ScreenStatus): this {
     const wasComplete = this.status === 'success' || this.status === 'fail'
@@ -124,14 +143,15 @@ export class ScreenInstance {
 
     // When transitioning to complete state
     if (!wasComplete && (status === 'success' || status === 'fail')) {
-      // Only print if TUI is NOT bound (non-interactive mode)
-      if (!this.manager?.isTuiBound()) {
+      // Only print immediately if NOT in TUI mode
+      // In TUI mode, printing happens on unbind()
+      if (!this.manager?.hasTuiRenderer()) {
         this.printToConsole()
       }
       this.manager?.onScreenCompleted(this)
     }
 
-    this.notifyChange()
+    this.emit('status:changed', status)
     return this
   }
 
@@ -143,10 +163,20 @@ export class ScreenInstance {
   }
 
   /**
-   * Check if this screen has been printed to console
+   * Check if this screen has been printed to console.
+   * Static screens in non-TUI modes are considered printed as they print incrementally.
    */
   hasPrintedToConsole(): boolean {
-    return this.hasPrinted
+    // If already fully printed, return true
+    if (this.hasPrinted) return true
+
+    // Static screens in non-TUI modes print incrementally, so they're considered "printed"
+    // as their messages are output immediately when added
+    if (this.status === 'static' && !this.manager?.hasTuiRenderer()) {
+      return true
+    }
+
+    return false
   }
 
   /**
@@ -171,7 +201,13 @@ export class ScreenInstance {
   addMessage(message: MessageData): void {
     this.messages.push(message)
     this.incrementVersion()
-    this.notifyChange()
+
+    // In non-TUI modes, static screens print messages immediately
+    if (this.status === 'static' && !this.manager?.hasTuiRenderer()) {
+      this.printSingleMessageToConsole(message)
+    }
+
+    this.emit('message:added', message.id)
   }
 
   /**
@@ -180,12 +216,23 @@ export class ScreenInstance {
   updateMessage(id: string, updates: Partial<LoadingMessageData>): void {
     const index = this.messages.findIndex((m) => m.id === id)
     if (index !== -1) {
+      const oldMessage = this.messages[index] as LoadingMessageData
       this.messages[index] = {
         ...this.messages[index],
         ...updates,
       } as MessageData
       this.incrementVersion()
-      this.notifyChange()
+
+      // In non-TUI modes for static screens, print when loading completes
+      if (this.status === 'static' && !this.manager?.hasTuiRenderer()) {
+        const newMessage = this.messages[index] as LoadingMessageData
+        // Only print when transitioning from 'loading' to 'success'/'fail'
+        if (newMessage.status !== 'loading' && oldMessage.status === 'loading') {
+          this.printSingleMessageToConsole(newMessage)
+        }
+      }
+
+      this.emit('message:updated', id)
     }
   }
 
@@ -195,12 +242,26 @@ export class ScreenInstance {
   updateProgressMessage(id: string, updates: Partial<ProgressMessageData>): void {
     const index = this.messages.findIndex((m) => m.id === id)
     if (index !== -1) {
+      const oldMessage = this.messages[index] as ProgressMessageData
       this.messages[index] = {
         ...this.messages[index],
         ...updates,
       } as MessageData
       this.incrementVersion()
-      this.notifyChange()
+
+      // In non-TUI modes for static screens, print when progress completes
+      if (this.status === 'static' && !this.manager?.hasTuiRenderer()) {
+        const newMessage = this.messages[index] as ProgressMessageData
+        if (
+          (newMessage.status === 'complete' || newMessage.status === 'failed') &&
+          oldMessage.status !== 'complete' &&
+          oldMessage.status !== 'failed'
+        ) {
+          this.printSingleMessageToConsole(newMessage)
+        }
+      }
+
+      this.emit('message:updated', id)
     }
   }
 
@@ -210,7 +271,7 @@ export class ScreenInstance {
   clear(): this {
     this.messages = []
     this.incrementVersion()
-    this.notifyChange()
+    this.emit('messages:cleared')
     return this
   }
 
@@ -224,14 +285,23 @@ export class ScreenInstance {
    */
   _addPrompt(prompt: PromptData): Promise<string | boolean | string[]> {
     return new Promise((resolve) => {
-      const pending: PendingPrompt = { data: prompt, resolve }
+      const mode = this.manager?.getRenderMode() ?? RenderMode.UNBOUND
 
-      // If TUI is not bound (non-interactive mode), return default immediately
-      if (!this.manager?.isTuiBound()) {
+      // UNBOUND mode: return defaults immediately (no interaction possible)
+      if (mode === RenderMode.UNBOUND) {
         this.resolvePromptWithDefault(prompt, resolve)
         return
       }
 
+      // STDOUT modes (STDOUT_INTERACTIVE, STDOUT_FALLBACK): use readline for interactive prompts
+      if (mode === RenderMode.STDOUT_INTERACTIVE || mode === RenderMode.STDOUT_FALLBACK) {
+        this.manager?.handleReadlinePrompt(prompt).then(resolve)
+        return
+      }
+
+      // TUI_ACTIVE mode: use TUI prompt queue system
+      const pending: PendingPrompt = { data: prompt, resolve }
+
       // Set up timeout if specified
       if (prompt.timeout && prompt.timeoutStarted) {
         pending.timeoutId = setTimeout(() => {
@@ -240,7 +310,7 @@ export class ScreenInstance {
             this.activePrompt = null
             this.activateNextPrompt()
             this.incrementVersion()
-            this.notifyChange()
+            this.emit('prompt:resolved')
           } else {
             // Remove from queue if not yet active
             const idx = this.promptQueue.indexOf(pending)
@@ -270,20 +340,7 @@ export class ScreenInstance {
     prompt: PromptData,
     resolve: (value: string | boolean | string[]) => void,
   ): void {
-    switch (prompt.type) {
-      case 'choice':
-        resolve(prompt.defaultChoice)
-        break
-      case 'confirm':
-        resolve(prompt.defaultValue)
-        break
-      case 'input':
-        resolve(prompt.defaultValue)
-        break
-      case 'multiChoice':
-        resolve(prompt.choices.filter((_, i) => prompt.selectedIndices.has(i)).map((c) => c.value))
-        break
-    }
+    resolve(getPromptDefaultValue(prompt))
   }
 
   /**
@@ -316,7 +373,7 @@ export class ScreenInstance {
     } else if (prompt.type === 'confirm') {
       ;(prompt as ConfirmPromptData).selectedValue = index === 0
     }
-    this.notifyChange()
+    this.emit('prompt:updated')
   }
 
   /**
@@ -359,7 +416,7 @@ export class ScreenInstance {
     const prompt = this.activePrompt.data
     if (prompt.type === 'confirm') {
       ;(prompt as ConfirmPromptData).selectedValue = true
-      this.notifyChange()
+      this.emit('prompt:updated')
     }
   }
 
@@ -368,7 +425,7 @@ export class ScreenInstance {
     const prompt = this.activePrompt.data
     if (prompt.type === 'confirm') {
       ;(prompt as ConfirmPromptData).selectedValue = false
-      this.notifyChange()
+      this.emit('prompt:updated')
     }
   }
 
@@ -385,7 +442,7 @@ export class ScreenInstance {
       } else if (p.selectedIndices.size < p.maxSelect) {
         p.selectedIndices.add(p.focusedIndex)
       }
-      this.notifyChange()
+      this.emit('prompt:updated')
     }
   }
 
@@ -401,7 +458,7 @@ export class ScreenInstance {
       const choice = prompt.choices[prompt.selectedIndex]
       if (choice?.input) {
         ;(prompt as ChoicePromptData).inputMode = true
-        this.notifyChange()
+        this.emit('prompt:updated')
         return true
       }
     } else if (prompt.type === 'input') {
@@ -420,7 +477,7 @@ export class ScreenInstance {
     const prompt = this.activePrompt.data
     if (prompt.type === 'choice' && prompt.inputMode) {
       ;(prompt as ChoicePromptData).inputMode = false
-      this.notifyChange()
+      this.emit('prompt:updated')
     }
     // Input prompts cannot exit input mode
   }
@@ -449,10 +506,10 @@ export class ScreenInstance {
     const prompt = this.activePrompt.data
     if (prompt.type === 'choice' && prompt.inputMode) {
       ;(prompt as ChoicePromptData).inputValue = value
-      this.notifyChange()
+      this.emit('prompt:updated')
     } else if (prompt.type === 'input') {
       ;(prompt as InputPromptData).value = value
-      this.notifyChange()
+      this.emit('prompt:updated')
     }
   }
 
@@ -465,10 +522,10 @@ export class ScreenInstance {
     const prompt = this.activePrompt.data
     if (prompt.type === 'choice' && prompt.inputMode) {
       ;(prompt as ChoicePromptData).inputValue += char
-      this.notifyChange()
+      this.emit('prompt:updated')
     } else if (prompt.type === 'input') {
       ;(prompt as InputPromptData).value += char
-      this.notifyChange()
+      this.emit('prompt:updated')
     }
   }
 
@@ -481,10 +538,10 @@ export class ScreenInstance {
     const prompt = this.activePrompt.data
     if (prompt.type === 'choice' && prompt.inputMode) {
       ;(prompt as ChoicePromptData).inputValue = prompt.inputValue.slice(0, -1)
-      this.notifyChange()
+      this.emit('prompt:updated')
     } else if (prompt.type === 'input') {
       ;(prompt as InputPromptData).value = prompt.value.slice(0, -1)
-      this.notifyChange()
+      this.emit('prompt:updated')
     }
   }
 
@@ -550,7 +607,7 @@ export class ScreenInstance {
     this.activePrompt = null
     this.activateNextPrompt()
     this.incrementVersion()
-    this.notifyChange()
+    this.emit('prompt:resolved')
   }
 
   /**
@@ -562,20 +619,15 @@ export class ScreenInstance {
       // Notify manager to focus this screen
       this.manager?.onScreenPromptActivated(this)
       this.incrementVersion()
-      this.notifyChange()
+      this.emit('prompt:activated')
     }
   }
 
   /**
-   * Register a change listener for re-renders
+   * Print a single message immediately to stdout (for static screens in stdout mode)
    */
-  onChange(listener: () => void): () => void {
-    this.changeListeners.add(listener)
-    return () => this.changeListeners.delete(listener)
-  }
-
-  private notifyChange(): void {
-    this.changeListeners.forEach((listener) => listener())
+  private printSingleMessageToConsole(message: MessageData): void {
+    printSingleMessage(message, this.name, false)
   }
 
   /**