@navios/commander-tui 1.0.0

package/src/overrides/console.logger.override.ts

@@ -0,0 +1,61 @@
+import {
+  inject,
+  Injectable,
+  LoggerOutput,
+  type ClassTypeWithInstance,
+  type LoggerService,
+  type LogLevel,
+} from '@navios/core'
+
+import { ScreenLogger } from '../tokens/index.ts'
+
+export function overrideConsoleLogger(
+  hidden: boolean = false,
+): ClassTypeWithInstance<LoggerService> {
+  /**
+   * Override the ConsoleLogger service to use the ScreenLogger service instead of the default ConsoleLogger service.
+   */
+  @Injectable({
+    token: LoggerOutput,
+    priority: 1000,
+  })
+  class ConsoleLoggerOverride implements LoggerService {
+    protected readonly logger = inject(ScreenLogger, {
+      screen: {
+        name: 'default',
+        icon: '💻',
+        hidden,
+      },
+    })
+
+    log(message: string): void {
+      this.logger.log(message)
+    }
+
+    error(message: string): void {
+      this.logger.error(message)
+    }
+
+    warn(message: string): void {
+      this.logger.warn(message)
+    }
+
+    debug(message: string): void {
+      this.logger.debug(message)
+    }
+
+    fatal(message: any) {
+      this.logger.fatal(message)
+    }
+
+    verbose(message: any) {
+      this.logger.verbose(message)
+    }
+
+    setLogLevels(levels: LogLevel[]): void {
+      this.logger.setLogLevels(levels)
+    }
+  }
+
+  return ConsoleLoggerOverride
+}

package/src/overrides/index.ts

@@ -0,0 +1 @@
+export * from './console.logger.override.ts'

package/src/schemas/index.ts

@@ -0,0 +1,3 @@
+export * from './screen-options.ts'
+export * from './logger-options.ts'
+export * from './prompt-options.ts'

package/src/schemas/logger-options.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod/v4'
+
+import { ALL_LOG_LEVELS } from '../types/index.ts'
+
+import { ScreenOptionsSchema } from './screen-options.ts'
+
+export const LoggerOptionsSchema = z.object({
+  screen: ScreenOptionsSchema.or(z.string()).optional().default('default'),
+  context: z.string().optional(),
+  enabledLevels: z.array(z.enum(ALL_LOG_LEVELS)).default(ALL_LOG_LEVELS),
+})
+
+export type LoggerOptions = z.infer<typeof LoggerOptionsSchema>

package/src/schemas/prompt-options.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod/v4'
+
+import { ScreenOptionsSchema } from './screen-options.ts'
+
+export const PromptOptionsSchema = z.object({
+  screen: ScreenOptionsSchema.or(z.string()).optional().default('default'),
+})
+
+export type PromptOptions = z.infer<typeof PromptOptionsSchema>

package/src/schemas/screen-options.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod/v4'
+
+export const ScreenOptionsSchema = z.object({
+  /** The name of the screen */
+  name: z.string(),
+  /** The icon of the screen */
+  icon: z.string().optional(),
+  /** The badge count of the screen */
+  badgeCount: z.number().optional(),
+  /** Whether the screen is hidden */
+  hidden: z.boolean().optional().default(false),
+})
+
+export type ScreenOptions = z.infer<typeof ScreenOptionsSchema>

package/src/services/index.ts

@@ -0,0 +1,4 @@
+export * from './screen_manager.tsx'
+export * from './screen.ts'
+export * from './logger.ts'
+export * from './prompt.ts'

package/src/services/logger.ts

