xtralab 0.4.0 → 0.6.0

package/lib/git/panelComponent.js

@@ -1,320 +0,0 @@
-import * as React from 'react';
-import { Poll } from '@lumino/polling';
-import { add, addAll, checkout, porcelainToFileChanges, reset, resetAll, showTopLevel, status } from './api';
-/**
- * The polling interval for the panel. We refresh the status periodically so
- * out-of-band changes (e.g. the user runs `git add` from a terminal) become
- * visible without requiring a manual refresh.
- */
-const STATUS_POLL_INTERVAL_MS = 5000;
-/**
- * Upper bound on the poll's exponential backoff when status requests fail
- * repeatedly. Matches the default JupyterLab file browser's `max`: long
- * enough that a server outage stops hammering the API, short enough that
- * a transient failure heals on its own.
- */
-const STATUS_POLL_MAX_MS = 300000;
-/**
- * Top-level React component rendered inside the {@link GitPanel} widget.
- * Owns the polling + refresh wiring around the `/git/status` endpoint and
- * the small bit of UI state that controls section collapse and the
- * in-flight per-file action spinners.
- */
-export function GitPanelComponent(props) {
-    const { handlers, refreshSignal } = props;
-    const [state, setState] = React.useState({
-        loading: true,
-        result: null,
-        error: null
-    });
-    // The absolute filesystem path of the resolved git top-level. Used purely
-    // for display in the panel header.
-    const [topLevel, setTopLevel] = React.useState(null);
-    // Per-action spinner gating: keyed by `${group}:${path}`, value is the
-    // action currently in flight. Lets the row render a disabled state on
-    // exactly the file that is being mutated, without locking the whole panel.
-    const [pendingActions, setPendingActions] = React.useState({});
-    const [stagedCollapsed, setStagedCollapsed] = React.useState(false);
-    const [changesCollapsed, setChangesCollapsed] = React.useState(false);
-    // The repo path passed to every API call. We use the JupyterLab server's
-    // root (the empty string) and let `git` resolve the enclosing repo on the
-    // server side. This works as long as the server was started inside a git
-    // repo — the common case.
-    const repoPath = '';
-    const refresh = React.useCallback(async () => {
-        var _a;
-        try {
-            const [topLevelResult, statusResult] = await Promise.all([
-                showTopLevel(repoPath),
-                status(repoPath)
-            ]);
-            setTopLevel(topLevelResult);
-            if (statusResult.code !== 0) {
-                setState({
-                    loading: false,
-                    result: null,
-                    error: (_a = statusResult.message) !== null && _a !== void 0 ? _a : 'Failed to load git status'
-                });
-                return;
-            }
-            setState({ loading: false, result: statusResult, error: null });
-        }
-        catch (err) {
-            setState({
-                loading: false,
-                result: null,
-                error: err instanceof Error ? err.message : String(err)
-            });
-        }
-    }, [repoPath]);
-    // Initial load + polling. Driven by a Lumino `Poll` so the panel stops
-    // hitting the git endpoint while the JupyterLab tab is hidden, and so
-    // repeated failures back off exponentially instead of spinning at 5s.
-    // External refresh triggers (toolbar button, plugin-level events) call
-    // `poll.refresh()` to schedule an immediate tick instead of running
-    // `refresh()` directly — that keeps the panel from issuing two parallel
-    // status requests when an automatic tick happens to land at the same
-    // time as an external trigger.
-    React.useEffect(() => {
-        const poll = new Poll({
-            name: '@xtralab/git:panelStatus',
-            factory: () => refresh(),
-            frequency: {
-                interval: STATUS_POLL_INTERVAL_MS,
-                backoff: true,
-                max: STATUS_POLL_MAX_MS
-            },
-            standby: 'when-hidden'
-        });
-        const handler = () => {
-            void poll.refresh();
-        };
-        refreshSignal.connect(handler);
-        return () => {
-            refreshSignal.disconnect(handler);
-            poll.dispose();
-        };
-    }, [refresh, refreshSignal]);
-    const runAction = React.useCallback(async (change, action, run) => {
-        const key = `${change.group}:${change.path}`;
-        setPendingActions(prev => ({ ...prev, [key]: action }));
-        try {
-            await run();
-            await refresh();
-        }
-        catch (err) {
-            await handlers.showError('Git operation failed', err instanceof Error ? err : new Error(String(err)));
-        }
-        finally {
-            setPendingActions(prev => {
-                const next = { ...prev };
-                delete next[key];
-                return next;
-            });
-        }
-    }, [handlers, refresh]);
-    const onStage = React.useCallback((change) => runAction(change, 'stage', () => add(repoPath, change.path)), [repoPath, runAction]);
-    const onUnstage = React.useCallback((change) => runAction(change, 'unstage', () => reset(repoPath, change.path)), [repoPath, runAction]);
-    const onDiscard = React.useCallback(async (change) => {
-        const verb = change.status === 'untracked' ? 'remove' : 'restore';
-        const accepted = await handlers.confirm(verb === 'remove' ? 'Remove file' : 'Discard changes', verb === 'remove'
-            ? `Permanently remove ${change.path}? This cannot be undone.`
-            : `Discard all changes to ${change.path}? This will revert the file to its last staged version and cannot be undone.`, verb === 'remove' ? 'Remove' : 'Discard');
-        if (!accepted) {
-            return;
-        }
-        // The git extension's `checkout` endpoint without a branch reverts the
-        // working tree copy of the file to the index. For untracked files we
-        // can't checkout, so the user is told the action is unsupported and we
-        // bail out — they can delete the file via the file browser instead.
-        if (change.status === 'untracked') {
-            await handlers.showError('Cannot discard untracked file', new Error('Untracked files cannot be discarded from the git panel — delete them from the file browser instead.'));
-            return;
-        }
-        await runAction(change, 'discard', () => checkout(repoPath, change.path));
-    }, [handlers, repoPath, runAction]);
-    const onStageAll = React.useCallback(async () => {
-        try {
-            await addAll(repoPath);
-            await refresh();
-        }
-        catch (err) {
-            await handlers.showError('Stage all failed', err instanceof Error ? err : new Error(String(err)));
-        }
-    }, [handlers, refresh, repoPath]);
-    const onUnstageAll = React.useCallback(async () => {
-        try {
-            await resetAll(repoPath);
-            await refresh();
-        }
-        catch (err) {
-            await handlers.showError('Unstage all failed', err instanceof Error ? err : new Error(String(err)));
-        }
-    }, [handlers, refresh, repoPath]);
-    // Categorize the porcelain entries into the two visible groups. Because
-    // `porcelainToFileChanges` may emit two changes per file (one staged, one
-    // unstaged), the same file can show up in both lists when it has been
-    // partially staged.
-    const { staged, unstaged } = React.useMemo(() => {
-        const stagedAcc = [];
-        const unstagedAcc = [];
-        if (state.result === null) {
-            return { staged: stagedAcc, unstaged: unstagedAcc };
-        }
-        for (const file of state.result.files) {
-            for (const change of porcelainToFileChanges(file)) {
-                if (change.group === 'staged') {
-                    stagedAcc.push(change);
-                }
-                else {
-                    unstagedAcc.push(change);
-                }
-            }
-        }
-        stagedAcc.sort((a, b) => a.path.localeCompare(b.path));
-        unstagedAcc.sort((a, b) => a.path.localeCompare(b.path));
-        return { staged: stagedAcc, unstaged: unstagedAcc };
-    }, [state.result]);
-    return (React.createElement("div", { className: "jp-xtralab-GitPanel-content" },
-        React.createElement(PanelHeader, { topLevel: topLevel, result: state.result, loading: state.loading, error: state.error, onRefresh: () => void refresh() }),
-        state.error !== null ? (React.createElement("div", { className: "jp-xtralab-GitPanel-error" }, state.error)) : (React.createElement(React.Fragment, null,
-            React.createElement(ChangeSection, { label: "Staged Changes", count: staged.length, collapsed: stagedCollapsed, onToggleCollapsed: () => setStagedCollapsed(c => !c), actions: staged.length > 0
-                    ? [
-                        {
-                            label: 'Unstage all changes',
-                            symbol: '−',
-                            onClick: onUnstageAll
-                        }
-                    ]
-                    : undefined }, staged.map(change => (React.createElement(ChangeRow, { key: `${change.group}:${change.path}`, change: change, pendingAction: pendingActions[`${change.group}:${change.path}`], onClick: event => handlers.openDiff(change, {
-                    pin: event.ctrlKey || event.metaKey
-                }), actions: [
-                    {
-                        label: 'Unstage changes',
-                        symbol: '−',
-                        onClick: () => void onUnstage(change)
-                    }
-                ] })))),
-            React.createElement(ChangeSection, { label: "Changes", count: unstaged.length, collapsed: changesCollapsed, onToggleCollapsed: () => setChangesCollapsed(c => !c), actions: unstaged.length > 0
-                    ? [
-                        {
-                            label: 'Stage all changes',
-                            symbol: '+',
-                            onClick: onStageAll
-                        }
-                    ]
-                    : undefined }, unstaged.map(change => (React.createElement(ChangeRow, { key: `${change.group}:${change.path}`, change: change, pendingAction: pendingActions[`${change.group}:${change.path}`], onClick: event => handlers.openDiff(change, {
-                    pin: event.ctrlKey || event.metaKey
-                }), actions: [
-                    {
-                        label: 'Discard changes',
-                        symbol: '⟲',
-                        onClick: () => void onDiscard(change)
-                    },
-                    {
-                        label: 'Stage changes',
-                        symbol: '+',
-                        onClick: () => void onStage(change)
-                    }
-                ] })))),
-            staged.length === 0 && unstaged.length === 0 && !state.loading ? (React.createElement("div", { className: "jp-xtralab-GitPanel-empty" }, "No changes detected.")) : null))));
-}
-function PanelHeader(props) {
-    var _a;
-    const { topLevel, result, loading, error, onRefresh } = props;
-    const repoName = topLevel !== null
-        ? ((_a = topLevel
-            .split('/')
-            .filter(s => s.length > 0)
-            .pop()) !== null && _a !== void 0 ? _a : topLevel)
-        : null;
-    return (React.createElement("div", { className: "jp-xtralab-GitPanel-header" },
-        React.createElement("div", { className: "jp-xtralab-GitPanel-headerInfo" },
-            repoName !== null ? (React.createElement("div", { className: "jp-xtralab-GitPanel-repo", title: topLevel !== null && topLevel !== void 0 ? topLevel : '' }, repoName)) : null,
-            (result === null || result === void 0 ? void 0 : result.branch) !== undefined && (result === null || result === void 0 ? void 0 : result.branch) !== null ? (React.createElement("div", { className: "jp-xtralab-GitPanel-branch" },
-                result.branch,
-                result.ahead > 0 ? React.createElement("span", null,
-                    " \u2191",
-                    result.ahead) : null,
-                result.behind > 0 ? React.createElement("span", null,
-                    " \u2193",
-                    result.behind) : null)) : null),
-        React.createElement("button", { type: "button", className: "jp-xtralab-GitPanel-iconButton", title: "Refresh", disabled: loading && error === null, onClick: onRefresh }, "\u27F3")));
-}
-function ChangeSection(props) {
-    const { label, count, collapsed, onToggleCollapsed, actions, children } = props;
-    return (React.createElement("div", { className: "jp-xtralab-GitPanel-section" },
-        React.createElement("div", { className: "jp-xtralab-GitPanel-sectionHeader", onClick: onToggleCollapsed },
-            React.createElement("span", { className: "jp-xtralab-GitPanel-sectionChevron" }, collapsed ? '▸' : '▾'),
-            React.createElement("span", { className: "jp-xtralab-GitPanel-sectionLabel" }, label),
-            actions !== undefined ? (React.createElement("span", { className: "jp-xtralab-GitPanel-sectionActions" }, actions.map(action => (React.createElement("button", { key: action.label, type: "button", className: "jp-xtralab-GitPanel-iconButton", title: action.label, onClick: event => {
-                    event.stopPropagation();
-                    action.onClick();
-                } }, action.symbol))))) : null,
-            React.createElement("span", { className: "jp-xtralab-GitPanel-sectionCount" }, count)),
-        !collapsed ? (React.createElement("div", { className: "jp-xtralab-GitPanel-sectionBody" }, children)) : null));
-}
-function ChangeRow(props) {
-    const { change, pendingAction, onClick, actions } = props;
-    const filename = basename(change.path);
-    const dirname = dirnameOrEmpty(change.path);
-    return (React.createElement("div", { className: "jp-xtralab-GitPanel-row", "data-status": change.status, title: change.from !== undefined
-            ? `${change.from} → ${change.path}`
-            : change.path, onClick: onClick },
-        React.createElement("span", { className: "jp-xtralab-GitPanel-rowLabel" },
-            React.createElement("span", { className: "jp-xtralab-GitPanel-rowName" }, filename),
-            dirname !== '' ? (React.createElement("span", { className: "jp-xtralab-GitPanel-rowPath" }, dirname)) : null),
-        React.createElement("span", { className: "jp-xtralab-GitPanel-rowActions", "data-pending": pendingAction !== undefined }, actions.map(action => (React.createElement("button", { key: action.label, type: "button", className: "jp-xtralab-GitPanel-iconButton", title: action.label, disabled: pendingAction !== undefined, onClick: event => {
-                event.stopPropagation();
-                action.onClick();
-            } }, action.symbol)))),
-        React.createElement("span", { className: "jp-xtralab-GitPanel-rowBadge", "data-status": change.status, title: statusTooltip(change.status) }, statusBadge(change.status))));
-}
-function statusBadge(status) {
-    switch (status) {
-        case 'modified':
-            return 'M';
-        case 'added':
-            return 'A';
-        case 'deleted':
-            return 'D';
-        case 'renamed':
-            return 'R';
-        case 'untracked':
-            return 'U';
-        case 'unmerged':
-            return '!';
-        case 'typechange':
-            return 'T';
-        default:
-            return '?';
-    }
-}
-function statusTooltip(status) {
-    switch (status) {
-        case 'modified':
-            return 'Modified';
-        case 'added':
-            return 'Added';
-        case 'deleted':
-            return 'Deleted';
-        case 'renamed':
-            return 'Renamed';
-        case 'untracked':
-            return 'Untracked';
-        case 'unmerged':
-            return 'Unmerged (conflict)';
-        case 'typechange':
-            return 'Type changed';
-        default:
-            return 'Unknown';
-    }
-}
-function basename(path) {
-    const idx = path.lastIndexOf('/');
-    return idx < 0 ? path : path.slice(idx + 1);
-}
-function dirnameOrEmpty(path) {
-    const idx = path.lastIndexOf('/');
-    return idx < 0 ? '' : path.slice(0, idx);
-}

