painapple-code 1.0.0__py3-none-any.whl

painapple_code/static/js/orphan-terminals.js

@@ -0,0 +1,373 @@
+import S from './strings.js';
+/**
+ * Orphaned Terminals Manager
+ *
+ * Handles detection, display, and reconnection of orphaned terminal sessions
+ * (PTY processes running on server without active WebSocket connections)
+ */
+
+import { CONFIG, debug } from './config.js';
+import { TerminalWidget } from './widget-system/init.js';
+import { escapeHtml, appConfirm } from './utils.js';
+import { showToast } from './context-menu.js';
+
+class OrphanTerminalsManager {
+    constructor() {
+        this.btn = null;
+        this.badge = null;
+        this.dropdown = null;
+        this.list = null;
+        this.bulkActions = null;
+        this.orphans = [];
+        this.isOpen = false;
+    }
+
+    /**
+     * Initialize the orphan terminals UI
+     */
+    init() {
+        this.btn = document.getElementById('orphan-terminals-btn');
+        this.badge = document.getElementById('orphan-badge');
+        this.dropdown = document.getElementById('orphan-dropdown');
+        this.list = document.getElementById('orphan-list');
+        this.bulkActions = document.getElementById('orphan-bulk-actions');
+        const refreshBtn = document.getElementById('orphan-refresh-btn');
+        const tabAllBtn = document.getElementById('orphan-tab-all-btn');
+        const killAllBtn = document.getElementById('orphan-kill-all-btn');
+
+        if (!this.btn || !this.dropdown) {
+            console.warn('Orphan terminals UI elements not found');
+            return;
+        }
+
+        // Toggle dropdown on button click
+        this.btn.addEventListener('click', (e) => {
+            // Don't toggle if clicking inside dropdown
+            if (e.target.closest('.orphan-terminals-dropdown')) {
+                return;
+            }
+            this.toggle();
+        });
+
+        // Refresh button
+        if (refreshBtn) {
+            refreshBtn.addEventListener('click', (e) => {
+                e.stopPropagation();
+                this.refresh();
+            });
+        }
+
+        // Tab All button
+        if (tabAllBtn) {
+            tabAllBtn.addEventListener('click', (e) => {
+                e.stopPropagation();
+                this.tabAll();
+            });
+        }
+
+        // Kill All button
+        if (killAllBtn) {
+            killAllBtn.addEventListener('click', (e) => {
+                e.stopPropagation();
+                this.killAll();
+            });
+        }
+
+        // Close on outside click
+        document.addEventListener('click', (e) => {
+            if (this.isOpen && !this.btn.contains(e.target)) {
+                this.close();
+            }
+        });
+
+        // Close on Escape
+        document.addEventListener('keydown', (e) => {
+            if (e.key === 'Escape' && this.isOpen) {
+                this.close();
+            }
+        });
+
+        // Initial check
+        this.refresh();
+
+        // Periodic refresh every 30 seconds
+        setInterval(() => this.refreshBadge(), 30000);
+    }
+
+    /**
+     * Toggle dropdown visibility
+     */
+    toggle() {
+        if (this.isOpen) {
+            this.close();
+        } else {
+            this.open();
+        }
+    }
+
+    /**
+     * Open the dropdown
+     */
+    open() {
+        this.isOpen = true;
+        this.dropdown.classList.add('visible');
+        this.refresh();
+    }
+
+    /**
+     * Close the dropdown
+     */
+    close() {
+        this.isOpen = false;
+        this.dropdown.classList.remove('visible');
+    }
+
+    /**
+     * Refresh the orphaned terminals list
+     */
+    async refresh() {
+        try {
+            const orphans = await this.fetchOrphans();
+            this.orphans = orphans;
+            this.updateBadge();
+            this.renderList();
+        } catch (err) {
+            console.error('Failed to fetch orphaned terminals:', err);
+            this.list.innerHTML = `<div class="orphan-dropdown-empty">${S.orphan_terminals.failed_load}</div>`;
+        }
+    }
+
+    /**
+     * Just refresh the badge count (lightweight)
+     */
+    async refreshBadge() {
+        try {
+            const orphans = await this.fetchOrphans();
+            this.orphans = orphans;
+            this.updateBadge();
+        } catch (err) {
+            // Silently fail for background refresh
+        }
+    }
+
+    /**
+     * Fetch orphaned terminals from server
+     * @returns {Promise<Array>} List of orphaned terminal sessions
+     */
+    async fetchOrphans() {
+        const response = await fetch(`${CONFIG.API_BASE}/api/terminals`);
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+        }
+        const data = await response.json();
+        const serverTerminals = data.terminals || [];
+
+        // Get currently connected terminal session IDs
+        const connectedIds = this.getConnectedSessionIds();
+
+        // Filter to only orphaned ones (not connected by any tab)
+        return serverTerminals.filter(t => !connectedIds.has(t.session));
+    }
+
+    /**
+     * Get session IDs of all currently connected terminals
+     * @returns {Set<string>}
+     */
+    getConnectedSessionIds() {
+        const ids = new Set();
+
+        // Get tab terminal session IDs
+        const tabIds = TerminalWidget.getTabIds();
+        for (const tabId of tabIds) {
+            const state = TerminalWidget.getTabState(tabId);
+            if (state?.sessionId) {
+                ids.add(state.sessionId);
+            }
+        }
+
+        // Get floating terminal session ID if exists
+        // Note: Floating terminal uses a different state access pattern
+        // We'll check via the floating state export if available
+
+        return ids;
+    }
+
+    /**
+     * Update the badge count and bulk actions visibility
+     */
+    updateBadge() {
+        const count = this.orphans.filter(t => t.alive).length;
+        if (this.badge) {
+            this.badge.textContent = count > 0 ? count : '';
+            this.badge.dataset.count = count;
+        }
+        // Show bulk actions only when there are orphans
+        if (this.bulkActions) {
+            this.bulkActions.style.display = this.orphans.length > 0 ? 'flex' : 'none';
+        }
+    }
+
+    /**
+     * Render the orphaned terminals list
+     */
+    renderList() {
+        if (!this.list) return;
+
+        if (this.orphans.length === 0) {
+            this.list.innerHTML = `<div class="orphan-dropdown-empty">${S.orphan_terminals.empty}</div>`;
+            return;
+        }
+
+        this.list.innerHTML = this.orphans.map(term => `
+            <div class="orphan-terminal-item" data-session="${escapeHtml(term.session)}">
+                <div class="orphan-terminal-info">
+                    <span class="orphan-terminal-pid">PID ${term.pid || '?'}</span>
+                    <span class="orphan-terminal-status ${term.alive ? '' : 'dead'}">
+                        ${term.alive ? 'running' : 'dead'}
+                    </span>
+                </div>
+                <div class="orphan-terminal-cwd" data-tooltip="${escapeHtml(term.cwd || '')}">${escapeHtml(term.cwd || 'unknown')}</div>
+                <div class="orphan-terminal-actions">
+                    ${term.alive ? `
+                        <button class="attach-btn" data-action="tab">Tab</button>
+                        <button class="float-btn" data-action="float">Float</button>
+                    ` : ''}
+                    <button class="kill-btn" data-action="kill">Kill</button>
+                </div>
+            </div>
+        `).join('');
+
+        // Add click handlers
+        this.list.querySelectorAll('.orphan-terminal-item').forEach(item => {
+            item.querySelectorAll('button').forEach(btn => {
+                btn.addEventListener('click', (e) => {
+                    e.stopPropagation();
+                    const action = btn.dataset.action;
+                    const session = item.dataset.session;
+                    if (action === 'tab') {
+                        this.attachToTab(session);
+                    } else if (action === 'float') {
+                        this.attachToFloat(session);
+                    } else if (action === 'kill') {
+                        this.killTerminal(session);
+                    }
+                });
+            });
+        });
+    }
+
+    /**
+     * Attach to an orphaned terminal by creating a new tab with its session ID
+     * @param {string} sessionId - The terminal session ID to attach to
+     */
+    attachToTab(sessionId) {
+        const term = this.orphans.find(t => t.session === sessionId);
+        if (!term) return;
+
+        // Create a new terminal tab with this session ID
+        if (window.app?.tabCtrl) {
+            const tabId = window.app.tabCtrl.openTerminalWidgetTab({
+                terminalSessionId: sessionId,
+                cwd: term.cwd
+            });
+            debug.log(`Attached to orphaned terminal ${sessionId} as tab ${tabId}`);
+        }
+
+        this.close();
+        this.refresh();
+    }
+
+    /**
+     * Attach to an orphaned terminal in the floating panel
+     * @param {string} sessionId - The terminal session ID to attach to
+     */
+    attachToFloat(sessionId) {
+        const term = this.orphans.find(t => t.session === sessionId);
+        if (!term) return;
+
+        // Attach to floating terminal with this session ID
+        TerminalWidget.attachToSession(sessionId, term.cwd);
+        debug.log(`Attached to orphaned terminal ${sessionId} in floating panel`);
+
+        this.close();
+        this.refresh();
+    }
+
+    /**
+     * Kill an orphaned terminal
+     * @param {string} sessionId - The terminal session ID to kill
+     */
+    async killTerminal(sessionId) {
+        try {
+            const response = await fetch(`${CONFIG.API_BASE}/api/terminal/${encodeURIComponent(sessionId)}`, {
+                method: 'DELETE'
+            });
+
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}`);
+            }
+
+            debug.log(`Killed orphaned terminal: ${sessionId}`);
+            this.refresh();
+        } catch (err) {
+            console.error('Failed to kill terminal:', err);
+            alert(S.orphan_terminals.kill_failed.replace('{error}', err.message));
+        }
+    }
+
+    /**
+     * Open all alive orphaned terminals in tabs
+     */
+    tabAll() {
+        const aliveOrphans = this.orphans.filter(t => t.alive);
+        if (aliveOrphans.length === 0) return;
+
+        for (const term of aliveOrphans) {
+            if (window.app?.tabCtrl) {
+                window.app.tabCtrl.openTerminalWidgetTab({
+                    terminalSessionId: term.session,
+                    cwd: term.cwd
+                });
+            }
+        }
+
+        debug.log(`Opened ${aliveOrphans.length} orphaned terminals as tabs`);
+        this.close();
+        this.refresh();
+    }
+
+    /**
+     * Kill all orphaned terminals
+     */
+    async killAll() {
+        if (this.orphans.length === 0) return;
+
+        const count = this.orphans.length;
+        const ok = await appConfirm(
+            S.orphan_terminals.kill_all_confirm.replace('{count}', count),
+            { confirmLabel: 'Kill All', danger: true }
+        );
+        if (!ok) return;
+
+        const results = await Promise.allSettled(
+            this.orphans.map(term =>
+                fetch(`${CONFIG.API_BASE}/api/terminal/${encodeURIComponent(term.session)}`, {
+                    method: 'DELETE'
+                })
+            )
+        );
+
+        const succeeded = results.filter(r => r.status === 'fulfilled' && r.value.ok).length;
+        const failed = count - succeeded;
+
+        debug.log(`Killed ${succeeded} orphaned terminals${failed > 0 ? `, ${failed} failed` : ''}`);
+        showToast(failed > 0
+            ? S.orphan_terminals.kill_all_partial
+                .replace('{ok}', succeeded).replace('{count}', count).replace('{failed}', failed)
+            : S.orphan_terminals.kill_all_done.replace('{count}', succeeded));
+        this.refresh();
+    }
+}
+
+// Singleton instance
+export const orphanTerminals = new OrphanTerminalsManager();

painapple_code/static/js/path-utils.js

@@ -0,0 +1,179 @@
+/**
+ * Server-flavored path helpers.
+ *
+ * Every path the client manipulates belongs to the SERVER's filesystem,
+ * not the browser's — an iPad can be driving a Windows server — so the
+ * flavor comes from what the server reports (INSTANCE_CONFIG.path_style),
+ * never from navigator.platform.
+ *
+ * Before this module the resolver was POSIX-only: `startsWith('/')` meant
+ * "absolute" and joins were `'/' + parts.join('/')`, so a Windows cwd came
+ * back as `/C:/Users/me/proj` — a drive letter demoted to a path segment,
+ * which then 404s every listing.
+ */
+
+const WIN_ABS = /^[A-Za-z]:[\\/]/;
+const UNC = /^\\\\[^\\/]+[\\/][^\\/]+/;
+
+/** Windows path semantics? Falls back to sniffing a known server path so a
+ *  cached page that predates the config flag still behaves. */
+export function isWindowsPaths(sampleAbsPath = '') {
+    const declared = window.INSTANCE_CONFIG?.path_style;
+    if (declared === 'windows') return true;
+    if (declared === 'posix') return false;
+    return WIN_ABS.test(sampleAbsPath) || UNC.test(sampleAbsPath);
+}
+
+export function pathSep(sample = '') {
+    return isWindowsPaths(sample) ? '\\' : '/';
+}
+
+/**
+ * Which separators the flavor ACCEPTS — a different question from which one
+ * `pathSep` emits, and the one this module used to get wrong. Windows treats
+ * '\' and '/' interchangeably, but on POSIX a backslash is an ordinary
+ * filename character: splitting on it truncates a real file called
+ * `notes\2024-Q1.md` down to `2024-Q1.md`.
+ */
+function splitRe(sample) { return isWindowsPaths(sample) ? /[\\/]+/ : /\/+/; }
+function trailSepRe(sample) { return isWindowsPaths(sample) ? /[\\/]+$/ : /\/+$/; }
+function leadSepRe(sample) { return isWindowsPaths(sample) ? /^[\\/]+/ : /^\/+/; }
+
+/** Windows flavor for a pair of paths — either one can carry the tell (a
+ *  drive letter or UNC prefix), and a declared path_style outranks both. */
+function winPair(a, b) { return isWindowsPaths(a || '') || isWindowsPaths(b || ''); }
+
+/** Does this path stand on its own (no cwd needed)? */
+export function isAbsolutePath(p, sample = '') {
+    if (!p) return false;
+    if (isWindowsPaths(sample || p)) return WIN_ABS.test(p) || UNC.test(p);
+    return p.startsWith('/');
+}
+
+/**
+ * The leading part that must survive normalization: '/' on POSIX,
+ * 'C:\' or '\\server\share\' on Windows. '' for a relative path.
+ */
+export function pathRoot(p) {
+    if (!p) return '';
+    if (isWindowsPaths(p)) {
+        const unc = p.match(UNC);
+        if (unc) return unc[0] + '\\';
+        if (WIN_ABS.test(p)) return p.slice(0, 2) + '\\';
+    }
+    if (p.startsWith('/')) return '/';
+    return '';
+}
+
+/**
+ * Split into components, dropping empties. `sample` exists for callers that
+ * hand us a rootless fragment — the drive letter that makes a path
+ * recognizably Windows has already been sliced off, so the fragment alone
+ * would sniff as POSIX.
+ */
+export function splitPath(p, sample = p) {
+    return (p || '').split(splitRe(sample)).filter(Boolean);
+}
+
+/**
+ * Resolve `rel` against `base`, collapsing . and .. — the cross-platform
+ * replacement for `'/' + combined.split('/').filter(...).join('/')`.
+ */
+export function resolvePath(base, rel) {
+    const startFrom = isAbsolutePath(rel, base) ? rel : `${base || ''}/${rel || ''}`;
+    const root = pathRoot(startFrom);
+    const sep = isWindowsPaths(startFrom) ? '\\' : '/';
+    const out = [];
+    for (const part of splitPath(root ? startFrom.slice(root.length) : startFrom, startFrom)) {
+        if (part === '.') continue;
+        if (part === '..') out.pop();
+        else out.push(part);
+    }
+    if (!root) return out.join(sep);
+    // root already ends with a separator; don't double it
+    return root + out.join(sep);
+}
+
+/** Last component, either separator. */
+export function basename(p) {
+    const parts = splitPath(p);
+    return parts.length ? parts[parts.length - 1] : '';
+}
+
+/** Containing directory, or null at the root. */
+export function parentOf(p) {
+    if (!p) return null;
+    const root = pathRoot(p);
+    const parts = splitPath(root ? p.slice(root.length) : p, p);
+    if (!parts.length) return null;           // already at the root
+    parts.pop();
+    const sep = isWindowsPaths(p) ? '\\' : '/';
+    if (root) return parts.length ? root + parts.join(sep) : root;
+    return parts.join(sep) || null;
+}
+
+/** Join a directory and a child name with the server's separator. */
+export function joinPath(dir, child) {
+    if (!dir) return child || '';
+    if (!child) return dir;
+    const sep = isWindowsPaths(dir) ? '\\' : '/';
+    return dir.replace(trailSepRe(dir), '') + sep + child;
+}
+
+/** Trailing separators removed, but never past the root. */
+export function stripTrailingSep(p) {
+    if (!p) return p;
+    const root = pathRoot(p);
+    const trimmed = p.replace(trailSepRe(p), '');
+    return trimmed.length >= root.length && trimmed ? trimmed : (root || p);
+}
+
+/**
+ * `path` expressed relative to `base`, or `path` unchanged when it isn't
+ * under `base`. Replaces the `p.startsWith(cwd + '/') ? p.slice(cwd.length + 1) : p`
+ * idiom, which on Windows never matched — so shadow-git/history endpoints
+ * that require a repo-relative pathspec were handed absolute paths and
+ * silently returned nothing.
+ *
+ * Emits forward slashes on Windows: the consumers are git pathspecs and API
+ * keys, which are '/' on every platform. On POSIX the backslashes that
+ * survive are part of the filename, so they're left alone.
+ */
+export function relativeTo(path, base) {
+    if (!path || !base) return path;
+    if (!isUnder(path, base)) return path;
+    const win = winPair(path, base);
+    // stripTrailingSep is what isUnder compared against — including when
+    // base IS the root, where it stops at '/' or 'C:\' rather than emptying
+    // out. Slicing by any other length eats a real character.
+    const rest = path.slice(stripTrailingSep(base).length);
+    const trimmed = rest.replace(leadSepRe(base), '');
+    return win ? trimmed.replace(/\\/g, '/') : trimmed;
+}
+
+/** Directory part of a path — '' when there's no separator. */
+export function dirname(p) {
+    const parent = parentOf(p);
+    return parent === null ? '' : parent;
+}
+
+/**
+ * Is `child` inside `dir` (or equal to it)?
+ *
+ * On Windows this is case- and separator-insensitive, because the same file
+ * is reachable as `C:/Users/me/proj` or `C:\Users\me\proj` and the two sides
+ * often come from different places (the server reports one, a link the other).
+ * On POSIX neither folding applies — case matters and '\' is a filename
+ * character. Normalization is 1:1 in length apart from the trailing strip,
+ * so `relativeTo` can slice by `stripTrailingSep(dir).length`.
+ */
+export function isUnder(child, dir) {
+    if (!child || !dir) return false;
+    const win = winPair(child, dir);
+    const sep = win ? '\\' : '/';
+    const norm = (s) => (win ? s.toLowerCase().replace(/\//g, '\\') : s).replace(win ? /\\+$/ : /\/+$/, '');
+    const c = norm(child);
+    const d = norm(dir);
+    if (c === d) return true;
+    return c.startsWith(d) && c.charAt(d.length) === sep;
+}

painapple_code/static/js/perf-marks.js

@@ -0,0 +1,102 @@
+/**
+ * Performance instrumentation module.
+ * Only loaded when ?perf=true is in the URL.
+ * Wraps key functions with performance.mark/measure calls.
+ *
+ * Usage from Playwright:
+ *   window.__perfCollect()  → returns all measures as array
+ *   window.__perfClear()    → clears all marks/measures
+ *   window.__perfEnabled    → true when loaded
+ */
+
+import { debug } from './config.js';
+
+window.__perfEnabled = true;
+
+// ── Wrap a method with performance marks ──
+function wrapMethod(obj, methodName, label) {
+    const original = obj[methodName];
+    if (!original) return;
+    obj[methodName] = function (...args) {
+        const markStart = `${label}-start`;
+        const markEnd = `${label}-end`;
+        performance.mark(markStart);
+        const result = original.apply(this, args);
+        performance.mark(markEnd);
+        performance.measure(label, markStart, markEnd);
+        return result;
+    };
+}
+
+// ── Instrument ChatController.renderMessages ──
+function instrumentChatController() {
+    const chatCtrl = window.app?.chatCtrl;
+    if (!chatCtrl) return false;
+    wrapMethod(chatCtrl, 'renderMessages', 'render-messages');
+    wrapMethod(chatCtrl, '_renderMessagesIntoContainer', 'render-into-container');
+    return true;
+}
+
+// ── Instrument SessionContainerPool.activate ──
+function instrumentContainerPool() {
+    const pool = window.app?.chatCtrl?._containerPool;
+    if (!pool) return false;
+    wrapMethod(pool, 'activate', 'pool-activate');
+    return true;
+}
+
+// ── Instrument App._doSessionSwitch ──
+function instrumentSessionSwitch() {
+    const app = window.app;
+    if (!app) return false;
+    wrapMethod(app, '_doSessionSwitch', 'session-switch');
+    return true;
+}
+
+// ── API: Collect all measures ──
+window.__perfCollect = function () {
+    return performance.getEntriesByType('measure').map(e => ({
+        name: e.name,
+        duration: Math.round(e.duration * 100) / 100,
+        startTime: Math.round(e.startTime * 100) / 100,
+    }));
+};
+
+// ── API: Clear all marks and measures ──
+window.__perfClear = function () {
+    performance.clearMarks();
+    performance.clearMeasures();
+};
+
+// ── API: Get measures by name ──
+window.__perfGet = function (name) {
+    return performance.getEntriesByName(name, 'measure').map(e => ({
+        duration: Math.round(e.duration * 100) / 100,
+        startTime: Math.round(e.startTime * 100) / 100,
+    }));
+};
+
+// ── Apply all instrumentation ──
+function applyInstrumentation() {
+    const results = {
+        chatController: instrumentChatController(),
+        containerPool: instrumentContainerPool(),
+        sessionSwitch: instrumentSessionSwitch(),
+    };
+    debug.log('[Perf] Instrumentation applied:', results);
+}
+
+// App may not be ready yet, wait for it
+if (window.app?.chatCtrl) {
+    applyInstrumentation();
+} else {
+    // Poll briefly for app readiness
+    let attempts = 0;
+    const interval = setInterval(() => {
+        if (window.app?.chatCtrl || ++attempts > 50) {
+            clearInterval(interval);
+            if (window.app?.chatCtrl) applyInstrumentation();
+            else console.warn('[Perf] App not ready after 5s, skipping instrumentation');
+        }
+    }, 100);
+}