@phenx-inc/ctlsurf 0.1.21 → 0.3.0

package/src/main/orchestrator.ts

@@ -7,6 +7,7 @@ import { AgentConfig, isCodingAgent } from './agents'
 import { CtlsurfApi } from './ctlsurfApi'
 import { ConversationBridge } from './bridge'
 import { WorkerWsClient, type WorkerWsStatus, type IncomingMessage } from './workerWs'
+import { TimeTracker } from './timeTracker'
 
 function log(...args: unknown[]): void {
   try { console.log(...args) } catch { /* EPIPE safe */ }
@@ -19,8 +20,12 @@ export interface Profile {
   apiKey: string
   baseUrl: string
   dataspacePageId: string
+  trackTime?: boolean
+  idleTimeoutMin?: number
 }
 
+const DEFAULT_IDLE_TIMEOUT_MIN = 15
+
 export interface SettingsData {
   activeProfile: string
   profiles: Record<string, Profile>
@@ -30,14 +35,22 @@ export interface SettingsData {
 }
 
 export interface OrchestratorEvents {
-  onPtyData: (data: string) => void
-  onPtyExit: (code: number) => void
+  onPtyData: (tabId: string, data: string) => void
+  onPtyExit: (tabId: string, code: number) => void
   onWorkerStatus: (status: string) => void
   onWorkerMessage: (message: IncomingMessage) => void
   onWorkerRegistered: (data: { worker_id: string; folder_id: string | null; status: string }) => void
   onCwdChanged: () => void
 }
 
+interface TabState {
+  ptyManager: PtyManager
+  agent: AgentConfig
+  cwd: string
+  termStreamBuffer: string
+  termStreamTimer: ReturnType<typeof setTimeout> | null
+}
+
 // ─── Orchestrator ─────────────────────────────────
 
 const DEFAULT_PROFILES: Record<string, Profile> = {
@@ -46,6 +59,8 @@ const DEFAULT_PROFILES: Record<string, Profile> = {
     apiKey: '',
     baseUrl: 'https://app.ctlsurf.com',
     dataspacePageId: '',
+    trackTime: true,
+    idleTimeoutMin: 15,
   },
 }
 
@@ -59,9 +74,11 @@ export class Orchestrator {
   readonly ctlsurfApi = new CtlsurfApi()
   readonly bridge = new ConversationBridge()
   readonly workerWs: WorkerWsClient
+  readonly timeTracker = new TimeTracker(this.ctlsurfApi)
 
   // State
-  private ptyManager: PtyManager | null = null
+  private tabs = new Map<string, TabState>()
+  private activeTabId: string | null = null
   private currentAgent: AgentConfig | null = null
   private currentCwd: string | null = null
   private settings: SettingsData = {
@@ -69,10 +86,6 @@ export class Orchestrator {
     profiles: { ...DEFAULT_PROFILES },
   }
 
-  // Terminal stream batching
-  private termStreamBuffer = ''
-  private termStreamTimer: ReturnType<typeof setTimeout> | null = null
-
   constructor(settingsDir: string, events: OrchestratorEvents) {
     this.settingsDir = settingsDir
     this.events = events
@@ -88,8 +101,9 @@ export class Orchestrator {
         this.workerWs.sendAck(message.id)
 
         if (message.type === 'prompt' || message.type === 'task_dispatch') {
-          if (this.ptyManager) {
-            this.ptyManager.write(message.content + '\r')
+          const activeTab = this.activeTabId ? this.tabs.get(this.activeTabId) : null
+          if (activeTab) {
+            activeTab.ptyManager.write(message.content + '\r')
             this.bridge.feedInput(message.content)
           }
         }
@@ -102,7 +116,8 @@ export class Orchestrator {
         }
       },
       onTerminalInput: (data: string) => {
-        this.ptyManager?.write(data)
+        const activeTab = this.activeTabId ? this.tabs.get(this.activeTabId) : null
+        activeTab?.ptyManager.write(data)
       },
     })
 
@@ -215,6 +230,8 @@ export class Orchestrator {
         baseUrl: p.baseUrl,
         hasApiKey: !!p.apiKey,
         dataspacePageId: p.dataspacePageId || null,
+        trackTime: p.trackTime !== false,
+        idleTimeoutMin: p.idleTimeoutMin ?? DEFAULT_IDLE_TIMEOUT_MIN,
       })),
     }
   }
