tuna-agent 0.1.165 → 0.1.167

package/dist/daemon/index.js

@@ -137,6 +137,7 @@ export async function startDaemon(config) {
     const pendingPermissionResolvers = new Map();
     // Track active tasks per agent (agentId → taskId)
     const activeAgentTasks = new Map();
+    const agentQueues = new Map();
     // Track abort controllers per task
     const taskAbortControllers = new Map();
     // Note: currentTaskId/currentTaskAbort removed — use taskAbortControllers + activeAgentTasks instead
@@ -218,41 +219,13 @@ export async function startDaemon(config) {
                 if (task.repoPath?.startsWith('~/')) {
                     task.repoPath = path.join(os.homedir(), task.repoPath.slice(2));
                 }
-                // Check per-agent concurrency (each agent can run 1 task at a time)
+                // Per-agent concurrency: if busy, queue instead of rejecting.
                 const agentId = task.agentId || '__default__';
                 if (activeAgentTasks.has(agentId)) {
-                    console.log(`[Daemon] Agent ${agentId} busy — rejecting task ${task.id}`);
-                    ws.send({ action: 'task_rejected', taskId: task.id, reason: 'agent_busy' });
+                    enqueueForAgent(agentId, { kind: 'task', task });
                     break;
                 }
-                activeTasks++;
-                activeAgentTasks.set(agentId, task.id);
-                const abort = new AbortController();
-                taskAbortControllers.set(task.id, abort);
-                console.log(`[Daemon] Received task: ${task.id} agent=${agentId} — ${task.description.slice(0, 80)} (attachments: ${task.attachments?.length ?? 0}) [active: ${activeTasks}]`);
-                // Run task in background (non-blocking) to allow parallel agent execution
-                (async () => {
-                    try {
-                        await adapter.handleTask(task, ws, pendingInputResolvers, abort.signal, pendingPermissionResolvers);
-                    }
-                    catch (err) {
-                        const errMsg = err instanceof Error ? err.message : String(err);
-                        if (abort.signal.aborted) {
-                            console.log(`[Daemon] Task ${task.id} cancelled`);
-                        }
-                        else {
-                            ws.sendTaskFailed(task.id, errMsg);
-                            console.error(`[Daemon] Task ${task.id} error:`, errMsg);
-                        }
-                    }
-                    finally {
-                        activeTasks--;
-                        activeAgentTasks.delete(agentId);
-                        taskAbortControllers.delete(task.id);
-                        pendingInputResolvers.delete(task.id);
-                        ws.send({ action: 'agent_ready', agentId });
-                    }
-                })();
+                runTaskNow(task);
                 break;
             }
             case 'task_cancelled': {
@@ -479,19 +452,15 @@ ${skillContent.slice(0, 15000)}`;
                     // No resolver — check if we have a persisted session to resume
                     const savedState = loadPMState(taskId);
                     if (savedState) {
-                        // Check per-agent concurrency before resuming
+                        // Per-agent concurrency: if busy, queue the reply instead of dropping it.
                         const resumeAgentId = savedState.agentId || '__default__';
                         if (activeAgentTasks.has(resumeAgentId)) {
                             const busyTask = activeAgentTasks.get(resumeAgentId);
-                            console.warn(`[Daemon] Cannot resume task ${taskId} — agent ${resumeAgentId} is busy with task ${busyTask}`);
-                            // Notify user and revert task status so it doesn't get stuck at "executing"
+                            console.log(`[Daemon] Agent ${resumeAgentId} busy with ${busyTask} — queuing reply for task ${taskId}`);
+                            enqueueForAgent(resumeAgentId, { kind: 'input', taskId, answer, attachments, savedState });
                             ws.sendPMMessage(taskId, {
                                 sender: 'pm',
-                                content: 'Agent is currently busy with another task. Please try again shortly.',
-                            });
-                            ws.sendTaskDone(taskId, {
-                                result: 'Agent busy — message not processed',
-                                durationMs: 0,
+                                content: '⏳ Đang xử lý việc khác, sẽ trả lời ngay khi xong.',
                             });
                             break;
                         }
@@ -697,6 +666,67 @@ ${skillContent.slice(0, 15000)}`;
                 console.log(`[Daemon] Unknown message type: ${type}`);
         }
     }, onAuthFailed);
