taist 0.2.10 → 0.2.12

package/lib/trace-collector.js

@@ -72,9 +72,15 @@ export class TraceCollector extends EventEmitter {
   _handleConnection(socket) {
     this.connections.add(socket);
     let buffer = "";
+    const lifecycleDebug = process.env.TAIST_TRACE_LIFECYCLE === 'true';
 
     socket.on("data", (chunk) => {
-      buffer += chunk.toString();
+      const data = chunk.toString();
+      buffer += data;
+
+      if (lifecycleDebug) {
+        console.log(`[LIFECYCLE collector] [${Date.now()}] RAW DATA received, length:`, data.length, 'buffer now:', buffer.length);
+      }
 
       // Process complete NDJSON lines
       const lines = buffer.split("\n");
@@ -88,6 +94,9 @@ export class TraceCollector extends EventEmitter {
     });
 
     socket.on("close", () => {
+      if (lifecycleDebug) {
+        console.log('[LIFECYCLE collector] Socket closed, remaining buffer:', buffer.length, 'chars');
+      }
       // Process any remaining data in buffer
       if (buffer.trim()) {
         this._processMessage(buffer);
@@ -96,18 +105,26 @@ export class TraceCollector extends EventEmitter {
     });
 
     socket.on("error", (err) => {
+      if (lifecycleDebug) {
+        console.log('[LIFECYCLE collector] Socket error:', err.message);
+      }
       this.emit("connectionError", err);
       this.connections.delete(socket);
     });
   }
 
   _processMessage(line) {
+    const lifecycleDebug = process.env.TAIST_TRACE_LIFECYCLE === 'true';
+
     try {
       const message = JSON.parse(line);
 
       if (message.type === "trace") {
         this._addTrace(message.data);
       } else if (message.type === "batch") {
+        if (lifecycleDebug) {
+          console.log('[LIFECYCLE collector] Processing batch of', message.data?.length, 'traces');
+        }
         for (const trace of message.data) {
           this._addTrace(trace);
         }
@@ -115,6 +132,9 @@ export class TraceCollector extends EventEmitter {
         this.emit("flush", { workerId: message.workerId });
       }
     } catch (err) {
+      if (lifecycleDebug) {
+        console.log('[LIFECYCLE collector] PARSE ERROR:', err.message, 'line:', line.slice(0, 100));
+      }
       this.emit("parseError", { error: err, line });
     }
   }
@@ -143,7 +163,7 @@ export class TraceCollector extends EventEmitter {
     }
 
     if (lifecycleDebug) {
-      console.log('[LIFECYCLE collector] RECEIVED:', trace.name, 'depth:', trace.depth, 'correlationId:', trace.correlationId);
+      console.log(`[LIFECYCLE collector] [${Date.now()}] RECEIVED:`, trace.name, 'depth:', trace.depth, 'correlationId:', trace.correlationId);
     } else if (debug) {
       console.log('[collector] RECEIVED:', trace.name, 'depth:', trace.depth, 'correlationId:', trace.correlationId);
     }
@@ -182,6 +202,12 @@ export class TraceCollector extends EventEmitter {
       return;
     }
 
+    const lifecycleDebug = process.env.TAIST_TRACE_LIFECYCLE === 'true';
+
+    if (lifecycleDebug) {
+      console.log(`[LIFECYCLE collector] [${Date.now()}] stop() called, connections:`, this.connections.size);
+    }
+
     // Send shutdown signal to all connected workers
     const shutdownMessage = JSON.stringify({ type: 'shutdown' }) + '\n';
     for (const socket of this.connections) {
@@ -198,45 +224,87 @@ export class TraceCollector extends EventEmitter {
       await new Promise(resolve => setTimeout(resolve, 50));
     }
 
+    if (lifecycleDebug) {
+      console.log('[LIFECYCLE collector] After wait, remaining connections:', this.connections.size);
+    }
+
     return new Promise((resolve) => {
-      // Gracefully close any remaining connections (allows pending data to be read)
-      for (const socket of this.connections) {
+      // If all connections closed gracefully, we're done
+      if (this.connections.size === 0) {
+        this._finishStop(resolve);
+        return;
+      }
+
+      // Track sockets that need closing
+      const socketsToClose = new Set(this.connections);
+      let closedCount = 0;
+
+      const onSocketClosed = (socket) => {
+        socketsToClose.delete(socket);
+        closedCount++;
+        if (lifecycleDebug) {
+          console.log('[LIFECYCLE collector] Socket closed during shutdown, remaining:', socketsToClose.size);
+        }
+        if (socketsToClose.size === 0) {
+          clearTimeout(forceCloseTimeout);
+          this._finishStop(resolve);
+        }
+      };
+
+      // Set up close handlers for remaining sockets
+      for (const socket of socketsToClose) {
+        socket.once('close', () => onSocketClosed(socket));
         try {
+          // socket.end() sends FIN but allows pending data to be read
           socket.end();
         } catch {
-          try { socket.destroy(); } catch { /* ignore */ }
+          // Socket already closed
+          onSocketClosed(socket);
         }
       }
 
-      // Give a moment for final data to arrive before destroying
-      setTimeout(() => {
-        // Force destroy any sockets that didn't close gracefully
-        for (const socket of this.connections) {
+      // Force close after extended grace period (500ms instead of 100ms)
+      // This gives more time for in-flight data to be received
+      const forceCloseTimeout = setTimeout(() => {
+        if (lifecycleDebug) {
+          console.log('[LIFECYCLE collector] Force closing', socketsToClose.size, 'remaining sockets');
+        }
+        for (const socket of socketsToClose) {
           try {
             socket.destroy();
           } catch {
             // Ignore
           }
         }
-        this.connections.clear();
-
-        // Close server
-        this.server.close(() => {
-          this.started = false;
-
-          // Clean up socket file
-          if (process.platform !== "win32") {
-            try {
-              fs.unlinkSync(this.socketPath);
-            } catch {
-              // Ignore
-            }
-          }
+        this._finishStop(resolve);
+      }, 500);
+    });
+  }
+
+  _finishStop(resolve) {
+    const lifecycleDebug = process.env.TAIST_TRACE_LIFECYCLE === 'true';
+
+    this.connections.clear();
+
+    // Close server
+    this.server.close(() => {
+      this.started = false;
+
+      // Clean up socket file
+      if (process.platform !== "win32") {
+        try {
+          fs.unlinkSync(this.socketPath);
+        } catch {
+          // Ignore
+        }
+      }
+
+      if (lifecycleDebug) {
+        console.log('[LIFECYCLE collector] Stopped, total traces collected:', this.traces.length);
+      }
 
-          this.emit("stopped");
-          resolve();
-        });
-      }, 100); // 100ms grace period for data to be read
+      this.emit("stopped");
+      resolve();
     });
   }
 

package/lib/trace-reporter.js

@@ -317,10 +317,16 @@ export class TraceReporter extends EventEmitter {
     const traces = this.buffer.splice(0, this.buffer.length);
 
     if (lifecycleDebug) {
-      console.log('[LIFECYCLE reporter] SENDING', traces.length, 'traces to collector');
+      const now = Date.now();
+      console.log(`[LIFECYCLE reporter] [${now}] SENDING`, traces.length, 'traces to collector');
       for (const t of traces) {
         console.log('[LIFECYCLE reporter]   -', t.name, 'depth:', t.depth);
       }
+      // Log socket state to diagnose connection issues
+      console.log(`[LIFECYCLE reporter] [${now}] Socket state: destroyed=`, this.socket.destroyed,
+        'writableEnded=', this.socket.writableEnded,
+        'readableEnded=', this.socket.readableEnded,
+        'pending=', this.socket.pending);
     }
 
     const message = JSON.stringify({
@@ -330,17 +336,21 @@ export class TraceReporter extends EventEmitter {
     });
 
     return new Promise((resolve, reject) => {
-      this.socket.write(message + "\n", (err) => {
+      const writeResult = this.socket.write(message + "\n", (err) => {
         if (err) {
-          if (lifecycleDebug) console.log('[LIFECYCLE reporter] SEND FAILED:', err.message);
+          if (lifecycleDebug) console.log('[LIFECYCLE reporter] WRITE CALLBACK error:', err.message);
           // Put traces back in buffer on failure
           this.buffer.unshift(...traces);
           reject(err);
         } else {
+          if (lifecycleDebug) console.log('[LIFECYCLE reporter] WRITE CALLBACK success for', traces.length, 'traces');
           this.emit("flushed", { count: traces.length });
           resolve();
         }
       });
+      if (lifecycleDebug) {
+        console.log('[LIFECYCLE reporter] socket.write() returned:', writeResult, '(true=flushed to kernel, false=buffered)');
+      }
     });
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taist",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "description": "Token-Optimized Testing Framework for AI-Assisted Development",
   "main": "index.js",
   "type": "module",