paneful 0.8.8 → 0.8.9

package/dist/server/claude-monitor.js

@@ -1,97 +1,58 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-// If the latest JSONL mtime is < 5s ago, Claude is actively working.
-// Otherwise Claude is open but idle (waiting for user input).
-const ACTIVE_THRESHOLD = 5_000;
+// Terminal had output within this window → Claude is actively working
+const ACTIVE_THRESHOLD = 3_000;
 export class ClaudeMonitor {
-    claudeDir;
     ptyManager;
-    projectStore;
     onChange;
+    lastOutput = new Map(); // terminalId → timestamp
     prevStatuses = {};
-    cachedLatestFile = new Map(); // cwd → latest .jsonl path
     pollTimer = null;
     destroyed = false;
-    constructor(ptyManager, projectStore, onChange) {
+    constructor(ptyManager, onChange) {
         this.ptyManager = ptyManager;
-        this.projectStore = projectStore;
         this.onChange = onChange;
-        this.claudeDir = path.join(os.homedir(), '.claude', 'projects');
     }
     start() {
         this.pollTimer = setInterval(() => this.poll(), 3000);
     }
+    /** Call from the PTY output path to record activity. */
+    recordOutput(terminalId) {
+        this.lastOutput.set(terminalId, Date.now());
+    }
+    /** Clean up when a terminal is removed. */
+    removeTerminal(terminalId) {
+        this.lastOutput.delete(terminalId);
+    }
     destroy() {
         this.destroyed = true;
         if (this.pollTimer) {
             clearInterval(this.pollTimer);
             this.pollTimer = null;
         }
+        this.lastOutput.clear();
     }
     poll() {
         if (this.destroyed)
             return;
-        // Step 1: Ask pty-manager which projects have `claude` as foreground process
+        const now = Date.now();
+        // Which projects have claude running, and what's the latest output time per project?
         const claudeProjects = this.ptyManager.getClaudeProjects();
-        // Step 2: For each, determine active vs idle by checking JSONL mtime
         const statuses = {};
-        for (const projectId of claudeProjects) {
-            const project = this.projectStore.get(projectId);
-            if (!project)
-                continue;
-            const status = this.checkMtime(project.cwd) ? 'active' : 'idle';
-            statuses[projectId] = status;
+        for (const [projectId, terminalIds] of claudeProjects) {
+            let latestOutput = 0;
+            for (const tid of terminalIds) {
+                const ts = this.lastOutput.get(tid) ?? 0;
+                if (ts > latestOutput)
+                    latestOutput = ts;
+            }
+            statuses[projectId] = (latestOutput > 0 && (now - latestOutput) < ACTIVE_THRESHOLD)
+                ? 'active'
+                : 'idle';
         }
-        // Step 3: Only notify if something changed
         if (!this.statusesEqual(statuses)) {
             this.prevStatuses = statuses;
             this.onChange(statuses);
         }
     }
-    /** Returns true if the project's latest JSONL was modified within ACTIVE_THRESHOLD. */
-    checkMtime(cwd) {
-        // Fast path: stat only the cached latest file
-        const cached = this.cachedLatestFile.get(cwd);
-        if (cached) {
-            try {
-                const stat = fs.statSync(cached);
-                if ((Date.now() - stat.mtimeMs) < ACTIVE_THRESHOLD)
-                    return true;
-            }
-            catch {
-                // File gone — fall through to full scan
-                this.cachedLatestFile.delete(cwd);
-            }
-        }
-        // Full scan: find the latest .jsonl (runs once on first check, then only
-        // when the cached file is stale — i.e. Claude started a new session)
-        const folder = path.join(this.claudeDir, cwd.replace(/\//g, '-'));
-        try {
-            const files = fs.readdirSync(folder).filter((f) => f.endsWith('.jsonl'));
-            let maxMtime = 0;
-            let maxFile = '';
-            for (const file of files) {
-                try {
-                    const filePath = path.join(folder, file);
-                    const stat = fs.statSync(filePath);
-                    if (stat.mtimeMs > maxMtime) {
-                        maxMtime = stat.mtimeMs;
-                        maxFile = filePath;
-                    }
-                }
-                catch {
-                    // skip
-                }
-            }
-            if (maxFile)
-                this.cachedLatestFile.set(cwd, maxFile);
-            return maxMtime > 0 && (Date.now() - maxMtime) < ACTIVE_THRESHOLD;
-        }
-        catch {
-            return false;
-        }
-    }
     statusesEqual(next) {
         const prevKeys = Object.keys(this.prevStatuses);
         const nextKeys = Object.keys(next);

package/dist/server/pty-manager.js

@@ -72,14 +72,17 @@ export class PtyManager {
     terminalExists(terminalId) {
         return this.sessions.has(terminalId);
     }
-    /** Returns projectIds that have a terminal with `claude` as the foreground process. */
+    /** Returns projectId → terminalIds[] for terminals with `claude` as foreground process. */
     getClaudeProjects() {
-        const result = new Set();
-        for (const managed of this.sessions.values()) {
+        const result = new Map();
+        for (const [terminalId, managed] of this.sessions) {
             try {
-                const proc = managed.process.process;
-                if (proc === 'claude') {
-                    result.add(managed.projectId);
+                if (managed.process.process === 'claude') {
+                    const list = result.get(managed.projectId);
+                    if (list)
+                        list.push(terminalId);
+                    else
+                        result.set(managed.projectId, [terminalId]);
                 }
             }
             catch {

package/dist/server/ws-handler.js

@@ -18,7 +18,7 @@ export class WsHandler {
         this.portMonitor = new PortMonitor((ports) => {
             this.send({ type: 'port:status', ports });
         });
-        this.claudeMonitor = new ClaudeMonitor(ptyManager, projectStore, (statuses) => {
+        this.claudeMonitor = new ClaudeMonitor(ptyManager, (statuses) => {
             this.send({ type: 'claude:status', statuses });
         });
         this.claudeMonitor.start();
@@ -92,6 +92,7 @@ export class WsHandler {
                 break;
             case 'pty:kill': {
                 this.portMonitor.removeTerminal(msg.terminalId);
+                this.claudeMonitor.removeTerminal(msg.terminalId);
                 const projectId = this.ptyManager.kill(msg.terminalId);
                 if (projectId) {
                     this.projectStore.removeTerminal(projectId, msg.terminalId);
@@ -132,8 +133,10 @@ export class WsHandler {
             this.ptyManager.spawn(terminalId, projectId, cwd, (tid, data) => {
                 this.send({ type: 'pty:output', terminalId: tid, data });
                 this.portMonitor.scanOutput(tid, projectId, data);
+                this.claudeMonitor.recordOutput(tid);
             }, (tid, exitCode) => {
                 this.portMonitor.removeTerminal(tid);
+                this.claudeMonitor.removeTerminal(tid);
                 this.send({ type: 'pty:exit', terminalId: tid, exitCode });
             });
             this.projectStore.addTerminal(projectId, terminalId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "paneful",
-  "version": "0.8.8",
+  "version": "0.8.9",
   "description": "Browser-based terminal multiplexer with tmux-style pane management",
   "type": "module",
   "bin": {