@phenx-inc/ctlsurf 0.3.3 → 0.3.5

package/src/main/bridge.ts

@@ -1,28 +1,34 @@
 import { WorkerWsClient } from './workerWs'
+import { Terminal as HeadlessTerminal } from '@xterm/headless/lib-headless/xterm-headless.js'
+import { SerializeAddon } from '@xterm/addon-serialize'
 
 /**
  * Conversation Bridge
  *
- * Captures PTY output, strips ANSI codes and terminal artifacts,
- * and sends cleaned text to the backend via WebSocket for chat logging.
- * Uses a simple buffer + byte threshold approach (no timers, since
- * setTimeout/setInterval don't reliably fire under TUI raw mode).
+ * Captures PTY output, renders it through a headless terminal,
+ * and sends cleaned text snapshots to the backend via WebSocket for chat logging.
+ * Flushes only after output settles so TUI redraws don't leak every
+ * intermediate repaint frame into chat logs.
  */
 export class ConversationBridge {
   private wsClient: WorkerWsClient | null = null
   private sessionActive: boolean = false
   private inputBuffer: string = ''
   private outputBuffer: string = ''
-
-  private readonly FLUSH_BYTES = 500
+  private outputFlushTimer: ReturnType<typeof setTimeout> | null = null
+  private pendingCandidate = ''
+  private pendingCandidateChangedAt = 0
+  private readonly terminalCapture = new TerminalCapture()
 
   setWsClient(ws: WorkerWsClient): void {
     this.wsClient = ws
   }
 
   startSession(): void {
+    this.clearOutputTimers()
     this.outputBuffer = ''
     this.inputBuffer = ''
+    this.terminalCapture.reset()
     this.sessionActive = true
     console.log('[bridge] Session started')
   }
@@ -31,10 +37,8 @@ export class ConversationBridge {
     if (!this.sessionActive) return
 
     this.outputBuffer += data
-
-    if (this.outputBuffer.length >= this.FLUSH_BYTES) {
-      this.flush()
-    }
+    this.terminalCapture.write(data)
+    this.scheduleOutputFlush()
   }
 
   feedInput(data: string): void {
@@ -50,17 +54,17 @@ export class ConversationBridge {
     }
   }
 
-  resize(_cols: number, _rows: number): void {
-    // no-op now (was used for xterm)
+  resize(cols: number, rows: number): void {
+    this.terminalCapture.resize(cols, rows)
   }
 
   private flush(): void {
+    this.clearOutputTimers()
     if (this.outputBuffer.length === 0) return
 
-    const raw = this.outputBuffer
     this.outputBuffer = ''
 
-    const cleaned = cleanOutput(raw)
+    const cleaned = this.terminalCapture.readCommittedDelta()
     if (cleaned.length === 0) return
 
     this.sendEntry('terminal_output', cleaned)
@@ -75,6 +79,50 @@ export class ConversationBridge {
     })
   }
 
+  private scheduleOutputFlush(): void {
+    if (!this.outputFlushTimer) {
+      this.outputFlushTimer = setTimeout(() => {
+        this.checkOutputStability()
+      }, OUTPUT_STABILITY_CHECK_MS)
+    }
+  }
+
+  private checkOutputStability(): void {
+    this.outputFlushTimer = null
+    if (this.outputBuffer.length === 0) return
+
+    const candidate = this.terminalCapture.currentCandidate()
+    const now = Date.now()
+
+    if (candidate.length === 0) {
+      this.outputBuffer = ''
+      return
+    }
+
+    if (candidate !== this.pendingCandidate) {
+      this.pendingCandidate = candidate
+      this.pendingCandidateChangedAt = now
+    }
+
+    if (now - this.pendingCandidateChangedAt >= OUTPUT_STABLE_MS) {
+      this.flush()
+      return
+    }
+
+    this.outputFlushTimer = setTimeout(() => {
+      this.checkOutputStability()
+    }, OUTPUT_STABILITY_CHECK_MS)
+  }
+
+  private clearOutputTimers(): void {
+    if (this.outputFlushTimer) {
+      clearTimeout(this.outputFlushTimer)
+      this.outputFlushTimer = null
+    }
+    this.pendingCandidate = ''
+    this.pendingCandidateChangedAt = 0
+  }
+
   endSession(): void {
     if (!this.sessionActive) return
 
@@ -87,6 +135,114 @@ export class ConversationBridge {
   }
 }
 
+const DEFAULT_COLS = 80
+const DEFAULT_ROWS = 24
+const OUTPUT_STABILITY_CHECK_MS = 250
+const OUTPUT_STABLE_MS = 1800
+const MAX_SNAPSHOT_LINES = 200
+const MAX_LOG_CHARS = 20_000
+
+class TerminalCapture {
+  private terminal: HeadlessTerminal
+  private serializeAddon: SerializeAddon
+  private lastCommittedCandidate = ''
+
+  constructor() {
+    this.terminal = this.createTerminal(DEFAULT_COLS, DEFAULT_ROWS)
+    this.serializeAddon = this.createSerializeAddon(this.terminal)
+  }
+
+  reset(): void {
+    this.terminal.dispose()
+    this.terminal = this.createTerminal(DEFAULT_COLS, DEFAULT_ROWS)
+    this.serializeAddon = this.createSerializeAddon(this.terminal)
+    this.lastCommittedCandidate = ''
+  }
+
+  resize(cols: number, rows: number): void {
+    if (!Number.isFinite(cols) || !Number.isFinite(rows)) return
+
+    const nextCols = Math.max(10, Math.floor(cols))
+    const nextRows = Math.max(5, Math.floor(rows))
+    this.terminal.resize(nextCols, nextRows)
+  }
+
+  write(data: string): void {
+    const writable = this.terminal as HeadlessTerminal & {
+      writeSync?: (data: string) => void
+      _core?: { writeSync?: (data: string) => void }
+    }
+    if (typeof writable.writeSync === 'function') {
+      writable.writeSync(data)
+    } else if (typeof writable._core?.writeSync === 'function') {
+      // The public headless API only exposes async write(). The bridge flushes
+      // synchronously on byte thresholds/session end, so use xterm's sync core
+      // writer for deterministic chat-log snapshots.
+      writable._core.writeSync(data)
+    } else {
+      this.terminal.write(data)
+    }
+  }
+
+  readCommittedDelta(): string {
+    const candidate = this.currentCandidate()
+    const delta = diffSnapshots(this.lastCommittedCandidate, candidate)
+    this.lastCommittedCandidate = candidate
+    return trimToLogLimit(delta)
+  }
+
+  currentCandidate(): string {
+    return extractTranscriptCandidate(normalizeTerminalText(this.readSnapshot()))
+  }
+
+  private createTerminal(cols: number, rows: number): HeadlessTerminal {
+    return new HeadlessTerminal({
+      cols,
+      rows,
+      scrollback: MAX_SNAPSHOT_LINES,
+      allowProposedApi: true,
+      logLevel: 'off',
+    })
+  }
+
+  private createSerializeAddon(terminal: HeadlessTerminal): SerializeAddon {
+    const addon = new SerializeAddon()
+    terminal.loadAddon(addon as any)
+    return addon
+  }
+
+  private readSnapshot(): string {
+    try {
+      return this.readPlainBufferSnapshot()
+    } catch {
+      return this.serializeAddon.serialize({
+        scrollback: MAX_SNAPSHOT_LINES,
+        excludeModes: true,
+      })
+    }
+  }
+
+  private readPlainBufferSnapshot(): string {
+    const buffer = this.terminal.buffer.active
+    const start = Math.max(0, buffer.length - MAX_SNAPSHOT_LINES)
+    const lines: string[] = []
+
+    for (let i = start; i < buffer.length; i++) {
+      const line = buffer.getLine(i)
+      if (!line) continue
+
+      const text = line.translateToString(true)
+      if (line.isWrapped && lines.length > 0) {
+        lines[lines.length - 1] += text
+      } else {
+        lines.push(text)
+      }
+    }
+
+    return lines.join('\n')
+  }
+}
+
 /**
  * Strip ANSI escape codes from a string.
  */
@@ -131,18 +287,111 @@ function cleanInput(str: string): string {
 }
 
 /**
- * Clean terminal output: strip ANSI, remove control chars, collapse noise.
+ * Clean rendered terminal text: strip any remaining ANSI, remove control chars, collapse noise.
  */
-function cleanOutput(str: string): string {
+function normalizeTerminalText(str: string): string {
   let cleaned = stripAnsi(str)
-  // Remove carriage returns
-  cleaned = cleaned.replace(/\r/g, '')
+  cleaned = cleaned.replace(/\r\n/g, '\n').replace(/\r/g, '\n')
   // Remove control characters except newline/tab
   // eslint-disable-next-line no-control-regex
   cleaned = cleaned.replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, '')
+  cleaned = cleaned.replace(/[ \t]+\n/g, '\n')
   // Collapse 3+ consecutive newlines into 2
   cleaned = cleaned.replace(/\n{3,}/g, '\n\n')
-  // Remove lines that are only whitespace
-  cleaned = cleaned.split('\n').filter(line => line.trim().length > 0).join('\n')
   return cleaned.trim()
 }
+
+function extractTranscriptCandidate(snapshot: string): string {
+  const lines = snapshot.split('\n')
+  const kept: string[] = []
+  let skipTipUrl = false
+
+  for (const rawLine of lines) {
+    const line = rawLine.trim()
+
+    if (skipTipUrl && isLikelyTipContinuation(line)) {
+      continue
+    }
+    skipTipUrl = false
+
+    if (line.length === 0) {
+      if (kept.length > 0 && kept[kept.length - 1] !== '') {
+        kept.push('')
+      }
+      continue
+    }
+
+    if (isTipLine(line)) {
+      skipTipUrl = true
+      continue
+    }
+
+    if (isTerminalChromeLine(line) || isBusyScreenLine(line)) {
+      continue
+    }
+
+    kept.push(line)
+  }
+
+  return kept
+    .join('\n')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim()
+}
+
+function diffSnapshots(previous: string, current: string): string {
+  if (current.length === 0 || current === previous) return ''
+  if (previous.length === 0) return current
+  if (current.startsWith(previous)) return current.slice(previous.length).trim()
+
+  const previousLines = previous.split('\n')
+  const currentLines = current.split('\n')
+
+  const maxOverlap = Math.min(previousLines.length, currentLines.length)
+  for (let overlap = maxOverlap; overlap > 0; overlap--) {
+    const previousTail = previousLines.slice(previousLines.length - overlap)
+    const currentHead = currentLines.slice(0, overlap)
+    if (linesEqual(previousTail, currentHead)) {
+      return currentLines.slice(overlap).join('\n').trim()
+    }
+  }
+
+  return current
+}
+
+function isTerminalChromeLine(line: string): boolean {
+  return (
+    /^[╭╰╮╯│─\s]+$/.test(line) ||
+    line.includes('OpenAI Codex') ||
+    line.includes('model:') ||
+    line.includes('directory:') ||
+    line.includes('/model to change') ||
+    /^gpt-[\w.-]+ .*·/.test(line) ||
+    /^›\s*/.test(line) ||
+    line === 'Write tests for @filename' ||
+    line === 'Implement {feature}' ||
+    /^[•◦∙·]$/.test(line)
+  )
+}
+
+function isBusyScreenLine(line: string): boolean {
+  return /\bWorking \(\d+s\b/.test(line) || line.includes('esc to interrupt')
+}
+
+function isTipLine(line: string): boolean {
+  return line.startsWith('Tip:')
+}
+
+function isLikelyTipContinuation(line: string): boolean {
+  return line.startsWith('http://') || line.startsWith('https://') || line.includes('chatgpt.com/codex')
+}
+
+function linesEqual(a: string[], b: string[]): boolean {
+  if (a.length !== b.length) return false
+  return a.every((line, index) => line === b[index])
+}
+
+function trimToLogLimit(str: string): string {
+  if (str.length <= MAX_LOG_CHARS) return str
+  return `[truncated]\n${str.slice(str.length - MAX_LOG_CHARS)}`
+}

package/src/main/index.ts

@@ -1,6 +1,7 @@
 import { app, BrowserWindow, ipcMain, dialog, nativeImage } from 'electron'
 import path from 'path'
 import fs from 'fs'
+import https from 'https'
 
 // Prevent EPIPE crashes when stdout pipe is closed
 process.stdout?.on?.('error', () => {})
@@ -174,6 +175,77 @@ ipcMain.handle('app:browseCwd', async () => {
   return result.filePaths[0]
 })
 
+// ─── Version + npm update check ───────────────────
+
+const NPM_PACKAGE = '@phenx-inc/ctlsurf'
+const UPDATE_CHECK_INTERVAL_MS = 6 * 60 * 60 * 1000 // 6 hours
+
+interface UpdateInfo {
+  current: string
+  latest: string | null
+  hasUpdate: boolean
+  checkedAt: number | null
+}
+
+let updateInfo: UpdateInfo = {
+  current: app.getVersion(),
+  latest: null,
+  hasUpdate: false,
+  checkedAt: null,
+}
+
+function compareSemver(a: string, b: string): number {
+  const pa = a.split('.').map(n => parseInt(n, 10) || 0)
+  const pb = b.split('.').map(n => parseInt(n, 10) || 0)
+  for (let i = 0; i < 3; i++) {
+    const ai = pa[i] || 0
+    const bi = pb[i] || 0
+    if (ai !== bi) return ai - bi
+  }
+  return 0
+}
+
+function fetchLatestNpmVersion(): Promise<string | null> {
+  return new Promise((resolve) => {
+    const url = `https://registry.npmjs.org/${encodeURIComponent(NPM_PACKAGE)}/latest`
+    const req = https.get(url, { headers: { 'Accept': 'application/json' } }, (res) => {
+      if (res.statusCode !== 200) {
+        res.resume()
+        resolve(null)
+        return
+      }
+      let body = ''
+      res.setEncoding('utf8')
+      res.on('data', (chunk) => { body += chunk })
+      res.on('end', () => {
+        try {
+          const json = JSON.parse(body)
+          resolve(typeof json?.version === 'string' ? json.version : null)
+        } catch {
+          resolve(null)
+        }
+      })
+    })
+    req.on('error', () => resolve(null))
+    req.setTimeout(8000, () => { req.destroy(); resolve(null) })
+  })
+}
+
+async function checkForUpdate(): Promise<void> {
+  const latest = await fetchLatestNpmVersion()
+  updateInfo = {
+    current: app.getVersion(),
+    latest,
+    hasUpdate: !!latest && compareSemver(latest, app.getVersion()) > 0,
+    checkedAt: Date.now(),
+  }
+  log(`[update] current=${updateInfo.current} latest=${latest ?? 'unknown'} hasUpdate=${updateInfo.hasUpdate}`)
+  mainWindow?.webContents.send('app:updateInfo', updateInfo)
+}
+
+ipcMain.handle('app:getVersion', () => app.getVersion())
+ipcMain.handle('app:getUpdateInfo', () => updateInfo)
+
 // ─── Filesystem IPC ───────────────────────────────
 
 ipcMain.handle('fs:readDir', async (_event, dirPath: string) => {
@@ -368,6 +440,10 @@ app.whenReady().then(() => {
 
   orchestrator.loadSettings()
   createWindow()
+
+  // Kick off an initial npm update check shortly after launch, then poll periodically.
+  setTimeout(() => { void checkForUpdate() }, 3000)
+  setInterval(() => { void checkForUpdate() }, UPDATE_CHECK_INTERVAL_MS)
 })
 
 app.on('window-all-closed', () => {

package/src/main/orchestrator.ts

@@ -104,7 +104,7 @@ export class Orchestrator {
           const activeTab = this.activeTabId ? this.tabs.get(this.activeTabId) : null
           if (activeTab) {
             activeTab.ptyManager.write(message.content + '\r')
-            this.bridge.feedInput(message.content)
+            this.bridge.feedInput(message.content + '\r')
           }
         }
       },

package/src/main/timeTracker.ts

@@ -11,6 +11,7 @@ const CHECKPOINT_INTERVAL_MS = 5 * 60 * 1000
 const COLUMNS: Array<{ name: string; type: string }> = [
   { name: 'Started', type: 'text' },
   { name: 'Active Time', type: 'number' },
+  { name: 'Last Updated', type: 'date' },
   { name: 'Agent', type: 'text' },
   { name: 'Worker', type: 'text' },
   { name: 'Session', type: 'text' },
@@ -32,6 +33,8 @@ interface SessionState {
   blockId: string
   rowId: string
   cwd: string
+  agentName: string
+  idleTimeoutMin: number
   startedAt: number
   lastActivity: number
   activeMs: number
@@ -41,6 +44,16 @@ interface SessionState {
   ended: boolean
 }
 
+function isSameLocalDay(a: number, b: number): boolean {
+  const da = new Date(a)
+  const db = new Date(b)
+  return (
+    da.getFullYear() === db.getFullYear() &&
+    da.getMonth() === db.getMonth() &&
+    da.getDate() === db.getDate()
+  )
+}
+
 function log(...args: unknown[]): void {
   try { console.log('[time-tracker]', ...args) } catch { /* EPIPE safe */ }
 }
@@ -60,6 +73,7 @@ export class TimeTracker {
   private api: CtlsurfApi
   private sessions = new Map<string, SessionState>()
   private blockCache = new Map<string, string>()
+  private rollingOver = new Set<string>()
 
   constructor(api: CtlsurfApi) {
     this.api = api
@@ -80,6 +94,7 @@ export class TimeTracker {
       const row = await this.api.addRow(blockId, {
         Started: formatStarted(startedAt),
         'Active Time': 0,
+        'Last Updated': new Date(startedAt).toISOString(),
         Agent: agentName,
         Worker: os.hostname(),
         Session: sessionUuid,
@@ -94,6 +109,8 @@ export class TimeTracker {
         blockId,
         rowId,
         cwd,
+        agentName,
+        idleTimeoutMin,
         startedAt,
         lastActivity: startedAt,
         activeMs: 0,
@@ -127,6 +144,10 @@ export class TimeTracker {
     const s = this.sessions.get(tabId)
     if (!s || s.ended) return
     const now = Date.now()
+    if (!isSameLocalDay(s.startedAt, now)) {
+      void this.rollover(tabId)
+      return
+    }
     const delta = now - s.lastActivity
     if (delta < s.idleTimeoutMs) {
       s.activeMs += delta
@@ -134,6 +155,23 @@ export class TimeTracker {
     s.lastActivity = now
   }
 
+  private async rollover(tabId: string): Promise<void> {
+    if (this.rollingOver.has(tabId)) return
+    const s = this.sessions.get(tabId)
+    if (!s || s.ended) return
+    this.rollingOver.add(tabId)
+    const { cwd, agentName, idleTimeoutMin } = s
+    log(`Day rolled over for tab=${tabId}; ending session and starting fresh`)
+    try {
+      await this.endSession(tabId)
+      await this.startSession(tabId, cwd, agentName, idleTimeoutMin)
+    } catch (err: any) {
+      log(`rollover failed: ${err?.message || err}`)
+    } finally {
+      this.rollingOver.delete(tabId)
+    }
+  }
+
   async endSession(tabId: string): Promise<void> {
     const s = this.sessions.get(tabId)
     if (!s || s.ended) return
@@ -159,7 +197,14 @@ export class TimeTracker {
     try {
       await this.writeRow(s, Date.now())
     } catch (err: any) {
-      log(`checkpoint failed: ${err?.message || err}`)
+      log(`checkpoint failed: ${err?.message || err}; retrying in 2s`)
+      setTimeout(() => {
+        const live = this.sessions.get(tabId)
+        if (!live || live.ended) return
+        this.writeRow(live, Date.now()).catch((err2: any) => {
+          log(`checkpoint retry failed: ${err2?.message || err2}`)
+        })
+      }, 2000)
     }
   }
 
@@ -167,6 +212,7 @@ export class TimeTracker {
     const activeMin = Math.round(s.activeMs / 60000)
     await this.api.updateRow(s.blockId, s.rowId, {
       'Active Time': activeMin,
+      'Last Updated': new Date().toISOString(),
     })
   }
 

package/src/main/workerWs.ts

@@ -18,7 +18,7 @@ export interface WorkerRegistration {
   cwd: string
   repo_url?: string
   agent: string
-  fingerprint: string
+  fingerprint?: string
 }
 
 export interface WorkerWsEvents {
@@ -135,6 +135,12 @@ export class WorkerWsClient {
   }
 
   sendChatLog(entry: { type: string; content: string; ts?: string }): void {
+    log('[worker-ws] chat_log DEBUG', {
+      type: entry.type,
+      chars: entry.content.length,
+      lines: entry.content.split('\n').length,
+      preview: entry.content.slice(0, 500),
+    })
     this.send({ type: 'chat_log', entry })
   }
 

package/src/main/xterm-headless.d.ts

@@ -0,0 +1,3 @@
+declare module '@xterm/headless/lib-headless/xterm-headless.js' {
+  export * from '@xterm/headless'
+}

package/src/preload/index.ts

@@ -46,6 +46,15 @@ const api = {
     ipcRenderer.invoke('app:cwd'),
   browseCwd: (): Promise<string | null> =>
     ipcRenderer.invoke('app:browseCwd'),
+  getVersion: (): Promise<string> =>
+    ipcRenderer.invoke('app:getVersion'),
+  getUpdateInfo: (): Promise<{ current: string; latest: string | null; hasUpdate: boolean; checkedAt: number | null }> =>
+    ipcRenderer.invoke('app:getUpdateInfo'),
+  onUpdateInfo: (callback: (info: { current: string; latest: string | null; hasUpdate: boolean; checkedAt: number | null }) => void) => {
+    const listener = (_event: Electron.IpcRendererEvent, info: any) => callback(info)
+    ipcRenderer.on('app:updateInfo', listener)
+    return () => ipcRenderer.removeListener('app:updateInfo', listener)
+  },
 
   // Settings (legacy)
   getSetting: (key: string): Promise<string | null> =>

package/src/renderer/App.tsx

@@ -59,10 +59,20 @@ declare global {
       readDir: (dirPath: string) => Promise<Array<{ name: string; path: string; isDirectory: boolean }>>
       readFile: (filePath: string) => Promise<{ ok: boolean; content?: string; error?: string }>
       writeFile: (filePath: string, content: string) => Promise<{ ok: boolean; error?: string }>
+      getVersion: () => Promise<string>
+      getUpdateInfo: () => Promise<UpdateInfo>
+      onUpdateInfo: (callback: (info: UpdateInfo) => void) => () => void
     }
   }
 }
 
+interface UpdateInfo {
+  current: string
+  latest: string | null
+  hasUpdate: boolean
+  checkedAt: number | null
+}
+
 const DEFAULT_LAYOUT: LayoutNode = {
   type: 'split',
   direction: 'horizontal',
@@ -95,6 +105,7 @@ export default function App() {
   const [showSettings, setShowSettings] = useState(false)
   const [wsStatus, setWsStatus] = useState('disconnected')
   const [cwd, setCwd] = useState<string | null>(null)
+  const [updateInfo, setUpdateInfo] = useState<UpdateInfo | null>(null)
 
   // Multi-tab state
   const [tabs, setTabs] = useState<TabInfo[]>(() => {
@@ -130,6 +141,15 @@ export default function App() {
     return unsub
   }, [])
 
+  useEffect(() => {
+    let cancelled = false
+    window.worker.getUpdateInfo().then(info => {
+      if (!cancelled) setUpdateInfo(info)
+    }).catch(() => { /* ignore */ })
+    const unsub = window.worker.onUpdateInfo((info) => setUpdateInfo(info))
+    return () => { cancelled = true; unsub() }
+  }, [])
+
   useEffect(() => {
     const unsub = window.worker.onWorkerMessage((message) => {
       console.log('[worker] Received message:', message)
@@ -433,7 +453,7 @@ export default function App() {
         )}
       </div>
 
-      <StatusBar wsStatus={wsStatus} cwd={cwd} onChangeCwd={handleChangeCwd} />
+      <StatusBar wsStatus={wsStatus} cwd={cwd} onChangeCwd={handleChangeCwd} updateInfo={updateInfo} />
       <SettingsDialog open={showSettings} onClose={() => setShowSettings(false)} />
 
       {showAgentPicker && agents.length > 0 && (