pilotswarm 0.5.0 → 0.5.2

package/ui/core/src/controller.js

@@ -18,6 +18,10 @@ import {
     getFocusRightTarget,
     getPromptInputRows,
     MIN_SESSION_PANE_HEIGHT,
+    MIN_CHAT_PANE_HEIGHT,
+    MIN_ACTIVITY_PANE_HEIGHT,
+    MIN_INSPECTOR_PANE_HEIGHT,
+    DEFAULT_ACTIVITY_PANE_RATIO,
     normalizeFocusRegion,
 } from "./layout.js";
 import { parseTerminalMarkupRuns } from "./formatting.js";
@@ -25,6 +29,7 @@ import {
     selectActiveArtifactLinks,
     selectActiveHttpLinks,
     selectActivityPane,
+    selectLiveActivityLines,
     selectChatLines,
     selectFileBrowserItems,
     selectFileSessionIdsForScope,
@@ -2155,6 +2160,7 @@ export class PilotSwarmUiController {
         try {
             const profile = await this.transport.getCurrentUserProfile();
             this.dispatch({ type: "admin/profile/loaded", profile });
+            await this.refreshSystemGhcpKeyStatus(profile);
             return profile || null;
         } catch (error) {
             this.dispatch({ type: "admin/profile/loadFailed", error: error?.message || String(error) });
@@ -2162,6 +2168,35 @@ export class PilotSwarmUiController {
         }
     }
 
+    /**
+     * Load the SYSTEM user's Copilot key status (admins only). Quietly a
+     * no-op when the caller is not admin or the transport predates the
+     * feature, so the Admin Console degrades to the per-user-only view.
+     */
+    async refreshSystemGhcpKeyStatus(profile = null) {
+        const effective = profile || this.getState().admin?.profile || null;
+        if (!effective?.isAdmin) return null;
+        if (typeof this.transport.getSystemGitHubCopilotKeyStatus !== "function") return null;
+        this.dispatch({ type: "admin/systemGhcpKey/loading" });
+        try {
+            const status = await this.transport.getSystemGitHubCopilotKeyStatus();
+            this.dispatch({ type: "admin/systemGhcpKey/loaded", status });
+            return status || null;
+        } catch (error) {
+            this.dispatch({ type: "admin/systemGhcpKey/loadFailed", error: error?.message || String(error) });
+            return null;
+        }
+    }
+
+    /**
+     * Admin-only: switch the key editor between "your key" and
+     * "System key" (the key ownerless system sessions run on).
+     */
+    setAdminGhcpKeyStoreAsSystem(value) {
+        if (value && !this.getState().admin?.profile?.isAdmin) return;
+        this.dispatch({ type: "admin/ghcpKey/setSystemTarget", value: Boolean(value) });
+    }
+
     beginAdminEditGhcpKey() {
         this.dispatch({ type: "admin/ghcpKey/beginEdit", draft: "" });
     }
@@ -2213,8 +2248,12 @@ export class PilotSwarmUiController {
      * use `clearAdminGhcpKey()` for that.
      */
     async saveAdminGhcpKey() {
-        if (typeof this.transport.setCurrentUserGitHubCopilotKey !== "function") {
-            this.dispatch({ type: "admin/ghcpKey/saveFailed", error: "Admin Console is not available on this transport." });
+        const storeAsSystem = Boolean(this.getState().admin.ghcpKey.storeAsSystem);
+        const setter = storeAsSystem ? "setSystemGitHubCopilotKey" : "setCurrentUserGitHubCopilotKey";
+        if (typeof this.transport[setter] !== "function") {
+            this.dispatch({ type: "admin/ghcpKey/saveFailed", error: storeAsSystem
+                ? "This deployment does not support System keys yet."
+                : "Admin Console is not available on this transport." });
             return;
         }
         const draft = String(this.getState().admin.ghcpKey.draft || "").trim();
@@ -2224,8 +2263,13 @@ export class PilotSwarmUiController {
         }
         this.dispatch({ type: "admin/ghcpKey/saving" });
         try {
-            const profile = await this.transport.setCurrentUserGitHubCopilotKey({ key: draft });
-            this.dispatch({ type: "admin/ghcpKey/saved", profile });
+            if (storeAsSystem) {
+                const status = await this.transport.setSystemGitHubCopilotKey({ key: draft });
+                this.dispatch({ type: "admin/systemGhcpKey/saved", status });
+            } else {
+                const profile = await this.transport.setCurrentUserGitHubCopilotKey({ key: draft });
+                this.dispatch({ type: "admin/ghcpKey/saved", profile });
+            }
         } catch (error) {
             this.dispatch({ type: "admin/ghcpKey/saveFailed", error: error?.message || String(error) });
         }
@@ -2236,14 +2280,23 @@ export class PilotSwarmUiController {
      * worker's env-supplied default token.
      */
     async clearAdminGhcpKey() {
-        if (typeof this.transport.setCurrentUserGitHubCopilotKey !== "function") {
-            this.dispatch({ type: "admin/ghcpKey/saveFailed", error: "Admin Console is not available on this transport." });
+        const storeAsSystem = Boolean(this.getState().admin.ghcpKey.storeAsSystem);
+        const setter = storeAsSystem ? "setSystemGitHubCopilotKey" : "setCurrentUserGitHubCopilotKey";
+        if (typeof this.transport[setter] !== "function") {
+            this.dispatch({ type: "admin/ghcpKey/saveFailed", error: storeAsSystem
+                ? "This deployment does not support System keys yet."
+                : "Admin Console is not available on this transport." });
             return;
         }
         this.dispatch({ type: "admin/ghcpKey/saving" });
         try {
-            const profile = await this.transport.setCurrentUserGitHubCopilotKey({ key: null });
-            this.dispatch({ type: "admin/ghcpKey/saved", profile });
+            if (storeAsSystem) {
+                const status = await this.transport.setSystemGitHubCopilotKey({ key: null });
+                this.dispatch({ type: "admin/systemGhcpKey/saved", status });
+            } else {
+                const profile = await this.transport.setCurrentUserGitHubCopilotKey({ key: null });
+                this.dispatch({ type: "admin/ghcpKey/saved", profile });
+            }
         } catch (error) {
             this.dispatch({ type: "admin/ghcpKey/saveFailed", error: error?.message || String(error) });
         }
@@ -2883,6 +2936,10 @@ export class PilotSwarmUiController {
                 this.exitPendingPromptEdit({ restoreDraft: true });
             }
             this.dispatch({ type: "sessions/selected", sessionId });
+            // Sequence-tab turn selection/expansion is per-session; clear it on
+            // switch so a stale turn index doesn't carry into another session.
+            this.dispatch({ type: "ui/sequenceExpandedTurns", turns: [] });
+            this.dispatch({ type: "ui/sequenceSelectedTurn", turn: null });
         }
         if (this.getState().sessions.byId[sessionId]?.isGroup) {
             this.detachActiveSession();
@@ -3534,6 +3591,19 @@ export class PilotSwarmUiController {
         await this.refreshSessions();
     }
 
+    openHelpModal() {
+        this.dispatch({
+            type: "ui/modal",
+            modal: {
+                type: "help",
+                title: "Keybindings",
+                selectedIndex: 0,
+                previousFocus: this.getState().ui.focusRegion,
+            },
+        });
+        this.dispatch({ type: "ui/status", text: "Keybindings — ? or Esc to close" });
+    }
+
     openThemePicker() {
         const themes = listThemes().map((theme) => ({
             id: theme.id,
@@ -4160,7 +4230,13 @@ export class PilotSwarmUiController {
 
     moveModalSelection(delta) {
         const modal = this.getState().ui.modal;
-        if (!modal || !Array.isArray(modal.items) || modal.items.length === 0) return;
+        if (!modal) return;
+        if (modal.type === "help") {
+            const current = Math.max(0, Number(modal.selectedIndex) || 0);
+            this.dispatch({ type: "ui/modalSelection", index: Math.max(0, current + delta) });
+            return;
+        }
+        if (!Array.isArray(modal.items) || modal.items.length === 0) return;
         if (modal.type === "logFilter" || modal.type === "filesFilter" || modal.type === "historyFormat") {
             const currentPaneIndex = Math.max(0, Math.min(Number(modal.selectedIndex) || 0, modal.items.length - 1));
             const selected = modal.items[currentPaneIndex];
@@ -4216,6 +4292,10 @@ export class PilotSwarmUiController {
     async confirmModal() {
         const modal = this.getState().ui.modal;
         if (!modal) return;
+        if (modal.type === "help") {
+            this.closeModal();
+            return;
+        }
         if (modal.type === "confirm") {
             const previousFocus = modal.previousFocus;
             this.dispatch({ type: "ui/modal", modal: null });
@@ -4782,6 +4862,88 @@ export class PilotSwarmUiController {
         }
     }
 
+    // Focus-aware vertical resize: [ / ] grow or shrink whichever pane is
+    // focused. Sessions and chat share the left-column vertical split;
+    // inspector and activity share the right-column vertical split. A positive
+    // delta always grows the focused pane at the expense of its sibling.
+    resizeFocusedPane(delta) {
+        const focus = this.getState().ui.focusRegion;
+        const layoutState = this.getState().ui.layout || {};
+        const bodyHeight = this.getCurrentLayout().bodyHeight ?? (layoutState.viewportHeight ?? 40);
+        const totalHeight = layoutState.viewportHeight ?? 40;
+        // Bound the adjust so BOTH panes stay strictly ABOVE their collapse
+        // thresholds (the collapse check is `<=`, hence the +1). A keyboard
+        // resize then never hides a pane — which would drop it from the Tab
+        // cycle — and never lands on a dead plateau. A positive delta grows the
+        // focused pane.
+        const clamp = (current, signed, min, max) => {
+            const hi = Math.max(min, max);
+            return Math.max(min, Math.min(hi, (current || 0) + signed));
+        };
+        if (focus === FOCUS_REGIONS.SESSIONS || focus === FOCUS_REGIONS.CHAT) {
+            const base = getBaseSessionPaneHeight(bodyHeight);
+            const minH = MIN_SESSION_PANE_HEIGHT + 1;
+            const maxH = Math.min(getMaxSessionPaneHeight(totalHeight, bodyHeight), bodyHeight - MIN_CHAT_PANE_HEIGHT - 1);
+            const signed = focus === FOCUS_REGIONS.CHAT ? -delta : delta;
+            const next = clamp(layoutState.sessionPaneAdjust, signed, minH - base, maxH - base);
+            this.dispatch({ type: "ui/sessionPaneAdjust", sessionPaneAdjust: next });
+        } else if (focus === FOCUS_REGIONS.INSPECTOR || focus === FOCUS_REGIONS.ACTIVITY) {
+            const base = Math.max(MIN_ACTIVITY_PANE_HEIGHT, Math.floor(bodyHeight * DEFAULT_ACTIVITY_PANE_RATIO));
+            const minH = MIN_ACTIVITY_PANE_HEIGHT + 1;
+            const maxH = bodyHeight - MIN_INSPECTOR_PANE_HEIGHT - 1;
+            const signed = focus === FOCUS_REGIONS.INSPECTOR ? -delta : delta;
+            const next = clamp(layoutState.activityPaneAdjust, signed, minH - base, maxH - base);
+            this.dispatch({ type: "ui/activityPaneAdjust", activityPaneAdjust: next });
+        }
+    }
+
+    getActiveSequenceCompletedTurns() {
+        const state = this.getState();
+        const sid = state.sessions.activeSessionId;
+        if (!sid) return [];
+        const history = state.history.bySessionId?.get?.(sid);
+        const turns = [];
+        const seen = new Set();
+        for (const event of history?.events || []) {
+            if (event?.eventType !== "session.turn_completed") continue;
+            const turn = Number(event?.data?.turnIndex ?? event?.data?.iteration);
+            if (!Number.isFinite(turn) || seen.has(turn)) continue;
+            seen.add(turn);
+            turns.push(turn);
+        }
+        turns.sort((a, b) => a - b);
+        return turns;
+    }
+
+    // Move the sequence-tab turn cursor among completed turns. First press with
+    // no selection lands on the latest turn; subsequent presses step.
+    moveSequenceSelection(delta) {
+        const turns = this.getActiveSequenceCompletedTurns();
+        if (turns.length === 0) return;
+        const at = turns.indexOf(Number(this.getState().ui.sequenceSelectedTurn));
+        const index = at === -1
+            ? turns.length - 1
+            : Math.max(0, Math.min(turns.length - 1, at + delta));
+        this.dispatch({ type: "ui/sequenceSelectedTurn", turn: turns[index] });
+    }
+
+    toggleSequenceTurnExpanded() {
+        const turns = this.getActiveSequenceCompletedTurns();
+        if (turns.length === 0) return;
+        let selected = Number(this.getState().ui.sequenceSelectedTurn);
+        if (!turns.includes(selected)) {
+            selected = turns[turns.length - 1];
+            this.dispatch({ type: "ui/sequenceSelectedTurn", turn: selected });
+        }
+        const expanded = Array.isArray(this.getState().ui.sequenceExpandedTurns)
+            ? this.getState().ui.sequenceExpandedTurns.map(Number)
+            : [];
+        const next = expanded.includes(selected)
+            ? expanded.filter((turn) => turn !== selected)
+            : [...expanded, selected];
+        this.dispatch({ type: "ui/sequenceExpandedTurns", turns: next });
+    }
+
     nextInspectorTab() {
         const current = this.getState().ui.inspectorTab;
         const inspectorTab = cycleValue(INSPECTOR_TABS, current, 1);
@@ -5058,7 +5220,10 @@ export class PilotSwarmUiController {
 
         const contentWidth = Math.max(20, layout.leftWidth - 4);
         const contentHeight = Math.max(1, layout.chatPaneHeight - 2);
-        const lines = selectChatLines(state, contentWidth);
+        const lines = [
+            ...selectChatLines(state, contentWidth),
+            ...selectLiveActivityLines(state),
+        ];
         const bottomStickyLines = selectOutboxOverlayLines(state, contentWidth);
         const bottomStickyHeight = Math.min(
             Math.max(0, Math.floor(contentHeight * 0.34)),
@@ -6030,9 +6195,27 @@ export class PilotSwarmUiController {
             case UI_COMMANDS.SHRINK_SESSION_PANE:
                 this.adjustSessionPaneSplit(-2);
                 return;
+            case UI_COMMANDS.GROW_FOCUSED_PANE:
+                this.resizeFocusedPane(2);
+                return;
+            case UI_COMMANDS.SHRINK_FOCUSED_PANE:
+                this.resizeFocusedPane(-2);
+                return;
             case UI_COMMANDS.OPEN_ARTIFACT_PICKER:
                 await this.openArtifactPicker();
                 return;
+            case UI_COMMANDS.OPEN_HELP:
+                this.openHelpModal();
+                return;
+            case UI_COMMANDS.SEQUENCE_SELECT_PREV:
+                this.moveSequenceSelection(-1);
+                return;
+            case UI_COMMANDS.SEQUENCE_SELECT_NEXT:
+                this.moveSequenceSelection(1);
+                return;
+            case UI_COMMANDS.TOGGLE_SEQUENCE_TURN:
+                this.toggleSequenceTurnExpanded();
+                return;
             case UI_COMMANDS.TOGGLE_LOG_TAIL:
                 this.toggleLogTail();
                 return;

package/ui/core/src/reducer.js

@@ -670,6 +670,24 @@ export function appReducer(state, action) {
                 },
             };
 
+        case "ui/sequenceExpandedTurns":
+            return {
+                ...state,
+                ui: {
+                    ...state.ui,
+                    sequenceExpandedTurns: Array.isArray(action.turns) ? action.turns : [],
+                },
+            };
+
+        case "ui/sequenceSelectedTurn":
+            return {
+                ...state,
+                ui: {
+                    ...state.ui,
+                    sequenceSelectedTurn: action.turn == null ? null : Number(action.turn),
+                },
+            };
+
         case "sessions/filterQuery":
             {
                 const nextSessions = {
@@ -701,7 +719,19 @@ export function appReducer(state, action) {
 
         case "ui/modalSelection": {
             const modal = state.ui.modal;
-            if (!modal || !Array.isArray(modal.items) || modal.items.length === 0) {
+            if (!modal) return state;
+            if (modal.type === "help") {
+                // The help overlay has no `items`; the row-count upper bound is
+                // clamped by selectHelpModal, so just track the scroll anchor.
+                return {
+                    ...state,
+                    ui: {
+                        ...state.ui,
+                        modal: { ...modal, selectedIndex: Math.max(0, Number(action.index) || 0) },
+                    },
+                };
+            }
+            if (!Array.isArray(modal.items) || modal.items.length === 0) {
                 return state;
             }
             const nextIndex = Math.max(0, Math.min(action.index ?? 0, modal.items.length - 1));
@@ -1458,6 +1488,7 @@ export function appReducer(state, action) {
                         saving: false,
                         error: null,
                         lastSavedAt: state.admin.ghcpKey.lastSavedAt,
+                        storeAsSystem: Boolean(state.admin.ghcpKey.storeAsSystem),
                     },
                 },
             };
@@ -1494,6 +1525,7 @@ export function appReducer(state, action) {
                         saving: false,
                         error: null,
                         lastSavedAt: state.admin.ghcpKey.lastSavedAt,
+                        storeAsSystem: Boolean(state.admin.ghcpKey.storeAsSystem),
                     },
                 },
             };
@@ -1537,6 +1569,91 @@ export function appReducer(state, action) {
                         saving: false,
                         error: null,
                         lastSavedAt: Date.now(),
+                        storeAsSystem: Boolean(state.admin.ghcpKey.storeAsSystem),
+                    },
+                },
+            };
+        }
+        case "admin/ghcpKey/setSystemTarget": {
+            const storeAsSystem = Boolean(action.value);
+            if (Boolean(state.admin.ghcpKey.storeAsSystem) === storeAsSystem) return state;
+            return {
+                ...state,
+                admin: {
+                    ...state.admin,
+                    ghcpKey: {
+                        ...state.admin.ghcpKey,
+                        storeAsSystem,
+                        error: null,
+                    },
+                },
+            };
+        }
+        case "admin/systemGhcpKey/loading": {
+            return {
+                ...state,
+                admin: {
+                    ...state.admin,
+                    systemGhcpKey: {
+                        ...state.admin.systemGhcpKey,
+                        loading: true,
+                        error: null,
+                    },
+                },
+            };
+        }
+        case "admin/systemGhcpKey/loaded": {
+            const status = action.status || {};
+            return {
+                ...state,
+                admin: {
+                    ...state.admin,
+                    systemGhcpKey: {
+                        supported: true,
+                        loading: false,
+                        configured: Boolean(status.configured),
+                        changedBy: status.changedBy || null,
+                        changedAt: status.changedAt || null,
+                        error: null,
+                    },
+                },
+            };
+        }
+        case "admin/systemGhcpKey/loadFailed": {
+            return {
+                ...state,
+                admin: {
+                    ...state.admin,
+                    systemGhcpKey: {
+                        ...state.admin.systemGhcpKey,
+                        loading: false,
+                        error: action.error ? String(action.error) : "Failed to load System key status",
+                    },
+                },
+            };
+        }
+        case "admin/systemGhcpKey/saved": {
+            const status = action.status || {};
+            return {
+                ...state,
+                admin: {
+                    ...state.admin,
+                    ghcpKey: {
+                        editing: false,
+                        draft: "",
+                        cursorIndex: 0,
+                        saving: false,
+                        error: null,
+                        lastSavedAt: Date.now(),
+                        storeAsSystem: Boolean(state.admin.ghcpKey.storeAsSystem),
+                    },
+                    systemGhcpKey: {
+                        supported: true,
+                        loading: false,
+                        configured: Boolean(status.configured),
+                        changedBy: status.changedBy || null,
+                        changedAt: status.changedAt || null,
+                        error: null,
                     },
                 },
             };