@@ -0,0 +1,369 @@
+import { inject, Injectable } from '@navios/core'
+
+import type { LoggerService, LogLevel } from '@navios/core'
+
+import { Screen, ScreenLogger } from '../tokens/index.ts'
+import { captureTrace, formatObject } from '../utils/index.ts'
+
+import type { LoggerOptions } from '../schemas/index.ts'
+import type {
+  DiffMessageData,
+  FileErrorMessageData,
+  FileMessageData,
+  GroupMessageData,
+  LoadingHandle,
+  LoadingMessageData,
+  LogMessageData,
+  LogMessageVariant,
+  ProgressHandle,
+  ProgressMessageData,
+  PromiseOptions,
+  TableMessageData,
+} from '../types/index.ts'
+
+import type { ScreenInstance } from './screen.ts'
+
+let messageIdCounter = 0
+function generateId(): string {
+  return `msg-${++messageIdCounter}`
+}
+
+@Injectable({
+  token: ScreenLogger,
+})
+export class ScreenLoggerInstance implements LoggerService {
+  private screen: ScreenInstance
+  private context?: string
+  private enabledLevels: Set<LogLevel>
+
+  constructor(options: LoggerOptions) {
+    this.screen = inject(
+      Screen,
+      typeof options.screen === 'string'
+        ? {
+            name: options.screen,
+          }
+        : options.screen,
+    )
+
+    this.context = options.context
+    this.enabledLevels = new Set(options.enabledLevels)
+  }
+
+  private isLevelEnabled(level: LogLevel): boolean {
+    return this.enabledLevels.has(level)
+  }
+
+  // ============================================
+  // Log Level Methods (chainable)
+  // ============================================
+
+  verbose(msg: string | object, label?: string): this {
+    return this.write('verbose', msg, label)
+  }
+
+  setLogLevels(levels: LogLevel[]) {
+    this.enabledLevels = new Set(levels)
+    return this
+  }
+
+  trace(msg: string | object, label?: string): this {
+    const trace = captureTrace()
+    return this.write('verbose', msg, label, trace, 'trace')
+  }
+
+  debug(msg: string | object, label?: string): this {
+    return this.write('debug', msg, label)
+  }
+
+  log(msg: string | object, label?: string): this {
+    return this.write('log', msg, label)
+  }
+
+  success(msg: string | object, label?: string): this {
+    return this.write('log', msg, label, undefined, 'success')
+  }
+
+  warn(msg: string | object, label?: string): this {
+    return this.write('warn', msg, label)
+  }
+
+  error(msg: string | object, label?: string): this {
+    return this.write('error', msg, label)
+  }
+
+  fatal(msg: string | object, label?: string): this {
+    return this.write('fatal', msg, label)
+  }
+
+  private write(
+    level: LogLevel,
+    content: string | object,
+    label?: string,
+    trace?: string,
+    variant?: LogMessageVariant,
+  ): this {
+    if (!this.isLevelEnabled(level)) {
+      return this
+    }
+
+    const formattedContent = typeof content === 'object' ? formatObject(content) : content
+    const message: LogMessageData = {
+      id: generateId(),
+      type: 'log',
+      timestamp: new Date(),
+      level,
+      content: formattedContent,
+      label: label ?? this.context,
+      trace,
+      variant,
+    }
+    this.screen.addMessage(message)
+    return this
+  }
+
+  // ============================================
+  // File Methods (chainable)
+  // ============================================
+
+  file(path: string, content: string): this {
+    if (!this.isLevelEnabled('debug')) {
+      return this
+    }
+
+    const message: FileMessageData = {
+      id: generateId(),
+      type: 'file',
+      timestamp: new Date(),
+      filePath: path,
+      content,
+    }
+    this.screen.addMessage(message)
+    return this
+  }
+
+  diff(path: string, diffContent: string, view?: 'unified' | 'split'): this {
+    if (!this.isLevelEnabled('debug')) {
+      return this
+    }
+
+    const message: DiffMessageData = {
+      id: generateId(),
+      type: 'diff',
+      timestamp: new Date(),
+      filePath: path,
+      diff: diffContent,
+      view,
+    }
+    this.screen.addMessage(message)
+    return this
+  }
+
+  fileError(path: string, content: string, errorLines: number[], startLine: number = 1): this {
+    if (!this.isLevelEnabled('debug')) {
+      return this
+    }
+
+    const message: FileErrorMessageData = {
+      id: generateId(),
+      type: 'fileError',
+      timestamp: new Date(),
+      filePath: path,
+      content,
+      errorLines,
+      startLine,
+    }
+    this.screen.addMessage(message)
+    return this
+  }
+
+  // ============================================
+  // Promise/Async Methods
+  // ============================================
+
+  /**
+   * Sonner-like promise handling
+   */
+  async promise<T>(promise: Promise<T>, options: PromiseOptions<T>): Promise<T> {
+    const id = generateId()
+
+    // Add loading message
+    const loadingMessage: LoadingMessageData = {
+      id,
+      type: 'loading',
+      timestamp: new Date(),
+      content: options.loading,
+      status: 'loading',
+    }
+    this.screen.addMessage(loadingMessage)
+
+    try {
+      const result = await promise
+
+      // Update to success
+      const successContent =
+        typeof options.success === 'function' ? options.success(result) : options.success
+
+      this.screen.updateMessage(id, {
+        status: 'success',
+        resolvedContent: successContent,
+      })
+
+      return result
+    } catch (err) {
+      // Update to error
+      const error = err instanceof Error ? err : new Error(String(err))
+      const errorContent =
+        typeof options.error === 'function' ? options.error(error) : options.error
+
+      this.screen.updateMessage(id, {
+        status: 'fail',
+        resolvedContent: errorContent,
+      })
+
+      throw err
+    }
+  }
+
+  /**
+   * Create a loading message with manual resolution
+   */
+  loading(message: string): LoadingHandle {
+    const id = generateId()
+
+    const loadingMessage: LoadingMessageData = {
+      id,
+      type: 'loading',
+      timestamp: new Date(),
+      content: message,
+      status: 'loading',
+    }
+    this.screen.addMessage(loadingMessage)
+
+    return {
+      success: (resolvedMessage: string) => {
+        this.screen.updateMessage(id, {
+          status: 'success',
+          resolvedContent: resolvedMessage,
+        })
+      },
+      fail: (resolvedMessage: string) => {
+        this.screen.updateMessage(id, {
+          status: 'fail',
+          resolvedContent: resolvedMessage,
+        })
+      },
+    }
+  }
+
+  // ============================================
+  // Progress Bar
+  // ============================================
+
+  /**
+   * Create a progress bar with manual updates
+   */
+  progress(label: string, options: { total: number }): ProgressHandle {
+    const id = generateId()
+
+    const progressMessage: ProgressMessageData = {
+      id,
+      type: 'progress',
+      timestamp: new Date(),
+      label,
+      current: 0,
+      total: options.total,
+      status: 'active',
+    }
+    this.screen.addMessage(progressMessage)
+
+    return {
+      update: (current: number, newLabel?: string) => {
+        this.screen.updateProgressMessage(id, {
+          current,
+          label: newLabel ?? label,
+        })
+      },
+      complete: (message?: string) => {
+        this.screen.updateProgressMessage(id, {
+          current: options.total,
+          status: 'complete',
+          resolvedContent: message,
+        })
+      },
+      fail: (message?: string) => {
+        this.screen.updateProgressMessage(id, {
+          status: 'failed',
+          resolvedContent: message,
+        })
+      },
+    }
+  }
+
+  // ============================================
+  // Log Groups
+  // ============================================
+
+  /**
+   * Start a collapsible log group
+   */
+  group(label: string): this {
+    const message: GroupMessageData = {
+      id: generateId(),
+      type: 'group',
+      timestamp: new Date(),
+      label,
+      collapsed: false,
+      isEnd: false,
+    }
+    this.screen.addMessage(message)
+    return this
+  }
+
+  /**
+   * End the current log group
+   */
+  groupEnd(): this {
+    const message: GroupMessageData = {
+      id: generateId(),
+      type: 'group',
+      timestamp: new Date(),
+      label: '',
+      collapsed: false,
+      isEnd: true,
+    }
+    this.screen.addMessage(message)
+    return this
+  }
+
+  // ============================================
+  // Table Display
+  // ============================================
+
+  /**
+   * Display tabular data
+   */
+  table(data: Record<string, unknown>[], options?: { title?: string }): this {
+    if (data.length === 0) return this
+
+    const firstRow = data[0]
+    if (!firstRow) return this
+
+    // Extract headers from first row
+    const headers = Object.keys(firstRow)
+
+    // Convert data to string rows
+    const rows = data.map((row) => headers.map((h) => String(row[h] ?? '')))
+
+    const message: TableMessageData = {
+      id: generateId(),
+      type: 'table',
+      timestamp: new Date(),
+      headers,
+      rows,
+      title: options?.title,
+    }
+    this.screen.addMessage(message)
+    return this
+  }
+}

