paneful 0.9.7 → 0.9.9

package/README.md

@@ -1,10 +1,10 @@
 # Paneful
 
-A terminal multiplexer that runs in your browser. Split panes, organize by project, drag and drop from Finder, sync with your editor — all from a single `npm install`.
+A fast, GPU-accelerated terminal multiplexer that runs in your browser — or as a native macOS app. Split panes, organize projects, sync with your editor, and detect AI agents and dev servers automatically. One `npm install`, no config.
 
 **Website:** [paneful.dev](https://paneful.dev)
 
-![Paneful](screenshot.png)
+![Paneful](screenshot.gif)
 
 ## Install
 
@@ -51,6 +51,10 @@ Requires:
 
 Save a workspace layout as a favourite — name, layout preset, and per-pane commands. Launch any favourite with a click to instantly recreate the setup.
 
+### GPU Rendering
+
+Terminals render via WebGL2 on the GPU by default, which is significantly faster for high-throughput output and multiple panes. Toggle it from the sidebar header (lightning bolt icon) or the command palette. Falls back to the DOM renderer automatically if WebGL2 is unavailable or context is lost. The setting persists across sessions.
+
 ### Terminal Search
 
 Press `Cmd+F` in any focused terminal to search its scrollback. Navigate matches with Enter / Shift+Enter or the up/down buttons. Press Escape to close.

package/dist/server/index.js

@@ -268,71 +268,168 @@ async function startServer(devMode, port) {
             res.json({ valid: false });
         }
     });
