@wingman-ai/gateway 0.1.0

package/dist/cli/ui/App.js

@@ -0,0 +1,241 @@
+import react, { useEffect, useRef, useState } from "react";
+import { Box, Text } from "ink";
+import { LogDisplay } from "./LogDisplay.js";
+import { AgentOutput } from "./AgentOutput.js";
+import { ErrorDisplay } from "./ErrorDisplay.js";
+import { parseStreamChunk } from "../core/streamParser.js";
+import { createTextBlock, createToolCallBlock } from "./blockHelpers.js";
+const App = ({ outputManager })=>{
+    const [logs, setLogs] = useState([]);
+    const [agentName, setAgentName] = useState("");
+    const [contentBlocks, setContentBlocks] = useState([]);
+    const [activeTools, setActiveTools] = useState(new Map());
+    const processedToolCallIdsRef = useRef(new Set());
+    const processedToolResultIdsRef = useRef(new Set());
+    const [isStreaming, setIsStreaming] = useState(false);
+    const [error, setError] = useState();
+    const [isComplete, setIsComplete] = useState(false);
+    useEffect(()=>{
+        const handleEvent = (event)=>{
+            switch(event.type){
+                case "log":
+                    setLogs((prev)=>[
+                            ...prev,
+                            {
+                                level: event.level,
+                                message: event.message,
+                                timestamp: event.timestamp,
+                                args: event.args
+                            }
+                        ]);
+                    break;
+                case "agent-start":
+                    setAgentName(event.agent);
+                    setIsStreaming(true);
+                    break;
+                case "agent-stream":
+                    const parsedArray = parseStreamChunk(event.chunk);
+                    if (!parsedArray || 0 === parsedArray.length) break;
+                    for (const parsed of parsedArray)switch(parsed.type){
+                        case "text":
+                            if (parsed.text) {
+                                const text = parsed.text;
+                                const messageId = parsed.messageId;
+                                setContentBlocks((prev)=>{
+                                    const updateBlockAtIndex = (index, text)=>{
+                                        const existingBlock = prev[index];
+                                        const existingContent = existingBlock.data.content;
+                                        let nextContent = existingContent;
+                                        nextContent = text.startsWith(existingContent) ? text : existingContent + text;
+                                        const updatedData = {
+                                            ...existingBlock.data,
+                                            content: nextContent,
+                                            isStreaming: true
+                                        };
+                                        return [
+                                            ...prev.slice(0, index),
+                                            {
+                                                ...existingBlock,
+                                                data: updatedData
+                                            },
+                                            ...prev.slice(index + 1)
+                                        ];
+                                    };
+                                    if (messageId) {
+                                        const existingIndex = prev.findIndex((block)=>"text" === block.type && block.id === messageId);
+                                        if (existingIndex >= 0) return updateBlockAtIndex(existingIndex, text);
+                                    } else {
+                                        const lastBlock = prev[prev.length - 1];
+                                        if (lastBlock?.type === "text") return updateBlockAtIndex(prev.length - 1, text);
+                                    }
+                                    return [
+                                        ...prev,
+                                        createTextBlock(text, true, messageId)
+                                    ];
+                                });
+                            }
+                            break;
+                        case "tool":
+                            if (parsed.toolCall) {
+                                const toolCall = parsed.toolCall;
+                                const alreadyProcessed = processedToolCallIdsRef.current.has(toolCall.id);
+                                let toolBlock = null;
+                                if (!alreadyProcessed) {
+                                    processedToolCallIdsRef.current.add(toolCall.id);
+                                    toolBlock = createToolCallBlock(toolCall);
+                                    setContentBlocks((prev)=>[
+                                            ...prev,
+                                            toolBlock
+                                        ]);
+                                }
+                                setActiveTools((prev)=>{
+                                    const updated = new Map(prev);
+                                    const existing = updated.get(toolCall.id);
+                                    if (existing) {
+                                        const incomingArgs = toolCall.args || {};
+                                        const mergedArgs = Object.keys(incomingArgs).length > 0 ? {
+                                            ...existing.args,
+                                            ...incomingArgs
+                                        } : existing.args;
+                                        updated.set(toolCall.id, {
+                                            ...existing,
+                                            args: mergedArgs
+                                        });
+                                        return updated;
+                                    }
+                                    if (toolBlock) {
+                                        updated.set(toolBlock.id, toolBlock.data);
+                                        return updated;
+                                    }
+                                    updated.set(toolCall.id, {
+                                        name: toolCall.name,
+                                        args: toolCall.args || {},
+                                        status: "running",
+                                        startTime: Date.now()
+                                    });
+                                    return updated;
+                                });
+                            }
+                            break;
+                        case "tool-result":
+                            if (parsed.toolResult) {
+                                if (processedToolResultIdsRef.current.has(parsed.toolResult.id)) break;
+                                processedToolResultIdsRef.current.add(parsed.toolResult.id);
+                                const outputStr = "string" == typeof parsed.toolResult.output ? parsed.toolResult.output : JSON.stringify(parsed.toolResult.output, null, 2);
+                                const truncated = outputStr.length > 5000;
+                                setActiveTools((prev)=>{
+                                    const updated = new Map(prev);
+                                    const tool = updated.get(parsed.toolResult.id);
+                                    if (tool) {
+                                        tool.status = parsed.toolResult.error ? "error" : "complete";
+                                        tool.endTime = Date.now();
+                                        tool.result = {
+                                            output: outputStr,
+                                            truncated,
+                                            error: parsed.toolResult.error
+                                        };
+                                    }
+                                    return updated;
+                                });
+                                setContentBlocks((prev)=>{
+                                    const toolIndex = prev.findIndex((block)=>"tool-call" === block.type && block.id === parsed.toolResult.id);
+                                    if (-1 === toolIndex) return prev;
+                                    const toolBlock = prev[toolIndex];
+                                    const status = parsed.toolResult.error ? "error" : "complete";
+                                    const updatedData = {
+                                        ...toolBlock.data,
+                                        status,
+                                        endTime: Date.now(),
+                                        result: {
+                                            output: outputStr,
+                                            truncated,
+                                            error: parsed.toolResult.error
+                                        }
+                                    };
+                                    return [
+                                        ...prev.slice(0, toolIndex),
+                                        {
+                                            ...toolBlock,
+                                            data: updatedData
+                                        },
+                                        ...prev.slice(toolIndex + 1)
+                                    ];
+                                });
+                            }
+                            break;
+                    }
+                    break;
+                case "agent-complete":
+                    setIsStreaming(false);
+                    setIsComplete(true);
+                    setContentBlocks((prev)=>{
+                        if (0 === prev.length) return prev;
+                        const lastBlock = prev[prev.length - 1];
+                        if ("text" === lastBlock.type) {
+                            const updatedData = {
+                                ...lastBlock.data,
+                                isStreaming: false
+                            };
+                            return [
+                                ...prev.slice(0, -1),
+                                {
+                                    ...lastBlock,
+                                    data: updatedData
+                                }
+                            ];
+                        }
+                        return prev;
+                    });
+                    break;
+                case "agent-error":
+                    setIsStreaming(false);
+                    setError({
+                        message: event.error,
+                        stack: event.stack,
+                        logFile: event.logFile
+                    });
+                    break;
+            }
+        };
+        outputManager.on("output-event", handleEvent);
+        return ()=>{
+            outputManager.off("output-event", handleEvent);
+        };
+    }, [
+        outputManager
+    ]);
+    return /*#__PURE__*/ react.createElement(Box, {
+        flexDirection: "column",
+        padding: 1
+    }, /*#__PURE__*/ react.createElement(Text, {
+        bold: true,
+        color: "cyan"
+    }, "Wingman CLI"), agentName && /*#__PURE__*/ react.createElement(Box, {
+        marginTop: 1
+    }, /*#__PURE__*/ react.createElement(Text, null, "Agent: ", /*#__PURE__*/ react.createElement(Text, {
+        color: "green"
+    }, agentName))), logs.length > 0 && /*#__PURE__*/ react.createElement(Box, {
+        flexDirection: "column",
+        marginTop: 1
+    }, /*#__PURE__*/ react.createElement(LogDisplay, {
+        logs: logs,
+        maxLogs: 20
+    })), contentBlocks.length > 0 && /*#__PURE__*/ react.createElement(Box, {
+        marginTop: 1
+    }, /*#__PURE__*/ react.createElement(AgentOutput, {
+        blocks: contentBlocks,
+        activeTools: activeTools,
+        isStreaming: isStreaming
+    })), error && /*#__PURE__*/ react.createElement(Box, {
+        marginTop: 1
+    }, /*#__PURE__*/ react.createElement(ErrorDisplay, {
+        error: error.message,
+        stack: error.stack,
+        logFile: error.logFile
+    })), isComplete && !error && /*#__PURE__*/ react.createElement(Box, {
+        marginTop: 1
+    }, /*#__PURE__*/ react.createElement(Text, {
+        color: "green"
+    }, "✓ Complete")));
+};
+export { App };

