@phenx-inc/ctlsurf 0.2.0 → 0.3.1

package/out/main/index.js

@@ -176,6 +176,25 @@ class CtlsurfApi {
     const folder = await this.request("GET", `/folders/${folderId}`);
     return folder?.pages || [];
   }
+  async getFolder(folderId) {
+    return this.request("GET", `/folders/${folderId}`);
+  }
+  // ─── Datastore ───────────────────────────────────────
+  async getPageBlockSummaries(pageId) {
+    return this.request("GET", `/blocks/page/${pageId}/summary`);
+  }
+  async addRow(blockId, data) {
+    return this.request("POST", `/datastore/${blockId}/rows`, { data });
+  }
+  async updateRow(blockId, rowId, data) {
+    return this.request("PUT", `/datastore/${blockId}/rows/${rowId}`, { data });
+  }
+  async getDatastoreSchema(blockId) {
+    return this.request("GET", `/datastore/${blockId}/schema`);
+  }
+  async updateDatastoreSchema(blockId, columns) {
+    return this.request("PUT", `/datastore/${blockId}/schema`, { columns });
+  }
   async findFolderByGitRemote(gitRemote) {
     const folders = await this.request("GET", "/folders");
     return folders?.find((f) => f.git_remote === gitRemote || f.root_path === gitRemote) || null;
@@ -4185,7 +4204,7 @@ function requireWebsocketServer() {
 }
 requireWebsocketServer();
 const WS = typeof WebSocket !== "undefined" ? WebSocket : WebSocket$1;
-function log$2(...args) {
+function log$3(...args) {
   try {
     console.log(...args);
   } catch {
@@ -4281,7 +4300,7 @@ class WorkerWsClient {
   }
   doConnect() {
     if (!this.apiKey || !this.registration) {
-      log$2("[worker-ws] No API key or registration, skipping connect");
+      log$3("[worker-ws] No API key or registration, skipping connect");
       return;
     }
     this.clearTimers();
@@ -4304,22 +4323,22 @@ class WorkerWsClient {
   doConnectNow() {
     if (!this.apiKey || !this.registration) return;
     if (!this.shouldReconnect) {
-      log$2("[worker-ws] shouldReconnect is false, aborting connect");
+      log$3("[worker-ws] shouldReconnect is false, aborting connect");
       return;
     }
     this.setStatus("connecting");
     const wsBase = this.baseUrl.replace(/^http/, "ws");
     const url = `${wsBase}/api/ws/worker?token=${encodeURIComponent(this.apiKey)}`;
-    log$2(`[worker-ws] Connecting to ${url.replace(/token=.*/, "token=***")}...`);
+    log$3(`[worker-ws] Connecting to ${url.replace(/token=.*/, "token=***")}...`);
     try {
       this.ws = new WS(url);
     } catch (err) {
-      log$2("[worker-ws] Failed to create WebSocket:", err);
+      log$3("[worker-ws] Failed to create WebSocket:", err);
       this.scheduleReconnect();
       return;
     }
     this.ws.onopen = () => {
-      log$2("[worker-ws] Connected, sending register");
+      log$3("[worker-ws] Connected, sending register");
       this.reconnectDelay = RECONNECT_DELAY_MS;
       this.send({
         type: "register",
@@ -4332,11 +4351,11 @@ class WorkerWsClient {
         const data = JSON.parse(String(event.data));
         this.handleMessage(data);
       } catch (err) {
-        log$2("[worker-ws] Failed to parse message:", err);
+        log$3("[worker-ws] Failed to parse message:", err);
       }
     };
     this.ws.onclose = (event) => {
-      log$2(`[worker-ws] Disconnected: ${event.code} ${event.reason}`);
+      log$3(`[worker-ws] Disconnected: ${event.code} ${event.reason}`);
       this.ws = null;
       this.clearHeartbeat();
       this.setStatus("disconnected");
@@ -4345,7 +4364,7 @@ class WorkerWsClient {
       }
     };
     this.ws.onerror = () => {
-      log$2("[worker-ws] WebSocket error");
+      log$3("[worker-ws] WebSocket error");
     };
   }
   handleMessage(data) {
@@ -4373,7 +4392,7 @@ class WorkerWsClient {
         break;
       }
       case "approved": {
-        log$2("[worker-ws] Worker approved!");
+        log$3("[worker-ws] Worker approved!");
         this.setStatus("connected");
         break;
       }
@@ -4431,18 +4450,211 @@ class WorkerWsClient {
     }
   }
 }
+const DATASTORE_TITLE = "Time Tracking";
+const AGENT_DATASTORE_PAGE_TITLE = "Agent Datastore";
+const FIRST_CHECKPOINT_DELAY_MS = 30 * 1e3;
+const CHECKPOINT_INTERVAL_MS = 5 * 60 * 1e3;
+const COLUMNS = [
+  { 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" }
+];
+function log$2(...args) {
+  try {
+    console.log("[time-tracker]", ...args);
+  } catch {
+  }
+}
+function findPageByTitle(pages, title) {
+  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;
+}
+class TimeTracker {
+  api;
+  sessions = /* @__PURE__ */ new Map();
+  blockCache = /* @__PURE__ */ new Map();
+  constructor(api) {
+    this.api = api;
+  }
+  async startSession(tabId, cwd, agentName, idleTimeoutMin) {
+    if (this.sessions.has(tabId)) {
+      await this.endSession(tabId);
+    }
+    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 startedIso = new Date(startedAt).toISOString();
+      const sessionUuid = require$$1.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$2("addRow returned no id; aborting tracking", row);
+        return;
+      }
+      const state = {
+        blockId,
+        rowId,
+        cwd,
+        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}`);
+    } catch (err) {
+      log$2(`startSession failed: ${err?.message || err}`);
+    }
+  }
+  isTracking(tabId) {
+    const s = this.sessions.get(tabId);
+    return !!s && !s.ended;
+  }
+  recordActivity(tabId) {
+    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) {
+    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) {
+      log$2(`endSession write failed: ${err?.message || err}`);
+    }
+    this.sessions.delete(tabId);
+  }
+  async endAll() {
+    const ids = [...this.sessions.keys()];
+    await Promise.all(ids.map((id) => this.endSession(id)));
+  }
+  async checkpoint(tabId) {
+    const s = this.sessions.get(tabId);
+    if (!s || s.ended) return;
+    try {
+      await this.writeRow(s, Date.now());
+    } catch (err) {
+      log$2(`checkpoint failed: ${err?.message || err}`);
+    }
+  }
+  async writeRow(s, _endTimeMs) {
+    const activeMin = Math.round(s.activeMs / 6e4);
+    await this.api.updateRow(s.blockId, s.rowId, {
+      "Active Time": activeMin
+    });
+  }
+  async ensureDatastore(cwd) {
+    const cached = this.blockCache.get(cwd);
+    if (cached) return cached;
+    let folder = 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) => 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$2(`Created "${DATASTORE_TITLE}" datastore on Agent Datastore page for ${cwd}`);
+      this.blockCache.set(cwd, created.id);
+      return created.id;
+    }
+    return null;
+  }
+  async ensureColumns(blockId) {
+    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$2(`Added ${missing.length} missing column(s) to existing Time Tracking datastore: ${missing.map((c) => c.name).join(", ")}`);
+    } catch (err) {
+      log$2(`ensureColumns failed: ${err?.message || err}`);
+    }
+  }
+}
 function log$1(...args) {
   try {
     console.log(...args);
   } catch {
   }
 }
+const DEFAULT_IDLE_TIMEOUT_MIN = 15;
 const DEFAULT_PROFILES = {
   production: {
     name: "Production",
     apiKey: "",
     baseUrl: "https://app.ctlsurf.com",
-    dataspacePageId: ""
+    dataspacePageId: "",
+    trackTime: true,
+    idleTimeoutMin: 15
   }
 };
 const TERM_STREAM_INTERVAL_MS = 50;
@@ -4453,6 +4665,7 @@ class Orchestrator {
   ctlsurfApi = new CtlsurfApi();
   bridge = new ConversationBridge();
   workerWs;
+  timeTracker = new TimeTracker(this.ctlsurfApi);
   // State
   tabs = /* @__PURE__ */ new Map();
   activeTabId = null;
@@ -4587,7 +4800,9 @@ class Orchestrator {
         name: p.name,
         baseUrl: p.baseUrl,
         hasApiKey: !!p.apiKey,
-        dataspacePageId: p.dataspacePageId || null
+        dataspacePageId: p.dataspacePageId || null,
+        trackTime: p.trackTime !== false,
+        idleTimeoutMin: p.idleTimeoutMin ?? DEFAULT_IDLE_TIMEOUT_MIN
       }))
     };
   }
@@ -4599,7 +4814,9 @@ class Orchestrator {
       name: p.name,
       baseUrl: p.baseUrl,
       hasApiKey: !!p.apiKey,
-      dataspacePageId: p.dataspacePageId || ""
+      dataspacePageId: p.dataspacePageId || "",
+      trackTime: p.trackTime !== false,
+      idleTimeoutMin: p.idleTimeoutMin ?? DEFAULT_IDLE_TIMEOUT_MIN
     };
   }
   saveProfile(profileId, data) {
@@ -4608,7 +4825,9 @@ class Orchestrator {
       name: data.name,
       apiKey: data.apiKey !== void 0 ? data.apiKey : existing?.apiKey || "",
       baseUrl: data.baseUrl || "https://app.ctlsurf.com",
-      dataspacePageId: data.dataspacePageId || ""
+      dataspacePageId: data.dataspacePageId || "",
+      trackTime: data.trackTime !== void 0 ? data.trackTime : existing?.trackTime !== false,
+      idleTimeoutMin: data.idleTimeoutMin !== void 0 ? data.idleTimeoutMin : existing?.idleTimeoutMin ?? DEFAULT_IDLE_TIMEOUT_MIN
     };
     this.saveSettings();
     if (profileId === this.settings.activeProfile) {
@@ -4646,7 +4865,7 @@ class Orchestrator {
     return { ok: true };
   }
   // ─── PTY & Agent (multi-tab) ─────────────────────
-  async spawnAgent(tabId, agent, cwd) {
+  async spawnAgent(tabId, agent, cwd, opts) {
     const existing = this.tabs.get(tabId);
     if (existing) {
       if (existing.termStreamTimer) clearTimeout(existing.termStreamTimer);
@@ -4665,6 +4884,7 @@ class Orchestrator {
     this.tabs.set(tabId, tab);
     ptyManager.onData((data) => {
       this.events.onPtyData(tabId, data);
+      this.timeTracker.recordActivity(tabId);
       if (tabId === this.activeTabId) {
         this.bridge.feedOutput(data);
         this.streamTerminalData(tabId, data);
@@ -4672,6 +4892,7 @@ class Orchestrator {
     });
     ptyManager.onExit(async (exitCode) => {
       this.events.onPtyExit(tabId, exitCode);
+      await this.timeTracker.endSession(tabId);
       if (tabId === this.activeTabId) {
         this.bridge.endSession();
         if (this.currentAgent && isCodingAgent(this.currentAgent)) {
@@ -4682,6 +4903,16 @@ class Orchestrator {
       if (t?.termStreamTimer) clearTimeout(t.termStreamTimer);
     });
     this.bridge.startSession();
+    const profile = this.getActiveProfile();
+    const shouldTrack = opts?.trackTime !== void 0 ? 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 {
@@ -4706,6 +4937,7 @@ class Orchestrator {
     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) {
@@ -4728,6 +4960,28 @@ class Orchestrator {
   getTabIds() {
     return [...this.tabs.keys()];
   }
+  // ─── Tracking control (active tab) ──────────────
+  isActiveTabTracking() {
+    if (!this.activeTabId) return false;
+    return this.timeTracker.isTracking(this.activeTabId);
+  }
+  async setActiveTabTracking(enabled) {
+    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);
+    }
+  }
   // ─── Worker WebSocket ───────────────────────────
   connectWorkerWs(agent, cwd) {
     const profile = this.getActiveProfile();
@@ -4773,6 +5027,7 @@ class Orchestrator {
   // ─── Shutdown ───────────────────────────────────
   async shutdown() {
     this.bridge.endSession();
+    await this.timeTracker.endAll();
     for (const [, tab] of this.tabs) {
       if (tab.termStreamTimer) clearTimeout(tab.termStreamTimer);
       tab.ptyManager.kill();
@@ -5024,6 +5279,11 @@ electron.ipcMain.handle("profiles:save", (_event, id, data) => {
 });
 electron.ipcMain.handle("profiles:switch", (_event, id) => orchestrator.switchProfile(id));
 electron.ipcMain.handle("profiles:delete", (_event, id) => orchestrator.deleteProfile(id));
+electron.ipcMain.handle("tracking:get", () => ({ active: orchestrator.isActiveTabTracking() }));
+electron.ipcMain.handle("tracking:set", async (_event, enabled) => {
+  await orchestrator.setActiveTabTracking(enabled);
+  return { active: orchestrator.isActiveTabTracking() };
+});
 electron.ipcMain.handle("settings:get", (_event, key) => {
   const profile = orchestrator.getActiveProfile();
   if (key === "ctlsurfApiKey") return profile.apiKey ? "***configured***" : null;

package/out/preload/index.js

@@ -35,6 +35,9 @@ const api = {
   saveProfile: (profileId, data) => electron.ipcRenderer.invoke("profiles:save", profileId, data),
   switchProfile: (profileId) => electron.ipcRenderer.invoke("profiles:switch", profileId),
   deleteProfile: (profileId) => electron.ipcRenderer.invoke("profiles:delete", profileId),
+  // Tracking (active tab)
+  getTracking: () => electron.ipcRenderer.invoke("tracking:get"),
+  setTracking: (enabled) => electron.ipcRenderer.invoke("tracking:set", enabled),
   // Filesystem
   readDir: (dirPath) => electron.ipcRenderer.invoke("fs:readDir", dirPath),
   readFile: (filePath) => electron.ipcRenderer.invoke("fs:readFile", filePath),

package/out/renderer/assets/{cssMode-D3kH1Kju.js → cssMode-BW-SuYuP.js}

@@ -1,6 +1,6 @@
-import { c as createWebWorker, l as languages } from "./index-BsdOeO0U.js";
-import { C as CompletionAdapter, H as HoverAdapter, D as DocumentHighlightAdapter, a as DefinitionAdapter, R as ReferenceAdapter, b as DocumentSymbolAdapter, c as RenameAdapter, d as DocumentColorAdapter, F as FoldingRangeAdapter, e as DiagnosticsAdapter, S as SelectionRangeAdapter, f as DocumentFormattingEditProvider, g as DocumentRangeFormattingEditProvider } from "./lspLanguageFeatures-hoVZfVKv.js";
-import { h, i, j, t, k } from "./lspLanguageFeatures-hoVZfVKv.js";
+import { c as createWebWorker, l as languages } from "./index-Bm_rbVP-.js";
+import { C as CompletionAdapter, H as HoverAdapter, D as DocumentHighlightAdapter, a as DefinitionAdapter, R as ReferenceAdapter, b as DocumentSymbolAdapter, c as RenameAdapter, d as DocumentColorAdapter, F as FoldingRangeAdapter, e as DiagnosticsAdapter, S as SelectionRangeAdapter, f as DocumentFormattingEditProvider, g as DocumentRangeFormattingEditProvider } from "./lspLanguageFeatures-peGVtLxi.js";
+import { h, i, j, t, k } from "./lspLanguageFeatures-peGVtLxi.js";
 const STOP_WHEN_IDLE_FOR = 2 * 60 * 1e3;
 class WorkerManager {
   constructor(defaults) {

package/out/renderer/assets/{freemarker2-BCHZUSLb.js → freemarker2-2YWYzawi.js}

@@ -1,4 +1,4 @@
-import { l as languages } from "./index-BsdOeO0U.js";
+import { l as languages } from "./index-Bm_rbVP-.js";
 const EMPTY_ELEMENTS = [
   "assign",
   "flush",

package/out/renderer/assets/{handlebars-DKx-Fw-H.js → handlebars-EwtUQRsf.js}

@@ -1,4 +1,4 @@
-import { l as languages } from "./index-BsdOeO0U.js";
+import { l as languages } from "./index-Bm_rbVP-.js";
 const EMPTY_ELEMENTS = [
   "area",
   "base",

package/out/renderer/assets/{html-BSCM04uL.js → html-BNZkIDb9.js}

@@ -1,4 +1,4 @@
-import { l as languages } from "./index-BsdOeO0U.js";
+import { l as languages } from "./index-Bm_rbVP-.js";
 const EMPTY_ELEMENTS = [
   "area",
   "base",

package/out/renderer/assets/{htmlMode-BucU1MUc.js → htmlMode-C2dZKrOy.js}

@@ -1,6 +1,6 @@
-import { c as createWebWorker, l as languages } from "./index-BsdOeO0U.js";
-import { H as HoverAdapter, D as DocumentHighlightAdapter, h as DocumentLinkAdapter, F as FoldingRangeAdapter, b as DocumentSymbolAdapter, S as SelectionRangeAdapter, c as RenameAdapter, f as DocumentFormattingEditProvider, g as DocumentRangeFormattingEditProvider, C as CompletionAdapter } from "./lspLanguageFeatures-hoVZfVKv.js";
-import { a, e, d, R, i, j, t, k } from "./lspLanguageFeatures-hoVZfVKv.js";
+import { c as createWebWorker, l as languages } from "./index-Bm_rbVP-.js";
+import { H as HoverAdapter, D as DocumentHighlightAdapter, h as DocumentLinkAdapter, F as FoldingRangeAdapter, b as DocumentSymbolAdapter, S as SelectionRangeAdapter, c as RenameAdapter, f as DocumentFormattingEditProvider, g as DocumentRangeFormattingEditProvider, C as CompletionAdapter } from "./lspLanguageFeatures-peGVtLxi.js";
+import { a, e, d, R, i, j, t, k } from "./lspLanguageFeatures-peGVtLxi.js";
 const STOP_WHEN_IDLE_FOR = 2 * 60 * 1e3;
 class WorkerManager {
   constructor(defaults) {