@phenx-inc/ctlsurf 0.3.5 → 0.3.7

package/out/headless/index.mjs

@@ -6056,12 +6056,6 @@ var WorkerWsClient = class {
     this.send({ type: "terminal_resize", cols, rows });
   }
   sendChatLog(entry) {
-    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 });
   }
   doConnect() {
@@ -6277,55 +6271,68 @@ var TimeTracker = class {
     if (this.sessions.has(tabId)) {
       await this.endSession(tabId);
     }
-    try {
-      const blockId = await this.ensureDatastore(cwd);
-      if (!blockId) {
-        log2(`No "${AGENT_DATASTORE_PAGE_TITLE}" page found for ${cwd} \u2014 tracking disabled for this session`);
-        return;
+    const startedAt = Date.now();
+    const state = {
+      blockId: null,
+      rowId: null,
+      sessionUuid: 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);
       }
-      const startedAt = Date.now();
-      const sessionUuid = randomUUID();
+    }, FIRST_CHECKPOINT_DELAY_MS);
+    const pending = !state.blockId || !state.rowId;
+    log2(`Started tracking tab=${tabId} agent="${agentName}" cwd=${cwd}${pending ? " (pending datastore \u2014 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(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: os2.hostname(),
-        Session: sessionUuid,
+        Session: s.sessionUuid,
         Notes: ""
       });
       const rowId = row?.id;
       if (!rowId) {
-        log2("addRow returned no id; aborting tracking", row);
-        return;
+        log2(`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);
-      log2(`Started tracking tab=${tabId} agent="${agentName}" cwd=${cwd}`);
+      s.blockId = blockId;
+      s.rowId = rowId;
+      log2(`Resolved datastore for tab=${tabId} (cwd=${s.cwd})`);
+      return true;
     } catch (err) {
-      log2(`startSession failed: ${err?.message || err}`);
+      log2(`tryResolve failed for tab=${tabId}: ${err?.message || err}`);
+      return false;
     }
   }
   isTracking(tabId) {
@@ -6365,14 +6372,21 @@ var TimeTracker = class {
   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 {
+        log2(`endSession for tab=${tabId}: never resolved datastore; ${Math.round(s.activeMs / 6e4)}min not recorded`);
+      }
     } catch (err) {
       log2(`endSession write failed: ${err?.message || err}`);
     }
+    s.ended = true;
     this.sessions.delete(tabId);
   }
   async endAll() {
@@ -6382,13 +6396,16 @@ var TimeTracker = class {
   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) {
       log2(`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) => {
           log2(`checkpoint retry failed: ${err2?.message || err2}`);
         });
@@ -6396,6 +6413,7 @@ var TimeTracker = class {
     }
   }
   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,