@wingman-ai/gateway 0.1.0

package/dist/cli/types.d.ts

@@ -0,0 +1,175 @@
+import type { LogLevel } from "../logger.js";
+export type OutputMode = "interactive" | "json";
+export interface WingmanConfig {
+    logLevel?: LogLevel;
+    defaultAgent?: string;
+    gateway?: {
+        host?: string;
+        port?: number;
+        stateDir?: string;
+        auth?: {
+            mode?: "token" | "password" | "none";
+            token?: string;
+            password?: string;
+            allowTailscale?: boolean;
+        };
+        controlUi?: {
+            enabled?: boolean;
+            port?: number;
+            pairingRequired?: boolean;
+            allowInsecureAuth?: boolean;
+        };
+        adapters?: {
+            discord?: {
+                enabled?: boolean;
+                token?: string;
+                mentionOnly?: boolean;
+                allowBots?: boolean;
+                allowedGuilds?: string[];
+                allowedChannels?: string[];
+                channelSessions?: Record<string, string>;
+                sessionCommand?: string;
+                gatewayUrl?: string;
+                gatewayToken?: string;
+                gatewayPassword?: string;
+                responseChunkSize?: number;
+            };
+        };
+    };
+    agents?: {
+        list?: Array<{
+            id: string;
+            name?: string;
+            default?: boolean;
+            workspace?: string;
+            agentDir?: string;
+            model?: string;
+        }>;
+        bindings?: Array<{
+            agentId: string;
+            match: {
+                channel: string;
+                accountId?: string;
+                guildId?: string;
+                teamId?: string;
+                peer?: {
+                    kind: "dm" | "group" | "channel";
+                    id: string;
+                };
+            };
+        }>;
+    };
+    cli?: {
+        theme?: string;
+        outputMode?: "auto" | OutputMode;
+    };
+}
+export interface LogEvent {
+    type: "log";
+    level: LogLevel;
+    message: string;
+    timestamp: string;
+    args?: any[];
+}
+export interface AgentStartEvent {
+    type: "agent-start";
+    agent: string;
+    prompt: string;
+    timestamp: string;
+}
+export interface AgentStreamEvent {
+    type: "agent-stream";
+    chunk: any;
+    timestamp: string;
+}
+export interface AgentCompleteEvent {
+    type: "agent-complete";
+    result: any;
+    timestamp: string;
+}
+export interface AgentErrorEvent {
+    type: "agent-error";
+    error: string;
+    stack?: string;
+    logFile?: string;
+    timestamp: string;
+}
+export interface SkillBrowseEvent {
+    type: "skill-browse";
+    skills: Array<{
+        name: string;
+        description: string;
+    }>;
+    timestamp: string;
+}
+export interface SkillInstallProgressEvent {
+    type: "skill-install-progress";
+    skill: string;
+    status: string;
+    timestamp: string;
+}
+export interface SkillInstallCompleteEvent {
+    type: "skill-install-complete";
+    skill: string;
+    path: string;
+    timestamp: string;
+}
+export interface SkillListEvent {
+    type: "skill-list";
+    skills: Array<{
+        name: string;
+        description: string;
+        path: string;
+    }>;
+    timestamp: string;
+}
+export interface SkillRemoveEvent {
+    type: "skill-remove";
+    skill: string;
+    timestamp: string;
+}
+export type OutputEvent = LogEvent | AgentStartEvent | AgentStreamEvent | AgentCompleteEvent | AgentErrorEvent | SkillBrowseEvent | SkillInstallProgressEvent | SkillInstallCompleteEvent | SkillListEvent | SkillRemoveEvent;
+export interface TextBlock {
+    content: string;
+    isStreaming: boolean;
+}
+export interface ToolCallBlock {
+    name: string;
+    args: Record<string, any>;
+    status: "running" | "complete" | "error";
+    startTime: number;
+    endTime?: number;
+    result?: {
+        output: string;
+        truncated: boolean;
+        error?: string;
+    };
+}
+export interface ToolResultBlock {
+    toolCallId: string;
+    output: string;
+    truncated: boolean;
+    error?: string;
+}
+export type ContentBlockData = TextBlock | ToolCallBlock | ToolResultBlock;
+export interface ContentBlock {
+    id: string;
+    type: "text" | "tool-call" | "tool-result";
+    timestamp: number;
+    data: ContentBlockData;
+}
+export interface AgentCommandArgs {
+    agent?: string;
+    verbosity: LogLevel;
+    outputMode: OutputMode;
+    prompt: string;
+}
+export interface ParsedArgs {
+    command: string;
+    args: string[];
+    flags: {
+        agent?: string;
+        verbose?: string;
+        help?: boolean;
+    };
+}

