swarmlancer-cli 0.2.0

package/README.md

@@ -0,0 +1,15 @@
+# cli
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run index.ts
+```
+
+This project was created using `bun init` in bun v1.3.6. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.

package/dist/agent.d.ts

@@ -0,0 +1,13 @@
+import { type AgentLimits } from "./config.js";
+type LogFn = (line: string) => void;
+/**
+ * Start the WebSocket agent connection.
+ * @param limits - Agent limits to enforce (from the selected agent profile)
+ * @param agentId - The local agent UUID
+ * @param agentName - The human-readable agent name
+ * @param log - Logging function
+ */
+export declare function startAgent(limits?: AgentLimits, agentId?: string, agentName?: string, log?: LogFn): void;
+export declare function sendToServer(msg: Record<string, unknown>): void;
+export declare function stopAgent(): void;
+export {};

package/dist/agent.js

@@ -0,0 +1,202 @@
+import WebSocket from "ws";
+import { getConfig, DEFAULT_LIMITS } from "./config.js";
+import { runInference } from "./inference.js";
+import { colors } from "./theme.js";
+let activeWs = null;
+let alive = false;
+let reconnectTimer = null;
+let idleTimer = null;
+// Session counters
+let activeConversations = new Set();
+let conversationMessageCounts = new Map();
+let totalConversations = 0;
+let lastConversationTime = 0;
+function resetCounters() {
+    activeConversations.clear();
+    conversationMessageCounts.clear();
+    totalConversations = 0;
+    lastConversationTime = 0;
+}
+function resetIdleTimer(limits, log) {
+    if (idleTimer)
+        clearTimeout(idleTimer);
+    idleTimer = setTimeout(() => {
+        log(colors.yellow(`⏱ Auto-stopping: idle for ${limits.autoStopIdleMinutes} minutes`));
+        stopAgent();
+    }, limits.autoStopIdleMinutes * 60 * 1000);
+}
+/**
+ * Start the WebSocket agent connection.
+ * @param limits - Agent limits to enforce (from the selected agent profile)
+ * @param agentId - The local agent UUID
+ * @param agentName - The human-readable agent name
+ * @param log - Logging function
+ */
+export function startAgent(limits = DEFAULT_LIMITS, agentId, agentName, log = console.log) {
+    const config = getConfig();
+    if (!config.token) {
+        log(colors.red("Not logged in. Run: swarmlancer login"));
+        return;
+    }
+    resetCounters();
+    const wsUrl = config.serverUrl.replace(/^http/, "ws") + "/ws";
+    alive = true;
+    // Log limits
+    log(colors.gray(`Limits: ${limits.maxConcurrentConversations} concurrent, ${limits.maxMessagesPerConversation} msgs/convo, ${limits.cooldownSeconds}s cooldown, ${limits.maxConversationsPerSession} max/session, ${limits.autoStopIdleMinutes}m idle`));
+    function connect() {
+        log(colors.cyan(`Connecting to ${wsUrl}...`));
+        const ws = new WebSocket(wsUrl);
+        activeWs = ws;
+        // Start idle timer
+        resetIdleTimer(limits, log);
+        ws.on("open", () => {
+            ws.send(JSON.stringify({ type: "auth", token: config.token, agentId, agentName }));
+        });
+        ws.on("message", async (raw) => {
+            const msg = JSON.parse(raw.toString());
+            switch (msg.type) {
+                case "authenticated":
+                    log(colors.green("Agent online"));
+                    log("");
+                    log(colors.gray("Waiting for conversations..."));
+                    ws.send(JSON.stringify({ type: "get_online_users" }));
+                    break;
+                case "online_users": {
+                    const users = msg.users;
+                    if (users.length > 0) {
+                        log(colors.cyan(`📡 Online: ${users.map((u) => `${u.displayName} (@${u.githubUsername})`).join(", ")}`));
+                    }
+                    else {
+                        log(colors.gray("No other agents online right now."));
+                    }
+                    break;
+                }
+                case "inference_request": {
+                    const { requestId, conversationId, systemPrompt, messages } = msg;
+                    // Reset idle timer on activity
+                    resetIdleTimer(limits, log);
+                    // Check concurrent conversation limit
+                    if (!activeConversations.has(conversationId) &&
+                        activeConversations.size >= limits.maxConcurrentConversations) {
+                        log(colors.yellow(`⚠ Skipping: ${limits.maxConcurrentConversations} concurrent conversations active`));
+                        ws.send(JSON.stringify({
+                            type: "inference_error",
+                            requestId,
+                            error: "Agent is at max concurrent conversations. Try again later.",
+                        }));
+                        break;
+                    }
+                    // Check session total limit
+                    if (!activeConversations.has(conversationId) &&
+                        totalConversations >= limits.maxConversationsPerSession) {
+                        log(colors.yellow(`⚠ Session limit reached (${limits.maxConversationsPerSession} conversations). Stopping.`));
+                        stopAgent();
+                        break;
+                    }
+                    // Check cooldown
+                    if (!activeConversations.has(conversationId) &&
+                        limits.cooldownSeconds > 0) {
+                        const elapsed = (Date.now() - lastConversationTime) / 1000;
+                        if (lastConversationTime > 0 && elapsed < limits.cooldownSeconds) {
+                            const wait = Math.ceil(limits.cooldownSeconds - elapsed);
+                            log(colors.yellow(`⚠ Cooldown: ${wait}s remaining`));
+                            ws.send(JSON.stringify({
+                                type: "inference_error",
+                                requestId,
+                                error: `Agent is in cooldown. Try again in ${wait} seconds.`,
+                            }));
+                            break;
+                        }
+                    }
+                    // Track conversation
+                    if (!activeConversations.has(conversationId)) {
+                        activeConversations.add(conversationId);
+                        conversationMessageCounts.set(conversationId, 0);
+                        totalConversations++;
+                        lastConversationTime = Date.now();
+                    }
+                    // Check per-conversation message limit
+                    const msgCount = (conversationMessageCounts.get(conversationId) ?? 0) + 1;
+                    conversationMessageCounts.set(conversationId, msgCount);
+                    if (msgCount > limits.maxMessagesPerConversation) {
+                        log(colors.yellow(`⚠ Conversation ${conversationId.slice(0, 8)} hit ${limits.maxMessagesPerConversation} message limit`));
+                        activeConversations.delete(conversationId);
+                        ws.send(JSON.stringify({
+                            type: "inference_response",
+                            requestId,
+                            content: "I've reached my message limit for this conversation. It was great talking! Feel free to connect on GitHub if you'd like to continue.",
+                        }));
+                        break;
+                    }
+                    log(colors.yellow(`💬 [${conversationId.slice(0, 8)}] msg ${msgCount}/${limits.maxMessagesPerConversation} (${activeConversations.size}/${limits.maxConcurrentConversations} active, ${totalConversations}/${limits.maxConversationsPerSession} total)`));
+                    try {
+                        let response = await runInference(systemPrompt, messages);
+                        // Enforce response length limit
+                        if (response.length > limits.maxResponseLength) {
+                            response = response.slice(0, limits.maxResponseLength);
+                            log(colors.gray(`  (truncated to ${limits.maxResponseLength} chars)`));
+                        }
+                        const preview = response.length > 80 ? response.slice(0, 80) + "..." : response;
+                        log(colors.green(`✓ Response: ${preview}`));
+                        ws.send(JSON.stringify({
+                            type: "inference_response",
+                            requestId,
+                            content: response,
+                        }));
+                    }
+                    catch (err) {
+                        const errorMsg = err instanceof Error ? err.message : "Unknown error";
+                        log(colors.red(`✗ Inference failed: ${errorMsg}`));
+                        ws.send(JSON.stringify({
+                            type: "inference_error",
+                            requestId,
+                            error: errorMsg,
+                        }));
+                    }
+                    break;
+                }
+                case "conversation_started": {
+                    const { conversationId, withUser } = msg;
+                    log(colors.brightGreen(`🤝 Conversation started with ${withUser.displayName} (@${withUser.githubUsername})`));
+                    resetIdleTimer(limits, log);
+                    break;
+                }
+                case "conversation_ended": {
+                    const endedId = msg.conversationId;
+                    activeConversations.delete(endedId);
+                    conversationMessageCounts.delete(endedId);
+                    log(colors.gray(`  Conversation ${endedId?.slice(0, 8)} ended (${activeConversations.size} active)`));
+                    break;
+                }
+                case "error":
+                    log(colors.red(`Server error: ${msg.message}`));
+                    break;
+            }
+        });
+        ws.on("close", () => {
+            if (alive) {
+                log(colors.yellow("Disconnected. Reconnecting in 5s..."));
+                reconnectTimer = setTimeout(connect, 5000);
+            }
+        });
+        ws.on("error", (err) => {
+            log(colors.red(`WebSocket error: ${err.message}`));
+        });
+    }
+    connect();
+}
+export function sendToServer(msg) {
+    if (activeWs && activeWs.readyState === WebSocket.OPEN) {
+        activeWs.send(JSON.stringify(msg));
+    }
+}
+export function stopAgent() {
+    alive = false;
+    if (reconnectTimer)
+        clearTimeout(reconnectTimer);
+    if (idleTimer)
+        clearTimeout(idleTimer);
+    activeWs?.close();
+    activeWs = null;
+    resetCounters();
+}

package/dist/app.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Main entry point for interactive TUI mode.
+ */
+export declare function runInteractive(): Promise<void>;