pi-harness-runtime 1.1.376 → 1.1.377

package/packages/provider-router/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/provider-router",
-  "version": "1.1.376",
+  "version": "1.1.377",
   "description": "Enhanced Provider Router for pi-harness-runtime — intelligent routing with capabilities, costs, and quotas",
   "type": "module",
   "main": "./dist/provider-router.js",

package/packages/provider-selector/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/provider-selector",
-  "version": "1.1.376",
+  "version": "1.1.377",
   "description": "Multi-Provider Selector — route requests by cost, quality, and latency (RFC-0012)",
   "type": "module",
   "main": "./dist/index.js",

package/packages/providers/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/providers",
-  "version": "1.1.376",
+  "version": "1.1.377",
   "description": "pi-harness-runtime — providers",
   "type": "module",
   "main": "./dist/index.js",

package/packages/qdrant-skills/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/qdrant-skills",
-  "version": "1.1.376",
+  "version": "1.1.377",
   "description": "Qdrant vector search integration for Hermes-style skill system",
   "type": "module",
   "main": "./dist/index.js",

package/packages/quota-manager/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/quota-manager",
-  "version": "1.1.376",
+  "version": "1.1.377",
   "description": "pi-harness-runtime — quota-manager",
   "type": "module",
   "main": "./dist/index.js",

package/packages/rate-limiter/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/rate-limiter",
-  "version": "1.1.376",
+  "version": "1.1.377",
   "type": "module",
   "description": "Rate limiting with token bucket algorithm (RFC-0023)",
   "main": "dist/index.js",

package/packages/react-vite-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/react-vite-plugin",
-  "version": "1.1.376",
+  "version": "1.1.377",
   "description": "React/Vite framework analysis — components, config, TypeScript setup",
   "type": "module",
   "main": "./dist/index.js",

package/packages/relay/dist/client.d.ts

@@ -1,53 +1,74 @@
 /**
- * Relay Client - Connect to relay server for remote access
- */
-import type { RelayConfig, RelayTunnel, RelayMessage } from './types.js';
-/**
- * Relay Client options
+ * Relay Client - Two-way streaming WebSocket client
+ *
+ * Implements t3code-style streaming with:
+ * - Connection state machine
+ * - Snapshot + live event handling
+ * - Typed message protocol
+ * - Automatic reconnection with backoff
  */
-export interface RelayClientOptions {
-    /** Called when connected */
-    onConnected?: () => void;
+import { type RelayConfig, type ConnectionState, type ConnectionStateChange, type CallbackPayload, type ClientMessage, type SnapshotMessage, type StatusMessage } from './types.js';
+export interface RelayClientCallbacks {
+    /** Called when connected and authenticated */
+    onConnected?: (sessionId: string) => void;
     /** Called when disconnected */
     onDisconnected?: () => void;
-    /** Called when tunnel is established */
-    onTunnel?: (tunnel: RelayTunnel) => void;
+    /** Called when snapshot is received (initial state) */
+    onSnapshot?: (snapshot: SnapshotMessage['payload']) => void;
+    /** Called when synchronized marker received (live events start) */
+    onSynchronized?: () => void;
+    /** Called when a callback event is received */
+    onCallback?: (callback: CallbackPayload) => void;
+    /** Called when a status message is received */
+    onStatus?: (status: StatusMessage['payload']) => void;
     /** Called on error */
     onError?: (error: Error) => void;
+    /** Called when connection state changes */
+    onStateChange?: (change: ConnectionStateChange) => void;
 }
-/**
- * Relay Client
- *
- * Connects to a relay server and establishes tunnels for remote access.
- */
 export declare class RelayClient {
+    private ws;
     private config;
-    private options;
-    private connected;
-    private tunnel?;
-    constructor(config: RelayConfig, options: RelayClientOptions);
+    private callbacks;
+    private state;
+    private sessionId;
+    private clientId;
+    private reconnectAttempt;
+    private reconnectDelay;
+    private reconnectTimer;
+    private connectTimeoutTimer;
+    private heartbeatTimer;
+    private snapshotReceived;
+    private synchronizedReceived;
+    constructor(config: RelayConfig, callbacks?: RelayClientCallbacks);
+    private setState;
+    private isConnected;
     /**
-     * Connect to relay server
+     * Connect to relay server with automatic authentication
      */
     connect(): Promise<void>;
     /**
      * Disconnect from relay server
      */
-    disconnect(): Promise<void>;
-    /**
-     * Create a tunnel
-     */
-    createTunnel(localPort: number): Promise<RelayTunnel>;
-    /**
-     * Send a message through the tunnel
-     */
-    send(_message: RelayMessage): Promise<void>;
-    /**
-     * Check if connected
-     */
-    isConnected(): boolean;
+    disconnect(): void;
     /**
-     * Get current tunnel
+     * Send a message through the WebSocket
      */
-    getTunnel(): RelayTunnel | undefined;
+    send(message: ClientMessage): void;
+    private handleMessage;
+    private handleConnected;
+    private handleAuth;
+    private handleSnapshot;
+    private handleSynchronized;
+    private handleCallback;
+    private handleStatus;
+    private handleDisconnect;
+    private scheduleReconnect;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private cleanup;
+    getState(): ConnectionState;
+    isReady(): boolean;
+    getSessionId(): string | null;
+    getClientId(): string | null;
 }

package/packages/relay/dist/client.js

@@ -1,95 +1,302 @@
 /**
- * Relay Client - Connect to relay server for remote access
- */
-/**
- * Generate a UUID v4
- */
-function generateUUID() {
-    // Use crypto.randomUUID if available (Node.js 14.17+)
-    const crypto = globalThis;
-    if (crypto.crypto?.randomUUID) {
-        return crypto.crypto.randomUUID();
-    }
-    // Fallback: simple UUID generation
-    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
-        const r = (Math.random() * 16) | 0;
-        const v = c === 'x' ? r : (r & 0x3) | 0x8;
-        return v.toString(16);
-    });
-}
-/**
- * Relay Client
+ * Relay Client - Two-way streaming WebSocket client
  *
- * Connects to a relay server and establishes tunnels for remote access.
+ * Implements t3code-style streaming with:
+ * - Connection state machine
+ * - Snapshot + live event handling
+ * - Typed message protocol
+ * - Automatic reconnection with backoff
  */
