@phenx-inc/ctlsurf 0.3.5 → 0.3.7

package/out/main/index.js

@@ -9949,12 +9949,6 @@ class WorkerWsClient {
     this.send({ type: "terminal_resize", cols, rows });
   }
   sendChatLog(entry) {
-    log$3("[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 });
   }
   doConnect() {
@@ -10166,55 +10160,68 @@ class TimeTracker {
     if (this.sessions.has(tabId)) {
       await this.endSession(tabId);
     }
+    const startedAt = Date.now();
+    const state = {
+      blockId: null,
+      rowId: null,
+      sessionUuid: require$$1.randomUUID(),
+      cwd,
+      agentName,
+      idleTimeoutMin,
+      startedAt,
+      lastActivity: startedAt,
+      activeMs: 0,
+      idleTimeoutMs: Math.max(1, idleTimeoutMin) * 60 * 1e3,
+      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);
+      }
+    }, FIRST_CHECKPOINT_DELAY_MS);
+    const pending = !state.blockId || !state.rowId;
+    log$2(`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. */
+  async tryResolve(tabId) {
+    const s = this.sessions.get(tabId);
+    if (!s) return false;
+    if (s.blockId && s.rowId) return true;
     try {
-      const blockId = await this.ensureDatastore(cwd);
-      if (!blockId) {
-        log$2(`No "${AGENT_DATASTORE_PAGE_TITLE}" page found for ${cwd} — tracking disabled for this session`);
-        return;
-      }
-      const startedAt = Date.now();
-      const sessionUuid = require$$1.randomUUID();
+      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 / 6e4),
+        "Last Updated": (/* @__PURE__ */ new Date()).toISOString(),
+        Agent: s.agentName,
         Worker: os.hostname(),
-        Session: sessionUuid,
+        Session: s.sessionUuid,
         Notes: ""
       });
       const rowId = row?.id;
       if (!rowId) {
-        log$2("addRow returned no id; aborting tracking", row);
-        return;
+        log$2(`addRow returned no id for tab=${tabId}; will retry on next checkpoint`);
+        return false;
       }
-      const state = {
-        blockId,
-        rowId,
-        cwd,
-        agentName,
-        idleTimeoutMin,
-        startedAt,
-        lastActivity: startedAt,
-        activeMs: 0,
-        idleTimeoutMs: Math.max(1, idleTimeoutMin) * 60 * 1e3,
-        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$2(`Started tracking tab=${tabId} agent="${agentName}" cwd=${cwd}`);
+      s.blockId = blockId;
+      s.rowId = rowId;
+      log$2(`Resolved datastore for tab=${tabId} (cwd=${s.cwd})`);
+      return true;
     } catch (err) {
-      log$2(`startSession failed: ${err?.message || err}`);
+      log$2(`tryResolve failed for tab=${tabId}: ${err?.message || err}`);
+      return false;
     }
   }
   isTracking(tabId) {
@@ -10254,14 +10261,21 @@ class TimeTracker {
   async endSession(tabId) {
     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$2(`endSession for tab=${tabId}: never resolved datastore; ${Math.round(s.activeMs / 6e4)}min not recorded`);
+      }
     } catch (err) {
       log$2(`endSession write failed: ${err?.message || err}`);
     }
+    s.ended = true;
     this.sessions.delete(tabId);
   }
   async endAll() {
@@ -10271,13 +10285,16 @@ class TimeTracker {
   async checkpoint(tabId) {
     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) {
       log$2(`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) => {
           log$2(`checkpoint retry failed: ${err2?.message || err2}`);
         });
@@ -10285,6 +10302,7 @@ class TimeTracker {
     }
   }
   async writeRow(s, _endTimeMs) {
+    if (!s.blockId || !s.rowId) return;
     const activeMin = Math.round(s.activeMs / 6e4);
     await this.api.updateRow(s.blockId, s.rowId, {
       "Active Time": activeMin,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phenx-inc/ctlsurf",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "description": "Agent-agnostic terminal and desktop app for ctlsurf — run Claude Code, Codex, or any coding agent with live session logging and remote control",
   "main": "out/main/index.js",
   "bin": {

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/workerWs.ts

@@ -135,12 +135,6 @@ 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 })
   }