package/dist/cli/ui/AgentOutput.cjs

@@ -0,0 +1,82 @@
+"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__, {
+    AgentOutput: ()=>AgentOutput
+});
+const external_react_namespaceObject = require("react");
+var external_react_default = /*#__PURE__*/ __webpack_require__.n(external_react_namespaceObject);
+const external_ink_namespaceObject = require("ink");
+const ToolCallDisplay_cjs_namespaceObject = require("./components/ToolCallDisplay.cjs");
+const AgentOutput = ({ blocks, activeTools, isStreaming })=>{
+    if (0 === blocks.length && !isStreaming) return null;
+    return /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Box, {
+        flexDirection: "column"
+    }, blocks.map((block, index)=>{
+        switch(block.type){
+            case "text":
+                {
+                    const textData = block.data;
+                    const isLastBlock = index === blocks.length - 1;
+                    const showStreamingIndicator = isLastBlock && isStreaming && textData.isStreaming;
+                    return /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Box, {
+                        key: block.id,
+                        flexDirection: "column"
+                    }, /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Text, null, textData.content), showStreamingIndicator && /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Text, {
+                        dimColor: true,
+                        italic: true
+                    }, "..."));
+                }
+            case "tool-call":
+                {
+                    const toolData = block.data;
+                    const activeTool = activeTools.get(block.id);
+                    const displayTool = activeTool || toolData;
+                    return /*#__PURE__*/ external_react_default().createElement(ToolCallDisplay_cjs_namespaceObject.ToolCallDisplay, {
+                        key: block.id,
+                        tool: displayTool
+                    });
+                }
+            default:
+                return null;
+        }
+    }));
+};
+exports.AgentOutput = __webpack_exports__.AgentOutput;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "AgentOutput"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,8 @@
+import React from "react";
+import type { ContentBlock, ToolCallBlock } from "../types.js";
+export interface AgentOutputProps {
+    blocks: ContentBlock[];
+    activeTools: Map<string, ToolCallBlock>;
+    isStreaming: boolean;
+}
+export declare const AgentOutput: React.FC<AgentOutputProps>;

package/dist/cli/ui/AgentOutput.js

@@ -0,0 +1,38 @@
+import react from "react";
+import { Box, Text } from "ink";
+import { ToolCallDisplay } from "./components/ToolCallDisplay.js";
+const AgentOutput = ({ blocks, activeTools, isStreaming })=>{
+    if (0 === blocks.length && !isStreaming) return null;
+    return /*#__PURE__*/ react.createElement(Box, {
+        flexDirection: "column"
+    }, blocks.map((block, index)=>{
+        switch(block.type){
+            case "text":
+                {
+                    const textData = block.data;
+                    const isLastBlock = index === blocks.length - 1;
+                    const showStreamingIndicator = isLastBlock && isStreaming && textData.isStreaming;
+                    return /*#__PURE__*/ react.createElement(Box, {
+                        key: block.id,
+                        flexDirection: "column"
+                    }, /*#__PURE__*/ react.createElement(Text, null, textData.content), showStreamingIndicator && /*#__PURE__*/ react.createElement(Text, {
+                        dimColor: true,
+                        italic: true
+                    }, "..."));
+                }
+            case "tool-call":
+                {
+                    const toolData = block.data;
+                    const activeTool = activeTools.get(block.id);
+                    const displayTool = activeTool || toolData;
+                    return /*#__PURE__*/ react.createElement(ToolCallDisplay, {
+                        key: block.id,
+                        tool: displayTool
+                    });
+                }
+            default:
+                return null;
+        }
+    }));
+};
+export { AgentOutput };

