@wingman-ai/gateway 0.1.0

package/dist/agent/tools/web_crawler.cjs

@@ -0,0 +1,180 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__, {
+    webCrawler: ()=>webCrawler,
+    createWebCrawlerTool: ()=>createWebCrawlerTool
+});
+const external_langchain_namespaceObject = require("langchain");
+const external_zod_namespaceObject = require("zod");
+const external_logger_cjs_namespaceObject = require("../../logger.cjs");
+const logger = (0, external_logger_cjs_namespaceObject.createLogger)();
+function extractTextContent(html) {
+    let text = html.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, "").replace(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gi, "");
+    text = text.replace(/<[^>]+>/g, " ");
+    text = text.replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&apos;/g, "'");
+    text = text.replace(/\s+/g, " ").trim();
+    return text;
+}
+function extractTitle(html) {
+    const titleMatch = html.match(/<title[^>]*>(.*?)<\/title>/i);
+    return titleMatch ? extractTextContent(titleMatch[1]) : "";
+}
+function extractLinks(html, baseUrl) {
+    const links = new Set();
+    const linkRegex = /<a[^>]+href=["']([^"']+)["']/gi;
+    let match = null;
+    while(null !== (match = linkRegex.exec(html)))try {
+        const href = match[1];
+        if (href.startsWith("#") || href.startsWith("javascript:") || href.startsWith("mailto:") || href.startsWith("tel:")) continue;
+        const absoluteUrl = new URL(href, baseUrl).href;
+        links.add(absoluteUrl);
+    } catch  {}
+    return Array.from(links);
+}
+async function crawlPage(url) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(()=>controller.abort(), 30000);
+    try {
+        const response = await fetch(url, {
+            signal: controller.signal,
+            headers: {
+                "User-Agent": "Mozilla/5.0 (compatible; WingmanBot/1.0; +https://github.com/RussellCanfield/wingman-ai)",
+                Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+                "Accept-Language": "en-US,en;q=0.5"
+            }
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        const contentType = response.headers.get("content-type") || "";
+        if (!contentType.includes("text/html") && !contentType.includes("application/xhtml")) throw new Error(`Not an HTML page: ${contentType}`);
+        const html = await response.text();
+        return {
+            url,
+            title: extractTitle(html),
+            content: extractTextContent(html),
+            links: extractLinks(html, url),
+            metadata: {
+                statusCode: response.status,
+                contentType,
+                timestamp: new Date().toISOString()
+            }
+        };
+    } catch (error) {
+        clearTimeout(timeoutId);
+        throw error;
+    }
+}
+async function crawlMultiplePages(startUrl, maxPages, sameDomain) {
+    const visited = new Set();
+    const queue = [
+        startUrl
+    ];
+    const results = [];
+    const startDomain = new URL(startUrl).hostname;
+    while(queue.length > 0 && results.length < maxPages){
+        const url = queue.shift();
+        if (visited.has(url)) continue;
+        visited.add(url);
+        try {
+            const result = await crawlPage(url);
+            results.push(result);
+            if (results.length < maxPages) {
+                for (const link of result.links)if (!visited.has(link)) {
+                    if (sameDomain) {
+                        const linkDomain = new URL(link).hostname;
+                        if (linkDomain !== startDomain) continue;
+                    }
+                    queue.push(link);
+                }
+            }
+        } catch (error) {
+            logger.error(`Failed to crawl ${url}`, error);
+        }
+    }
+    return results;
+}
+const createWebCrawlerTool = ()=>(0, external_langchain_namespaceObject.tool)(async ({ url, maxPages = 1, sameDomain = true })=>{
+        try {
+            new URL(url);
+            if (maxPages < 1 || maxPages > 10) return "Error: maxPages must be between 1 and 10";
+            const results = await crawlMultiplePages(url, maxPages, sameDomain);
+            if (0 === results.length) return `Failed to crawl ${url}. The page may be inaccessible or blocked.`;
+            let output = "";
+            if (1 === results.length) {
+                const result = results[0];
+                output = `# ${result.title || "Untitled Page"}
+
+**URL**: ${result.url}
+**Status**: ${result.metadata.statusCode}
+**Crawled**: ${result.metadata.timestamp}
+
+## Content
+
+${result.content.substring(0, 10000)}${result.content.length > 10000 ? "\n\n[Content truncated - showing first 10,000 characters]" : ""}
+
+## Links Found
+
+${result.links.length > 0 ? result.links.slice(0, 20).map((link)=>`- ${link}`).join("\n") : "No links found"}${result.links.length > 20 ? `\n\n[${result.links.length - 20} more links not shown]` : ""}`;
+            } else {
+                output = `# Crawled ${results.length} pages from ${url}\n\n`;
+                for (const result of results)output += `## ${result.title || "Untitled Page"}
+
+**URL**: ${result.url}
+
+${result.content.substring(0, 2000)}${result.content.length > 2000 ? "..." : ""}
+
+---
+
+`;
+                output += `\n## Summary
+
+Total pages crawled: ${results.length}
+Total links discovered: ${results.reduce((sum, r)=>sum + r.links.length, 0)}`;
+            }
+            return output;
+        } catch (error) {
+            if (error instanceof TypeError && error.message.includes("Invalid URL")) return `Error: Invalid URL format - ${url}`;
+            return `Error crawling ${url}: ${error instanceof Error ? error.message : "Unknown error"}`;
+        }
+    }, {
+        name: "web_crawler",
+        description: "Crawls web pages and extracts their content. Can visit a single page or crawl multiple pages following links. Handles modern SPAs and JavaScript-rendered content. Use this to gather detailed information from websites, documentation, or web applications. Maximum 10 pages per crawl.",
+        schema: external_zod_namespaceObject.z.object({
+            url: external_zod_namespaceObject.z.string().describe("The URL to start crawling from (must be a valid HTTP/HTTPS URL)"),
+            maxPages: external_zod_namespaceObject.z.number().optional().default(1).describe("Maximum number of pages to crawl (1-10). Default is 1 for single page crawl."),
+            sameDomain: external_zod_namespaceObject.z.boolean().optional().default(true).describe("Whether to restrict crawling to the same domain as the start URL. Default is true.")
+        })
+    });
+const webCrawler = createWebCrawlerTool();
+exports.createWebCrawlerTool = __webpack_exports__.createWebCrawlerTool;
+exports.webCrawler = __webpack_exports__.webCrawler;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createWebCrawlerTool",
+    "webCrawler"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/agent/tools/web_crawler.d.ts

@@ -0,0 +1,31 @@
+import { z } from "zod";
+/**
+ * Creates a web crawler tool for visiting and extracting content from web pages.
+ * SPA-friendly: handles basic JavaScript-rendered content via fetch.
+ */
+export declare const createWebCrawlerTool: () => import("langchain").DynamicStructuredTool<z.ZodObject<{
+    url: z.ZodString;
+    maxPages: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    sameDomain: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>, {
+    url: string;
+    maxPages?: number;
+    sameDomain?: boolean;
+}, {
+    url: string;
+    maxPages?: number | undefined;
+    sameDomain?: boolean | undefined;
+}, string, "web_crawler">;
+export declare const webCrawler: import("langchain").DynamicStructuredTool<z.ZodObject<{
+    url: z.ZodString;
+    maxPages: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    sameDomain: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>, {
+    url: string;
+    maxPages?: number;
+    sameDomain?: boolean;
+}, {
+    url: string;
+    maxPages?: number | undefined;
+    sameDomain?: boolean | undefined;
+}, string, "web_crawler">;

package/dist/agent/tools/web_crawler.js

@@ -0,0 +1,143 @@
+import { tool } from "langchain";
+import { z } from "zod";
+import { createLogger } from "../../logger.js";
+const logger = createLogger();
+function extractTextContent(html) {
+    let text = html.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, "").replace(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gi, "");
+    text = text.replace(/<[^>]+>/g, " ");
+    text = text.replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&apos;/g, "'");
+    text = text.replace(/\s+/g, " ").trim();
+    return text;
+}
+function extractTitle(html) {
+    const titleMatch = html.match(/<title[^>]*>(.*?)<\/title>/i);
+    return titleMatch ? extractTextContent(titleMatch[1]) : "";
+}
+function extractLinks(html, baseUrl) {
+    const links = new Set();
+    const linkRegex = /<a[^>]+href=["']([^"']+)["']/gi;
+    let match = null;
+    while(null !== (match = linkRegex.exec(html)))try {
+        const href = match[1];
+        if (href.startsWith("#") || href.startsWith("javascript:") || href.startsWith("mailto:") || href.startsWith("tel:")) continue;
+        const absoluteUrl = new URL(href, baseUrl).href;
+        links.add(absoluteUrl);
+    } catch  {}
+    return Array.from(links);
+}
+async function crawlPage(url) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(()=>controller.abort(), 30000);
+    try {
+        const response = await fetch(url, {
+            signal: controller.signal,
+            headers: {
+                "User-Agent": "Mozilla/5.0 (compatible; WingmanBot/1.0; +https://github.com/RussellCanfield/wingman-ai)",
+                Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+                "Accept-Language": "en-US,en;q=0.5"
+            }
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        const contentType = response.headers.get("content-type") || "";
+        if (!contentType.includes("text/html") && !contentType.includes("application/xhtml")) throw new Error(`Not an HTML page: ${contentType}`);
+        const html = await response.text();
+        return {
+            url,
+            title: extractTitle(html),
+            content: extractTextContent(html),
+            links: extractLinks(html, url),
+            metadata: {
+                statusCode: response.status,
+                contentType,
+                timestamp: new Date().toISOString()
+            }
+        };
+    } catch (error) {
+        clearTimeout(timeoutId);
+        throw error;
+    }
+}
+async function crawlMultiplePages(startUrl, maxPages, sameDomain) {
+    const visited = new Set();
+    const queue = [
+        startUrl
+    ];
+    const results = [];
+    const startDomain = new URL(startUrl).hostname;
+    while(queue.length > 0 && results.length < maxPages){
+        const url = queue.shift();
+        if (visited.has(url)) continue;
+        visited.add(url);
+        try {
+            const result = await crawlPage(url);
+            results.push(result);
+            if (results.length < maxPages) {
+                for (const link of result.links)if (!visited.has(link)) {
+                    if (sameDomain) {
+                        const linkDomain = new URL(link).hostname;
+                        if (linkDomain !== startDomain) continue;
+                    }
+                    queue.push(link);
+                }
+            }
+        } catch (error) {
+            logger.error(`Failed to crawl ${url}`, error);
+        }
+    }
+    return results;
+}
+const createWebCrawlerTool = ()=>tool(async ({ url, maxPages = 1, sameDomain = true })=>{
+        try {
+            new URL(url);
+            if (maxPages < 1 || maxPages > 10) return "Error: maxPages must be between 1 and 10";
+            const results = await crawlMultiplePages(url, maxPages, sameDomain);
+            if (0 === results.length) return `Failed to crawl ${url}. The page may be inaccessible or blocked.`;
+            let output = "";
+            if (1 === results.length) {
+                const result = results[0];
+                output = `# ${result.title || "Untitled Page"}
+
+**URL**: ${result.url}
+**Status**: ${result.metadata.statusCode}
+**Crawled**: ${result.metadata.timestamp}
+
+## Content
+
+${result.content.substring(0, 10000)}${result.content.length > 10000 ? "\n\n[Content truncated - showing first 10,000 characters]" : ""}
+
+## Links Found
+
+${result.links.length > 0 ? result.links.slice(0, 20).map((link)=>`- ${link}`).join("\n") : "No links found"}${result.links.length > 20 ? `\n\n[${result.links.length - 20} more links not shown]` : ""}`;
+            } else {
+                output = `# Crawled ${results.length} pages from ${url}\n\n`;
+                for (const result of results)output += `## ${result.title || "Untitled Page"}
+
+**URL**: ${result.url}
+
+${result.content.substring(0, 2000)}${result.content.length > 2000 ? "..." : ""}
+
+---
+
+`;
+                output += `\n## Summary
+
+Total pages crawled: ${results.length}
+Total links discovered: ${results.reduce((sum, r)=>sum + r.links.length, 0)}`;
+            }
+            return output;
+        } catch (error) {
+            if (error instanceof TypeError && error.message.includes("Invalid URL")) return `Error: Invalid URL format - ${url}`;
+            return `Error crawling ${url}: ${error instanceof Error ? error.message : "Unknown error"}`;
+        }
+    }, {
+        name: "web_crawler",
+        description: "Crawls web pages and extracts their content. Can visit a single page or crawl multiple pages following links. Handles modern SPAs and JavaScript-rendered content. Use this to gather detailed information from websites, documentation, or web applications. Maximum 10 pages per crawl.",
+        schema: z.object({
+            url: z.string().describe("The URL to start crawling from (must be a valid HTTP/HTTPS URL)"),
+            maxPages: z.number().optional().default(1).describe("Maximum number of pages to crawl (1-10). Default is 1 for single page crawl."),
+            sameDomain: z.boolean().optional().default(true).describe("Whether to restrict crawling to the same domain as the start URL. Default is true.")
+        })
+    });
+const webCrawler = createWebCrawlerTool();
+export { createWebCrawlerTool, webCrawler };

package/dist/agent/utils.cjs

@@ -0,0 +1,54 @@
+"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__, {
+    getMachineDetails: ()=>getMachineDetails
+});
+const external_node_os_namespaceObject = require("node:os");
+var external_node_os_default = /*#__PURE__*/ __webpack_require__.n(external_node_os_namespaceObject);
+const getMachineDetails = ()=>{
+    const userInfo = external_node_os_default().userInfo();
+    const machineInfo = `# User's Machine Information
+Operating System: ${external_node_os_default().platform()}
+Architecture: ${external_node_os_default().arch()}
+Default Shell: ${userInfo.shell}`;
+    return machineInfo;
+};
+exports.getMachineDetails = __webpack_exports__.getMachineDetails;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getMachineDetails"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/agent/utils.d.ts

