paneful 0.9.16 → 0.9.18

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/settings-store.js

@@ -6,6 +6,8 @@ const DEFAULTS = {
         theme: 'system',
         sidebarWidth: 224,
         editorSyncEnabled: true,
+        sourceControlOpen: false,
+        sourceControlWidth: 360,
     },
     activeProjectId: null,
 };
@@ -24,6 +26,8 @@ export class SettingsStore {
                         theme: raw.ui?.theme ?? DEFAULTS.ui.theme,
                         sidebarWidth: raw.ui?.sidebarWidth ?? DEFAULTS.ui.sidebarWidth,
                         editorSyncEnabled: raw.ui?.editorSyncEnabled ?? DEFAULTS.ui.editorSyncEnabled,
+                        sourceControlOpen: raw.ui?.sourceControlOpen ?? DEFAULTS.ui.sourceControlOpen,
+                        sourceControlWidth: raw.ui?.sourceControlWidth ?? DEFAULTS.ui.sourceControlWidth,
                     },
                     activeProjectId: raw.activeProjectId ?? DEFAULTS.activeProjectId,
                 };

package/dist/server/ws-handler.js

@@ -4,6 +4,7 @@ import { newProject } from './project-store.js';
 import { PortMonitor } from './port-monitor.js';
 import { ClaudeMonitor } from './claude-monitor.js';
 import { GitMonitor } from './git-monitor.js';