package/dist/cli/ui/App.cjs

@@ -0,0 +1,285 @@
+"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__, {
+    App: ()=>App
+});
+const external_react_namespaceObject = require("react");
+var external_react_default = /*#__PURE__*/ __webpack_require__.n(external_react_namespaceObject);
+const external_ink_namespaceObject = require("ink");
+const external_LogDisplay_cjs_namespaceObject = require("./LogDisplay.cjs");
+const external_AgentOutput_cjs_namespaceObject = require("./AgentOutput.cjs");
+const external_ErrorDisplay_cjs_namespaceObject = require("./ErrorDisplay.cjs");
+const streamParser_cjs_namespaceObject = require("../core/streamParser.cjs");
+const external_blockHelpers_cjs_namespaceObject = require("./blockHelpers.cjs");
+const App = ({ outputManager })=>{
+    const [logs, setLogs] = (0, external_react_namespaceObject.useState)([]);
+    const [agentName, setAgentName] = (0, external_react_namespaceObject.useState)("");
+    const [contentBlocks, setContentBlocks] = (0, external_react_namespaceObject.useState)([]);
+    const [activeTools, setActiveTools] = (0, external_react_namespaceObject.useState)(new Map());
+    const processedToolCallIdsRef = (0, external_react_namespaceObject.useRef)(new Set());
+    const processedToolResultIdsRef = (0, external_react_namespaceObject.useRef)(new Set());
+    const [isStreaming, setIsStreaming] = (0, external_react_namespaceObject.useState)(false);
+    const [error, setError] = (0, external_react_namespaceObject.useState)();
+    const [isComplete, setIsComplete] = (0, external_react_namespaceObject.useState)(false);
+    (0, external_react_namespaceObject.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 = (0, streamParser_cjs_namespaceObject.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,
+                                        (0, external_blockHelpers_cjs_namespaceObject.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 = (0, external_blockHelpers_cjs_namespaceObject.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__*/ external_react_default().createElement(external_ink_namespaceObject.Box, {
+        flexDirection: "column",
+        padding: 1
+    }, /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Text, {
+        bold: true,
+        color: "cyan"
+    }, "Wingman CLI"), agentName && /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Box, {
+        marginTop: 1
+    }, /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Text, null, "Agent: ", /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Text, {
+        color: "green"
+    }, agentName))), logs.length > 0 && /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Box, {
+        flexDirection: "column",
+        marginTop: 1
+    }, /*#__PURE__*/ external_react_default().createElement(external_LogDisplay_cjs_namespaceObject.LogDisplay, {
+        logs: logs,
+        maxLogs: 20
+    })), contentBlocks.length > 0 && /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Box, {
+        marginTop: 1
+    }, /*#__PURE__*/ external_react_default().createElement(external_AgentOutput_cjs_namespaceObject.AgentOutput, {
+        blocks: contentBlocks,
+        activeTools: activeTools,
+        isStreaming: isStreaming
+    })), error && /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Box, {
+        marginTop: 1
+    }, /*#__PURE__*/ external_react_default().createElement(external_ErrorDisplay_cjs_namespaceObject.ErrorDisplay, {
+        error: error.message,
+        stack: error.stack,
+        logFile: error.logFile
+    })), isComplete && !error && /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Box, {
+        marginTop: 1
+    }, /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Text, {
+        color: "green"
+    }, "✓ Complete")));
+};
+exports.App = __webpack_exports__.App;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "App"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,6 @@
+import React from "react";
+import type { OutputManager } from "../core/outputManager.js";
+export interface AppProps {
+    outputManager: OutputManager;
+}
+export declare const App: React.FC<AppProps>;