paneful 0.9.1 → 0.9.2

package/dist/server/claude-monitor.js

@@ -11,9 +11,24 @@ export class ClaudeMonitor {
         this.ptyManager = ptyManager;
         this.onChange = onChange;
     }
-    start() {
+    resume() {
+        if (this.destroyed || this.pollTimer)
+            return;
         this.pollTimer = setInterval(() => this.poll(), 3000);
     }
+    pause() {
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = null;
+        }
+    }
+    getStatuses() {
+        return { ...this.prevStatuses };
+    }
+    /** @deprecated Use resume() instead */
+    start() {
+        this.resume();
+    }
     /** Call from the PTY output path to record activity. */
     recordOutput(terminalId) {
         this.lastOutput.set(terminalId, Date.now());

package/dist/server/editor-monitor.js

@@ -0,0 +1,394 @@
+import { spawn, execFile } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir, tmpdir } from 'node:os';
+const EDITOR_PATTERNS = ['cursor', 'code', 'vscode', 'visual studio code', 'zed', 'windsurf', 'electron'];
+// Long-lived osascript fallback — same as before.
+const STREAMING_SCRIPT = `
+repeat
+  try
+    tell application "System Events"
+      set frontApp to name of first application process whose frontmost is true
+      set winTitle to ""
+      tell process frontApp
+        if exists front window then
+          set winTitle to name of front window
+        end if
+      end tell
+    end tell
+    log frontApp & "\\t" & winTitle
+  end try
+  delay 0.75
+end repeat
+`;
+// Swift helper: event-driven app switches via NSWorkspace, AX observer for window/title changes.
+const SWIFT_SOURCE = `
+import Cocoa
+
+let editorPatterns: [String] = ["cursor", "code", "vscode", "visual studio code", "zed", "windsurf", "electron"]
+
+func isEditor(_ name: String) -> Bool {
+    let lower = name.lowercased()
+    return editorPatterns.contains { lower.contains($0) }
+}
+
+func getWindowTitle(pid: pid_t) -> String {
+    let app = AXUIElementCreateApplication(pid)
+    var value: AnyObject?
+    guard AXUIElementCopyAttributeValue(app, kAXFocusedWindowAttribute as CFString, &value) == .success else {
+        return ""
+    }
+    var title: AnyObject?
+    guard AXUIElementCopyAttributeValue(value as! AXUIElement, kAXTitleAttribute as CFString, &title) == .success else {
+        return ""
+    }
+    return title as? String ?? ""
+}
+
+setbuf(stdout, nil)
+setbuf(stderr, nil)
+
+let startTime = CFAbsoluteTimeGetCurrent()
+func log(_ msg: String) {
+    let elapsed = String(format: "%.3f", CFAbsoluteTimeGetCurrent() - startTime)
+    fputs("[swift +\\(elapsed)s] \\(msg)\\n", stderr)
+}
+
+var lastOutput = ""
+var currentPid: pid_t = 0
+var currentAppName = ""
+var axObserver: AXObserver?
+var observedWindow: AXUIElement?
+var fallbackTimer: Timer?
+
+func emit(_ appName: String, _ title: String, source: String) {
+    let output = "\\(appName)\\t\\(title)"
+    guard output != lastOutput else { return }
+    lastOutput = output
+    log("emit (\\(source)): \\(appName) | \\(title.isEmpty ? "(no title)" : title)")
+    print(output)
+}
+
+func emitCurrentTitle(source: String) {
+    let title = getWindowTitle(pid: currentPid)
+    emit(currentAppName, title, source: source)
+}
+
+let axCallback: AXObserverCallback = { _, _, notification, _ in
+    let name = notification as String
+    if name == (kAXFocusedWindowChangedNotification as String) {
+        log("AX: focused window changed")
+        observeFocusedWindowTitle()
+        emitCurrentTitle(source: "ax-window-change")
+    } else if name == (kAXTitleChangedNotification as String) {
+        log("AX: title changed")
+        emitCurrentTitle(source: "ax-title-change")
+    } else {
+        emitCurrentTitle(source: "ax-\\(name)")
+    }
+}
+
+func observeFocusedWindowTitle() {
+    guard let obs = axObserver else { return }
+    if let old = observedWindow {
+        AXObserverRemoveNotification(obs, old, kAXTitleChangedNotification as CFString)
+        observedWindow = nil
+    }
+    let app = AXUIElementCreateApplication(currentPid)
+    var winValue: AnyObject?
+    guard AXUIElementCopyAttributeValue(app, kAXFocusedWindowAttribute as CFString, &winValue) == .success else { return }
+    let window = winValue as! AXUIElement
+    AXObserverAddNotification(obs, window, kAXTitleChangedNotification as CFString, nil)
+    observedWindow = window
+}
+
+func startObserving(pid: pid_t) {
+    stopObserving()
+    emitCurrentTitle(source: "editor-activated")
+
+    var observer: AXObserver?
+    guard AXObserverCreate(pid, axCallback, &observer) == .success, let obs = observer else {
+        log("AXObserver failed for pid \\(pid), using poll fallback")
+        fallbackTimer = Timer.scheduledTimer(withTimeInterval: 0.5, repeats: true) { _ in
+            emitCurrentTitle(source: "poll")
+        }
+        return
+    }
+
+    let appElement = AXUIElementCreateApplication(pid)
+    AXObserverAddNotification(obs, appElement, kAXFocusedWindowChangedNotification as CFString, nil)
+    CFRunLoopAddSource(CFRunLoopGetMain(), AXObserverGetRunLoopSource(obs), .defaultMode)
+    axObserver = obs
+    observeFocusedWindowTitle()
+    log("AXObserver active for pid \\(pid)")
+
+    // AX notifications don't fire for Electron apps (Cursor, VS Code, etc.)
+    // so this timer is the primary mechanism for those editors
+    fallbackTimer = Timer.scheduledTimer(withTimeInterval: 0.5, repeats: true) { _ in
+        emitCurrentTitle(source: "poll")
+    }
+}
+
+func stopObserving() {
+    if let obs = axObserver {
+        CFRunLoopRemoveSource(CFRunLoopGetMain(), AXObserverGetRunLoopSource(obs), .defaultMode)
+        axObserver = nil
+        observedWindow = nil
+    }
+    fallbackTimer?.invalidate()
+    fallbackTimer = nil
+}
+
+let nc = NSWorkspace.shared.notificationCenter
+nc.addObserver(forName: NSWorkspace.didActivateApplicationNotification, object: nil, queue: .main) { notif in
+    guard let app = notif.userInfo?[NSWorkspace.applicationUserInfoKey] as? NSRunningApplication,
+          let name = app.localizedName else { return }
+    log("app switch: \\(name)")
+    currentAppName = name
+    currentPid = app.processIdentifier
+    if isEditor(name) {
+        startObserving(pid: currentPid)
+    } else {
+        stopObserving()
+        emit(name, "", source: "app-switch")
+    }
+}
+
+if let front = NSWorkspace.shared.frontmostApplication, let name = front.localizedName {
+    log("seed: \\(name)")
+    currentAppName = name
+    currentPid = front.processIdentifier
+    if isEditor(name) {
+        startObserving(pid: currentPid)
+    } else {
+        emit(name, "", source: "seed")
+    }
+}
+
+RunLoop.main.run()
+`;
+export class EditorMonitor {
+    onChange;
+    proc = null;
+    destroyed = false;
+    lineBuffer = '';
+    cache = { projectName: null };
+    restartTimer = null;
+    mode = 'osascript';
+    compiling = false;
+    constructor(onChange) {
+        this.onChange = onChange;
+    }
+    getState() {
+        return this.cache;
+    }
+    get helperPath() {
+        return join(homedir(), '.paneful', 'paneful-editor-helper');
+    }
+    get versionPath() {
+        return this.helperPath + '.version';
+    }
+    sourceHash() {
+        return createHash('sha256').update(SWIFT_SOURCE).digest('hex').slice(0, 16);
+    }
+    isHelperCurrent() {
+        if (!existsSync(this.helperPath))
+            return false;
+        try {
+            const stored = readFileSync(this.versionPath, 'utf-8').trim();
+            return stored === this.sourceHash();
+        }
+        catch {
+            return false;
+        }
+    }
+    async compileHelper() {
+        if (this.compiling)
+            return;
+        this.compiling = true;
+        const dir = join(homedir(), '.paneful');
+        mkdirSync(dir, { recursive: true });
+        const tmpSrc = join(tmpdir(), `paneful-editor-helper-${process.pid}.swift`);
+        writeFileSync(tmpSrc, SWIFT_SOURCE);
+        try {
+            await new Promise((resolve, reject) => {
+                const child = execFile('swiftc', [tmpSrc, '-o', this.helperPath, '-framework', 'Cocoa', '-O'], { timeout: 60_000 }, (err) => (err ? reject(err) : resolve()));
+                child.unref();
+            });
+            writeFileSync(this.versionPath, this.sourceHash());
+        }
+        finally {
+            this.compiling = false;
+            try {
+                unlinkSync(tmpSrc);
+            }
+            catch { }
+        }
+    }
+    resume() {
+        if (this.destroyed || this.proc)
+            return;
+        if (process.platform !== 'darwin')
+            return;
+        if (this.isHelperCurrent()) {
+            this.mode = 'native';
+            console.log('[editor-monitor] native helper is current, starting directly');
+            this.startProcess();
+        }
+        else {
+            this.mode = 'osascript';
+            console.log('[editor-monitor] native helper not found, starting osascript fallback');
+            this.startProcess();
+            console.log('[editor-monitor] compiling native helper in background...');
+            this.compileHelper()
+                .then(() => {
+                if (this.destroyed)
+                    return;
+                console.log('[editor-monitor] compilation done, hot-swapping to native helper');
+                this.stopProcess();
+                this.mode = 'native';
+                this.startProcess();
+            })
+                .catch((err) => {
+                console.log(`[editor-monitor] compilation failed, keeping osascript: ${err.message}`);
+            });
+        }
+    }
+    pause() {
+        this.stopProcess();
+    }
+    destroy() {
+        this.destroyed = true;
+        this.stopProcess();
+    }
+    startProcess() {
+        if (this.destroyed || this.proc)
+            return;
+        let proc;
+        if (this.mode === 'native') {
+            proc = spawn(this.helperPath, [], {
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            this.proc = proc;
+            this.lineBuffer = '';
+            proc.stdout.on('data', (chunk) => {
+                if (this.destroyed)
+                    return;
+                this.feedData(chunk);
+            });
+            // Forward Swift helper's debug logs to server console
+            let stderrBuf = '';
+            proc.stderr.on('data', (chunk) => {
+                stderrBuf += chunk.toString();
+                const lines = stderrBuf.split('\n');
+                stderrBuf = lines.pop() ?? '';
+                for (const line of lines) {
+                    if (line.trim())
+                        console.log(`[editor-monitor] ${line.trim()}`);
+                }
+            });
+        }
+        else {
+            proc = spawn('osascript', ['-e', STREAMING_SCRIPT], {
+                stdio: ['ignore', 'ignore', 'pipe'],
+            });
+            this.proc = proc;
+            this.lineBuffer = '';
+            proc.stderr.on('data', (chunk) => {
+                if (this.destroyed)
+                    return;
+                this.feedData(chunk);
+            });
+        }
+        const currentMode = this.mode;
+        proc.on('error', (err) => {
+            if (this.proc !== proc)
+                return;
+            const msg = err.message || '';
+            const needsAccess = msg.includes('not allowed assistive access') || msg.includes('1719');
+            this.cache = { projectName: null, needsAccessibility: needsAccess || undefined };
+            this.proc = null;
+            if (currentMode === 'native') {
+                console.log(`[editor-monitor] native helper error, falling back to osascript: ${msg}`);
+                this.mode = 'osascript';
+            }
+            this.scheduleRestart();
+        });
+        proc.on('exit', (code) => {
+            if (this.proc !== proc)
+                return;
+            this.proc = null;
+            if (currentMode === 'native' && code !== 0) {
+                console.log(`[editor-monitor] native helper exited (code ${code}), falling back to osascript`);
+                this.mode = 'osascript';
+            }
+            this.scheduleRestart();
+        });
+    }
+    feedData(chunk) {
+        this.lineBuffer += chunk.toString();
+        const lines = this.lineBuffer.split('\n');
+        this.lineBuffer = lines.pop() ?? '';
+        for (const line of lines) {
+            this.handleLine(line.trim());
+        }
+    }
+    stopProcess() {
+        if (this.restartTimer) {
+            clearTimeout(this.restartTimer);
+            this.restartTimer = null;
+        }
+        if (this.proc) {
+            this.proc.kill();
+            this.proc = null;
+        }
+    }
+    scheduleRestart() {
+        if (this.destroyed)
+            return;
+        if (this.restartTimer)
+            return;
+        this.restartTimer = setTimeout(() => {
+            this.restartTimer = null;
+            if (!this.destroyed && !this.proc) {
+                this.startProcess();
+            }
+        }, 5000);
+    }
+    handleLine(line) {
+        if (!line)
+            return;
+        const tabIdx = line.indexOf('\t');
+        const appName = tabIdx >= 0 ? line.slice(0, tabIdx) : line;
+        const title = tabIdx >= 0 ? line.slice(tabIdx + 1) : '';
+        const isEditor = EDITOR_PATTERNS.some((pat) => appName.toLowerCase().includes(pat));
+        if (!isEditor || !title) {
+            this.cache = { projectName: null };
+            return;
+        }
+        let projectName = null;
+        const pathMatch = title.match(/^(~?\/[^\s]+)/);
+        if (pathMatch) {
+            const segments = pathMatch[1].replace(/\/$/, '').split('/');
+            projectName = segments[segments.length - 1] || null;
+        }
+        if (!projectName) {
+            const parts = title.split(' \u2014 ');
+            if (parts.length >= 3) {
+                projectName = parts[parts.length - 2];
+            }
+            else if (parts.length === 2) {
+                projectName = parts[0];
+            }
+            else {
+                projectName = title;
+            }
+        }
+        const prev = this.cache.projectName;
+        this.cache = { projectName };
+        if (projectName && projectName !== prev) {
+            this.onChange(projectName);
+        }
+    }
+}

package/dist/server/git-monitor.js

@@ -5,12 +5,25 @@ export class GitMonitor {
     branches = new Map();
     pollTimer = null;
     destroyed = false;
+    polling = false;
     constructor(projectStore, onChange) {
         this.projectStore = projectStore;
         this.onChange = onChange;
+        // Initial poll to have data ready for first client connection
+        this.poll();
+    }
+    resume() {
+        if (this.destroyed || this.pollTimer)
+            return;
         this.poll();
         this.pollTimer = setInterval(() => this.poll(), 10_000);
     }
+    pause() {
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = null;
+        }
+    }
     getBranches() {
         const result = {};
         for (const [id, branch] of this.branches) {
@@ -27,6 +40,17 @@ export class GitMonitor {
         this.branches.clear();
     }
     async poll() {
+        if (this.destroyed || this.polling)
+            return;
+        this.polling = true;
+        try {
+            await this.doPoll();
+        }
+        finally {
+            this.polling = false;
+        }
+    }
+    async doPoll() {
         if (this.destroyed)
             return;
         const projects = this.projectStore.list();

package/dist/server/index.js

@@ -268,71 +268,6 @@ async function startServer(devMode, port) {
             res.json({ valid: false });
         }
     });
-    // Active editor detection — single AppleScript gets frontmost app + window title
-    const editorPatterns = ['cursor', 'code', 'vscode', 'visual studio code', 'zed', 'windsurf', 'electron'];
-    let editorCache = { projectName: null };
-    const editorScript = `
-    tell application "System Events"
-      set frontApp to name of first application process whose frontmost is true
-      set winTitle to ""
-      tell process frontApp
-        if exists front window then
-          set winTitle to name of front window
-        end if
-      end tell
-      return frontApp & linefeed & winTitle
-    end tell
-  `;
-    function pollActiveEditor() {
-        if (process.platform !== 'darwin')
-            return;
-        execFile('osascript', ['-e', editorScript], { timeout: 2000 }, (err, stdout, stderr) => {
-            if (err) {
-                const needsAccess = stderr?.includes('not allowed assistive access') || stderr?.includes('1719');
-                editorCache = { projectName: null, needsAccessibility: needsAccess || undefined };
-                return;
-            }
-            const lines = stdout.trim().split('\n');
-            const appName = (lines[0] || '').trim();
-            const title = (lines[1] || '').trim();
-            const isEditor = editorPatterns.some((pat) => appName.toLowerCase().includes(pat));
-            if (!isEditor || !title) {
-                editorCache = { projectName: null };
-                return;
-            }
-            let projectName = null;
-            // Try to extract a path from the title (e.g. "~/Documents/source/foo - branch")
-            const pathMatch = title.match(/^(~?\/[^\s]+)/);
-            if (pathMatch) {
-                const segments = pathMatch[1].replace(/\/$/, '').split('/');
-                projectName = segments[segments.length - 1] || null;
-            }
-            // Fallback: default title format "file — project — Editor" or "project — Editor"
-            if (!projectName) {
-                const parts = title.split(' \u2014 ');
-                if (parts.length >= 3) {
-                    projectName = parts[parts.length - 2];
-                }
-                else if (parts.length === 2) {
-                    projectName = parts[0];
-                }
-                else {
-                    projectName = title;
-                }
-            }
-            const prev = editorCache.projectName;
-            editorCache = { projectName };
-            if (projectName && projectName !== prev) {
-                wsHandler.send({ type: 'editor:active', projectName });
-            }
-        });
-    }
-    // Poll every 500ms — single osascript call is fast
-    pollActiveEditor();
-    setInterval(pollActiveEditor, 500);
-    app.get('/api/active-editor', (_req, res) => {
-        res.json(editorCache);
-    });
     // Resolve a dropped file's full path using OS file index (Spotlight on macOS)
     app.post('/api/resolve-path', (req, res) => {
         const { name, size, lastModified } = req.body;
@@ -415,6 +350,9 @@ async function startServer(devMode, port) {
     const server = http.createServer(app);
     // WebSocket handler
     const wsHandler = new WsHandler(server, ptyManager, projectStore, { onIdle: () => shutdown() });
+    app.get('/api/active-editor', (_req, res) => {
+        res.json(wsHandler.getEditorState());
+    });
     // IPC listener
     const ipcServer = startIpcListener(socketPath(), ptyManager, projectStore, wsHandler);
     server.on('error', (err) => {

package/dist/server/port-monitor.js

@@ -9,10 +9,31 @@ export class PortMonitor {
     pollTimer = null;
     onChange;
     destroyed = false;
+    polling = false;
+    paused = true;
     constructor(onChange) {
         this.onChange = onChange;
+    }
+    resume() {
+        if (this.destroyed || !this.paused)
+            return;
+        this.paused = false;
         this.pollTimer = setInterval(() => this.poll(), 5000);
     }
+    pause() {
+        this.paused = true;
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = null;
+        }
+    }
+    getPortStatus() {
+        const result = {};
+        for (const [pid, ports] of this.alivePorts) {
+            result[pid] = [...ports];
+        }
+        return result;
+    }
     scanOutput(terminalId, projectId, data) {
         if (this.destroyed)
             return;
@@ -55,7 +76,7 @@ export class PortMonitor {
                 found = true;
             }
         }
-        if (found) {
+        if (found && !this.paused) {
             this.poll();
         }
     }
@@ -88,6 +109,17 @@ export class PortMonitor {
         this.alivePorts.clear();
     }
     async poll() {
+        if (this.destroyed || this.polling)
+            return;
+        this.polling = true;
+        try {
+            await this.doPoll();
+        }
+        finally {
+            this.polling = false;
+        }
+    }
+    async doPoll() {
         if (this.destroyed)
             return;
         // Build projectId → Set<port> from all terminals
@@ -128,7 +160,7 @@ export class PortMonitor {
                         resolve();
                     }
                 });
-                sock.setTimeout(2000, () => {
+                sock.setTimeout(500, () => {
                     sock.destroy();
                     if (fallback) {
                         tryConnect(fallback);