+import WebSocket from "ws";
+import { PROTOCOL_VERSION, createTimestamp, } from './types.js';
+// ============================================================================
+// Constants
+// ============================================================================
+const DEFAULT_RECONNECT_DELAY_MS = 1000;
+const MAX_RECONNECT_DELAY_MS = 30000;
+const HEARTBEAT_INTERVAL_MS = 30000;
+const CONNECT_TIMEOUT_MS = 10000;
+// ============================================================================
+// Relay Client - Two-way Streaming Implementation
+// ============================================================================
 export class RelayClient {
+    ws = null;
     config;
-    options;
-    connected = false;
-    tunnel;
-    constructor(config, options) {
+    callbacks;
+    // State machine
+    state = { state: 'disconnected' };
+    sessionId = null;
+    clientId = null;
+    // Reconnection
+    reconnectAttempt = 0;
+    reconnectDelay = DEFAULT_RECONNECT_DELAY_MS;
+    reconnectTimer = null;
+    connectTimeoutTimer = null;
+    // Heartbeat
+    heartbeatTimer = null;
+    // Snapshot tracking (t3code pattern)
+    snapshotReceived = false;
+    synchronizedReceived = false;
+    constructor(config, callbacks = {}) {
         this.config = config;
-        this.options = options;
+        this.callbacks = callbacks;
+    }
+    // ========================================================================
+    // Connection State Machine
+    // ========================================================================
+    setState(newState) {
+        const previous = this.state;
+        this.state = newState;
+        this.callbacks.onStateChange?.({
+            previous,
+            current: newState,
+            timestamp: createTimestamp(),
+        });
     }
+    isConnected() {
+        return this.ws?.readyState === WebSocket.OPEN &&
+            this.state.state === 'connected';
+    }
+    // ========================================================================
+    // Lifecycle
+    // ========================================================================
     /**
-     * Connect to relay server
+     * Connect to relay server with automatic authentication
      */
     async connect() {
-        if (this.connected)
+        if (this.isConnected())
             return;
-        try {
-            // In a real implementation, this would establish WebSocket connection
-            // to the relay server and authenticate
-            this.connected = true;
-            this.options.onConnected?.();
-        }
-        catch (error) {
-            this.options.onError?.(error);
-            throw error;
-        }
+        // Clear any existing connection
+        this.cleanup();
+        this.setState({ state: 'connecting' });
+        const url = this.config.serverUrl;
+        console.log(`[RelayClient] Connecting to ${url}...`);
+        return new Promise((resolve, reject) => {
+            // Set connect timeout
+            this.connectTimeoutTimer = setTimeout(() => {
+                if (this.state.state === 'connecting') {
+                    this.ws?.close();
+                    reject(new Error('Connection timeout'));
+                }
+            }, CONNECT_TIMEOUT_MS);
+            this.ws = new WebSocket(url);
+            this.ws.on("open", () => {
+                console.log("[RelayClient] WebSocket opened");
+                this.setState({ state: 'authenticating' });
+                // Send authentication
+                this.send({
+                    version: PROTOCOL_VERSION,
+                    type: 'auth',
+                    payload: { token: this.config.token || '' },
+                    timestamp: createTimestamp(),
+                });
+            });
+            this.ws.on("message", (data) => {
+                this.handleMessage(data.toString());
+            });
+            this.ws.on("close", () => {
+                console.log("[RelayClient] WebSocket closed");
+                this.handleDisconnect();
+            });
+            this.ws.on("error", (err) => {
+                console.error("[RelayClient] WebSocket error:", err.message);
+                this.callbacks.onError?.(err);
+                if (this.state.state === 'connecting' || this.state.state === 'authenticating') {
+                    clearTimeout(this.connectTimeoutTimer);
+                    reject(err);
+                }
+                this.handleDisconnect();
+            });
+        });
     }
     /**
      * Disconnect from relay server
      */
-    async disconnect() {
-        this.connected = false;
-        this.tunnel = undefined;
-        this.options.onDisconnected?.();
+    disconnect() {
+        console.log("[RelayClient] Disconnecting...");
+        this.cleanup();
+        this.setState({ state: 'disconnected' });
+        this.callbacks.onDisconnected?.();
     }
     /**
-     * Create a tunnel
+     * Send a message through the WebSocket
      */
-    async createTunnel(localPort) {
-        const tunnel = {
-            id: generateUUID(),
-            url: `${this.config.serverUrl}/tunnel/${localPort}`,
-            localPort,
-            status: this.connected ? 'connected' : 'disconnected',
-            createdAt: new Date().toISOString(),
-        };
-        this.tunnel = tunnel;
-        this.options.onTunnel?.(tunnel);
-        return tunnel;
+    send(message) {
+        if (this.isConnected()) {
+            this.ws.send(JSON.stringify(message));
+        }
     }
-    /**
-     * Send a message through the tunnel
-     */
-    async send(_message) {
-        if (!this.connected) {
-            throw new Error('Not connected to relay server');
+    // ========================================================================
+    // Message Handling
+    // ========================================================================
+    handleMessage(data) {
+        try {
+            const msg = JSON.parse(data);
+            switch (msg.type) {
+                case 'connected':
+                    this.handleConnected(msg);
+                    break;
+                case 'auth':
+                    this.handleAuth(msg);
+                    break;
+                case 'snapshot':
+                    this.handleSnapshot(msg);
+                    break;
+                case 'synchronized':
+                    this.handleSynchronized(msg);
+                    break;
+                case 'callback':
+                    this.handleCallback(msg);
+                    break;
+                case 'status':
+                    this.handleStatus(msg);
+                    break;
+                case 'pong':
+                    // Heartbeat response - connection is alive
+                    break;
+                default: {
+                    const unknownMsg = msg;
+                    console.warn(`[RelayClient] Unknown message type: ${unknownMsg.type}`);
+                }
+            }
+        }
+        catch (err) {
+            console.error("[RelayClient] Failed to parse message:", err);
+            this.callbacks.onError?.(err);
         }
-        // In a real implementation, this would send the message over WebSocket
     }
-    /**
-     * Check if connected
-     */
-    isConnected() {
-        return this.connected;
+    handleConnected(msg) {
+        this.clientId = msg.payload.clientId;
+        console.log(`[RelayClient] Connected, clientId: ${this.clientId}`);
     }
-    /**
-     * Get current tunnel
-     */
-    getTunnel() {
-        return this.tunnel;
+    handleAuth(msg) {
+        if (msg.payload.success) {
+            this.sessionId = msg.payload.sessionId || null;
+            this.setState({ state: 'connected', sessionId: this.sessionId || '' });
+            // Reset reconnection state
+            this.reconnectAttempt = 0;
+            this.reconnectDelay = DEFAULT_RECONNECT_DELAY_MS;
+            // Start heartbeat
+            this.startHeartbeat();
+            // Notify callback
+            this.callbacks.onConnected?.(this.sessionId || '');
+            console.log(`[RelayClient] Authenticated, sessionId: ${this.sessionId}`);
+        }
+        else {
+            console.error(`[RelayClient] Auth failed: ${msg.payload.error}`);
+            this.callbacks.onError?.(new Error(msg.payload.error || 'Authentication failed'));
+            this.disconnect();
+        }
+    }
+    handleSnapshot(msg) {
+        console.log(`[RelayClient] Snapshot received: ${msg.payload.recentCallbacks.length} recent callbacks`);
+        this.snapshotReceived = true;
+        // Notify callback
+        this.callbacks.onSnapshot?.(msg.payload);
+    }
+    handleSynchronized(_msg) {
+        console.log("[RelayClient] Synchronized - live events starting");
+        this.synchronizedReceived = true;
+        // Notify callback
+        this.callbacks.onSynchronized?.();
+    }
+    handleCallback(msg) {
+        // Only process callbacks after synchronized
+        if (!this.synchronizedReceived) {
+            console.warn("[RelayClient] Ignoring callback before synchronized");
+            return;
+        }
+        this.callbacks.onCallback?.(msg.payload);
+    }
+    handleStatus(msg) {
+        console.log(`[RelayClient] Status [${msg.payload.kind}]: ${msg.payload.code} - ${msg.payload.message}`);
+        this.callbacks.onStatus?.(msg.payload);
+    }
+    // ========================================================================
+    // Disconnect & Reconnect
+    // ========================================================================
+    handleDisconnect() {
+        this.stopHeartbeat();
+        const wasConnected = this.state.state === 'connected';
+        this.setState({ state: 'disconnected' });
+        if (wasConnected) {
+            this.callbacks.onDisconnected?.();
+            this.scheduleReconnect();
+        }
+    }
+    scheduleReconnect() {
+        if (this.reconnectTimer)
+            return;
+        this.reconnectAttempt++;
+        this.setState({ state: 'reconnecting', attempt: this.reconnectAttempt });
+        console.log(`[RelayClient] Scheduling reconnect attempt ${this.reconnectAttempt} in ${this.reconnectDelay}ms`);
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            this.connect().catch((err) => {
+                console.error(`[RelayClient] Reconnect failed: ${err.message}`);
+            });
+        }, this.reconnectDelay);
+        // Exponential backoff
+        this.reconnectDelay = Math.min(this.reconnectDelay * 2, MAX_RECONNECT_DELAY_MS);
+    }
+    // ========================================================================
+    // Heartbeat
+    // ========================================================================
+    startHeartbeat() {
+        this.stopHeartbeat();
+        this.heartbeatTimer = setInterval(() => {
+            if (this.isConnected()) {
+                this.send({
+                    version: PROTOCOL_VERSION,
+                    type: 'ping',
+                    payload: {},
+                    timestamp: createTimestamp(),
+                });
+            }
+        }, HEARTBEAT_INTERVAL_MS);
+    }
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+    // ========================================================================
+    // Cleanup
+    // ========================================================================
+    cleanup() {
+        // Clear timers
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.connectTimeoutTimer) {
+            clearTimeout(this.connectTimeoutTimer);
+            this.connectTimeoutTimer = null;
+        }
+        this.stopHeartbeat();
+        // Reset snapshot state
+        this.snapshotReceived = false;
+        this.synchronizedReceived = false;
+        // Close WebSocket
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+    }
+    // ========================================================================
+    // Public API
+    // ========================================================================
+    getState() {
+        return this.state;
+    }
+    isReady() {
+        return this.isConnected() && this.synchronizedReceived;
+    }
+    getSessionId() {
+        return this.sessionId;
+    }
+    getClientId() {
+        return this.clientId;
     }
 }

package/packages/relay/dist/index.d.ts

@@ -1,9 +1,16 @@
 /**
- * Cloud Relay - T3 Connect Style
+ * Cloud Relay - Two-way Streaming Communication
  *
- * Enables remote access to pi-harness without router/port forwarding.
- * Based on T3Code's T3 Connect architecture.
+ * Enables real-time two-way communication with pi-harness without router/port forwarding.
+ * Based on T3Code's streaming architecture:
+ * - Snapshot + Live event pattern
+ * - Typed message protocol
+ * - Connection state machine
+ * - Stream coalescing
  */
-export { RelayServer } from './server.js';
+export { RelayServer, createRelayServer } from './server.js';
+export type { RelayServerOptions } from './server.js';
 export { RelayClient } from './client.js';
-export { RelayConfig, RelayTunnel } from './types.js';
+export type { RelayClientCallbacks } from './client.js';
+export { PROTOCOL_VERSION, generateMessageId, createTimestamp, } from './types.js';
+export type { RelayConfig, RelayTunnel, ConnectionState, ConnectionStateChange, BaseMessage, SnapshotMessage, SynchronizedMessage, CallbackPayload, CallbackMessage, StatusKind, StatusMessage, PingMessage, PongMessage, AuthRequestMessage, AuthResponseMessage, SubscribeMessage, ConnectedMessage, ServerMessage, ClientMessage, RelayMessage, } from './types.js';

package/packages/relay/dist/index.js

@@ -1,8 +1,16 @@
 /**
- * Cloud Relay - T3 Connect Style
+ * Cloud Relay - Two-way Streaming Communication
  *
- * Enables remote access to pi-harness without router/port forwarding.
- * Based on T3Code's T3 Connect architecture.
+ * Enables real-time two-way communication with pi-harness without router/port forwarding.
+ * Based on T3Code's streaming architecture:
+ * - Snapshot + Live event pattern
+ * - Typed message protocol
+ * - Connection state machine
+ * - Stream coalescing
  */
-export { RelayServer } from './server.js';
+// Server
+export { RelayServer, createRelayServer } from './server.js';
+// Client
 export { RelayClient } from './client.js';
+// Types
+export { PROTOCOL_VERSION, generateMessageId, createTimestamp, } from './types.js';