@phenx-inc/ctlsurf 0.2.0 → 0.3.0

package/out/headless/index.mjs

@@ -37,7 +37,7 @@ var require_electron = __commonJS({
 // src/main/orchestrator.ts
 import path from "path";
 import fs from "fs";
-import os2 from "os";
+import os3 from "os";
 
 // src/main/pty.ts
 import { createRequire } from "module";
@@ -198,6 +198,25 @@ var CtlsurfApi = class {
     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;
@@ -567,19 +586,216 @@ var WorkerWsClient = class {
   }
 };
 
-// src/main/orchestrator.ts
+// src/main/timeTracker.ts
+import os2 from "os";
+import { randomUUID } from "crypto";
+var DATASTORE_TITLE = "Time Tracking";
+var AGENT_DATASTORE_PAGE_TITLE = "Agent Datastore";
+var FIRST_CHECKPOINT_DELAY_MS = 30 * 1e3;
+var CHECKPOINT_INTERVAL_MS = 5 * 60 * 1e3;
+var 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 log2(...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;
+}
+var TimeTracker = class {
+  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) {
+        log2(`No "${AGENT_DATASTORE_PAGE_TITLE}" page found for ${cwd} \u2014 tracking disabled for this session`);
+        return;
+      }
+      const startedAt = Date.now();
+      const startedIso = new Date(startedAt).toISOString();
+      const sessionUuid = randomUUID();
+      const row = await this.api.addRow(blockId, {
+        Started: startedIso,
+        "Active Time": 0,
+        Agent: agentName,
+        Worker: os2.hostname(),
+        Session: sessionUuid,
+        Notes: ""
+      });
+      const rowId = row?.id;
+      if (!rowId) {
+        log2("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);
+      log2(`Started tracking tab=${tabId} agent="${agentName}" cwd=${cwd}`);
+    } catch (err) {
+      log2(`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) {
+      log2(`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) {
+      log2(`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) {
+      log2(`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);
+      log2(`Added ${missing.length} missing column(s) to existing Time Tracking datastore: ${missing.map((c) => c.name).join(", ")}`);
+    } catch (err) {
+      log2(`ensureColumns failed: ${err?.message || err}`);
+    }
+  }
+};
+
+// src/main/orchestrator.ts
+function log3(...args) {
   try {
     console.log(...args);
   } catch {
   }
 }
+var DEFAULT_IDLE_TIMEOUT_MIN = 15;
 var DEFAULT_PROFILES = {
   production: {
     name: "Production",
     apiKey: "",
     baseUrl: "https://app.ctlsurf.com",
-    dataspacePageId: ""
+    dataspacePageId: "",
+    trackTime: true,
+    idleTimeoutMin: 15
   }
 };
 var TERM_STREAM_INTERVAL_MS = 50;
@@ -590,6 +806,7 @@ var Orchestrator = class {
   ctlsurfApi = new CtlsurfApi();
   bridge = new ConversationBridge();
   workerWs;
+  timeTracker = new TimeTracker(this.ctlsurfApi);
   // State
   tabs = /* @__PURE__ */ new Map();
   activeTabId = null;
@@ -604,11 +821,11 @@ var Orchestrator = class {
     this.events = events;
     this.workerWs = new WorkerWsClient({
       onStatusChange: (status) => {
-        log2(`[worker-ws] Status: ${status}`);
+        log3(`[worker-ws] Status: ${status}`);
         events.onWorkerStatus(status);
       },
       onMessage: (message) => {
-        log2(`[worker-ws] Incoming message: ${message.id} (${message.type})`);
+        log3(`[worker-ws] Incoming message: ${message.id} (${message.type})`);
         events.onWorkerMessage(message);
         this.workerWs.sendAck(message.id);
         if (message.type === "prompt" || message.type === "task_dispatch") {
@@ -620,7 +837,7 @@ var Orchestrator = class {
         }
       },
       onRegistered: (data) => {
-        log2(`[worker-ws] Registered: worker_id=${data.worker_id}, folder_id=${data.folder_id}, status=${data.status}`);
+        log3(`[worker-ws] Registered: worker_id=${data.worker_id}, folder_id=${data.folder_id}, status=${data.status}`);
         events.onWorkerRegistered(data);
         if (!data.folder_id) {
           events.onWorkerStatus("no_project");
@@ -658,7 +875,7 @@ var Orchestrator = class {
     const baseUrl = profile.baseUrl || process.env.CTLSURF_BASE_URL || "https://app.ctlsurf.com";
     this.ctlsurfApi.setBaseUrl(baseUrl);
     this.workerWs.setBaseUrl(baseUrl);
-    log2(`[settings] Profile applied: ${profile.name} (${baseUrl})`);
+    log3(`[settings] Profile applied: ${profile.name} (${baseUrl})`);
   }
   loadSettings() {
     try {
@@ -682,7 +899,7 @@ var Orchestrator = class {
             }
           };
           this.saveSettings();
-          log2("[settings] Migrated legacy settings to profiles");
+          log3("[settings] Migrated legacy settings to profiles");
         } else {
           this.settings = raw;
           if (!this.settings.profiles.production) {
@@ -704,7 +921,7 @@ var Orchestrator = class {
       fs.mkdirSync(this.settingsDir, { recursive: true });
       fs.writeFileSync(settingsPath, JSON.stringify(this.settings, null, 2));
     } catch (err) {
-      log2("[settings] Failed to save:", err.message);
+      log3("[settings] Failed to save:", err.message);
     }
   }
   overrideApiKey(key) {
@@ -724,7 +941,9 @@ var Orchestrator = class {
         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
       }))
     };
   }
@@ -736,7 +955,9 @@ var Orchestrator = class {
       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) {
@@ -745,7 +966,9 @@ var Orchestrator = class {
       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) {
@@ -783,7 +1006,7 @@ var Orchestrator = class {
     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);
@@ -802,6 +1025,7 @@ var Orchestrator = class {
     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);
@@ -809,6 +1033,7 @@ var Orchestrator = class {
     });
     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)) {
@@ -819,6 +1044,16 @@ var Orchestrator = class {
       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 {
@@ -843,6 +1078,7 @@ var Orchestrator = class {
     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) {
@@ -865,16 +1101,38 @@ var Orchestrator = class {
   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();
     const apiKey = profile.apiKey || process.env.CTLSURF_API_KEY;
     if (!apiKey) {
-      log2("[worker-ws] No API key, skipping WS connect");
+      log3("[worker-ws] No API key, skipping WS connect");
       return;
     }
     this.workerWs.connect({
-      machine: os2.hostname(),
+      machine: os3.hostname(),
       cwd,
       agent: agent.name
     });
@@ -910,6 +1168,7 @@ var Orchestrator = class {
   // ─── 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();
@@ -921,17 +1180,17 @@ var Orchestrator = class {
 
 // src/main/settingsDir.ts
 import path2 from "path";
-import os3 from "os";
+import os4 from "os";
 function getSettingsDir(useElectron) {
   if (useElectron) {
     const { app } = require_electron();
     return app.getPath("userData");
   }
   if (process.platform === "darwin") {
-    return path2.join(os3.homedir(), "Library", "Application Support", "ctlsurf-worker");
+    return path2.join(os4.homedir(), "Library", "Application Support", "ctlsurf-worker");
   }
   return path2.join(
-    process.env.XDG_CONFIG_HOME || path2.join(os3.homedir(), ".config"),
+    process.env.XDG_CONFIG_HOME || path2.join(os4.homedir(), ".config"),
     "ctlsurf-worker"
   );
 }
@@ -1038,11 +1297,12 @@ var Tui = class {
    * Show an interactive agent picker modal.
    * Uses alternate screen just for the picker, then exits back to normal.
    */
-  showAgentPicker(agents) {
+  showAgentPicker(agents, options) {
     return new Promise((resolve) => {
       let selected = 0;
+      let trackTime = options.initialTrackTime;
       const modalWidth = 44;
-      const modalHeight = agents.length + 4;
+      const modalHeight = agents.length + 4 + 2;
       const startCol = Math.max(1, Math.floor((this.cols - modalWidth) / 2));
       const startRow = Math.max(1, Math.floor((this.rows - modalHeight) / 2));
       this.write(`${CSI}?1049h`);
@@ -1076,9 +1336,19 @@ var Tui = class {
           const pad = " ".repeat(Math.max(0, modalWidth - 2 - contentLen));
           this.write(`${CSI}${row};${startCol}H${bg}${FG_DIM}\u2502${RESET}${bg}${content}${pad}${RESET}${BG_MODAL}${FG_DIM}\u2502${RESET}`);
         }
-        const botRow = startRow + 3 + agents.length;
+        const innerSep = "\u251C" + "\u2500".repeat(modalWidth - 2) + "\u2524";
+        const sepRow = startRow + 3 + agents.length;
+        this.write(`${CSI}${sepRow};${startCol}H${BG_MODAL}${FG_DIM}${innerSep}${RESET}`);
+        const trackRow = sepRow + 1;
+        const checkbox = trackTime ? `${FG_GREEN}[\u2713]${RESET}${BG_MODAL}` : `${FG_DIM}[ ]${RESET}${BG_MODAL}`;
+        const trackLabelFg = trackTime ? FG_WHITE : FG_DIM;
+        const trackContent = `  ${checkbox} ${trackLabelFg}Track time${RESET}${BG_MODAL}`;
+        const trackContentLen = 2 + 3 + 1 + "Track time".length;
+        const trackPad = " ".repeat(Math.max(0, modalWidth - 2 - trackContentLen));
+        this.write(`${CSI}${trackRow};${startCol}H${BG_MODAL}${FG_DIM}\u2502${RESET}${BG_MODAL}${trackContent}${trackPad}${FG_DIM}\u2502${RESET}`);
+        const botRow = trackRow + 1;
         this.write(`${CSI}${botRow};${startCol}H${BG_MODAL}${FG_DIM}${botBorder}${RESET}`);
-        const hint = "\u2191\u2193 navigate \xB7 Enter select \xB7 q quit";
+        const hint = "\u2191\u2193 navigate \xB7 Enter select \xB7 t track \xB7 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}`);
       };
@@ -1095,9 +1365,12 @@ var Tui = class {
         } else if (key === "\x1B[B" || key === "j") {
           selected = (selected + 1) % agents.length;
           drawModal();
+        } else if (key === "t" || key === "T" || key === " ") {
+          trackTime = !trackTime;
+          drawModal();
         } else if (key === "\r" || key === "\n") {
           cleanup();
-          resolve(selected);
+          resolve({ agentIdx: selected, trackTime });
         } else if (key === "q" || key === "\x1B" || key === "") {
           cleanup();
           this.write(`${CSI}?25h`);
@@ -1221,26 +1494,6 @@ async function main() {
   const settingsDir = getSettingsDir(false);
   const tui = new Tui();
   const agents = getBuiltinAgents();
-  let agent;
-  if (args.agent) {
-    const found = agents.find((a) => a.id === args.agent);
-    agent = found || {
-      id: args.agent,
-      name: args.agent,
-      command: args.agent,
-      args: [],
-      description: `Custom agent: ${args.agent}`
-    };
-  } else {
-    const selectedIdx = await tui.showAgentPicker(agents);
-    agent = agents[selectedIdx];
-  }
-  tui.update({
-    agentName: agent.name,
-    cwd: args.cwd,
-    mode: "terminal"
-  });
-  tui.init();
   const orchestrator = new Orchestrator(settingsDir, {
     onPtyData: (_tabId, data) => {
       tui.writePtyData(data);
@@ -1266,9 +1519,32 @@ async function main() {
   if (args.profile) orchestrator.switchProfile(args.profile);
   if (args.apiKey) orchestrator.overrideApiKey(args.apiKey);
   if (args.baseUrl) orchestrator.overrideBaseUrl(args.baseUrl);
+  let agent;
+  let trackTimeOverride;
+  if (args.agent) {
+    const found = agents.find((a) => a.id === args.agent);
+    agent = found || {
+      id: args.agent,
+      name: args.agent,
+      command: args.agent,
+      args: [],
+      description: `Custom agent: ${args.agent}`
+    };
+  } else {
+    const initialTrackTime = orchestrator.getActiveProfile().trackTime !== false;
+    const picked = await tui.showAgentPicker(agents, { initialTrackTime });
+    agent = agents[picked.agentIdx];
+    trackTimeOverride = picked.trackTime;
+  }
+  tui.update({
+    agentName: agent.name,
+    cwd: args.cwd,
+    mode: "terminal"
+  });
+  tui.init();
   const HEADLESS_TAB = "headless";
   const ptySize = tui.getPtySize();
-  await orchestrator.spawnAgent(HEADLESS_TAB, agent, args.cwd);
+  await orchestrator.spawnAgent(HEADLESS_TAB, agent, args.cwd, { trackTime: trackTimeOverride });
   orchestrator.resizePty(HEADLESS_TAB, ptySize.cols, ptySize.rows);
   if (isCodingAgent(agent)) {
     setTimeout(() => {