package/lib/statusBar/index.d.ts

@@ -1,14 +0,0 @@
-import { JupyterFrontEndPlugin } from '@jupyterlab/application';
-/**
- * Surfaces every running terminal session as its own item on the left
- * side of the status bar. The list is driven by
- * `serviceManager.terminals.runningChanged`, not by the widget tracker,
- * so a session that has its tab closed but is still running on the
- * backend keeps its slot — the typical state for an agent the user has
- * stepped away from. Clicking an item activates the existing tab if one
- * is open, or reopens the session in a fresh terminal widget. The
- * inline `×` button shuts the session down on the server, which
- * cascades through the widget if it is currently open.
- */
-declare const plugin: JupyterFrontEndPlugin<void>;
-export default plugin;

package/lib/statusBar/index.js

@@ -1,89 +0,0 @@
-import { IStatusBar } from '@jupyterlab/statusbar';
-import { ITerminalTracker } from '@jupyterlab/terminal';
-import { ITranslator, nullTranslator } from '@jupyterlab/translation';
-import { DisposableSet } from '@lumino/disposable';
-import { SessionRegistry, TerminalSessionItem } from './widget';
-const PLUGIN_ID = 'xtralab:statusBar';
-/**
- * Surfaces every running terminal session as its own item on the left
- * side of the status bar. The list is driven by
- * `serviceManager.terminals.runningChanged`, not by the widget tracker,
- * so a session that has its tab closed but is still running on the
- * backend keeps its slot — the typical state for an agent the user has
- * stepped away from. Clicking an item activates the existing tab if one
- * is open, or reopens the session in a fresh terminal widget. The
- * inline `×` button shuts the session down on the server, which
- * cascades through the widget if it is currently open.
- */
-const plugin = {
-    id: PLUGIN_ID,
-    description: 'Surface each running terminal session as its own status bar item so users can jump to (or reopen) backgrounded agents from anywhere in the workspace.',
-    autoStart: true,
-    requires: [IStatusBar, ITerminalTracker],
-    optional: [ITranslator],
-    activate: (app, statusBar, tracker, translator) => {
-        const trans = (translator !== null && translator !== void 0 ? translator : nullTranslator).load('jupyterlab');
-        const registry = new SessionRegistry(app.serviceManager, tracker);
-        // One DisposableSet per session — registerStatusItem returns an
-        // IDisposable for the registration, and the item widget itself
-        // implements IDisposable. Bundling them lets a single `dispose()`
-        // tear the slot down completely when the session goes away.
-        const items = new Map();
-        const onActivate = (name) => {
-            // `terminal:open` is the upstream entry point that handles both
-            // sides of this: if a widget is already attached to the named
-            // session it activates that tab, otherwise it spins up a fresh
-            // widget connected to the live session. Reusing it keeps the
-            // path identical to a click in the running-sessions sidebar.
-            void app.commands.execute('terminal:open', { name });
-        };
-        const onShutdown = (name) => {
-            void app.serviceManager.terminals.shutdown(name).catch(reason => {
-                console.error(`xtralab: failed to shut down terminal ${name}: ${reason}`);
-            });
-        };
-        const sync = () => {
-            const live = new Set(registry.sessionNames());
-            // Add items for newly-seen sessions. We register each at its
-            // stable rank from the registry so re-creating an item between
-            // syncs (e.g. if we ever decide to swap representations) lands
-            // in the same slot.
-            for (const name of live) {
-                if (items.has(name)) {
-                    continue;
-                }
-                const item = new TerminalSessionItem({
-                    registry,
-                    sessionName: name,
-                    trans,
-                    onActivate,
-                    onShutdown
-                });
-                const registration = statusBar.registerStatusItem(`${PLUGIN_ID}:${name}`, {
-                    item,
-                    align: 'left',
-                    rank: registry.rankFor(name)
-                });
-                const set = new DisposableSet();
-                set.add(registration);
-                set.add(item);
-                items.set(name, set);
-            }
-            // Remove items for sessions the server no longer knows about.
-            for (const [name, disposable] of Array.from(items.entries())) {
-                if (!live.has(name)) {
-                    disposable.dispose();
-                    items.delete(name);
-                }
-            }
-        };
-        registry.stateChanged.connect(sync);
-        void app.serviceManager.terminals.ready.then(() => {
-            // The first `runningChanged` may have fired before our connect,
-            // depending on how the manager initialises — refresh once after
-            // it is ready so any pre-existing sessions get their items.
-            sync();
-        });
-    }
-};
-export default plugin;