+import { GitSourceControl, } from './git-source-control.js';
 import { EditorMonitor } from './editor-monitor.js';
 import { InboxMonitor } from './inbox-monitor.js';
 export class WsHandler {
@@ -14,6 +15,7 @@ export class WsHandler {
     portMonitor;
     claudeMonitor;
     gitMonitor;
+    sourceControl;
     editorMonitor;
     inboxMonitor;
     idleTimer = null;
@@ -22,7 +24,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) => {
@@ -31,6 +33,9 @@ export class WsHandler {
         this.gitMonitor = new GitMonitor(projectStore, (branches) => {
             this.send({ type: 'git:branch', branches });
         });
+        this.sourceControl = new GitSourceControl(projectStore, (projectId, status) => {
+            this.send({ type: 'sc:status', projectId, status });
+        });
         this.editorMonitor = new EditorMonitor((projectName) => {
             this.send({ type: 'editor:active', projectName });
         }, (needsAccessibility) => {
@@ -135,7 +140,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 +149,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 +161,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 });
@@ -175,6 +177,22 @@ export class WsHandler {
                 }
                 break;
             }
+            case 'open:file': {
+                const project = this.projectStore.list().find((p) => p.id === msg.projectId);
+                if (!project)
+                    break;
+                // Resolve and guard against path traversal
+                import('node:path').then((path) => {
+                    const abs = path.resolve(project.cwd, msg.path);
+                    const projectRoot = path.resolve(project.cwd);
+                    if (abs !== projectRoot && !abs.startsWith(projectRoot + path.sep))
+                        return;
+                    import('open').then(({ default: open }) => {
+                        open(abs).catch(() => { });
+                    });
+                });
+                break;
+            }
             case 'editor:sync': {
                 if (msg.enabled) {
                     this.editorMonitor.resume();
@@ -193,6 +211,97 @@ export class WsHandler {
                 }
                 break;
             }
+            case 'sc:set-active': {
+                this.sourceControl.setActive(msg.projectId);
+                break;
+            }
+            case 'sc:diff:request': {
+                const { projectId, file, kind } = msg;
+                this.sourceControl.requestDiff(projectId, file, kind).then((result) => {
+                    if (!result)
+                        return;
+                    this.send({
+                        type: 'sc:diff',
+                        projectId,
+                        file,
+                        kind,
+                        diff: result.diff,
+                        binary: result.binary,
+                        truncated: result.truncated,
+                    });
+                });
+                break;
+            }
+            case 'sc:stage': {
+                const { projectId, files } = msg;
+                this.sourceControl.stage(projectId, files).then((res) => {
+                    this.send({ type: 'sc:action:result', projectId, action: 'stage', ok: res.ok, error: res.error });
+                });
+                break;
+            }
+            case 'sc:unstage': {
+                const { projectId, files } = msg;
+                this.sourceControl.unstage(projectId, files).then((res) => {
+                    this.send({ type: 'sc:action:result', projectId, action: 'unstage', ok: res.ok, error: res.error });
+                });
+                break;
+            }
+            case 'sc:discard': {
+                const { projectId, trackedFiles, untrackedFiles } = msg;
+                this.sourceControl.discard(projectId, trackedFiles, untrackedFiles).then((res) => {
+                    this.send({ type: 'sc:action:result', projectId, action: 'discard', ok: res.ok, error: res.error });
+                });
+                break;
+            }
+            case 'sc:commit': {
+                const { projectId, message } = msg;
+                this.sourceControl.commit(projectId, message).then((res) => {
+                    this.send({ type: 'sc:action:result', projectId, action: 'commit', ok: res.ok, error: res.error });
+                });
+                break;
+            }
+            case 'sc:push': {
+                const { projectId } = msg;
+                this.sourceControl.push(projectId).then((res) => {
+                    this.send({ type: 'sc:action:result', projectId, action: 'push', ok: res.ok, error: res.error });
+                });
+                break;
+            }
+            case 'sc:pull': {
+                const { projectId } = msg;
+                this.sourceControl.pull(projectId).then((res) => {
+                    this.send({ type: 'sc:action:result', projectId, action: 'pull', ok: res.ok, error: res.error });
+                });
+                break;
+            }
+            case 'sc:stash:create': {
+                const { projectId, message } = msg;
+                this.sourceControl.stashCreate(projectId, message).then((res) => {
+                    this.send({ type: 'sc:action:result', projectId, action: 'stash:create', ok: res.ok, error: res.error });
+                });
+                break;
+            }
+            case 'sc:stash:pop': {
+                const { projectId, index } = msg;
+                this.sourceControl.stashPop(projectId, index).then((res) => {
+                    this.send({ type: 'sc:action:result', projectId, action: 'stash:pop', ok: res.ok, error: res.error });
+                });
+                break;
+            }
+            case 'sc:stash:apply': {
+                const { projectId, index } = msg;
+                this.sourceControl.stashApply(projectId, index).then((res) => {
+                    this.send({ type: 'sc:action:result', projectId, action: 'stash:apply', ok: res.ok, error: res.error });
+                });
+                break;
+            }
+            case 'sc:stash:drop': {
+                const { projectId, index } = msg;
+                this.sourceControl.stashDrop(projectId, index).then((res) => {
+                    this.send({ type: 'sc:action:result', projectId, action: 'stash:drop', ok: res.ok, error: res.error });
+                });
+                break;
+            }
         }
     }
     getEditorState() {
@@ -202,6 +311,7 @@ export class WsHandler {
         this.portMonitor.resume();
         this.claudeMonitor.resume();
         this.gitMonitor.resume();
+        this.sourceControl.resume();
         // Editor monitor is started on-demand via editor:sync message
         this.inboxMonitor.resume();
     }
@@ -209,6 +319,7 @@ export class WsHandler {
         this.portMonitor.pause();
         this.claudeMonitor.pause();
         this.gitMonitor.pause();
+        this.sourceControl.pause();
         this.editorMonitor.pause();
         this.inboxMonitor.pause();
     }
@@ -216,6 +327,7 @@ export class WsHandler {
         this.portMonitor.destroy();
         this.claudeMonitor.destroy();
         this.gitMonitor.destroy();
+        this.sourceControl.destroy();
         this.editorMonitor.destroy();
         this.inboxMonitor.destroy();
     }
@@ -223,10 +335,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 });
             });