package/src/services/prompt.ts

@@ -0,0 +1,169 @@
+import { inject, Injectable } from '@navios/core'
+
+import { Prompt, Screen } from '../tokens/index.ts'
+
+import type { PromptOptions } from '../schemas/index.ts'
+import type {
+  ChoiceOptions,
+  ChoicePromptData,
+  ConfirmOptions,
+  ConfirmPromptData,
+  InputOptions,
+  InputPromptData,
+  MultiChoiceOptions,
+  MultiChoicePromptData,
+} from '../types/index.ts'
+
+import type { ScreenInstance } from './screen.ts'
+
+/**
+ * Prompt class for interactive user input.
+ * Similar to Logger, but for prompts that require user interaction.
+ */
+@Injectable({
+  token: Prompt,
+})
+export class PromptInstance {
+  private screen: ScreenInstance
+
+  constructor(options: PromptOptions) {
+    this.screen = inject(
+      Screen,
+      typeof options.screen === 'string'
+        ? {
+            name: options.screen,
+          }
+        : options.screen,
+    )
+  }
+
+  /**
+   * Display a choice prompt and wait for user selection.
+   * Returns the selected value (or input text if an input option was selected).
+   */
+  async choice(options: ChoiceOptions): Promise<string> {
+    const { question, choices, defaultChoice, timeout } = options
+
+    if (choices.length === 0) {
+      throw new Error('Choices array cannot be empty')
+    }
+
+    // Find default index
+    const defaultIndex = defaultChoice ? choices.findIndex((c) => c.value === defaultChoice) : 0
+
+    const prompt: ChoicePromptData = {
+      type: 'choice',
+      id: `prompt-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      timestamp: new Date(),
+      question,
+      choices,
+      defaultChoice: defaultChoice ?? choices[0]?.value ?? '',
+      selectedIndex: Math.max(0, defaultIndex),
+      inputMode: false,
+      inputValue: '',
+      resolved: false,
+      timeout,
+      timeoutStarted: timeout ? Date.now() : undefined,
+    }
+
+    return this.screen._addPrompt(prompt) as Promise<string>
+  }
+
+  /**
+   * Display a confirmation prompt and wait for user response.
+   * Returns true for confirm, false for cancel.
+   */
+  async confirm(options: ConfirmOptions): Promise<boolean> {
+    const {
+      question,
+      confirmText = 'Yes',
+      cancelText = 'No',
+      defaultValue = true,
+      timeout,
+    } = options
+
+    const prompt: ConfirmPromptData = {
+      type: 'confirm',
+      id: `prompt-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      timestamp: new Date(),
+      question,
+      confirmText,
+      cancelText,
+      defaultValue,
+      selectedValue: defaultValue,
+      resolved: false,
+      timeout,
+      timeoutStarted: timeout ? Date.now() : undefined,
+    }
+
+    return this.screen._addPrompt(prompt) as Promise<boolean>
+  }
+
+  /**
+   * Display a text input prompt and wait for user input.
+   * Returns the entered text.
+   */
+  async input(options: InputOptions): Promise<string> {
+    const { question, placeholder = '', defaultValue = '', timeout } = options
+
+    const prompt: InputPromptData = {
+      type: 'input',
+      id: `prompt-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      timestamp: new Date(),
+      question,
+      placeholder,
+      defaultValue,
+      value: defaultValue,
+      resolved: false,
+      timeout,
+      timeoutStarted: timeout ? Date.now() : undefined,
+    }
+
+    return this.screen._addPrompt(prompt) as Promise<string>
+  }
+
+  /**
+   * Display a multi-select choice prompt.
+   * Returns an array of selected values.
+   */
+  async multiChoice(options: MultiChoiceOptions): Promise<string[]> {
+    const {
+      question,
+      choices,
+      defaultChoices = [],
+      minSelect = 0,
+      maxSelect = choices.length,
+      timeout,
+    } = options
+
+    if (choices.length === 0) {
+      throw new Error('Choices array cannot be empty')
+    }
+
+    // Find default indices
+    const selectedIndices = new Set<number>()
+    defaultChoices.forEach((value) => {
+      const index = choices.findIndex((c) => c.value === value)
+      if (index !== -1) {
+        selectedIndices.add(index)
+      }
+    })
+
+    const prompt: MultiChoicePromptData = {
+      type: 'multiChoice',
+      id: `prompt-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      timestamp: new Date(),
+      question,
+      choices,
+      selectedIndices,
+      focusedIndex: 0,
+      minSelect,
+      maxSelect,
+      resolved: false,
+      timeout,
+      timeoutStarted: timeout ? Date.now() : undefined,
+    }
+
+    return this.screen._addPrompt(prompt) as Promise<string[]>
+  }
+}