package/lib/statusBar/widget.d.ts

@@ -1,121 +0,0 @@
-import type { MainAreaWidget } from '@jupyterlab/apputils';
-import type { ServiceManager } from '@jupyterlab/services';
-import type { ITerminal, ITerminalTracker } from '@jupyterlab/terminal';
-import { type TranslationBundle } from '@jupyterlab/translation';
-import { VDomModel, VDomRenderer } from '@jupyterlab/ui-components';
-import * as React from 'react';
-/**
- * The widget shape every entry in `ITerminalTracker` takes — kept here
- * so the registry's call sites read cleanly.
- */
-export type TerminalWidget = MainAreaWidget<ITerminal.ITerminal>;
-/**
- * Source-of-truth model for the status bar. Each running terminal
- * session known to the server is one entry; the registry caches the
- * last `widget.title.label` we observed so the agent name (or any
- * xterm-published title) survives the user closing the tab while the
- * session continues running on the backend.
- *
- * Two upstream signals feed the model:
- *   - `serviceManager.terminals.runningChanged` is the authoritative
- *     list of live sessions; everything not in it has been shut down
- *     server-side and we must drop it.
- *   - `tracker.widgetAdded` plus the per-widget `title.changed` /
- *     `disposed` signals keep our label cache in sync with whatever
- *     xterm/the launcher has set on the open tabs.
- *
- * `stateChanged` is reused for both kinds of update so consumers
- * (the per-session status item, the plugin's add/remove sync) can
- * subscribe once.
- */
-export declare class SessionRegistry extends VDomModel {
-    constructor(serviceManager: ServiceManager.IManager, tracker: ITerminalTracker);
-    /**
-     * Names of all live sessions, ordered by their stable rank so the
-     * status bar items keep their slots as new sessions are added.
-     */
-    sessionNames(): string[];
-    /**
-     * True iff the named session is still on the server. Used by the
-     * per-session item to render `null` during the brief window between
-     * the session's shutdown and the plugin disposing the item.
-     */
-    has(name: string): boolean;
-    /**
-     * Display name for the session. The cache wins because it only
-     * holds "real" labels (the launcher's agent name or an xterm escape
-     * sequence — see `_cacheLabel` for the filter); reading it first
-     * prevents the transient `Terminal {name}` an XTerm widget shows
-     * during reconnect from flickering into the status bar. The live
-     * widget title is used when no cache exists, and the
-     * `Terminal {name}` fallback covers sessions we have never seen a
-     * widget for (e.g. surviving a lab reload).
-     */
-    labelFor(name: string): string;
-    /**
-     * Return the open widget for a session, if any. The status item
-     * uses this to switch behaviour between "activate existing tab"
-     * and "open a new tab connected to the live session".
-     */
-    widgetFor(name: string): TerminalWidget | null;
-    /**
-     * Stable per-session rank assigned in observation order. Reused
-     * across `registerStatusItem` calls so an item that is briefly
-     * unregistered (e.g. while a widget is being recreated) lands back
-     * in the same slot. Cleaned up when the session is shut down so the
-     * counter does not grow without bound across long sessions.
-     */
-    rankFor(name: string): number;
-    dispose(): void;
-    private _refreshLive;
-    private _onRunningChanged;
-    private _onWidgetAdded;
-    private _trackWidget;
-    private _untrackWidget;
-    private _onTitleChanged;
-    /**
-     * Update the cached label for a session, but only when the new
-     * label is "real" — non-empty and not one of the transient defaults
-     * the XTerm widget cycles through during reconnect (`'...'` while
-     * the websocket is opening, `'Terminal {name}'` once
-     * `_initialConnection` fires). Without the filter, briefly
-     * reopening a tab while an agent has yet to re-emit its xterm
-     * title escape sequence would clobber the cached agent name with
-     * `Terminal 1`, which is exactly the regression we are guarding
-     * against. Live widget titles still display whatever the widget
-     * currently holds because `labelFor` consults the widget first;
-     * the filter only affects what survives a tab close.
-     */
-    private _cacheLabel;
-    private _onWidgetDisposed;
-    private _terminals;
-    private _tracker;
-    private _labels;
-    private _ranks;
-    private _live;
-    private _nextRank;
-}
-/**
- * One status bar item per live terminal session. Renders a terminal
- * icon plus the session's label, with an inline shutdown button that
- * appears on hover/focus. The item delegates click handling to the
- * plugin so the lifecycle (create/dispose) and the user-facing
- * behaviour (activate vs. reopen, shutdown) live in one place.
- */
-export declare class TerminalSessionItem extends VDomRenderer<SessionRegistry> {
-    constructor(options: TerminalSessionItem.IOptions);
-    render(): React.ReactElement | null;
-    private _sessionName;
-    private _trans;
-    private _onActivate;
-    private _onShutdown;
-}
-export declare namespace TerminalSessionItem {
-    interface IOptions {
-        registry: SessionRegistry;
-        sessionName: string;
-        trans?: TranslationBundle;
-        onActivate: (sessionName: string) => void;
-        onShutdown: (sessionName: string) => void;
-    }
-}