@phenx-inc/ctlsurf 0.3.6 → 0.3.8

package/src/main/timeTracker.ts

@@ -30,8 +30,9 @@ function formatStarted(ms: number): string {
 }
 
 interface SessionState {
-  blockId: string
-  rowId: string
+  blockId: string | null
+  rowId: string | null
+  sessionUuid: string
   cwd: string
   agentName: string
   idleTimeoutMin: number
@@ -83,55 +84,72 @@ export class TimeTracker {
     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 state: SessionState = {
+      blockId: null,
+      rowId: null,
+      sessionUuid: randomUUID(),
+      cwd,
+      agentName,
+      idleTimeoutMin,
+      startedAt,
+      lastActivity: startedAt,
+      activeMs: 0,
+      idleTimeoutMs: Math.max(1, idleTimeoutMin) * 60 * 1000,
+      firstCheckpointTimer: null,
+      checkpointTimer: null,
+      ended: false,
+    }
+    this.sessions.set(tabId, state)
+
+    await this.tryResolve(tabId)
+
+    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)
       }
-      const startedAt = Date.now()
-      const sessionUuid = randomUUID()
+    }, FIRST_CHECKPOINT_DELAY_MS)
+
+    const pending = !state.blockId || !state.rowId
+    log(`Started tracking tab=${tabId} agent="${agentName}" cwd=${cwd}${pending ? ' (pending datastore — will retry on each checkpoint)' : ''}`)
+  }
+
+  /** Attempts to locate (or create) the datastore + add the session row.
+   * Returns true once the session is resolved (blockId + rowId set).
+   * Safe to call repeatedly: re-running while pending will keep retrying;
+   * once resolved it's a no-op. */
+  private async tryResolve(tabId: string): Promise<boolean> {
+    const s = this.sessions.get(tabId)
+    if (!s) return false
+    if (s.blockId && s.rowId) return true
+    try {
+      const blockId = await this.ensureDatastore(s.cwd)
+      if (!blockId) return false
       const row = await this.api.addRow(blockId, {
-        Started: formatStarted(startedAt),
-        'Active Time': 0,
-        'Last Updated': new Date(startedAt).toISOString(),
-        Agent: agentName,
+        Started: formatStarted(s.startedAt),
+        'Active Time': Math.round(s.activeMs / 60000),
+        'Last Updated': new Date().toISOString(),
+        Agent: s.agentName,
         Worker: os.hostname(),
-        Session: sessionUuid,
+        Session: s.sessionUuid,
         Notes: '',
       })
       const rowId = row?.id
       if (!rowId) {
-        log('addRow returned no id; aborting tracking', row)
-        return
+        log(`addRow returned no id for tab=${tabId}; will retry on next checkpoint`)
+        return false
       }
-      const state: SessionState = {
-        blockId,
-        rowId,
-        cwd,
-        agentName,
-        idleTimeoutMin,
-        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}`)
+      s.blockId = blockId
+      s.rowId = rowId
+      log(`Resolved datastore for tab=${tabId} (cwd=${s.cwd})`)
+      return true
     } catch (err: any) {
-      log(`startSession failed: ${err?.message || err}`)
+      log(`tryResolve failed for tab=${tabId}: ${err?.message || err}`)
+      return false
     }
   }
 
@@ -175,14 +193,21 @@ export class TimeTracker {
   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())
+      if (!s.blockId || !s.rowId) {
+        await this.tryResolve(tabId)
+      }
+      if (s.blockId && s.rowId) {
+        await this.writeRow(s, Date.now())
+      } else {
+        log(`endSession for tab=${tabId}: never resolved datastore; ${Math.round(s.activeMs / 60000)}min not recorded`)
+      }
     } catch (err: any) {
       log(`endSession write failed: ${err?.message || err}`)
     }
+    s.ended = true
     this.sessions.delete(tabId)
   }
 
@@ -194,13 +219,16 @@ export class TimeTracker {
   private async checkpoint(tabId: string): Promise<void> {
     const s = this.sessions.get(tabId)
     if (!s || s.ended) return
+    if (!s.blockId || !s.rowId) {
+      if (!(await this.tryResolve(tabId))) return
+    }
     try {
       await this.writeRow(s, Date.now())
     } catch (err: any) {
       log(`checkpoint failed: ${err?.message || err}; retrying in 2s`)
       setTimeout(() => {
         const live = this.sessions.get(tabId)
-        if (!live || live.ended) return
+        if (!live || live.ended || !live.blockId || !live.rowId) return
         this.writeRow(live, Date.now()).catch((err2: any) => {
           log(`checkpoint retry failed: ${err2?.message || err2}`)
         })
@@ -209,6 +237,7 @@ export class TimeTracker {
   }
 
   private async writeRow(s: SessionState, _endTimeMs: number): Promise<void> {
+    if (!s.blockId || !s.rowId) return
     const activeMin = Math.round(s.activeMs / 60000)
     await this.api.updateRow(s.blockId, s.rowId, {
       'Active Time': activeMin,

package/src/main/tui.ts

@@ -134,14 +134,15 @@ export class Tui {
    */
   showAgentPicker(
     agents: { name: string; description: string }[],
-    options: { initialTrackTime: boolean },
-  ): Promise<{ agentIdx: number; trackTime: boolean }> {
+    options: { initialTrackTime: boolean; initialLogChat: boolean },
+  ): Promise<{ agentIdx: number; trackTime: boolean; logChat: boolean }> {
     return new Promise((resolve) => {
       let selected = 0
       let trackTime = options.initialTrackTime
+      let logChat = options.initialLogChat
       const modalWidth = 44
-      // +4 for borders/title/sep, +2 for track-time separator + row
-      const modalHeight = agents.length + 4 + 2
+      // +4 for borders/title/sep, +3 for separator + track-time row + log-chat row
+      const modalHeight = agents.length + 4 + 3
       const startCol = Math.max(1, Math.floor((this.cols - modalWidth) / 2))
       const startRow = Math.max(1, Math.floor((this.rows - modalHeight) / 2))
 
@@ -197,10 +198,18 @@ export class Tui {
         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
+        const logRow = trackRow + 1
+        const logCheckbox = logChat ? `${FG_GREEN}[\u2713]${RESET}${BG_MODAL}` : `${FG_DIM}[ ]${RESET}${BG_MODAL}`
+        const logLabelFg = logChat ? FG_WHITE : FG_DIM
+        const logContent = `  ${logCheckbox} ${logLabelFg}Log chat${RESET}${BG_MODAL}`
+        const logContentLen = 2 + 3 + 1 + 'Log chat'.length
+        const logPad = ' '.repeat(Math.max(0, modalWidth - 2 - logContentLen))
+        this.write(`${CSI}${logRow};${startCol}H${BG_MODAL}${FG_DIM}\u2502${RESET}${BG_MODAL}${logContent}${logPad}${FG_DIM}\u2502${RESET}`)
+
+        const botRow = logRow + 1
         this.write(`${CSI}${botRow};${startCol}H${BG_MODAL}${FG_DIM}${botBorder}${RESET}`)
 
-        const hint = '\u2191\u2193 navigate \u00B7 Enter select \u00B7 t track \u00B7 q quit'
+        const hint = '\u2191\u2193 nav \u00B7 Enter \u00B7 t track \u00B7 l log \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}`)
       }
