@lightcone-ai/daemon 0.6.1 → 0.6.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightcone-ai/daemon",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "type": "module",
   "main": "src/index.js",
   "bin": {

package/src/agent-manager.js

@@ -81,15 +81,16 @@ export class AgentManager {
 
     if (config.mysqlAccess) {
       const mysqlServerPath = new URL('../../mcp-servers/mysql/index.js', import.meta.url).pathname;
+      const agentEnv = config.envVars ?? {};
       mcpServers['mysql'] = {
         command: 'node',
         args: [mysqlServerPath],
         env: {
-          DB_HOST:     process.env.DB_HOST     ?? '',
+          DB_HOST:     process.env.DB_HOST      ?? '',
           DB_PORT:     process.env.DB_PORT      ?? '3306',
           DB_USER:     process.env.DB_USER      ?? '',
           DB_PASSWORD: process.env.DB_PASSWORD  ?? '',
-          DB_NAME:     process.env.DB_NAME      ?? '',
+          DB_NAME:     agentEnv.MYSQL_DB ?? process.env.DB_NAME ?? '',
         },
       };
     }
@@ -145,6 +146,17 @@ export class AgentManager {
     proc.on('exit', (code) => {
       console.log(`[AgentManager] Agent ${agentId} channel=${channelId ?? 'none'} exited (code=${code})`);
       this.agents.delete(key);
+
+      // If exited immediately with an error and had a session, retry without session (session file may not exist on this machine)
+      if (code !== 0 && config.sessionId && !this._retried?.has(key)) {
+        if (!this._retried) this._retried = new Set();
+        this._retried.add(key);
+        console.log(`[AgentManager] Retrying ${agentId} channel=${channelId} without session (session may not exist locally)`);
+        const retryConfig = { ...config, sessionId: null };
+        this._startAgent({ agentId, channelId, config: retryConfig }, connection);
+        return;
+      }
+
       connection.send({ type: 'agent:status', agentId, channelId, status: 'inactive' });
       connection.send({ type: 'agent:activity', agentId, channelId, activity: 'offline', detail: '', entries: [] });
     });
@@ -154,6 +166,9 @@ export class AgentManager {
 
     connection.send({ type: 'agent:status', agentId, channelId, status: 'active' });
     connection.send({ type: 'agent:activity', agentId, channelId, activity: 'online', detail: '', entries: [] });
+
+    // Flush any messages that arrived while the agent was starting
+    this._flushPending(key, connection);
   }
 
   _stopAgent(agentId, channelId, connection) {
@@ -165,12 +180,29 @@ export class AgentManager {
     // exit handler will report status
   }
 
-  _deliverMessage({ agentId, channelId, seq, message }, connection) {
+  _deliverMessage(msg, connection) {
+    const { agentId, channelId, seq, message } = msg;
     const key = this._key(agentId, channelId);
     connection.send({ type: 'agent:deliver:ack', agentId, channelId, seq });
 
-    if (!this.agents.has(key)) {
-      console.warn(`[AgentManager] Agent ${agentId} channel=${channelId} not running, dropping seq=${seq}`);
+    if (!this.agents.has(key) && !this.starting.has(key)) {
+      // Agent not running — queue the message and request config to spawn it
+      console.log(`[AgentManager] Agent ${agentId} channel=${channelId} not running, requesting start for seq=${seq}`);
+      if (!this._pendingMessages) this._pendingMessages = new Map();
+      const pending = this._pendingMessages.get(key) ?? [];
+      pending.push(msg);
+      this._pendingMessages.set(key, pending);
+      connection.send({ type: 'agent:request_start', agentId, channelId });
+      return;
+    }
+
+    if (this.starting.has(key)) {
+      // Spawn in progress — queue the message for delivery after start
+      console.log(`[AgentManager] Agent ${agentId} channel=${channelId} still starting, queuing seq=${seq}`);
+      if (!this._pendingMessages) this._pendingMessages = new Map();
+      const pending = this._pendingMessages.get(key) ?? [];
+      pending.push(msg);
+      this._pendingMessages.set(key, pending);
       return;
     }
 
@@ -179,6 +211,19 @@ export class AgentManager {
     this._write(key, text);
   }
 
+  _flushPending(key, connection) {
+    if (!this._pendingMessages) return;
+    const pending = this._pendingMessages.get(key);
+    if (!pending || pending.length === 0) return;
+    this._pendingMessages.delete(key);
+    for (const msg of pending) {
+      const { agentId, channelId, seq, message } = msg;
+      const text = `New message in ${message.channel_type === 'dm' ? `dm from` : `#${message.channel_name} from`} ${message.sender_name}: ${message.content}`;
+      console.log(`[AgentManager] Flushing queued seq=${seq} to agent ${agentId} channel=${channelId}`);
+      this._write(key, text);
+    }
+  }
+
   // Write a user message to the running Claude process via stdin
   _write(key, text) {
     const agent = this.agents.get(key);