package/dist/cli/ui/ErrorDisplay.cjs

@@ -0,0 +1,65 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    ErrorDisplay: ()=>ErrorDisplay
+});
+const external_react_namespaceObject = require("react");
+var external_react_default = /*#__PURE__*/ __webpack_require__.n(external_react_namespaceObject);
+const external_ink_namespaceObject = require("ink");
+const ErrorDisplay = ({ error, stack, showStack = false, logFile })=>/*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Box, {
+        flexDirection: "column",
+        paddingY: 1
+    }, /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Text, {
+        color: "red",
+        bold: true
+    }, "Error:"), /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Text, {
+        color: "red"
+    }, error), logFile && /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Text, {
+        color: "gray"
+    }, "Logs: ", logFile), showStack && stack && /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Box, {
+        flexDirection: "column",
+        marginTop: 1
+    }, /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Text, {
+        color: "gray"
+    }, "Stack trace:"), /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Text, {
+        color: "gray"
+    }, stack)));
+exports.ErrorDisplay = __webpack_exports__.ErrorDisplay;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ErrorDisplay"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cli/ui/ErrorDisplay.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+export interface ErrorDisplayProps {
+    error: string;
+    stack?: string;
+    showStack?: boolean;
+    logFile?: string;
+}
+export declare const ErrorDisplay: React.FC<ErrorDisplayProps>;

package/dist/cli/ui/ErrorDisplay.js

@@ -0,0 +1,21 @@
+import react from "react";
+import { Box, Text } from "ink";
+const ErrorDisplay = ({ error, stack, showStack = false, logFile })=>/*#__PURE__*/ react.createElement(Box, {
+        flexDirection: "column",
+        paddingY: 1
+    }, /*#__PURE__*/ react.createElement(Text, {
+        color: "red",
+        bold: true
+    }, "Error:"), /*#__PURE__*/ react.createElement(Text, {
+        color: "red"
+    }, error), logFile && /*#__PURE__*/ react.createElement(Text, {
+        color: "gray"
+    }, "Logs: ", logFile), showStack && stack && /*#__PURE__*/ react.createElement(Box, {
+        flexDirection: "column",
+        marginTop: 1
+    }, /*#__PURE__*/ react.createElement(Text, {
+        color: "gray"
+    }, "Stack trace:"), /*#__PURE__*/ react.createElement(Text, {
+        color: "gray"
+    }, stack)));
+export { ErrorDisplay };