@@ -221,12 +230,15 @@ export class Tui {
         } else if (key === '\x1b[B' || key === 'j') {
           selected = (selected + 1) % agents.length
           drawModal()
-        } else if (key === 't' || key === 'T' || key === ' ') {
+        } else if (key === 't' || key === 'T') {
           trackTime = !trackTime
           drawModal()
+        } else if (key === 'l' || key === 'L') {
+          logChat = !logChat
+          drawModal()
         } else if (key === '\r' || key === '\n') {
           cleanup()
-          resolve({ agentIdx: selected, trackTime })
+          resolve({ agentIdx: selected, trackTime, logChat })
         } else if (key === 'q' || key === '\x1b' || key === '\x03') {
           cleanup()
           this.write(`${CSI}?25h`)

package/src/main/updateCheck.ts

@@ -0,0 +1,40 @@
+import https from 'https'
+
+export const NPM_PACKAGE = '@phenx-inc/ctlsurf'
+
+export 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
+}
+
+export function fetchLatestNpmVersion(timeoutMs = 8000): 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(timeoutMs, () => { req.destroy(); resolve(null) })
+  })
+}

package/src/preload/index.ts

@@ -82,6 +82,12 @@ const api = {
   setTracking: (enabled: boolean): Promise<{ active: boolean }> =>
     ipcRenderer.invoke('tracking:set', enabled),
 
+  // Chat logging (global)
+  getLogChat: (): Promise<{ enabled: boolean }> =>
+    ipcRenderer.invoke('logchat:get'),
+  setLogChat: (enabled: boolean): Promise<{ enabled: boolean }> =>
+    ipcRenderer.invoke('logchat:set', enabled),
+
   // Filesystem
   readDir: (dirPath: string): Promise<Array<{ name: string; path: string; isDirectory: boolean }>> =>
     ipcRenderer.invoke('fs:readDir', dirPath),

package/src/renderer/App.tsx

@@ -46,6 +46,8 @@ declare global {
       deleteProfile: (profileId: string) => Promise<{ ok: boolean }>
       getTracking: () => Promise<{ active: boolean }>
       setTracking: (enabled: boolean) => Promise<{ active: boolean }>
+      getLogChat: () => Promise<{ enabled: boolean }>
+      setLogChat: (enabled: boolean) => Promise<{ enabled: boolean }>
       createProject: () => Promise<{ ok: boolean; folder_id?: string; error?: string }>
       getWebviewInfo: () => Promise<{
         frontendUrl: string; pageUrl?: string; authenticated: boolean;

package/src/renderer/components/AgentPicker.tsx

@@ -1,3 +1,5 @@
+import { useEffect, useState } from 'react'
+
 interface AgentConfig {
   id: string
   name: string
@@ -14,9 +16,32 @@ interface AgentPickerProps {
 }
 
 export function AgentPicker({ agents, cwd, onSelect, onChangeCwd }: AgentPickerProps) {
-  const home = typeof window !== 'undefined' ? '' : ''
-  // Shorten home dir for display
   const displayPath = cwd.replace(/^\/Users\/[^/]+/, '~')
+  const [logChat, setLogChat] = useState(false)
+  const [loaded, setLoaded] = useState(false)
+
+  useEffect(() => {
+    let cancelled = false
+    window.worker.getLogChat().then(r => {
+      if (cancelled) return
+      setLogChat(!!r?.enabled)
+      setLoaded(true)
+    }).catch(() => setLoaded(true))
+    return () => { cancelled = true }
+  }, [])
+
+  const toggleLogChat = async () => {
+    const next = !logChat
+    setLogChat(next)
+    try { await window.worker.setLogChat(next) } catch { /* ignore */ }
+  }
+
+  const handleSelect = async (agent: AgentConfig) => {
+    if (loaded) {
+      try { await window.worker.setLogChat(logChat) } catch { /* ignore */ }
+    }
+    onSelect(agent)
+  }
 
   return (
     <div className="agent-picker-overlay">
@@ -35,13 +60,23 @@ export function AgentPicker({ agents, cwd, onSelect, onChangeCwd }: AgentPickerP
             <button
               key={a.id}
               className="agent-picker-item"
-              onClick={() => onSelect(a)}
+              onClick={() => handleSelect(a)}
             >
               <span className="agent-picker-name">{a.name}</span>
               <span className="agent-picker-desc">{a.description}</span>
             </button>
           ))}
         </div>
+
+        <label className="agent-picker-option" onClick={(e) => e.stopPropagation()}>
+          <input
+            type="checkbox"
+            checked={logChat}
+            onChange={toggleLogChat}
+          />
+          <span>Log chat to ctlsurf</span>
+        </label>
+
         <div className="agent-picker-hint">Select an agent to start</div>
       </div>
     </div>

package/src/renderer/styles.css

@@ -821,6 +821,22 @@ html, body, #root {
   color: #414868;
 }
 
+.agent-picker-option {
+  margin-top: 16px;
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  font-size: 12px;
+  color: #a9b1d6;
+  cursor: pointer;
+  user-select: none;
+}
+
+.agent-picker-option input[type="checkbox"] {
+  cursor: pointer;
+  accent-color: #7aa2f7;
+}
+
 /* Settings dialog */
 .settings-overlay {
   position: fixed;