paneful 0.9.16 → 0.9.17

package/README.md

@@ -155,6 +155,9 @@ npm run build
 
 # Run locally
 npm start
+
+# Install the local build globally (replaces any npm-published version)
+npm -g uninstall paneful; npm run build; npm install -g .; paneful --install-app
 ```
 
 Vite dev server proxies `/ws` and `/api` to `localhost:3000`. Open `http://localhost:5173` or use Chrome in app mode for full keyboard shortcut support:

package/dist/server/port-monitor.js

@@ -1,110 +1,31 @@
-import net from "node:net";
-// Strip ANSI escape codes from PTY output
-const ANSI_RE = /\x1b\[[0-9;]*[a-zA-Z]|\x1b\].*?(?:\x07|\x1b\\)|\x1b[()][0-9A-B]/g;
-// Match dev-server URLs like http://localhost:3000, http://127.0.0.1:8080, etc.
-const PORT_RE = /https?:\/\/(?:localhost|127\.0\.0\.1|0\.0\.0\.0|\[?::1?\]?):(\d{1,5})/g;
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileP = promisify(execFile);
 export class PortMonitor {
-    terminals = new Map();
-    alivePorts = new Map(); // projectId → alive ports
-    pollTimer = null;
-    immediatePollTimer = null;
+    ptyManager;
     onChange;
+    pollTimer = null;
+    prevPorts = {};
     destroyed = false;
     polling = false;
-    paused = true;
-    constructor(onChange) {
+    constructor(ptyManager, onChange) {
+        this.ptyManager = ptyManager;
         this.onChange = onChange;
     }
     resume() {
-        if (this.destroyed || !this.paused)
+        if (this.destroyed || this.pollTimer)
             return;
-        this.paused = false;
-        this.pollTimer = setInterval(() => this.poll(), 10_000);
+        this.pollTimer = setInterval(() => this.poll(), 3_000);
+        this.poll();
     }
     pause() {
-        this.paused = true;
         if (this.pollTimer) {
             clearInterval(this.pollTimer);
             this.pollTimer = null;
         }
-        if (this.immediatePollTimer) {
-            clearTimeout(this.immediatePollTimer);
-            this.immediatePollTimer = null;
-        }
     }
     getPortStatus() {
-        const result = {};
-        for (const [pid, ports] of this.alivePorts) {
-            result[pid] = [...ports];
-        }
-        return result;
-    }
-    scanOutput(terminalId, projectId, data) {
-        if (this.destroyed)
-            return;
-        let info = this.terminals.get(terminalId);
-        if (!info) {
-            info = { projectId, ports: new Set(), lineBuffer: "" };
-            this.terminals.set(terminalId, info);
-        }
-        // Already found ports for this terminal — skip scanning.
-        // If the port goes down, the poll scrubs it from info.ports,
-        // so scanning resumes automatically on restart.
-        if (info.ports.size > 0)
-            return;
-        // Strip ANSI codes from just the new chunk, then append to line buffer
-        const clean = data.replace(ANSI_RE, "");
-        const combined = info.lineBuffer + clean;
-        const lines = combined.split(/\r?\n/);
-        // Keep last incomplete line in buffer, capped to prevent unbounded growth
-        const tail = lines.pop() ?? "";
-        info.lineBuffer = tail.length > 512 ? tail.slice(-512) : tail;
-        let found = false;
-        for (const line of lines) {
-            PORT_RE.lastIndex = 0;
-            let match;
-            while ((match = PORT_RE.exec(line)) !== null) {
-                const port = parseInt(match[1], 10);
-                if (port > 0 && port <= 65535 && !info.ports.has(port)) {
-                    info.ports.add(port);
-                    found = true;
-                }
-            }
-        }
-        // Also scan the buffer (for single-line output without trailing newline)
-        PORT_RE.lastIndex = 0;
-        let match;
-        while ((match = PORT_RE.exec(info.lineBuffer)) !== null) {
-            const port = parseInt(match[1], 10);
-            if (port > 0 && port <= 65535 && !info.ports.has(port)) {
-                info.ports.add(port);
-                found = true;
-            }
-        }
-        if (found && !this.paused) {
-            if (this.immediatePollTimer)
-                clearTimeout(this.immediatePollTimer);
-            this.immediatePollTimer = setTimeout(() => this.poll(), 500);
-        }
-    }
-    removeTerminal(terminalId) {
-        const info = this.terminals.get(terminalId);
-        if (!info)
-            return;
-        this.terminals.delete(terminalId);
-        this.rebuildAndNotify();
-    }
-    removeProject(projectId) {
-        for (const [tid, info] of this.terminals) {
-            if (info.projectId === projectId) {
-                this.terminals.delete(tid);
-            }
-        }
-        const hadPorts = this.alivePorts.has(projectId);
-        this.alivePorts.delete(projectId);
-        if (hadPorts) {
-            this.notify();
-        }
+        return { ...this.prevPorts };
     }
     destroy() {
         this.destroyed = true;
@@ -112,12 +33,6 @@ export class PortMonitor {
             clearInterval(this.pollTimer);
             this.pollTimer = null;
         }
-        if (this.immediatePollTimer) {
-            clearTimeout(this.immediatePollTimer);
-            this.immediatePollTimer = null;
-        }
-        this.terminals.clear();
-        this.alivePorts.clear();
     }
     async poll() {
         if (this.destroyed || this.polling)
@@ -126,116 +41,141 @@ export class PortMonitor {
         try {
             await this.doPoll();
         }
+        catch {
+            // Swallow poll errors so a transient ps/lsof hiccup doesn't kill the loop
+        }
         finally {
             this.polling = false;
         }
     }
     async doPoll() {
-        if (this.destroyed)
+        const ptys = this.ptyManager.getProjectPids();
+        if (ptys.length === 0) {
+            this.updateAndNotify({});
             return;
-        // Build projectId → Set<port> from all terminals
-        const projectPorts = new Map();
-        for (const info of this.terminals.values()) {
-            if (info.ports.size === 0)
-                continue;
-            let set = projectPorts.get(info.projectId);
-            if (!set) {
-                set = new Set();
-                projectPorts.set(info.projectId, set);
-            }
-            for (const p of info.ports)
-                set.add(p);
-        }
-        // TCP-probe each unique port
-        const uniquePorts = new Set();
-        for (const set of projectPorts.values()) {
-            for (const p of set)
-                uniquePorts.add(p);
         }
-        const probeResults = new Map();
-        await Promise.all([...uniquePorts].map((port) => new Promise((resolve) => {
-            // Try IPv4 first, fall back to IPv6 (::1).
-            // Many dev servers (Angular/Vite) bind to ::1 on macOS.
-            const tryConnect = (host, fallback) => {
-                const sock = net.createConnection({ port, host }, () => {
-                    probeResults.set(port, true);
-                    sock.destroy();
-                    resolve();
-                });
-                sock.on("error", () => {
-                    if (fallback) {
-                        tryConnect(fallback);
-                    }
-                    else {
-                        probeResults.set(port, false);
-                        resolve();
-                    }
-                });
-                sock.setTimeout(500, () => {
-                    sock.destroy();
-                    if (fallback) {
-                        tryConnect(fallback);
-                    }
-                    else {
-                        probeResults.set(port, false);
-                        resolve();
-                    }
-                });
-            };
-            tryConnect("127.0.0.1", "::1");
-        })));
+        const [tree, listeners] = await Promise.all([
+            this.getProcessTree(),
+            this.getListeners(),
+        ]);
         if (this.destroyed)
             return;
-        // Scrub dead ports from terminal tracking so stale entries
-        // don't cause overlap when another project reuses the same port
-        for (const info of this.terminals.values()) {
-            for (const p of info.ports) {
-                if (!probeResults.get(p)) {
-                    info.ports.delete(p);
+        const result = {};
+        for (const { pid, projectId } of ptys) {
+            const desc = this.descendants(pid, tree);
+            for (const { pid: listenerPid, port } of listeners) {
+                if (desc.has(listenerPid)) {
+                    if (!result[projectId])
+                        result[projectId] = new Set();
+                    result[projectId].add(port);
                 }
             }
         }
-        // Build new alive state
-        const newAlive = new Map();
-        for (const [projectId, ports] of projectPorts) {
-            const alive = new Set();
-            for (const p of ports) {
-                if (probeResults.get(p))
-                    alive.add(p);
-            }
-            if (alive.size > 0) {
-                newAlive.set(projectId, alive);
-            }
+        const final = {};
+        for (const [projectId, set] of Object.entries(result)) {
+            final[projectId] = [...set].sort((a, b) => a - b);
         }
-        // Check if changed
-        if (this.setsEqual(newAlive))
-            return;
-        this.alivePorts = newAlive;
-        this.notify();
+        this.updateAndNotify(final);
     }
-    rebuildAndNotify() {
-        // After terminal removal, re-poll immediately to update state
-        this.poll();
+    updateAndNotify(next) {
+        if (this.portsEqual(next, this.prevPorts))
+            return;
+        this.prevPorts = next;
+        this.onChange(next);
     }
-    setsEqual(newAlive) {
-        if (newAlive.size !== this.alivePorts.size)
+    portsEqual(a, b) {
+        const aKeys = Object.keys(a);
+        const bKeys = Object.keys(b);
+        if (aKeys.length !== bKeys.length)
             return false;
-        for (const [pid, ports] of newAlive) {
-            const existing = this.alivePorts.get(pid);
-            if (!existing || existing.size !== ports.size)
+        for (const key of aKeys) {
+            const av = a[key];
+            const bv = b[key];
+            if (!bv || av.length !== bv.length)
                 return false;
-            for (const p of ports) {
-                if (!existing.has(p))
+            for (let i = 0; i < av.length; i++) {
+                if (av[i] !== bv[i])
                     return false;
             }
         }
         return true;
     }
-    notify() {
-        const result = {};
-        for (const [pid, ports] of this.alivePorts) {
-            result[pid] = [...ports];
+    async getProcessTree() {
+        const { stdout } = await execFileP('ps', ['-A', '-o', 'pid=,ppid=']);
+        const children = new Map();
+        for (const line of stdout.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            const match = trimmed.match(/^(\d+)\s+(\d+)$/);
+            if (!match)
+                continue;
+            const pid = parseInt(match[1], 10);
+            const ppid = parseInt(match[2], 10);
+            const list = children.get(ppid);
+            if (list)
+                list.push(pid);
+            else
+                children.set(ppid, [pid]);
+        }
+        return children;
+    }
+    descendants(root, tree) {
+        const result = new Set([root]);
+        const stack = [root];
+        while (stack.length > 0) {
+            const pid = stack.pop();
+            const kids = tree.get(pid);
+            if (!kids)
+                continue;
+            for (const kid of kids) {
+                if (!result.has(kid)) {
+                    result.add(kid);
+                    stack.push(kid);
+                }
+            }
+        }
+        return result;
+    }
+    async getListeners() {
+        // lsof exits non-zero when there are no matches — read stdout from the error anyway
+        let stdout = '';
+        try {
+            const result = await execFileP('lsof', [
+                '-nP',
+                '-iTCP',
+                '-sTCP:LISTEN',
+                '-F',
+                'pn',
+            ]);
+            stdout = result.stdout;
+        }
+        catch (e) {
+            const err = e;
+            stdout = err.stdout ?? '';
+        }
+        const out = [];
+        let currentPid = null;
+        for (const line of stdout.split('\n')) {
+            if (line.length === 0)
+                continue;
+            const tag = line[0];
+            const value = line.slice(1);
+            if (tag === 'p') {
+                const pid = parseInt(value, 10);
+                currentPid = Number.isFinite(pid) ? pid : null;
+            }
+            else if (tag === 'n' && currentPid !== null) {
+                // Address forms: *:3000, 127.0.0.1:3000, [::1]:3000
+                const portMatch = value.match(/:(\d+)$/);
+                if (!portMatch)
+                    continue;
+                const port = parseInt(portMatch[1], 10);
+                if (port > 0 && port <= 65535) {
+                    out.push({ pid: currentPid, port });
+                }
+            }
         }
-        this.onChange(result);
+        return out;
     }
 }

package/dist/server/pty-manager.js

@@ -73,6 +73,19 @@ export class PtyManager {
     terminalExists(terminalId) {
         return this.sessions.has(terminalId);
     }
+    /** Returns {pid, projectId} for every active PTY. Used to attribute listening sockets to projects. */
+    getProjectPids() {
+        const result = [];
+        for (const managed of this.sessions.values()) {
+            try {
+                result.push({ pid: managed.process.pid, projectId: managed.projectId });
+            }
+            catch {
+                // PTY may have been killed
+            }
+        }
+        return result;
+    }
     /** Returns projectId → terminalIds[] for terminals running an AI coding agent. */
     getAgentProjects() {
         const result = new Map();

package/dist/server/ws-handler.js

@@ -22,7 +22,7 @@ export class WsHandler {
         this.ptyManager = ptyManager;
         this.projectStore = projectStore;
         this.onIdle = options?.onIdle;
-        this.portMonitor = new PortMonitor((ports) => {
+        this.portMonitor = new PortMonitor(ptyManager, (ports) => {
             this.send({ type: 'port:status', ports });
         });
         this.claudeMonitor = new ClaudeMonitor(ptyManager, (statuses) => {
@@ -135,7 +135,6 @@ export class WsHandler {
                 this.ptyManager.resize(msg.terminalId, msg.cols, msg.rows);
                 break;
             case 'pty:kill': {
-                this.portMonitor.removeTerminal(msg.terminalId);
                 this.claudeMonitor.removeTerminal(msg.terminalId);
                 const projectId = this.ptyManager.kill(msg.terminalId);
                 if (projectId) {
@@ -145,7 +144,6 @@ export class WsHandler {
                 break;
             }
             case 'project:kill': {
-                this.portMonitor.removeProject(msg.projectId);
                 const killed = this.ptyManager.killProject(msg.projectId);
                 for (const tid of killed) {
                     this.send({ type: 'pty:exit', terminalId: tid, exitCode: 0 });
@@ -158,7 +156,6 @@ export class WsHandler {
                 break;
             }
             case 'project:remove': {
-                this.portMonitor.removeProject(msg.projectId);
                 const killed = this.ptyManager.killProject(msg.projectId);
                 for (const tid of killed) {
                     this.send({ type: 'pty:exit', terminalId: tid, exitCode: 0 });
@@ -223,10 +220,8 @@ export class WsHandler {
         try {
             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 });
             });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "paneful",
-  "version": "0.9.16",
+  "version": "0.9.17",
   "description": "A fast, GPU-accelerated terminal manager with split panes, project organization, editor sync, and AI agent detection. Native macOS app or browser.",
   "type": "module",
   "bin": {