@tiflis-io/tiflis-code-workstation 0.3.29 → 0.3.30

package/dist/main.js

@@ -1398,7 +1398,7 @@ function getMessageType(data) {
 }
 
 // src/infrastructure/websocket/tunnel-client.ts
-var TunnelClient = class {
+var TunnelClient = class _TunnelClient {
   config;
   callbacks;
   logger;
@@ -1412,6 +1412,8 @@ var TunnelClient = class {
   reconnectTimeout = null;
   registrationTimeout = null;
   messageBuffer = [];
+  static MAX_SEND_RETRIES = 3;
+  static SEND_RETRY_DELAY_MS = 100;
   constructor(config2, callbacks) {
     this.config = config2;
     this.callbacks = callbacks;
@@ -1514,8 +1516,9 @@ var TunnelClient = class {
     this.messageBuffer = [];
   }
   /**
-   * Sends a message to the tunnel (for forwarding to clients).
-   * Detects send failures and triggers reconnection.
+   * Sends a message to the tunnel (for forwarding to clients) with retry logic (FIX #3).
+   * Buffers during reconnection, retries on transient failures with exponential backoff.
+   * Returns true if send was successful or queued for retry.
    */
   send(message) {
     if (this.state !== "registered" || !this.ws) {
@@ -1528,18 +1531,55 @@ var TunnelClient = class {
     if (this.ws.readyState !== WebSocket.OPEN) {
       this.logger.warn(
         { readyState: this.ws.readyState },
-        "Socket not open, triggering reconnection"
+        "Socket not open, buffering message and triggering reconnection"
       );
+      this.messageBuffer.push(message);
       this.handleSendFailure();
+      return true;
+    }
+    return this.sendWithRetry(message, 0);
+  }
+  /**
+   * FIX #3: Send with exponential backoff retry.
+   * On failure, schedules retry with exponential delay (100ms, 200ms, 400ms).
+   */
+  sendWithRetry(message, attempt) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      if (attempt === 0) {
+        this.messageBuffer.push(message);
+      }
       return false;
     }
-    this.ws.send(message, (error) => {
-      if (error) {
-        this.logger.error({ error }, "Send failed, triggering reconnection");
-        this.handleSendFailure();
+    try {
+      this.ws.send(message, (error) => {
+        if (error) {
+          if (attempt < _TunnelClient.MAX_SEND_RETRIES) {
+            const delay = _TunnelClient.SEND_RETRY_DELAY_MS * Math.pow(2, attempt);
+            this.logger.debug(
+              { attempt: attempt + 1, delay, errorType: error.name },
+              "Send failed, scheduling retry with exponential backoff"
+            );
+            setTimeout(() => {
+              this.sendWithRetry(message, attempt + 1);
+            }, delay);
+          } else {
+            this.logger.error(
+              { error: error.message, attempts: attempt + 1 },
+              "Send failed after all retries, buffering message"
+            );
+            this.messageBuffer.push(message);
+            this.handleSendFailure();
+          }
+        }
+      });
+      return true;
+    } catch (error) {
+      this.logger.error({ error: error.message }, "Unexpected error in send");
+      if (attempt === 0) {
+        this.messageBuffer.push(message);
       }
-    });
-    return true;
+      return false;
+    }
   }
   /**
    * Handles send failure by disconnecting and scheduling reconnection.
@@ -3055,39 +3095,32 @@ var HeadlessAgentExecutor = class extends EventEmitter {
       cwd: this.workingDir,
       env: {
         ...shellEnv,
-        // Apply alias env vars (e.g., CLAUDE_CONFIG_DIR)
         ...aliasEnvVars,
-        // Ensure proper terminal environment
         TERM: "xterm-256color",
-        // Disable interactive prompts
         CI: "true"
       },
       stdio: ["ignore", "pipe", "pipe"],
-      // stdin ignored, stdout/stderr piped
-      detached: true,
-      // Create new process group for clean termination
-      // Ensure child doesn't interfere with parent's signal handling
-      // @ts-expect-error - Node.js 16+ option
-      ignoreParentSignals: true
+      detached: true
     });
-    this.subprocess.stdout?.on("data", (data) => {
+    const proc = this.subprocess;
+    proc.stdout?.on("data", (data) => {
       if (this.isKilled) return;
       const text2 = data.toString();
       this.emit("stdout", text2);
     });
-    this.subprocess.stderr?.on("data", (data) => {
+    proc.stderr?.on("data", (data) => {
       if (this.isKilled) return;
       const text2 = data.toString();
       this.emit("stderr", text2);
     });
-    this.subprocess.on("exit", (code) => {
+    proc.on("exit", (code) => {
       this.clearExecutionTimeout();
       if (!this.isKilled) {
         this.emit("exit", code);
       }
       this.subprocess = null;
     });
-    this.subprocess.on("error", (error) => {
+    proc.on("error", (error) => {
       this.clearExecutionTimeout();
       if (!this.isKilled) {
         this.emit("error", error);
@@ -5067,13 +5100,58 @@ var SubscriptionService = class {
 };
 
 // src/application/services/message-broadcaster-impl.ts
-var MessageBroadcasterImpl = class {
+var MessageBroadcasterImpl = class _MessageBroadcasterImpl {
   deps;
   logger;
+  /** FIX #4: Buffer messages for devices during auth flow */
+  authBuffers = /* @__PURE__ */ new Map();
+  static AUTH_BUFFER_TTL_MS = 5e3;
+  // 5 second buffer TTL
   constructor(deps) {
     this.deps = deps;
     this.logger = deps.logger.child({ service: "broadcaster" });
   }
+  /**
+   * FIX #4: Buffers a message for a device during auth flow.
+   * Called when subscribing clients are not yet authenticated.
+   * Messages are buffered with TTL and flushed when auth completes.
+   */
+  bufferMessageForAuth(deviceId, sessionId, message) {
+    if (!this.authBuffers.has(deviceId)) {
+      this.authBuffers.set(deviceId, []);
+    }
+    const buffer = this.authBuffers.get(deviceId) ?? [];
+    buffer.push({ sessionId, message, timestamp: Date.now() });
+    const now = Date.now();
+    const filtered = buffer.filter(
+      (item) => now - item.timestamp < _MessageBroadcasterImpl.AUTH_BUFFER_TTL_MS
+    );
+    this.authBuffers.set(deviceId, filtered);
+    this.logger.debug(
+      { deviceId, bufferSize: filtered.length },
+      "Buffered message for authenticating device"
+    );
+  }
+  /**
+   * FIX #4: Flushes buffered messages for a device after authentication.
+   * Called from main.ts after subscription restore completes.
+   * Returns buffered messages so they can be sent to subscribed sessions.
+   */
+  flushAuthBuffer(deviceId) {
+    const buffer = this.authBuffers.get(deviceId) ?? [];
+    this.authBuffers.delete(deviceId);
+    const now = Date.now();
+    const validMessages = buffer.filter(
+      (item) => now - item.timestamp < _MessageBroadcasterImpl.AUTH_BUFFER_TTL_MS
+    );
+    if (validMessages.length > 0) {
+      this.logger.info(
+        { deviceId, messageCount: validMessages.length },
+        "Flushing auth buffer - delivering buffered messages"
+      );
+    }
+    return validMessages;
+  }
   /**
    * Broadcasts a message to all connected clients via tunnel.
    * The tunnel handles client filtering and delivery.
@@ -5115,6 +5193,8 @@ var MessageBroadcasterImpl = class {
    * Broadcasts a message to all clients subscribed to a session (by session ID string).
    * Sends targeted messages to each subscriber in parallel with timeout.
    * Prevents slow clients from blocking others.
+   *
+   * FIX #4: Also buffers messages for unauthenticated subscribers during auth flow.
    */
   async broadcastToSubscribers(sessionId, message) {
     const session = new SessionId(sessionId);
@@ -5123,9 +5203,36 @@ var MessageBroadcasterImpl = class {
       (c) => c.isAuthenticated
     );
     if (authenticatedSubscribers.length === 0) {
+      const unauthenticatedCount = subscribers.length - authenticatedSubscribers.length;
+      if (unauthenticatedCount > 0) {
+        this.logger.debug(
+          { sessionId, unauthenticatedCount },
+          "Subscribers are authenticating - buffering message for delivery after auth"
+        );
+        for (const client of subscribers) {
+          if (!client.isAuthenticated) {
+            this.bufferMessageForAuth(client.deviceId.value, sessionId, message);
+          }
+        }
+      } else {
+        let messageType = "unknown";
+        try {
+          const parsed = JSON.parse(message);
+          messageType = parsed.type ?? "unknown";
+        } catch {
+        }
+        this.logger.debug(
+          { sessionId, messageType },
+          "No subscribers found for session"
+        );
+      }
       return;
     }
     const SEND_TIMEOUT_MS = 2e3;
+    this.logger.debug(
+      { sessionId, subscriberCount: authenticatedSubscribers.length },
+      "Broadcasting message to subscribers"
+    );
     const sendPromises = authenticatedSubscribers.map(async (client) => {
       try {
         await Promise.race([
@@ -5162,7 +5269,18 @@ var MessageBroadcasterImpl = class {
         );
       }
     });
-    await Promise.allSettled(sendPromises);
+    const results = await Promise.allSettled(sendPromises);
+    const failedCount = results.filter((r) => r.status === "rejected").length;
+    if (failedCount > 0) {
+      this.logger.warn(
+        { sessionId, totalSubscribers: authenticatedSubscribers.length, failedCount },
+        "Some subscribers failed to receive message"
+      );
+    }
+  }
+  getAuthenticatedDeviceIds() {
+    const clients = this.deps.clientRegistry.getAll();
+    return clients.filter((c) => c.isAuthenticated).map((c) => c.deviceId.value);
   }
 };
 
@@ -6655,6 +6773,7 @@ import { EventEmitter as EventEmitter4 } from "events";
 import { ChatOpenAI } from "@langchain/openai";
 import { createReactAgent } from "@langchain/langgraph/prebuilt";
 import { HumanMessage, AIMessage, isAIMessage } from "@langchain/core/messages";
+import AsyncLock from "async-lock";
 
 // src/infrastructure/agents/supervisor/tools/workspace-tools.ts
 import { tool } from "@langchain/core/tools";
@@ -7560,7 +7679,7 @@ function formatSize(bytes) {
 }
 
 // src/infrastructure/agents/supervisor/supervisor-agent.ts
-var SupervisorAgent = class extends EventEmitter4 {
+var SupervisorAgent = class _SupervisorAgent extends EventEmitter4 {
   logger;
   agent;
   getMessageBroadcaster;
@@ -7573,6 +7692,11 @@ var SupervisorAgent = class extends EventEmitter4 {
   isProcessingCommand = false;
   /** Timestamp when current execution started (for race condition protection) */
   executionStartedAt = 0;
+  clearContextLock = new AsyncLock();
+  static CLEAR_CONTEXT_TIMEOUT_MS = 1e4;
+  // 10 seconds
+  /** FIX #6: Broadcast acknowledgment tracking */
+  broadcastAcknowledgments = /* @__PURE__ */ new Map();
   constructor(config2) {
     super();
     this.logger = config2.logger.child({ component: "SupervisorAgent" });
@@ -7598,7 +7722,11 @@ var SupervisorAgent = class extends EventEmitter4 {
         config2.workspacesRoot,
         config2.getMessageBroadcaster,
         config2.getChatHistoryService,
-        () => this.clearContext(),
+        () => {
+          this.clearContext().catch((error) => {
+            this.logger.error({ error }, "Failed to clear supervisor context");
+          });
+        },
         terminateSessionCallback
       ),
       ...createFilesystemTools(config2.workspacesRoot)
@@ -7860,27 +7988,86 @@ var SupervisorAgent = class extends EventEmitter4 {
     this.logger.info("Global conversation history cleared");
   }
   /**
-   * Clears supervisor context completely:
-   * - In-memory conversation history
-   * - Persistent history in database
-   * - Notifies all connected clients
+   * Clears supervisor context completely with multi-device synchronization:
+   * - Acquires lock to prevent concurrent execution during clear
+   * - Cancels active execution streams
+   * - Clears in-memory conversation history
+   * - Clears persistent history in database
+   * - Broadcasts notification to all clients with ack tracking (FIX #6, #9)
+   */
+  async clearContext() {
+    await this.clearContextLock.acquire("clear", async () => {
+      this.logger.info({ isExecuting: this.isExecuting }, "Acquiring lock for context clear");
+      if (this.isExecuting || this.isProcessingCommand) {
+        this.logger.info("Active execution detected, cancelling before clear");
+        this.cancel();
+        await new Promise((resolve2) => setTimeout(resolve2, 50));
+      }
+      this.conversationHistory = [];
+      this.isCancelled = false;
+      const chatHistoryService = this.getChatHistoryService?.();
+      if (chatHistoryService) {
+        try {
+          chatHistoryService.clearSupervisorHistory();
+          this.logger.debug("Persistent supervisor history cleared");
+        } catch (error) {
+          this.logger.error({ error }, "Failed to clear persistent supervisor history");
+        }
+      }
+      const broadcaster = this.getMessageBroadcaster?.();
+      if (broadcaster) {
+        const broadcastId = `clear_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+        const clearNotification = JSON.stringify({
+          type: "supervisor.context_cleared",
+          payload: { timestamp: Date.now(), broadcast_id: broadcastId }
+        });
+        try {
+          const deviceIds = new Set(broadcaster.getAuthenticatedDeviceIds());
+          if (deviceIds.size > 0) {
+            this.broadcastAcknowledgments.set(broadcastId, {
+              deviceIds,
+              timestamp: Date.now(),
+              timeout: setTimeout(() => {
+                const ack = this.broadcastAcknowledgments.get(broadcastId);
+                if (ack && ack.deviceIds.size > 0) {
+                  this.logger.warn({
+                    broadcastId,
+                    missingDevices: Array.from(ack.deviceIds)
+                  }, "Context clear broadcast - missing acks from devices");
+                }
+                this.broadcastAcknowledgments.delete(broadcastId);
+              }, 5e3)
+              // 5 second timeout
+            });
+          }
+          broadcaster.broadcastToAll(clearNotification);
+          this.logger.info({
+            broadcastId,
+            deviceCount: deviceIds.size
+          }, "Broadcasted context cleared notification to all clients");
+        } catch (error) {
+          this.logger.error({ error }, "Failed to broadcast context cleared");
+        }
+      } else {
+        this.logger.warn("MessageBroadcaster not available");
+      }
+      this.logger.info("Supervisor context cleared (lock released)");
+    }, { timeout: _SupervisorAgent.CLEAR_CONTEXT_TIMEOUT_MS });
+  }
+  /**
+   * FIX #6: Records acknowledgment from a device for context clear broadcast.
    */
-  clearContext() {
-    this.conversationHistory = [];
-    this.isCancelled = false;
-    const chatHistoryService = this.getChatHistoryService?.();
-    if (chatHistoryService) {
-      chatHistoryService.clearSupervisorHistory();
-    }
-    const broadcaster = this.getMessageBroadcaster?.();
-    if (broadcaster) {
-      const clearNotification = JSON.stringify({
-        type: "supervisor.context_cleared",
-        payload: { timestamp: Date.now() }
-      });
-      broadcaster.broadcastToAll(clearNotification);
+  recordClearAck(broadcastId, deviceId) {
+    const ack = this.broadcastAcknowledgments.get(broadcastId);
+    if (ack) {
+      ack.deviceIds.delete(deviceId);
+      this.logger.debug({ broadcastId, deviceId, remaining: ack.deviceIds.size }, "Received clear ack");
+      if (ack.deviceIds.size === 0) {
+        clearTimeout(ack.timeout);
+        this.broadcastAcknowledgments.delete(broadcastId);
+        this.logger.info({ broadcastId }, "All devices acknowledged context clear");
+      }
     }
-    this.logger.info("Supervisor context cleared (in-memory, persistent, and clients notified)");
   }
   /**
    * Resets the cancellation state.
@@ -8375,9 +8562,15 @@ var MockSupervisorAgent = class extends EventEmitter5 {
   getConversationHistory() {
     return [...this.conversationHistory];
   }
-  /**
-   * Sleep utility.
-   */
+  clearContext() {
+    this.conversationHistory = [];
+    this.isCancelled = false;
+    this.logger.info("Mock context cleared");
+    return Promise.resolve();
+  }
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  recordClearAck(_broadcastId, _deviceId) {
+  }
   sleep(ms) {
     return new Promise((resolve2) => setTimeout(resolve2, ms));
   }
@@ -9181,7 +9374,7 @@ function handleTunnelMessage(rawMessage, tunnelClient, messageBroadcaster, creat
     );
   }
 }
-function handleAuthMessageViaTunnel(data, tunnelClient, authenticateClient, logger, subscriptionService) {
+function handleAuthMessageViaTunnel(data, tunnelClient, authenticateClient, logger, subscriptionService, messageBroadcaster) {
   const authResult = AuthMessageSchema.safeParse(data);
   if (!authResult.success) {
     logger.warn(
@@ -9211,6 +9404,32 @@ function handleAuthMessageViaTunnel(data, tunnelClient, authenticateClient, logg
         );
       }
     }
+    if (messageBroadcaster) {
+      const bufferedMessages = messageBroadcaster.flushAuthBuffer(deviceId);
+      if (bufferedMessages.length > 0) {
+        logger.info(
+          { deviceId, messageCount: bufferedMessages.length },
+          "Flushing buffered messages after subscription restore"
+        );
+        (async () => {
+          for (const bufferedMsg of bufferedMessages) {
+            try {
+              await messageBroadcaster.broadcastToSubscribers(
+                bufferedMsg.sessionId,
+                bufferedMsg.message
+              );
+            } catch (error) {
+              logger.error(
+                { error, deviceId, sessionId: bufferedMsg.sessionId },
+                "Failed to send buffered message"
+              );
+            }
+          }
+        })().catch((error) => {
+          logger.error({ error, deviceId }, "Error flushing buffered messages");
+        });
+      }
+    }
     const responseJson = JSON.stringify(result);
     if (tunnelClient.send(responseJson)) {
       logger.info(
@@ -9449,7 +9668,7 @@ async function bootstrap() {
     }
   };
   const createMessageHandlers = () => ({
-    auth: (socket, message) => {
+    auth: async (socket, message) => {
       const authMessage = message;
       const deviceId = authMessage.payload.device_id;
       const result = authenticateClient.execute({
@@ -9467,6 +9686,21 @@ async function bootstrap() {
           );
         }
       }
+      if (broadcaster) {
+        const bufferedMessages = broadcaster.flushAuthBuffer(deviceId);
+        if (bufferedMessages.length > 0) {
+          logger.info(
+            { deviceId, messageCount: bufferedMessages.length },
+            "Flushing buffered messages after subscription restore"
+          );
+          for (const bufferedMsg of bufferedMessages) {
+            await broadcaster.broadcastToSubscribers(
+              bufferedMsg.sessionId,
+              bufferedMsg.message
+            );
+          }
+        }
+      }
       sendToDevice(socket, deviceId, JSON.stringify(result));
       return Promise.resolve();
     },
@@ -9911,13 +10145,13 @@ async function bootstrap() {
       return Promise.resolve();
     },
     // Clear supervisor conversation history (global)
-    "supervisor.clear_context": (socket, message) => {
+    "supervisor.clear_context": async (socket, message) => {
       const clearMessage = message;
       const directClient = clientRegistry.getBySocket(socket);
       const tunnelClient2 = clearMessage.device_id ? clientRegistry.getByDeviceId(new DeviceId(clearMessage.device_id)) : void 0;
       const isAuthenticated = directClient?.isAuthenticated ?? tunnelClient2?.isAuthenticated;
       if (isAuthenticated) {
-        supervisorAgent.clearContext();
+        await supervisorAgent.clearContext();
         sendToDevice(
           socket,
           clearMessage.device_id,
@@ -10869,8 +11103,27 @@ async function bootstrap() {
               tunnelClient,
               authenticateClient,
               logger,
-              subscriptionService
+              subscriptionService,
+              broadcaster
             );
+          } else if (messageType === "supervisor.context_cleared.ack") {
+            try {
+              const ackData = data;
+              const broadcastId = ackData.payload?.broadcast_id;
+              const deviceId = ackData.payload?.device_id;
+              if (broadcastId && deviceId && supervisorAgent) {
+                supervisorAgent.recordClearAck(broadcastId, deviceId);
+                logger.debug(
+                  { broadcastId, deviceId },
+                  "Recorded context clear acknowledgment"
+                );
+              }
+            } catch (ackError) {
+              logger.warn(
+                { error: ackError, message: message.slice(0, 100) },
+                "Failed to process context clear acknowledgment"
+              );
+            }
           } else {
             handleTunnelMessage(
               message,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiflis-io/tiflis-code-workstation",
-  "version": "0.3.29",
+  "version": "0.3.30",
   "description": "Workstation server for tiflis-code - manages agent sessions and terminal access",
   "author": "Roman Barinov <rbarinov@gmail.com>",
   "license": "FSL-1.1-NC",
@@ -36,6 +36,7 @@
     "@langchain/core": "^0.3.26",
     "@langchain/langgraph": "^0.2.42",
     "@langchain/openai": "^0.3.17",
+    "async-lock": "^1.4.0",
     "better-sqlite3": "^11.7.0",
     "dotenv": "^16.4.7",
     "drizzle-orm": "^0.38.3",
@@ -51,6 +52,7 @@
   },
   "devDependencies": {
     "@eslint/js": "^9.17.0",
+    "@types/async-lock": "^1.4.2",
     "@types/better-sqlite3": "^7.6.12",
     "@types/node": "^22.10.2",
     "@types/ws": "^8.5.13",