@@ -228,16 +245,27 @@ export class Orchestrator {
       baseUrl: p.baseUrl,
       hasApiKey: !!p.apiKey,
       dataspacePageId: p.dataspacePageId || '',
+      trackTime: p.trackTime !== false,
+      idleTimeoutMin: p.idleTimeoutMin ?? DEFAULT_IDLE_TIMEOUT_MIN,
     }
   }
 
-  saveProfile(profileId: string, data: { name: string; apiKey?: string; baseUrl: string; dataspacePageId: string }) {
+  saveProfile(profileId: string, data: {
+    name: string
+    apiKey?: string
+    baseUrl: string
+    dataspacePageId: string
+    trackTime?: boolean
+    idleTimeoutMin?: number
+  }) {
     const existing = this.settings.profiles[profileId]
     this.settings.profiles[profileId] = {
       name: data.name,
       apiKey: data.apiKey !== undefined ? data.apiKey : (existing?.apiKey || ''),
       baseUrl: data.baseUrl || 'https://app.ctlsurf.com',
       dataspacePageId: data.dataspacePageId || '',
+      trackTime: data.trackTime !== undefined ? data.trackTime : (existing?.trackTime !== false),
+      idleTimeoutMin: data.idleTimeoutMin !== undefined ? data.idleTimeoutMin : (existing?.idleTimeoutMin ?? DEFAULT_IDLE_TIMEOUT_MIN),
     }
     this.saveSettings()
 
@@ -280,41 +308,65 @@ export class Orchestrator {
     return { ok: true }
   }
 
-  // ─── PTY & Agent ────────────────────────────────
+  // ─── PTY & Agent (multi-tab) ─────────────────────
 
-  async spawnAgent(agent: AgentConfig, cwd: string): Promise<void> {
-    if (this.ptyManager) {
-      this.bridge.endSession()
-      this.ptyManager.kill()
+  async spawnAgent(tabId: string, agent: AgentConfig, cwd: string, opts?: { trackTime?: boolean }): Promise<void> {
+    // Kill existing PTY on this tab if any
+    const existing = this.tabs.get(tabId)
+    if (existing) {
+      if (existing.termStreamTimer) clearTimeout(existing.termStreamTimer)
+      existing.ptyManager.kill()
+      this.tabs.delete(tabId)
     }
 
     this.currentAgent = agent
     const prevCwd = this.currentCwd
     this.currentCwd = cwd
+    this.activeTabId = tabId
     if (prevCwd !== cwd) {
       this.events.onCwdChanged()
     }
 
-    this.ptyManager = new PtyManager(agent, cwd)
+    const ptyManager = new PtyManager(agent, cwd)
+    const tab: TabState = { ptyManager, agent, cwd, termStreamBuffer: '', termStreamTimer: null }
+    this.tabs.set(tabId, tab)
 
-    this.ptyManager.onData((data: string) => {
-      this.events.onPtyData(data)
-      this.bridge.feedOutput(data)
-      this.streamTerminalData(data)
+    ptyManager.onData((data: string) => {
+      this.events.onPtyData(tabId, data)
+      this.timeTracker.recordActivity(tabId)
+      if (tabId === this.activeTabId) {
+        this.bridge.feedOutput(data)
+        this.streamTerminalData(tabId, data)
+      }
     })
 
-    const thisPtyManager = this.ptyManager
-
-    this.ptyManager.onExit(async (exitCode: number) => {
-      this.events.onPtyExit(exitCode)
-      this.bridge.endSession()
-      if (thisPtyManager === this.ptyManager && this.currentAgent && isCodingAgent(this.currentAgent)) {
-        this.workerWs.disconnect()
+    ptyManager.onExit(async (exitCode: number) => {
+      this.events.onPtyExit(tabId, exitCode)
+      await this.timeTracker.endSession(tabId)
+      if (tabId === this.activeTabId) {
+        this.bridge.endSession()
+        if (this.currentAgent && isCodingAgent(this.currentAgent)) {
+          this.workerWs.disconnect()
+        }
       }
+      // Clean up tab state
+      const t = this.tabs.get(tabId)
+      if (t?.termStreamTimer) clearTimeout(t.termStreamTimer)
     })
 
     this.bridge.startSession()
 
+    const profile = this.getActiveProfile()
+    const shouldTrack = opts?.trackTime !== undefined ? opts.trackTime : (profile.trackTime !== false)
+    if (shouldTrack) {
+      void this.timeTracker.startSession(
+        tabId,
+        cwd,
+        agent.name,
+        profile.idleTimeoutMin ?? DEFAULT_IDLE_TIMEOUT_MIN,
+      )
+    }
+
     if (isCodingAgent(agent)) {
       this.connectWorkerWs(agent, cwd)
     } else {
@@ -323,23 +375,74 @@ export class Orchestrator {
     }
   }
 
-  writePty(data: string): void {
-    this.ptyManager?.write(data)
-    this.bridge.feedInput(data)
+  writePty(tabId: string, data: string): void {
+    this.tabs.get(tabId)?.ptyManager.write(data)
+    if (tabId === this.activeTabId) {
+      this.bridge.feedInput(data)
+    }
   }
 
-  resizePty(cols: number, rows: number): void {
-    this.ptyManager?.resize(cols, rows)
-    this.bridge.resize(cols, rows)
-    this.workerWs.sendTerminalResize(cols, rows)
+  resizePty(tabId: string, cols: number, rows: number): void {
+    this.tabs.get(tabId)?.ptyManager.resize(cols, rows)
+    if (tabId === this.activeTabId) {
+      this.bridge.resize(cols, rows)
+      this.workerWs.sendTerminalResize(cols, rows)
+    }
   }
 
-  async killAgent(): Promise<void> {
-    this.bridge.endSession()
-    this.ptyManager?.kill()
-    this.ptyManager = null
-    if (this.currentAgent && isCodingAgent(this.currentAgent)) {
-      this.workerWs.disconnect()
+  async killTab(tabId: string): Promise<void> {
+    const tab = this.tabs.get(tabId)
+    if (!tab) return
+    if (tab.termStreamTimer) clearTimeout(tab.termStreamTimer)
+    await this.timeTracker.endSession(tabId)
+    tab.ptyManager.kill()
+    this.tabs.delete(tabId)
+    if (tabId === this.activeTabId) {
+      this.bridge.endSession()
+      if (isCodingAgent(tab.agent)) {
+        this.workerWs.disconnect()
+      }
+      // Switch active to another tab if available
+      const remaining = [...this.tabs.keys()]
+      this.activeTabId = remaining.length > 0 ? remaining[remaining.length - 1] : null
+    }
+  }
+
+  setActiveTab(tabId: string): void {
+    this.activeTabId = tabId
+    const tab = this.tabs.get(tabId)
+    if (tab) {
+      this.currentAgent = tab.agent
+      this.currentCwd = tab.cwd
+    }
+  }
+
+  getTabIds(): string[] {
+    return [...this.tabs.keys()]
+  }
+
+  // ─── Tracking control (active tab) ──────────────
+
+  isActiveTabTracking(): boolean {
+    if (!this.activeTabId) return false
+    return this.timeTracker.isTracking(this.activeTabId)
+  }
+
+  async setActiveTabTracking(enabled: boolean): Promise<void> {
+    if (!this.activeTabId) return
+    const tab = this.tabs.get(this.activeTabId)
+    if (!tab) return
+    if (enabled) {
+      if (this.timeTracker.isTracking(this.activeTabId)) return
+      const profile = this.getActiveProfile()
+      await this.timeTracker.startSession(
+        this.activeTabId,
+        tab.cwd,
+        tab.agent.name,
+        profile.idleTimeoutMin ?? DEFAULT_IDLE_TIMEOUT_MIN,
+      )
+    } else {
+      await this.timeTracker.endSession(this.activeTabId)
     }
   }
 
@@ -375,15 +478,17 @@ export class Orchestrator {
     }
   }
 
-  private streamTerminalData(data: string): void {
-    this.termStreamBuffer += data
-    if (!this.termStreamTimer) {
-      this.termStreamTimer = setTimeout(() => {
-        if (this.termStreamBuffer) {
-          this.workerWs.sendTerminalData(this.termStreamBuffer)
-          this.termStreamBuffer = ''
+  private streamTerminalData(tabId: string, data: string): void {
+    const tab = this.tabs.get(tabId)
+    if (!tab) return
+    tab.termStreamBuffer += data
+    if (!tab.termStreamTimer) {
+      tab.termStreamTimer = setTimeout(() => {
+        if (tab.termStreamBuffer) {
+          this.workerWs.sendTerminalData(tab.termStreamBuffer)
+          tab.termStreamBuffer = ''
         }
-        this.termStreamTimer = null
+        tab.termStreamTimer = null
       }, TERM_STREAM_INTERVAL_MS)
     }
   }
@@ -392,12 +497,12 @@ export class Orchestrator {
 
   async shutdown(): Promise<void> {
     this.bridge.endSession()
-    this.ptyManager?.kill()
-    this.ptyManager = null
-    this.workerWs.disconnect()
-    if (this.termStreamTimer) {
-      clearTimeout(this.termStreamTimer)
-      this.termStreamTimer = null
+    await this.timeTracker.endAll()
+    for (const [, tab] of this.tabs) {
+      if (tab.termStreamTimer) clearTimeout(tab.termStreamTimer)
+      tab.ptyManager.kill()
     }
+    this.tabs.clear()
+    this.workerWs.disconnect()
   }
 }

package/src/main/timeTracker.ts

@@ -0,0 +1,223 @@
+import os from 'os'
+import { randomUUID } from 'crypto'
+import type { CtlsurfApi } from './ctlsurfApi'
+
+const DATASTORE_TITLE = 'Time Tracking'
+const AGENT_DATASTORE_PAGE_TITLE = 'Agent Datastore'
+const FIRST_CHECKPOINT_DELAY_MS = 30 * 1000
+const CHECKPOINT_INTERVAL_MS = 5 * 60 * 1000
+
+const COLUMNS: Array<{ name: string; type: string }> = [
+  { name: 'Started', type: 'date' },
+  { name: 'Active Time', type: 'number' },
+  { name: 'Agent', type: 'text' },
+  { name: 'Worker', type: 'text' },
+  { name: 'Session', type: 'text' },
+  { name: 'Notes', type: 'text' },
+]
+
+interface SessionState {
+  blockId: string
+  rowId: string
+  cwd: string
+  startedAt: number
+  lastActivity: number
+  activeMs: number
+  idleTimeoutMs: number
+  firstCheckpointTimer: ReturnType<typeof setTimeout> | null
+  checkpointTimer: ReturnType<typeof setInterval> | null
+  ended: boolean
+}
+
+function log(...args: unknown[]): void {
+  try { console.log('[time-tracker]', ...args) } catch { /* EPIPE safe */ }
+}
+
+function findPageByTitle(pages: any[], title: string): any | null {
+  for (const p of pages) {
+    if (p?.title === title) return p
+    if (p?.children?.length) {
+      const c = findPageByTitle(p.children, title)
+      if (c) return c
+    }
+  }
+  return null
+}
+
+export class TimeTracker {
+  private api: CtlsurfApi
+  private sessions = new Map<string, SessionState>()
+  private blockCache = new Map<string, string>()
+
+  constructor(api: CtlsurfApi) {
+    this.api = api
+  }
+
+  async startSession(tabId: string, cwd: string, agentName: string, idleTimeoutMin: number): Promise<void> {
+    if (this.sessions.has(tabId)) {
+      await this.endSession(tabId)
+    }
+    try {
+      const blockId = await this.ensureDatastore(cwd)
+      if (!blockId) {
+        log(`No "${AGENT_DATASTORE_PAGE_TITLE}" page found for ${cwd} — tracking disabled for this session`)
+        return
+      }
+      const startedAt = Date.now()
+      const startedIso = new Date(startedAt).toISOString()
+      const sessionUuid = randomUUID()
+      const row = await this.api.addRow(blockId, {
+        Started: startedIso,
+        'Active Time': 0,
+        Agent: agentName,
+        Worker: os.hostname(),
+        Session: sessionUuid,
+        Notes: '',
+      })
+      const rowId = row?.id
+      if (!rowId) {
+        log('addRow returned no id; aborting tracking', row)
+        return
+      }
+      const state: SessionState = {
+        blockId,
+        rowId,
+        cwd,
+        startedAt,
+        lastActivity: startedAt,
+        activeMs: 0,
+        idleTimeoutMs: Math.max(1, idleTimeoutMin) * 60 * 1000,
+        firstCheckpointTimer: null,
+        checkpointTimer: null,
+        ended: false,
+      }
+      state.firstCheckpointTimer = setTimeout(() => {
+        void this.checkpoint(tabId)
+        const live = this.sessions.get(tabId)
+        if (live && !live.ended) {
+          live.checkpointTimer = setInterval(() => {
+            void this.checkpoint(tabId)
+          }, CHECKPOINT_INTERVAL_MS)
+        }
+      }, FIRST_CHECKPOINT_DELAY_MS)
+      this.sessions.set(tabId, state)
+      log(`Started tracking tab=${tabId} agent="${agentName}" cwd=${cwd}`)
+    } catch (err: any) {
+      log(`startSession failed: ${err?.message || err}`)
+    }
+  }
+
+  isTracking(tabId: string): boolean {
+    const s = this.sessions.get(tabId)
+    return !!s && !s.ended
+  }
+
+  recordActivity(tabId: string): void {
+    const s = this.sessions.get(tabId)
+    if (!s || s.ended) return
+    const now = Date.now()
+    const delta = now - s.lastActivity
+    if (delta < s.idleTimeoutMs) {
+      s.activeMs += delta
+    }
+    s.lastActivity = now
+  }
+
+  async endSession(tabId: string): Promise<void> {
+    const s = this.sessions.get(tabId)
+    if (!s || s.ended) return
+    s.ended = true
+    if (s.firstCheckpointTimer) clearTimeout(s.firstCheckpointTimer)
+    if (s.checkpointTimer) clearInterval(s.checkpointTimer)
+    try {
+      await this.writeRow(s, Date.now())
+    } catch (err: any) {
+      log(`endSession write failed: ${err?.message || err}`)
+    }
+    this.sessions.delete(tabId)
+  }
+
+  async endAll(): Promise<void> {
+    const ids = [...this.sessions.keys()]
+    await Promise.all(ids.map(id => this.endSession(id)))
+  }
+
+  private async checkpoint(tabId: string): Promise<void> {
+    const s = this.sessions.get(tabId)
+    if (!s || s.ended) return
+    try {
+      await this.writeRow(s, Date.now())
+    } catch (err: any) {
+      log(`checkpoint failed: ${err?.message || err}`)
+    }
+  }
+
+  private async writeRow(s: SessionState, _endTimeMs: number): Promise<void> {
+    const activeMin = Math.round(s.activeMs / 60000)
+    await this.api.updateRow(s.blockId, s.rowId, {
+      'Active Time': activeMin,
+    })
+  }
+
+  private async ensureDatastore(cwd: string): Promise<string | null> {
+    const cached = this.blockCache.get(cwd)
+    if (cached) return cached
+
+    let folder: any = null
+    try {
+      folder = await this.api.findFolderByPath(cwd)
+    } catch {
+      return null
+    }
+    if (!folder?.id) return null
+
+    const folderDetail = await this.api.getFolder(folder.id)
+    const agentPage = findPageByTitle(folderDetail?.pages || [], AGENT_DATASTORE_PAGE_TITLE)
+    if (!agentPage?.id) return null
+
+    const summaries = await this.api.getPageBlockSummaries(agentPage.id)
+    const existing = (summaries || []).find((b: any) => b?.type === 'datastore' && b?.title === DATASTORE_TITLE)
+    if (existing?.id) {
+      await this.ensureColumns(existing.id)
+      this.blockCache.set(cwd, existing.id)
+      return existing.id
+    }
+
+    const columns = COLUMNS.map((c, i) => ({ id: `col_${i}`, name: c.name, type: c.type }))
+    const created = await this.api.createBlock(agentPage.id, {
+      type: 'datastore',
+      title: DATASTORE_TITLE,
+      props: { columns },
+    })
+    if (created?.id) {
+      log(`Created "${DATASTORE_TITLE}" datastore on Agent Datastore page for ${cwd}`)
+      this.blockCache.set(cwd, created.id)
+      return created.id
+    }
+    return null
+  }
+
+  private async ensureColumns(blockId: string): Promise<void> {
+    try {
+      const schema = await this.api.getDatastoreSchema(blockId)
+      const existingCols = schema.columns || []
+      const existingNames = new Set(existingCols.map(c => c.name))
+      const missing = COLUMNS.filter(c => !existingNames.has(c.name))
+      if (missing.length === 0) return
+
+      const usedIds = new Set(existingCols.map(c => c.id))
+      let nextIdx = existingCols.length
+      const appended = missing.map(c => {
+        let id = `col_${nextIdx++}`
+        while (usedIds.has(id)) id = `col_${nextIdx++}`
+        usedIds.add(id)
+        return { id, name: c.name, type: c.type }
+      })
+      const merged = [...existingCols, ...appended]
+      await this.api.updateDatastoreSchema(blockId, merged)
+      log(`Added ${missing.length} missing column(s) to existing Time Tracking datastore: ${missing.map(c => c.name).join(', ')}`)
+    } catch (err: any) {
+      log(`ensureColumns failed: ${err?.message || err}`)
+    }
+  }
+}

package/src/main/tui.ts

@@ -132,11 +132,16 @@ export class Tui {
    * Show an interactive agent picker modal.
    * Uses alternate screen just for the picker, then exits back to normal.
    */
-  showAgentPicker(agents: { name: string; description: string }[]): Promise<number> {
+  showAgentPicker(
+    agents: { name: string; description: string }[],
+    options: { initialTrackTime: boolean },
+  ): Promise<{ agentIdx: number; trackTime: boolean }> {
     return new Promise((resolve) => {
       let selected = 0
+      let trackTime = options.initialTrackTime
       const modalWidth = 44
-      const modalHeight = agents.length + 4
+      // +4 for borders/title/sep, +2 for track-time separator + row
+      const modalHeight = agents.length + 4 + 2
       const startCol = Math.max(1, Math.floor((this.cols - modalWidth) / 2))
       const startRow = Math.max(1, Math.floor((this.rows - modalHeight) / 2))
 
@@ -180,10 +185,22 @@ export class Tui {
           this.write(`${CSI}${row};${startCol}H${bg}${FG_DIM}\u2502${RESET}${bg}${content}${pad}${RESET}${BG_MODAL}${FG_DIM}\u2502${RESET}`)
         }
 
-        const botRow = startRow + 3 + agents.length
+        const innerSep = '\u251c' + '\u2500'.repeat(modalWidth - 2) + '┤'
+        const sepRow = startRow + 3 + agents.length
+        this.write(`${CSI}${sepRow};${startCol}H${BG_MODAL}${FG_DIM}${innerSep}${RESET}`)
+
+        const trackRow = sepRow + 1
+        const checkbox = trackTime ? `${FG_GREEN}[✓]${RESET}${BG_MODAL}` : `${FG_DIM}[ ]${RESET}${BG_MODAL}`
+        const trackLabelFg = trackTime ? FG_WHITE : FG_DIM
+        const trackContent = `  ${checkbox} ${trackLabelFg}Track time${RESET}${BG_MODAL}`
+        const trackContentLen = 2 + 3 + 1 + 'Track time'.length
+        const trackPad = ' '.repeat(Math.max(0, modalWidth - 2 - trackContentLen))
+        this.write(`${CSI}${trackRow};${startCol}H${BG_MODAL}${FG_DIM}│${RESET}${BG_MODAL}${trackContent}${trackPad}${FG_DIM}│${RESET}`)
+
+        const botRow = trackRow + 1
         this.write(`${CSI}${botRow};${startCol}H${BG_MODAL}${FG_DIM}${botBorder}${RESET}`)
 
-        const hint = '\u2191\u2193 navigate \u00B7 Enter select \u00B7 q quit'
+        const hint = '\u2191\u2193 navigate \u00B7 Enter select \u00B7 t track \u00B7 q quit'
         const hintCol = Math.max(1, Math.floor((this.cols - hint.length) / 2))
         this.write(`${CSI}${botRow + 2};${hintCol}H${FG_DIM}${hint}${RESET}`)
       }
@@ -204,9 +221,12 @@ export class Tui {
         } else if (key === '\x1b[B' || key === 'j') {
           selected = (selected + 1) % agents.length
           drawModal()
+        } else if (key === 't' || key === 'T' || key === ' ') {
+          trackTime = !trackTime
+          drawModal()
         } else if (key === '\r' || key === '\n') {
           cleanup()
-          resolve(selected)
+          resolve({ agentIdx: selected, trackTime })
         } else if (key === 'q' || key === '\x1b' || key === '\x03') {
           cleanup()
           this.write(`${CSI}?25h`)