pilotswarm 0.0.1 → 0.4.1

package/ui/core/src/session-errors.js

@@ -0,0 +1,14 @@
+export function isRecoverableTransportErrorText(text) {
+    const value = String(text || "");
+    return /\bConnection is closed\b/i.test(value)
+        || /\bLive Copilot connection lost\b/i.test(value);
+}
+
+export function shouldKeepRecoverableTransportWarning(previousSession, nextSession) {
+    if (!isRecoverableTransportErrorText(previousSession?.error)) return false;
+    if (nextSession?.error !== undefined) return false;
+    const nextStatus = String(nextSession?.status || "");
+    if (nextStatus !== "running") return false;
+    if (["Completed", "Failed", "Terminated"].includes(String(nextSession?.orchestrationStatus || ""))) return false;
+    return true;
+}

package/ui/core/src/session-tree.js

@@ -0,0 +1,151 @@
+import { systemSessionSortOrder } from "./system-titles.js";
+
+function systemSessionOrder(session) {
+    if (!session?.isSystem) return Number.MAX_SAFE_INTEGER;
+    return systemSessionSortOrder(session);
+}
+
+function buildPreviousOrderMap(previousFlat = []) {
+    const order = new Map();
+    for (let index = 0; index < previousFlat.length; index += 1) {
+        const sessionId = previousFlat[index]?.sessionId;
+        if (!sessionId || order.has(sessionId)) continue;
+        order.set(sessionId, index);
+    }
+    return order;
+}
+
+function buildStableOrderMap(orderSource = []) {
+    if (orderSource instanceof Map) {
+        return new Map(orderSource);
+    }
+    if (Array.isArray(orderSource)) {
+        return buildPreviousOrderMap(orderSource);
+    }
+    const order = new Map();
+    for (const [sessionId, index] of Object.entries(orderSource || {})) {
+        if (!sessionId || typeof index !== "number" || Number.isNaN(index)) continue;
+        order.set(sessionId, index);
+    }
+    return order;
+}
+
+function isTreePinnableSession(session) {
+    return Boolean(
+        session
+        && !session.isSystem
+        && (session.isGroup || (!session.parentSessionId && !session.groupId)),
+    );
+}
+
+function isPinnedSession(session, pinnedIds) {
+    return Boolean(isTreePinnableSession(session) && pinnedIds && pinnedIds.has(session.sessionId));
+}
+
+function rankSessionBand(session, pinnedIds) {
+    if (session.isSystem) return 0;
+    if (session.isGroup && isPinnedSession(session, pinnedIds)) return 1;
+    if (isPinnedSession(session, pinnedIds)) return 2;
+    if (session.isGroup) return 3;
+    return 4;
+}
+
+function summaryTimestamp(session) {
+    const raw = session?.updatedAt
+        ?? session?.summaryUpdatedAt
+        ?? session?.latestSummaryUpdatedAt;
+    const value = typeof raw === "number" ? raw : Date.parse(raw || "");
+    return Number.isFinite(value) ? value : 0;
+}
+
+function sortSessions(a, b, stableOrderMap, pinnedIds) {
+    const aRank = rankSessionBand(a, pinnedIds);
+    const bRank = rankSessionBand(b, pinnedIds);
+    if (aRank !== bRank) return aRank - bRank;
+
+    const aSystemOrder = systemSessionOrder(a);
+    const bSystemOrder = systemSessionOrder(b);
+    if (aSystemOrder !== bSystemOrder) return aSystemOrder - bSystemOrder;
+
+    const aPreviousOrder = stableOrderMap.get(a.sessionId);
+    const bPreviousOrder = stableOrderMap.get(b.sessionId);
+    if (
+        typeof aPreviousOrder === "number"
+        && typeof bPreviousOrder === "number"
+        && aPreviousOrder !== bPreviousOrder
+    ) {
+        return aPreviousOrder - bPreviousOrder;
+    }
+
+    const aSummaryAt = summaryTimestamp(a);
+    const bSummaryAt = summaryTimestamp(b);
+    if (aSummaryAt > 0 && bSummaryAt > 0 && aSummaryAt !== bSummaryAt) {
+        return bSummaryAt - aSummaryAt;
+    }
+
+    const createdDiff = (b.createdAt || 0) - (a.createdAt || 0);
+    if (createdDiff !== 0) return createdDiff;
+
+    const aTitle = String(a.title || "");
+    const bTitle = String(b.title || "");
+    const titleDiff = aTitle.localeCompare(bTitle);
+    if (titleDiff !== 0) return titleDiff;
+
+    return String(a.sessionId || "").localeCompare(String(b.sessionId || ""));
+}
+
+export function buildSessionTree(sessions = [], collapsedIds = new Set(), orderSource = [], pinnedIds = null) {
+    const byId = new Map();
+    const children = new Map();
+    const stableOrderMap = buildStableOrderMap(orderSource);
+    const pinSet = pinnedIds instanceof Set
+        ? pinnedIds
+        : new Set(Array.isArray(pinnedIds) ? pinnedIds : []);
+
+    for (const session of sessions) {
+        byId.set(session.sessionId, session);
+    }
+
+    for (const session of sessions) {
+        const groupParentId = !session.isGroup && session.groupId && !session.parentSessionId && byId.has(`group:${session.groupId}`)
+            ? `group:${session.groupId}`
+            : null;
+        const parentId = session.parentSessionId || groupParentId;
+        if (!parentId || !byId.has(parentId)) continue;
+        if (!children.has(parentId)) children.set(parentId, []);
+        children.get(parentId).push(session);
+    }
+
+    for (const childList of children.values()) {
+        // Pins are a top-level concept. If a previously pinned session moves
+        // into a group, the reducer prunes the pin and the tree ignores any
+        // stale pin while ordering children.
+        childList.sort((a, b) => sortSessions(a, b, stableOrderMap, pinSet));
+    }
+
+    const roots = sessions
+        .filter((session) => {
+            if (session.parentSessionId && byId.has(session.parentSessionId)) return false;
+            if (!session.isGroup && session.groupId && !session.parentSessionId && byId.has(`group:${session.groupId}`)) return false;
+            return true;
+        })
+        .sort((a, b) => sortSessions(a, b, stableOrderMap, pinSet));
+
+    const flat = [];
+
+    function visit(session, depth) {
+        const childList = children.get(session.sessionId) || [];
+        flat.push({
+            sessionId: session.sessionId,
+            depth,
+            hasChildren: childList.length > 0,
+            collapsed: collapsedIds.has(session.sessionId),
+        });
+        if (collapsedIds.has(session.sessionId)) return;
+        for (const child of childList) visit(child, depth + 1);
+    }
+
+    for (const root of roots) visit(root, 0);
+
+    return flat;
+}