@@ -0,0 +1 @@
+export declare const getMachineDetails: () => string;

package/dist/agent/utils.js

@@ -0,0 +1,10 @@
+import node_os from "node:os";
+const getMachineDetails = ()=>{
+    const userInfo = node_os.userInfo();
+    const machineInfo = `# User's Machine Information
+Operating System: ${node_os.platform()}
+Architecture: ${node_os.arch()}
+Default Shell: ${userInfo.shell}`;
+    return machineInfo;
+};
+export { getMachineDetails };

package/dist/cli/commands/agent.cjs

@@ -0,0 +1,169 @@
+"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__, {
+    executeAgentCommand: ()=>executeAgentCommand
+});
+const external_react_namespaceObject = require("react");
+var external_react_default = /*#__PURE__*/ __webpack_require__.n(external_react_namespaceObject);
+const external_ink_namespaceObject = require("ink");
+const agentInvoker_cjs_namespaceObject = require("../core/agentInvoker.cjs");
+const outputManager_cjs_namespaceObject = require("../core/outputManager.cjs");
+const sessionManager_cjs_namespaceObject = require("../core/sessionManager.cjs");
+const external_logger_cjs_namespaceObject = require("../../logger.cjs");
+const external_node_path_namespaceObject = require("node:path");
+const App_cjs_namespaceObject = require("../ui/App.cjs");
+const rpcClient_cjs_namespaceObject = require("../../gateway/rpcClient.cjs");
+async function executeAgentCommand(args, options = {}) {
+    const outputManager = new outputManager_cjs_namespaceObject.OutputManager(args.outputMode);
+    let inkInstance;
+    if ("interactive" === args.outputMode) inkInstance = (0, external_ink_namespaceObject.render)(external_react_default().createElement(App_cjs_namespaceObject.App, {
+        outputManager
+    }));
+    const logger = (0, external_logger_cjs_namespaceObject.createLogger)(args.verbosity);
+    let sessionManager = null;
+    try {
+        if (!args.agent) {
+            const invoker = new agentInvoker_cjs_namespaceObject.AgentInvoker({
+                workspace: options.workspace,
+                configDir: options.configDir,
+                outputManager,
+                logger
+            });
+            const agents = invoker.listAgents();
+            const logFile = (0, external_logger_cjs_namespaceObject.getLogFilePath)();
+            logger.error("No agent specified");
+            if ("interactive" === outputManager.getMode()) {
+                console.log("\nAvailable agents:");
+                for (const agent of agents)console.log(`  ${agent.name}: ${agent.description}`);
+                console.log('\nUsage: wingman agent --agent <name> "your prompt here"');
+                console.error(`\nLogs: ${logFile}`);
+            } else outputManager.emitEvent({
+                type: "agent-error",
+                error: "No agent specified",
+                logFile,
+                timestamp: new Date().toISOString()
+            });
+            process.exit(1);
+        }
+        if (!options.local) {
+            if (!options.gatewayUrl) throw new Error("Gateway URL not configured. Use --gateway or set gateway.host/port in wingman.config.json.");
+            const client = new rpcClient_cjs_namespaceObject.GatewayRpcClient(options.gatewayUrl, {
+                token: options.token,
+                password: options.password,
+                clientType: "cli"
+            });
+            await client.connect();
+            await client.requestAgent({
+                agentId: args.agent,
+                content: args.prompt,
+                routing: {
+                    channel: "cli",
+                    peer: {
+                        kind: "channel",
+                        id: "cli"
+                    }
+                },
+                sessionKey: options.sessionId
+            }, (event)=>{
+                outputManager.emitEvent(event);
+            });
+            client.disconnect();
+            if (inkInstance) inkInstance.unmount();
+            return;
+        }
+        const workspace = options.workspace || process.cwd();
+        const configDir = options.configDir || ".wingman";
+        const dbPath = (0, external_node_path_namespaceObject.join)(workspace, configDir, "wingman.db");
+        sessionManager = new sessionManager_cjs_namespaceObject.SessionManager(dbPath);
+        await sessionManager.initialize();
+        const invoker = new agentInvoker_cjs_namespaceObject.AgentInvoker({
+            workspace,
+            configDir,
+            outputManager,
+            logger,
+            sessionManager
+        });
+        let sessionId = options.sessionId;
+        if (!sessionId) {
+            const lastSession = sessionManager.getLastSession();
+            if (lastSession && lastSession.agentName === args.agent) {
+                sessionId = lastSession.id;
+                logger.debug(`Resuming session: ${sessionId}`);
+            } else {
+                const newSession = sessionManager.createSession(args.agent);
+                sessionId = newSession.id;
+                logger.info(`Created new session: ${sessionId}`);
+            }
+        }
+        sessionManager.updateSession(sessionId, {
+            lastMessagePreview: args.prompt.substring(0, 200)
+        });
+        await invoker.invokeAgent(args.agent, args.prompt, sessionId);
+        const session = sessionManager.getSession(sessionId);
+        if (session) sessionManager.updateSession(sessionId, {
+            messageCount: session.messageCount + 1
+        });
+        sessionManager.close();
+        sessionManager = null;
+        if (inkInstance) inkInstance.unmount();
+    } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        const logFile = (0, external_logger_cjs_namespaceObject.getLogFilePath)();
+        logger.error("Agent command failed", {
+            error: errorMsg
+        });
+        if (sessionManager) {
+            sessionManager.close();
+            sessionManager = null;
+        }
+        if (inkInstance) inkInstance.unmount();
+        if ("interactive" === outputManager.getMode()) {
+            console.error(`\nError: ${errorMsg}`);
+            console.error(`Logs: ${logFile}`);
+            process.exit(1);
+        } else {
+            const isAgentError = Boolean(error instanceof Error && error.isAgentError);
+            if (!isAgentError) outputManager.emitAgentError(error);
+            process.exit(1);
+        }
+    }
+}
+exports.executeAgentCommand = __webpack_exports__.executeAgentCommand;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "executeAgentCommand"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cli/commands/agent.d.ts

@@ -0,0 +1,15 @@
+import type { AgentCommandArgs } from "../types.js";
+export interface AgentCommandOptions {
+    workspace?: string;
+    configDir?: string;
+    sessionId?: string;
+    local?: boolean;
+    gatewayUrl?: string;
+    token?: string;
+    password?: string;
+}
+/**
+ * Execute the agent command
+ * This is the handler for: wingman agent --agent <name> <prompt>
+ */
+export declare function executeAgentCommand(args: AgentCommandArgs, options?: AgentCommandOptions): Promise<void>;