-    // Resolve a dropped file's full path using OS file index (Spotlight on macOS)
+    // Resolve a dropped file's full path via tiered search (stat → find → Spotlight)
+    const resolvePathCache = new Map();
+    const RESOLVE_CACHE_TTL = 30_000;
     app.post('/api/resolve-path', (req, res) => {
-        const { name, size, lastModified } = req.body;
+        const { name, size, lastModified, cwd: hintCwd } = req.body;
         if (!name) {
             res.status(400).json({ error: 'name required' });
             return;
         }
-        const findBest = (candidates) => {
-            if (candidates.length === 0)
-                return null;
-            if (candidates.length === 1)
-                return candidates[0];
-            // Score candidates: exact size + mtime match wins, then size-only, then most recent
-            let best = null;
-            for (const candidate of candidates) {
+        const cacheKey = `${name}:${size ?? ''}:${lastModified ?? ''}`;
+        const cached = resolvePathCache.get(cacheKey);
+        if (cached && Date.now() - cached.ts < RESOLVE_CACHE_TTL) {
+            res.json({ path: cached.path, isDirectory: cached.isDirectory });
+            return;
+        }
+        const respond = (resolved) => {
+            let isDirectory = false;
+            if (resolved) {
                 try {
-                    const stat = fs.statSync(candidate);
-                    let score = 0;
-                    if (size && stat.size === size)
-                        score += 10;
-                    if (lastModified && Math.abs(stat.mtimeMs - lastModified) < 2000)
-                        score += 5;
-                    // Exclude node_modules and hidden dirs to prefer "real" files
-                    if (!candidate.includes('node_modules') && !candidate.includes('/.'))
-                        score += 1;
-                    if (!best || score > best.score || (score === best.score && stat.mtimeMs > best.mtime)) {
-                        best = { path: candidate, score, mtime: stat.mtimeMs };
-                    }
+                    isDirectory = fs.statSync(resolved).isDirectory();
                 }
-                catch { /* skip inaccessible */ }
+                catch { }
             }
-            return best?.path ?? candidates[0];
+            resolvePathCache.set(cacheKey, { path: resolved, isDirectory, ts: Date.now() });
+            res.json({ path: resolved, isDirectory });
         };
-        const respond = (resolved) => {
-            if (!resolved) {
-                res.json({ path: null });
-                return;
-            }
+        const homeDir = os.homedir();
+        const quickDirs = [
+            homeDir,
+            path.join(homeDir, 'Desktop'),
+            path.join(homeDir, 'Downloads'),
+            path.join(homeDir, 'Documents'),
+            path.join(homeDir, 'Developer'),
+            path.join(homeDir, 'Projects'),
+            path.join(homeDir, 'Source'),
+            path.join(homeDir, 'src'),
+            path.join(homeDir, 'code'),
+            path.join(homeDir, 'repos'),
+            path.join(homeDir, 'workspace'),
+            '/tmp',
+        ];
+        for (const proj of projectStore.list()) {
+            const parent = path.dirname(proj.cwd);
+            if (!quickDirs.includes(parent))
+                quickDirs.push(parent);
+        }
+        for (const dir of quickDirs) {
+            const candidate = path.join(dir, name);
             try {
-                const isDirectory = fs.statSync(resolved).isDirectory();
-                res.json({ path: resolved, isDirectory });
-            }
-            catch {
-                res.json({ path: resolved, isDirectory: false });
-            }
-        };
-        if (process.platform === 'darwin') {
-            execFile('mdfind', [`kMDItemFSName == '${name.replace(/'/g, "\\'")}'`], (err, stdout) => {
-                if (err) {
-                    respond(null);
+                const stat = fs.statSync(candidate);
+                if (!size || stat.size === size) {
+                    respond(candidate);
                     return;
                 }
-                const candidates = stdout.trim().split('\n').filter(Boolean);
-                respond(findBest(candidates));
-            });
+            }
+            catch { }
+        }
+        const projectCwds = hintCwd ? [hintCwd] : [];
+        for (const proj of projectStore.list()) {
+            if (proj.cwd !== hintCwd)
+                projectCwds.push(proj.cwd);
+        }
+        const subDirs = ['', 'server', 'src', 'lib', 'app', 'web', 'web/src', 'web/src/lib',
+            'web/src/hooks', 'web/src/stores', 'web/src/components', 'test', 'tests', 'scripts'];
+        for (const cwd of projectCwds) {
+            for (const sub of subDirs) {
+                const candidate = sub ? path.join(cwd, sub, name) : path.join(cwd, name);
+                try {
+                    const stat = fs.statSync(candidate);
+                    if (!size || stat.size === size) {
+                        respond(candidate);
+                        return;
+                    }
+                }
+                catch { }
+            }
+        }
+        const searchDirs = projectCwds;
+        if (searchDirs.length > 0) {
+            let found = false;
+            let pending = searchDirs.length;
+            for (const dir of searchDirs) {
+                execFile('find', [
+                    dir, '-name', name, '-maxdepth', '10',
+                    '-not', '-path', '*/node_modules/*',
+                    '-not', '-path', '*/.*/*',
+                    '-print', '-quit',
+                ], { timeout: 1000 }, (err, stdout) => {
+                    pending--;
+                    if (found)
+                        return;
+                    const match = stdout?.trim();
+                    if (!err && match) {
+                        try {
+                            const stat = fs.statSync(match);
+                            if (!size || stat.size === size) {
+                                found = true;
+                                respond(match);
+                                return;
+                            }
+                        }
+                        catch { }
+                    }
+                    if (pending === 0 && !found)
+                        fallbackSearch();
+                });
+            }
         }
         else {
-            execFile('locate', ['-l', '20', '-b', `\\${name}`], (err, stdout) => {
-                if (err) {
-                    respond(null);
-                    return;
+            fallbackSearch();
+        }
+        function fallbackSearch() {
+            const findBest = (candidates) => {
+                if (candidates.length === 0)
+                    return null;
+                if (candidates.length === 1)
+                    return candidates[0];
+                const capped = candidates.slice(0, 20);
+                let best = null;
+                for (const candidate of capped) {
+                    try {
+                        const stat = fs.statSync(candidate);
+                        let score = 0;
+                        if (size && stat.size === size)
+                            score += 10;
+                        if (lastModified && Math.abs(stat.mtimeMs - lastModified) < 2000)
+                            score += 5;
+                        if (!candidate.includes('node_modules') && !candidate.includes('/.'))
+                            score += 1;
+                        if (!best || score > best.score || (score === best.score && stat.mtimeMs > best.mtime)) {
+                            best = { path: candidate, score, mtime: stat.mtimeMs };
+                        }
+                        if (best.score >= 16)
+                            break;
+                    }
+                    catch { }
                 }
-                const candidates = stdout.trim().split('\n').filter(Boolean);
-                respond(findBest(candidates));
-            });
+                return best?.path ?? candidates[0];
+            };
+            if (process.platform === 'darwin') {
+                execFile('mdfind', [
+                    '-onlyin', homeDir,
+                    `kMDItemFSName == '${name.replace(/'/g, "\\'")}'`,
+                ], { timeout: 3000 }, (err, stdout) => {
+                    if (err) {
+                        respond(null);
+                        return;
+                    }
+                    const candidates = stdout.trim().split('\n').filter(Boolean);
+                    respond(findBest(candidates));
+                });
+            }
+            else {
+                execFile('locate', ['-l', '20', '-b', `\\${name}`], { timeout: 3000 }, (err, stdout) => {
+                    if (err) {
+                        respond(null);
+                        return;
+                    }
+                    const candidates = stdout.trim().split('\n').filter(Boolean);
+                    respond(findBest(candidates));
+                });
+            }
         }
     });
     // Serve static frontend (production only)

package/dist/server/install-app.js

@@ -158,6 +158,61 @@ func readLockfile() -> (pid: pid_t, port: Int)? {
     return (pid, port)
 }
 
+class DropWebView: WKWebView {
+    override init(frame: CGRect, configuration: WKWebViewConfiguration) {
+        super.init(frame: frame, configuration: configuration)
+        registerForDraggedTypes([
+            .fileURL,
+            .URL,
+            .string,
+            NSPasteboard.PasteboardType("public.url"),
+            NSPasteboard.PasteboardType("com.apple.pasteboard.promised-file-url"),
+            NSPasteboard.PasteboardType("Apple files promise pasteboard type"),
+        ])
+    }
+    required init?(coder: NSCoder) { super.init(coder: coder) }
+
+    private func extractPaths(from pasteboard: NSPasteboard) -> [String] {
+        var paths: [String] = []
+        guard let items = pasteboard.pasteboardItems else { return paths }
+        for item in items {
+            // Try public.url first (file:// URI from VS Code)
+            if let urlStr = item.string(forType: NSPasteboard.PasteboardType("public.url")),
+               urlStr.hasPrefix("file://"),
+               let url = URL(string: urlStr) {
+                paths.append(url.path)
+                continue
+            }
+            // Fallback: plain text absolute path
+            if let text = item.string(forType: .string), text.hasPrefix("/") {
+                paths.append(text.trimmingCharacters(in: .whitespacesAndNewlines))
+            }
+        }
+        return paths
+    }
+
+    override func draggingEntered(_ sender: NSDraggingInfo) -> NSDragOperation {
+        return extractPaths(from: sender.draggingPasteboard).isEmpty
+            ? super.draggingEntered(sender) : .copy
+    }
+
+    override func performDragOperation(_ sender: NSDraggingInfo) -> Bool {
+        let paths = extractPaths(from: sender.draggingPasteboard)
+        if !paths.isEmpty {
+            if let json = try? JSONSerialization.data(withJSONObject: paths),
+               let jsonStr = String(data: json, encoding: .utf8) {
+                // Convert AppKit coordinates (origin bottom-left) to web coordinates (origin top-left)
+                let loc = sender.draggingLocation
+                let x = loc.x
+                let y = bounds.height - loc.y
+                evaluateJavaScript("window.__panefulHandleDrop && window.__panefulHandleDrop(\\(jsonStr), \\(x), \\(y))") { _, _ in }
+            }
+            return true
+        }
+        return super.performDragOperation(sender)
+    }
+}
+
 class AppDelegate: NSObject, NSApplicationDelegate {
     var window: NSWindow!
     var webView: WKWebView!
@@ -244,7 +299,7 @@ class AppDelegate: NSObject, NSApplicationDelegate {
         let config = WKWebViewConfiguration()
         config.preferences.setValue(true, forKey: "developerExtrasEnabled")
 
-        webView = WKWebView(frame: .zero, configuration: config)
+        webView = DropWebView(frame: .zero, configuration: config)
         webView.load(URLRequest(url: URL(string: "http://localhost:\\(self.port)")!))
 
         window = NSWindow(

package/dist/server/pty-manager.js

@@ -1,4 +1,5 @@
 import * as pty from 'node-pty';
+import { execSync } from 'node:child_process';
 import os from 'node:os';
 export class PtyManager {
     sessions = new Map();
@@ -78,7 +79,9 @@ export class PtyManager {
         for (const [terminalId, managed] of this.sessions) {
             try {
                 const proc = managed.process.process;
-                if (proc === 'claude' || proc.startsWith('codex')) {
+                const isAgent = proc === 'claude' || proc === 'aider' || proc.startsWith('codex')
+                    || (RUNTIME_PROCESSES.has(proc) && this.checkChildCmdline(managed.process.pid));
+                if (isAgent) {
                     const list = result.get(managed.projectId);
                     if (list)
                         list.push(terminalId);
@@ -92,4 +95,25 @@ export class PtyManager {
         }
         return result;
     }
+    /** Check if any child process of the shell is a known AI agent. */
+    checkChildCmdline(shellPid) {
+        try {
+            const childPids = execSync(`pgrep -P ${shellPid}`, { encoding: 'utf8', timeout: 1000 })
+                .trim().split('\n').filter(Boolean);
+            if (childPids.length === 0)
+                return false;
+            for (const pid of childPids) {
+                const cmdline = execSync(`ps -o args= -p ${pid}`, { encoding: 'utf8', timeout: 1000 }).trim();
+                if (AGENT_CMD_PATTERN.test(cmdline))
+                    return true;
+            }
+            return false;
+        }
+        catch {
+            return false;
+        }
+    }
 }
+const RUNTIME_PROCESSES = new Set(['node', 'python', 'python3']);
+// Match agent binary names at the end of a path or as a standalone token
+const AGENT_CMD_PATTERN = /(?:^|\/)(codex|claude|aider)(?:\s|$)/;

package/dist/server/ws-handler.js

@@ -152,6 +152,15 @@ export class WsHandler {
                 this.projectStore.remove(msg.projectId);
                 break;
             }
+            case 'open:url': {
+                const url = msg.url;
+                if (/^https?:\/\//i.test(url)) {
+                    import('open').then(({ default: open }) => {
+                        open(url).catch(() => { });
+                    });
+                }
+                break;
+            }
         }
     }
     getEditorState() {