+    /** Queue work for an agent that is currently busy. */
+    function enqueueForAgent(agentId, item) {
+        let q = agentQueues.get(agentId);
+        if (!q) {
+            q = [];
+            agentQueues.set(agentId, q);
+        }
+        q.push(item);
+        console.log(`[Daemon] Agent ${agentId} busy — queued ${item.kind} (queue: ${q.length})`);
+    }
+    /** Start the next queued item for an agent, if any and the agent is free. */
+    function processNextForAgent(agentId) {
+        if (activeAgentTasks.has(agentId))
+            return; // still busy
+        const q = agentQueues.get(agentId);
+        if (!q || q.length === 0)
+            return;
+        const item = q.shift();
+        console.log(`[Daemon] Dequeue ${item.kind} for agent ${agentId} (remaining: ${q.length})`);
+        if (item.kind === 'task') {
+            runTaskNow(item.task);
+        }
+        else if (item.savedState.mode === 'agent_team') {
+            resumeAgentTeamChat(item.taskId, item.answer, item.attachments, item.savedState, ws, pendingInputResolvers);
+        }
+        else {
+            resumePMChat(item.taskId, item.answer, item.attachments, item.savedState, ws, pendingInputResolvers);
+        }
+    }
+    /** Run a task immediately (agent assumed free). Drains the queue when done. */
+    function runTaskNow(task) {
+        const agentId = task.agentId || '__default__';
+        activeTasks++;
+        activeAgentTasks.set(agentId, task.id);
+        const abort = new AbortController();
+        taskAbortControllers.set(task.id, abort);
+        console.log(`[Daemon] Received task: ${task.id} agent=${agentId} — ${task.description.slice(0, 80)} (attachments: ${task.attachments?.length ?? 0}) [active: ${activeTasks}]`);
+        (async () => {
+            try {
+                await adapter.handleTask(task, ws, pendingInputResolvers, abort.signal, pendingPermissionResolvers);
+            }
+            catch (err) {
+                const errMsg = err instanceof Error ? err.message : String(err);
+                if (abort.signal.aborted) {
+                    console.log(`[Daemon] Task ${task.id} cancelled`);
+                }
+                else {
+                    ws.sendTaskFailed(task.id, errMsg);
+                    console.error(`[Daemon] Task ${task.id} error:`, errMsg);
+                }
+            }
+            finally {
+                activeTasks--;
+                activeAgentTasks.delete(agentId);
+                taskAbortControllers.delete(task.id);
+                pendingInputResolvers.delete(task.id);
+                ws.send({ action: 'agent_ready', agentId });
+                processNextForAgent(agentId);
+            }
+        })();
+    }
     /**
      * Resume PM chat for a task after agent restart or done task reopen.
      * Loads persisted pmSessionId and runs a chat loop.
@@ -803,6 +833,7 @@ ${skillContent.slice(0, 15000)}`;
             resolvers.delete(taskId);
             cleanupAttachments(taskId);
             wsClient.send({ action: 'agent_ready', agentId });
+            processNextForAgent(agentId);
         }
     }
     /**
@@ -1049,6 +1080,7 @@ ${skillContent.slice(0, 15000)}`;
             resolvers.delete(taskId);
             cleanupAttachments(taskId);
             wsClient.send({ action: 'agent_ready', agentId });
+            processNextForAgent(agentId);
         }
     }
     // Wire up agent metrics to heartbeat

package/dist/daemon/ws-client.js

@@ -224,6 +224,18 @@ export class AgentWebSocketClient {
         return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
     }
     _connect() {
+        // Tear down any previous socket first. Without this, a reconnect could leak the
+        // old connection: it stays half-open on the server (readyState OPEN) and becomes
+        // a zombie the API keeps sending to, while this daemon listens on the new one.
+        if (this.ws) {
+            try {
+                this.ws.removeAllListeners();
+                this.ws.terminate();
+            }
+            catch { /* ignore */ }
+            this.ws = null;
+        }
+        this._stopHeartbeat();
         try {
             this.ws = new WebSocket(this.config.wsUrl, {
                 headers: { 'Authorization': `Bearer ${this.config.agentToken}` },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tuna-agent",
-  "version": "0.1.165",
+  "version": "0.1.167",
   "description": "Tuna Agent - Run AI coding tasks on your machine",
   "bin": {
     "tuna-agent": "dist/cli/index.js"