package/ui/core/src/state.js

@@ -0,0 +1,251 @@
+import { FOCUS_REGIONS, INSPECTOR_TABS } from "./commands.js";
+import { DEFAULT_THEME_ID, getTheme } from "./themes/index.js";
+
+const ARTIFACT_SOURCES = new Set(["agent", "user", "system"]);
+
+export function normalizeSessionOwnerFilter(filter) {
+    const ownerKeys = Array.isArray(filter?.ownerKeys)
+        ? [...new Set(filter.ownerKeys.map((key) => String(key || "").trim()).filter(Boolean))]
+        : [];
+    const hasExplicitFilter = filter && typeof filter === "object";
+    return {
+        all: hasExplicitFilter ? filter?.all === true : true,
+        includeSystem: filter?.includeSystem === true,
+        includeUnowned: filter?.includeUnowned === true,
+        includeMe: filter?.includeMe === true,
+        ownerKeys,
+    };
+}
+
+export function normalizeArtifactEntry(entry) {
+    if (typeof entry === "string") {
+        const filename = entry.trim();
+        if (!filename) return null;
+        return {
+            filename,
+            sizeBytes: null,
+            contentType: "",
+            isBinary: false,
+            uploadedAt: "",
+            source: "agent",
+        };
+    }
+    if (!entry || typeof entry !== "object") return null;
+    const filename = String(entry.filename || "").trim();
+    if (!filename) return null;
+    const sizeBytes = Number(entry.sizeBytes);
+    const contentType = typeof entry.contentType === "string" ? entry.contentType : "";
+    return {
+        filename,
+        sizeBytes: Number.isFinite(sizeBytes) && sizeBytes >= 0 ? sizeBytes : null,
+        contentType,
+        isBinary: entry.isBinary === true,
+        uploadedAt: typeof entry.uploadedAt === "string" ? entry.uploadedAt : "",
+        source: ARTIFACT_SOURCES.has(entry.source) ? entry.source : "agent",
+    };
+}
+
+export function normalizeArtifactEntries(entries) {
+    const list = Array.isArray(entries) ? entries : [];
+    const normalized = [];
+    const seen = new Set();
+    for (const entry of list) {
+        const candidate = normalizeArtifactEntry(entry);
+        if (!candidate || seen.has(candidate.filename)) continue;
+        seen.add(candidate.filename);
+        normalized.push(candidate);
+    }
+    return normalized;
+}
+
+export function findArtifactEntry(entries, filename) {
+    const target = String(filename || "").trim();
+    if (!target) return null;
+    return normalizeArtifactEntries(entries).find((entry) => entry.filename === target) || null;
+}
+
+export function normalizeStoredLayoutAdjustments(layoutAdjustments) {
+    const candidate = layoutAdjustments && typeof layoutAdjustments === "object"
+        ? layoutAdjustments
+        : {};
+    const paneAdjust = Number(candidate.paneAdjust);
+    const sessionPaneAdjust = Number(candidate.sessionPaneAdjust);
+    const portalSessionColumnAdjust = Number(candidate.portalSessionColumnAdjust);
+    const activityPaneAdjust = Number(candidate.activityPaneAdjust);
+    return {
+        paneAdjust: Number.isFinite(paneAdjust) ? Math.trunc(paneAdjust) : 0,
+        sessionPaneAdjust: Number.isFinite(sessionPaneAdjust) ? Math.trunc(sessionPaneAdjust) : 0,
+        portalSessionColumnAdjust: Number.isFinite(portalSessionColumnAdjust) ? Math.trunc(portalSessionColumnAdjust) : 0,
+        activityPaneAdjust: Number.isFinite(activityPaneAdjust) ? Math.trunc(activityPaneAdjust) : 0,
+    };
+}
+
+export function normalizeStoredPinnedSessionIds(value) {
+    if (!Array.isArray(value)) return [];
+    const seen = new Set();
+    const out = [];
+    for (const entry of value) {
+        const id = String(entry || "").trim();
+        if (!id || seen.has(id)) continue;
+        seen.add(id);
+        out.push(id);
+    }
+    return out;
+}
+
+export function normalizeStoredCollapsedSessionIds(value) {
+    if (!Array.isArray(value)) return new Set();
+    const out = new Set();
+    for (const entry of value) {
+        const id = String(entry || "").trim();
+        if (!id) continue;
+        out.add(id);
+    }
+    return out;
+}
+
+export function normalizeStoredActiveSessionId(value) {
+    if (value == null) return null;
+    const id = String(value).trim();
+    return id ? id : null;
+}
+
+export function createInitialState({ mode = "local", branding = null, themeId = null, chatViewMode = null, sessionOwnerFilter = null, layoutAdjustments = null, pinnedSessionIds = null, collapsedSessionIds = null, activeSessionId = null } = {}) {
+    const hasStoredSessionOwnerFilter = sessionOwnerFilter != null;
+    const hasStoredCollapsedSessionIds = collapsedSessionIds != null;
+    const initialLayoutAdjustments = normalizeStoredLayoutAdjustments(layoutAdjustments);
+    return {
+        branding: branding || {
+            title: "PilotSwarm",
+            splash: "{bold}{cyan-fg}PilotSwarm{/cyan-fg}{/bold}",
+        },
+        auth: {
+            principal: null,
+            authorization: null,
+        },
+        ui: {
+            focusRegion: FOCUS_REGIONS.SESSIONS,
+            inspectorTab: INSPECTOR_TABS[0],
+            chatViewMode: chatViewMode === "summary" ? "summary" : "transcript",
+            statsViewMode: "session",
+            prompt: "",
+            promptCursor: 0,
+            promptRows: 1,
+            promptAttachments: [],
+            promptEdit: null,
+            statusText: "Starting PilotSwarm...",
+            // A persisted theme id may name a theme that no longer ships —
+            // fall back to the default instead of crashing theme consumers.
+            themeId: getTheme(themeId)?.id || DEFAULT_THEME_ID,
+            modal: null,
+            fullscreenPane: null,
+            layout: {
+                ...initialLayoutAdjustments,
+                viewportWidth: 120,
+                viewportHeight: 40,
+            },
+            scroll: {
+                chat: 0,
+                inspector: 0,
+                activity: 0,
+                filePreview: 0,
+            },
+            // Per-session chat scroll memory (rows from bottom), restored on
+            // sessions/selected and evicted with the session's history.
+            chatScrollBySession: {},
+            followBottom: {
+                inspector: true,
+                activity: true,
+            },
+        },
+        connection: {
+            mode,
+            connected: false,
+            workersOnline: null,
+            error: null,
+        },
+        sessions: {
+            byId: {},
+            flat: [],
+            activeSessionId: normalizeStoredActiveSessionId(activeSessionId),
+            collapsedIds: normalizeStoredCollapsedSessionIds(collapsedSessionIds),
+            collapsedIdsExplicit: hasStoredCollapsedSessionIds,
+            pinnedIds: normalizeStoredPinnedSessionIds(pinnedSessionIds),
+            selectedIds: [],
+            selectMode: false,
+            orderById: {},
+            nextOrderOrdinal: 0,
+            filterQuery: "",
+            ownerFilterExplicit: hasStoredSessionOwnerFilter,
+            ownerFilter: normalizeSessionOwnerFilter(sessionOwnerFilter),
+        },
+        history: {
+            bySessionId: new Map(),
+        },
+        outbox: {
+            bySessionId: {},
+        },
+        orchestration: {
+            bySessionId: {},
+        },
+        executionHistory: {
+            bySessionId: {},
+            format: "pretty",
+        },
+        files: {
+            bySessionId: {},
+            fullscreen: false,
+            selectedArtifactId: null,
+            filter: {
+                scope: "selectedSession",
+                query: "",
+            },
+        },
+        logs: {
+            available: false,
+            availabilityReason: "Log tailing disabled: no K8S_CONTEXT configured in the env file.",
+            tailing: false,
+            entries: [],
+            filter: {
+                source: "allNodes",
+                level: "all",
+                format: "pretty",
+            },
+        },
+        sessionStats: {
+            bySessionId: {},
+        },
+        fleetStats: {
+            loading: false,
+            data: null,
+            userStats: null,
+            fetchedAt: 0,
+        },
+        admin: {
+            // Whether the Admin Console is taking over the workspace and
+            // hiding the session/chat panes. Persisted only in-memory.
+            visible: false,
+            loading: false,
+            loadError: null,
+            // Public profile snapshot from the management API. Never holds
+            // the raw GitHub Copilot key — only the `githubCopilotKeySet`
+            // boolean flag.
+            profile: null,
+            ghcpKey: {
+                // Editing flag is the single host-neutral signal that the
+                // user is composing a new key. Both the portal's inline
+                // form and the native TUI's overlay render against this.
+                editing: false,
+                draft: "",
+                // cursorIndex is only consumed by the native TUI overlay
+                // (browser <input> elements manage their own cursor). It
+                // is kept in shared state so the controller mutators can
+                // remain host-neutral.
+                cursorIndex: 0,
+                saving: false,
+                error: null,
+                lastSavedAt: 0,
+            },
+        },
+    };
+}

