@wingman-ai/gateway 0.1.0

package/dist/cli/commands/agent.js

@@ -0,0 +1,125 @@
+import react from "react";
+import { render } from "ink";
+import { AgentInvoker } from "../core/agentInvoker.js";
+import { OutputManager } from "../core/outputManager.js";
+import { SessionManager } from "../core/sessionManager.js";
+import { createLogger, getLogFilePath } from "../../logger.js";
+import { join } from "node:path";
+import { App } from "../ui/App.js";
+import { GatewayRpcClient } from "../../gateway/rpcClient.js";
+async function executeAgentCommand(args, options = {}) {
+    const outputManager = new OutputManager(args.outputMode);
+    let inkInstance;
+    if ("interactive" === args.outputMode) inkInstance = render(react.createElement(App, {
+        outputManager
+    }));
+    const logger = createLogger(args.verbosity);
+    let sessionManager = null;
+    try {
+        if (!args.agent) {
+            const invoker = new AgentInvoker({
+                workspace: options.workspace,
+                configDir: options.configDir,
+                outputManager,
+                logger
+            });
+            const agents = invoker.listAgents();
+            const logFile = 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 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 = join(workspace, configDir, "wingman.db");
+        sessionManager = new SessionManager(dbPath);
+        await sessionManager.initialize();
+        const invoker = new 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 = 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);
+        }
+    }
+}
+export { executeAgentCommand };