package/dist/cli/ui/LogDisplay.cjs

@@ -0,0 +1,74 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    LogDisplay: ()=>LogDisplay
+});
+const external_react_namespaceObject = require("react");
+var external_react_default = /*#__PURE__*/ __webpack_require__.n(external_react_namespaceObject);
+const external_ink_namespaceObject = require("ink");
+const LogDisplay = ({ logs, maxLogs = 100 })=>{
+    const displayLogs = logs.slice(-maxLogs);
+    const getColor = (level)=>{
+        switch(level){
+            case "debug":
+                return "gray";
+            case "info":
+                return "blue";
+            case "warn":
+                return "yellow";
+            case "error":
+                return "red";
+            default:
+                return "white";
+        }
+    };
+    return /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Box, {
+        flexDirection: "column"
+    }, displayLogs.map((log, index)=>/*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Box, {
+            key: index,
+            flexDirection: "column"
+        }, /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Text, {
+            color: getColor(log.level)
+        }, "[", log.level.toUpperCase(), "] ", log.message), log.args && log.args.length > 0 && /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Text, {
+            color: "gray"
+        }, JSON.stringify(log.args, null, 2)))));
+};
+exports.LogDisplay = __webpack_exports__.LogDisplay;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "LogDisplay"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cli/ui/LogDisplay.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+import type { LogLevel } from "../../logger.js";
+export interface LogEntry {
+    level: LogLevel;
+    message: string;
+    timestamp: string;
+    args?: any[];
+}
+export interface LogDisplayProps {
+    logs: LogEntry[];
+    maxLogs?: number;
+}
+export declare const LogDisplay: React.FC<LogDisplayProps>;

package/dist/cli/ui/LogDisplay.js

@@ -0,0 +1,30 @@
+import react from "react";
+import { Box, Text } from "ink";
+const LogDisplay = ({ logs, maxLogs = 100 })=>{
+    const displayLogs = logs.slice(-maxLogs);
+    const getColor = (level)=>{
+        switch(level){
+            case "debug":
+                return "gray";
+            case "info":
+                return "blue";
+            case "warn":
+                return "yellow";
+            case "error":
+                return "red";
+            default:
+                return "white";
+        }
+    };
+    return /*#__PURE__*/ react.createElement(Box, {
+        flexDirection: "column"
+    }, displayLogs.map((log, index)=>/*#__PURE__*/ react.createElement(Box, {
+            key: index,
+            flexDirection: "column"
+        }, /*#__PURE__*/ react.createElement(Text, {
+            color: getColor(log.level)
+        }, "[", log.level.toUpperCase(), "] ", log.message), log.args && log.args.length > 0 && /*#__PURE__*/ react.createElement(Text, {
+            color: "gray"
+        }, JSON.stringify(log.args, null, 2)))));
+};
+export { LogDisplay };

package/dist/cli/ui/SessionListDisplay.cjs

@@ -0,0 +1,135 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    SessionListDisplay: ()=>SessionListDisplay
+});
+const external_react_namespaceObject = require("react");
+var external_react_default = /*#__PURE__*/ __webpack_require__.n(external_react_namespaceObject);
+const external_ink_namespaceObject = require("ink");
+const SessionListDisplay = ({ sessions })=>{
+    if (0 === sessions.length) return /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Box, {
+        flexDirection: "column",
+        paddingY: 1
+    }, /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Text, {
+        color: "yellow"
+    }, "No sessions found."), /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Text, {
+        dimColor: true
+    }, "Use /clear to start a new session."));
+    const formatRelativeTime = (date)=>{
+        const now = new Date();
+        const diffMs = now.getTime() - date.getTime();
+        const diffMins = Math.floor(diffMs / 60000);
+        const diffHours = Math.floor(diffMs / 3600000);
+        const diffDays = Math.floor(diffMs / 86400000);
+        if (diffMins < 1) return "just now";
+        if (diffMins < 60) return `${diffMins}m ago`;
+        if (diffHours < 24) return `${diffHours}h ago`;
+        if (diffDays < 30) return `${diffDays}d ago`;
+        return date.toLocaleDateString();
+    };
+    const truncate = (text, maxLen)=>{
+        if (text.length <= maxLen) return text;
+        return text.substring(0, maxLen - 3) + "...";
+    };
+    return /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Box, {
+        flexDirection: "column",
+        paddingY: 1
+    }, /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Box, {
+        marginBottom: 1
+    }, /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Text, {
+        bold: true,
+        color: "cyan"
+    }, "Active Sessions (", sessions.length, ")")), /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Box, null, /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Box, {
+        width: 12
+    }, /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Text, {
+        bold: true,
+        dimColor: true
+    }, "ID")), /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Box, {
+        width: 25
+    }, /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Text, {
+        bold: true,
+        dimColor: true
+    }, "Name")), /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Box, {
+        width: 15
+    }, /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Text, {
+        bold: true,
+        dimColor: true
+    }, "Agent")), /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Box, {
+        width: 10
+    }, /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Text, {
+        bold: true,
+        dimColor: true
+    }, "Messages")), /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Box, {
+        width: 15
+    }, /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Text, {
+        bold: true,
+        dimColor: true
+    }, "Last Active"))), /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Box, {
+        marginY: 0
+    }, /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Text, {
+        dimColor: true
+    }, "─".repeat(77))), sessions.map((session)=>/*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Box, {
+            key: session.id
+        }, /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Box, {
+            width: 12
+        }, /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Text, {
+            color: "gray"
+        }, truncate(session.id, 10))), /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Box, {
+            width: 25
+        }, /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Text, null, truncate(session.name, 23))), /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Box, {
+            width: 15
+        }, /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Text, {
+            color: "cyan"
+        }, truncate(session.agentName, 13))), /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Box, {
+            width: 10
+        }, /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Text, {
+            color: "yellow"
+        }, session.messageCount)), /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Box, {
+            width: 15
+        }, /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Text, {
+            dimColor: true
+        }, formatRelativeTime(session.updatedAt))))), /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Box, {
+        marginTop: 1
+    }, /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Text, {
+        dimColor: true
+    }, "Use /resume ", "<id>", " to resume a session, or /clear ", "<agent>", " to start new")));
+};
+exports.SessionListDisplay = __webpack_exports__.SessionListDisplay;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "SessionListDisplay"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cli/ui/SessionListDisplay.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import type { Session } from "../core/sessionManager.js";
+export interface SessionListDisplayProps {
+    sessions: Session[];
+}
+/**
+ * Display a list of sessions in a table format
+ */
+export declare const SessionListDisplay: React.FC<SessionListDisplayProps>;