package/ui/core/src/store.js

@@ -0,0 +1,23 @@
+export function createStore(reducer, initialState) {
+    let state = initialState;
+    const listeners = new Set();
+
+    return {
+        getState() {
+            return state;
+        },
+        dispatch(action) {
+            const nextState = reducer(state, action);
+            if (Object.is(nextState, state)) {
+                return action;
+            }
+            state = nextState;
+            for (const listener of listeners) listener(state, action);
+            return action;
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+    };
+}

package/ui/core/src/system-titles.js

@@ -0,0 +1,24 @@
+export function canonicalSystemTitle(session, brandingTitle = "PilotSwarm") {
+    const brandedRootTitle = brandingTitle || "PilotSwarm";
+    const agentId = String(session?.agentId || "");
+    if (agentId === "pilotswarm") return brandedRootTitle;
+    if (agentId === "sweeper") return "Sweeper Agent";
+    if (agentId === "resourcemgr") return "Resource Manager Agent";
+    if (agentId === "facts-manager") return "Facts Manager";
+
+    const rawTitle = String(session?.title || "").trim();
+    if (/^pilotswarm(?: agent)?$/i.test(rawTitle)) return brandedRootTitle;
+    if (/^sweeper agent$/i.test(rawTitle) || /^sweeper$/i.test(rawTitle)) return "Sweeper Agent";
+    if (/^resource manager agent$/i.test(rawTitle) || /^resourcemgr$/i.test(rawTitle)) return "Resource Manager Agent";
+    if (/^facts manager$/i.test(rawTitle) || /^facts-manager$/i.test(rawTitle)) return "Facts Manager";
+    return rawTitle || "System Agent";
+}
+
+export function systemSessionSortOrder(session) {
+    const title = canonicalSystemTitle(session, "PilotSwarm");
+    if (title === "PilotSwarm") return 0;
+    if (title === "Sweeper Agent") return 1;
+    if (title === "Resource Manager Agent") return 2;
+    if (title === "Facts Manager") return 3;
+    return 10;
+}

package/ui/core/src/themes/catppuccin-mocha.js

@@ -0,0 +1,56 @@
+import { createTheme } from "./helpers.js";
+
+const catppuccinMochaTheme = createTheme({
+    id: "catppuccin-mocha",
+    label: "Catppuccin Mocha",
+    description: "Creamy dark palette with soft pastels and high legibility.",
+    page: {
+        background: "#1e1e2e",
+        foreground: "#cdd6f4",
+        overlayBackground: "#1e1e2e",
+        overlayForeground: "#cdd6f4",
+        hintColor: "#bac2de",
+        modalBackdrop: "rgba(17, 17, 27, 0.74)",
+        modalBackground: "#313244",
+        modalBorder: "#585b70",
+        modalForeground: "#cdd6f4",
+        modalMuted: "#bac2de",
+        modalSelectedBackground: "#45475a",
+        modalSelectedBorder: "#89b4fa",
+        modalSelectedForeground: "#cdd6f4",
+    },
+    terminal: {
+        background: "#1e1e2e",
+        foreground: "#cdd6f4",
+        cursor: "#f5e0dc",
+        cursorAccent: "#1e1e2e",
+        selectionBackground: "rgba(137, 180, 250, 0.22)",
+        black: "#45475a",
+        red: "#f38ba8",
+        green: "#a6e3a1",
+        yellow: "#f9e2af",
+        blue: "#89b4fa",
+        magenta: "#f5c2e7",
+        cyan: "#94e2d5",
+        white: "#bac2de",
+        brightBlack: "#585b70",
+        brightRed: "#f38ba8",
+        brightGreen: "#a6e3a1",
+        brightYellow: "#f9e2af",
+        brightBlue: "#89b4fa",
+        brightMagenta: "#f5c2e7",
+        brightCyan: "#94e2d5",
+        brightWhite: "#f5e0dc",
+    },
+    tui: {
+        surface: "#1e1e2e",
+        activeHighlightBackground: "#45475a",
+        activeHighlightForeground: "#cdd6f4",
+        selectionBackground: "#89b4fa",
+        selectionForeground: "#1e1e2e",
+        promptCursorBackground: "#f5e0dc",
+        promptCursorForeground: "#1e1e2e",
+    },
+});
+
+export default catppuccinMochaTheme;

package/ui/core/src/themes/cobalt2.js

@@ -0,0 +1,56 @@
+import { createTheme } from "./helpers.js";
+
+const cobalt2Theme = createTheme({
+    id: "cobalt2",
+    label: "Cobalt2",
+    description: "Electric blue shell with bright yellow accents and saturated syntax colors.",
+    page: {
+        background: "#193549",
+        foreground: "#ffffff",
+        overlayBackground: "#193549",
+        overlayForeground: "#ffffff",
+        hintColor: "#a8c5e6",
+        modalBackdrop: "rgba(7, 17, 28, 0.68)",
+        modalBackground: "#224b68",
+        modalBorder: "#2e6c99",
+        modalForeground: "#ffffff",
+        modalMuted: "#a8c5e6",
+        modalSelectedBackground: "#ffc600",
+        modalSelectedBorder: "#ffc600",
+        modalSelectedForeground: "#193549",
+    },
+    terminal: {
+        background: "#193549",
+        foreground: "#ffffff",
+        cursor: "#ffc600",
+        cursorAccent: "#193549",
+        selectionBackground: "rgba(255, 255, 255, 0.18)",
+        black: "#000000",
+        red: "#ff628c",
+        green: "#3ad900",
+        yellow: "#ff9d00",
+        blue: "#0088ff",
+        magenta: "#ff628c",
+        cyan: "#80ffbb",
+        white: "#ffffff",
+        brightBlack: "#666666",
+        brightRed: "#ff628c",
+        brightGreen: "#3ad900",
+        brightYellow: "#ff9d00",
+        brightBlue: "#0088ff",
+        brightMagenta: "#ff9d00",
+        brightCyan: "#80ffbb",
+        brightWhite: "#ffffff",
+    },
+    tui: {
+        surface: "#193549",
+        activeHighlightBackground: "#0f5f91",
+        activeHighlightForeground: "#ffffff",
+        selectionBackground: "#ffc600",
+        selectionForeground: "#193549",
+        promptCursorBackground: "#ffc600",
+        promptCursorForeground: "#193549",
+    },
+});
+
+export default cobalt2Theme;

package/ui/core/src/themes/dark-high-contrast.js

@@ -0,0 +1,56 @@
+import { createTheme } from "./helpers.js";
+
+const darkHighContrastTheme = createTheme({
+    id: "dark-high-contrast",
+    label: "Dark High Contrast",
+    description: "Pure black background with maximum contrast ANSI colors for accessibility.",
+    page: {
+        background: "#000000",
+        foreground: "#ffffff",
+        overlayBackground: "#000000",
+        overlayForeground: "#ffffff",
+        hintColor: "#3794ff",
+        modalBackdrop: "rgba(0, 0, 0, 0.85)",
+        modalBackground: "#0c0c0c",
+        modalBorder: "#6fc3df",
+        modalForeground: "#ffffff",
+        modalMuted: "#9d9d9d",
+        modalSelectedBackground: "#0f4a85",
+        modalSelectedBorder: "#f38518",
+        modalSelectedForeground: "#ffffff",
+    },
+    terminal: {
+        background: "#000000",
+        foreground: "#ffffff",
+        cursor: "#ffffff",
+        cursorAccent: "#000000",
+        selectionBackground: "rgba(255, 255, 255, 0.3)",
+        black: "#000000",
+        red: "#f44747",
+        green: "#73c991",
+        yellow: "#e5e510",
+        blue: "#3794ff",
+        magenta: "#bc3fbc",
+        cyan: "#29b8db",
+        white: "#e5e5e5",
+        brightBlack: "#666666",
+        brightRed: "#f14c4c",
+        brightGreen: "#89d185",
+        brightYellow: "#f5f543",
+        brightBlue: "#6fc3df",
+        brightMagenta: "#d670d6",
+        brightCyan: "#2ee2e2",
+        brightWhite: "#ffffff",
+    },
+    tui: {
+        surface: "#000000",
+        activeHighlightBackground: "#0f4a85",
+        activeHighlightForeground: "#ffffff",
+        selectionBackground: "#f38518",
+        selectionForeground: "#000000",
+        promptCursorBackground: "#ffffff",
+        promptCursorForeground: "#000000",
+    },
+});
+
+export default darkHighContrastTheme;