agent-relay 1.2.3 → 1.3.0

package/dist/wrapper/tmux-wrapper.d.ts

@@ -11,22 +11,17 @@
  * The key insight: user sees the REAL tmux session, not a proxy.
  * We just do background parsing and injection.
  */
+import { BaseWrapper, type BaseWrapperConfig } from './base-wrapper.js';
+import { type ParsedCommand, type ParsedSummary } from './parser.js';
+import type { SendPayload, SendMeta } from '../protocol/types.js';
 import { type CliType } from './shared.js';
-export interface TmuxWrapperConfig {
-    name: string;
-    command: string;
-    args?: string[];
-    socketPath?: string;
+export interface TmuxWrapperConfig extends BaseWrapperConfig {
     cols?: number;
     rows?: number;
-    cwd?: string;
-    env?: Record<string, string>;
     /** Optional program identifier (e.g., 'claude', 'gpt-4o') */
     program?: string;
     /** Optional model identifier (e.g., 'claude-3-opus') */
     model?: string;
-    /** Optional task/role description for dashboard/registry */
-    task?: string;
     /** Use file-based inbox in addition to injection */
     useInbox?: boolean;
     /** Custom inbox directory */
@@ -47,26 +42,12 @@ export interface TmuxWrapperConfig {
     inputWaitTimeoutMs?: number;
     /** Polling interval when waiting for clear input (ms) */
     inputWaitPollMs?: number;
-    /** CLI type for special handling (auto-detected from command if not set) */
-    cliType?: 'claude' | 'codex' | 'gemini' | 'droid' | 'opencode' | 'other';
     /** Enable tmux mouse mode for scroll passthrough (default: true) */
     mouseMode?: boolean;
-    /** Relay prefix pattern (default: '->relay:') */
-    relayPrefix?: string;
-    /** Callback for spawn commands (@relay:spawn WorkerName cli "task") */
-    onSpawn?: (name: string, cli: string, task: string) => Promise<void>;
-    /** Callback for release commands (@relay:release WorkerName) */
-    onRelease?: (name: string) => Promise<void>;
     /** Max time to wait for stable pane output before injection (ms) */
     outputStabilityTimeoutMs?: number;
     /** Poll interval when checking pane stability before injection (ms) */
     outputStabilityPollMs?: number;
-    /** Stream output to daemon for dashboard log viewing (default: true) */
-    streamLogs?: boolean;
-    /** Resume from a previous agent ID (for crash recovery) */
-    resumeAgentId?: string;
-    /** Dashboard port for API-based spawn/release (preferred over callbacks) */
-    dashboardPort?: number;
 }
 /**
  * Get the default relay prefix for a given CLI type.
@@ -74,15 +55,13 @@ export interface TmuxWrapperConfig {
  * @deprecated Use getDefaultRelayPrefix() from shared.js instead
  */
 export declare function getDefaultPrefix(_cliType: CliType): string;
-export declare class TmuxWrapper {
-    private config;
+export declare class TmuxWrapper extends BaseWrapper {
+    protected config: TmuxWrapperConfig;
     private sessionName;
-    private client;
     private parser;
     private inbox?;
     private storage?;
     private storageReady;
-    private running;
     private pollTimer?;
     private attachProcess?;
     private lastCapturedOutput;
@@ -90,24 +69,13 @@ export declare class TmuxWrapper {
     private lastActivityTime;
     private activityState;
     private recentlySentMessages;
-    private sentMessageHashes;
-    private messageQueue;
-    private isInjecting;
     private processedOutputLength;
     private lastLoggedLength;
     private lastDebugLog;
-    private cliType;
-    private relayPrefix;
     private lastSummaryHash;
-    private lastSummaryRawContent;
-    private sessionEndProcessed;
-    private sessionEndData?;
     private pendingRelayCommands;
     private queuedMessageHashes;
     private readonly MAX_PENDING_RELAY_COMMANDS;
-    private processedSpawnCommands;
-    private processedReleaseCommands;
-    private pendingFencedSpawn;
     private receivedMessageIdSet;
     private receivedMessageIdOrder;
     private readonly MAX_RECEIVED_MESSAGES;
@@ -116,11 +84,18 @@ export declare class TmuxWrapper {
     private lastDetectedPhase?;
     private seenToolCalls;
     private seenErrors;
-    private continuity?;
-    private processedContinuityCommands;
-    private agentId?;
-    private injectionMetrics;
+    private authRevoked;
+    private lastAuthCheck;
+    private readonly AUTH_CHECK_INTERVAL;
     constructor(config: TmuxWrapperConfig);
+    /**
+     * Inject content into the tmux session via paste
+     */
+    protected performInjection(content: string): Promise<void>;
+    /**
+     * Get cleaned output for parsing (strip ANSI codes)
+     */
+    protected getCleanOutput(): string;
     /**
      * Log to stderr (safe - doesn't interfere with tmux display)
      */
@@ -149,13 +124,9 @@ export declare class TmuxWrapper {
      */
     private initializeTrajectory;
     /**
-     * Initialize agent ID for continuity/resume functionality
+     * Initialize agent ID for continuity/resume functionality (uses logStderr for tmux)
      */
-    private initializeAgentId;
-    /**
-     * Get the current agent ID
-     */
-    getAgentId(): string | undefined;
+    protected initializeAgentId(): Promise<void>;
     /**
      * Inject usage instructions for the agent including persistence protocol
      */
@@ -186,13 +157,6 @@ export declare class TmuxWrapper {
      * Poll for ->relay commands in output (silent)
      */
     private pollForRelayCommands;
-    /**
-     * Join continuation lines after ->relay commands.
-     * Claude Code and other TUIs insert real newlines in output, causing
-     * ->relay messages to span multiple lines. This joins indented
-     * continuation lines back to the ->relay line.
-     */
-    private joinContinuationLines;
     /**
      * Record recent activity and transition back to active if needed.
      */
@@ -202,9 +166,22 @@ export declare class TmuxWrapper {
      */
     private updateActivityState;
     /**
-     * Send relay command to daemon
+     * Check if the CLI output indicates auth has been revoked.
+     * This can happen when the user authenticates elsewhere (limited sessions).
+     */
+    private checkAuthRevocation;
+    /**
+     * Reset auth revocation state (called after successful re-authentication)
+     */
+    resetAuthState(): void;
+    /**
+     * Check if auth has been revoked
+     */
+    isAuthRevoked(): boolean;
+    /**
+     * Send relay command to daemon (overrides BaseWrapper for offline queue support)
      */
-    private sendRelayCommand;
+    protected sendRelayCommand(cmd: ParsedCommand): void;
     /**
      * Flush any queued relay commands when the client reconnects.
      */
@@ -219,10 +196,10 @@ export declare class TmuxWrapper {
      */
     private parseSummaryAndSave;
     /**
-     * Save a parsed summary to the continuity ledger.
+     * Save a parsed summary to the continuity ledger (uses logStderr for tmux).
      * Maps summary fields to ledger fields for session recovery.
      */
-    private saveSummaryToLedger;
+    protected saveSummaryToLedger(summary: ParsedSummary): Promise<void>;
     /**
      * Parse ->continuity: commands from output and handle them.
      * Supported commands:
@@ -232,7 +209,7 @@ export declare class TmuxWrapper {
      *   ->continuity:uncertain "..."  - Mark item as uncertain
      *   ->continuity:handoff <<<...>>> - Create explicit handoff
      */
-    private parseContinuityCommands;
+    protected parseContinuityCommands(content: string): Promise<void>;
     /**
      * Parse [[SESSION_END]] blocks from output and close session explicitly.
      * Agents output this to mark their work session as complete:
@@ -247,11 +224,11 @@ export declare class TmuxWrapper {
     /**
      * Execute spawn via API (if dashboardPort set) or callback
      */
-    private executeSpawn;
+    protected executeSpawn(name: string, cli: string, task: string): Promise<void>;
     /**
      * Execute release via API (if dashboardPort set) or callback
      */
-    private executeRelease;
+    protected executeRelease(name: string): Promise<void>;
     /**
      * Parse ->relay:spawn and ->relay:release commands from output.
      * Supports two formats:
@@ -261,13 +238,13 @@ export declare class TmuxWrapper {
      *                        can span multiple lines>>>
      *   ->relay:release WorkerName
      */
-    private parseSpawnReleaseCommands;
+    protected parseSpawnReleaseCommands(content: string): void;
     /**
      * Handle incoming message from relay
      * @param originalTo - The original 'to' field from sender. '*' indicates this was a broadcast message.
      *                     Agents should reply to originalTo to maintain channel routing (e.g., respond to #general, not DM).
      */
-    private handleIncomingMessage;
+    protected handleIncomingMessage(from: string, payload: SendPayload, messageId: string, meta?: SendMeta, originalTo?: string): void;
     /**
      * Check if we should inject a message
      */
@@ -340,7 +317,5 @@ export declare class TmuxWrapper {
      * Stop and cleanup
      */
     stop(): void;
-    get isRunning(): boolean;
-    get name(): string;
 }
 //# sourceMappingURL=tmux-wrapper.d.ts.map

package/dist/wrapper/tmux-wrapper.js

@@ -14,8 +14,9 @@
 import { exec, execSync, spawn } from 'node:child_process';
 import crypto from 'node:crypto';
 import { promisify } from 'node:util';
-import { RelayClient } from './client.js';
+import { BaseWrapper } from './base-wrapper.js';
 import { OutputParser, parseSummaryWithDetails, parseSessionEndFromOutput } from './parser.js';
+import { hasContinuityCommand, parseContinuityCommand, } from '../continuity/index.js';
 import { InboxManager } from './inbox.js';
 import { SqliteStorageAdapter } from '../storage/sqlite-adapter.js';
 import { getProjectPaths } from '../utils/project-namespace.js';
@@ -23,10 +24,9 @@ import { getTmuxPath } from '../utils/tmux-resolver.js';
 import { findAgentConfig } from '../utils/agent-config.js';
 import { getTrajectoryIntegration, detectPhaseFromContent, detectToolCalls, detectErrors, getCompactTrailInstructions, getTrailEnvVars, } from '../trajectory/integration.js';
 import { escapeForShell } from '../bridge/utils.js';
-import { getContinuityManager, parseContinuityCommand, hasContinuityCommand, } from '../continuity/index.js';
-import { stripAnsi, sleep, getDefaultRelayPrefix, createInjectionMetrics, buildInjectionString, injectWithRetry as sharedInjectWithRetry, INJECTION_CONSTANTS, CLI_QUIRKS, } from './shared.js';
+import { detectProviderAuthRevocation } from './auth-detection.js';
+import { stripAnsi, sleep, getDefaultRelayPrefix, buildInjectionString, injectWithRetry as sharedInjectWithRetry, INJECTION_CONSTANTS, CLI_QUIRKS, } from './shared.js';
 const execAsync = promisify(exec);
-const escapeRegex = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 // Constants for cursor stability detection in waitForClearInput
 /** Number of consecutive polls with stable cursor before assuming input is clear */
 const STABLE_CURSOR_THRESHOLD = 3;
@@ -44,15 +44,13 @@ const RELAY_LOG_TRUNCATE_LENGTH = 50;
 export function getDefaultPrefix(_cliType) {
     return getDefaultRelayPrefix();
 }
-export class TmuxWrapper {
+export class TmuxWrapper extends BaseWrapper {
     config;
     sessionName;
-    client;
     parser;
     inbox;
     storage;
     storageReady; // Resolves true if storage initialized, false if failed
-    running = false;
     pollTimer;
     attachProcess;
     lastCapturedOutput = '';
@@ -60,25 +58,14 @@ export class TmuxWrapper {
     lastActivityTime = Date.now();
     activityState = 'disconnected';
     recentlySentMessages = new Map();
-    sentMessageHashes = new Set(); // Permanent dedup
-    messageQueue = [];
-    isInjecting = false;
     // Track processed output to avoid re-parsing
     processedOutputLength = 0;
     lastLoggedLength = 0; // Track length for incremental log streaming
     lastDebugLog = 0;
-    cliType;
-    relayPrefix;
     lastSummaryHash = ''; // Dedup summary saves
-    lastSummaryRawContent = ''; // Dedup invalid JSON error logging
-    sessionEndProcessed = false; // Track if we've already processed session end
-    sessionEndData; // Store SESSION_END data for handoff
     pendingRelayCommands = [];
     queuedMessageHashes = new Set(); // For offline queue dedup
     MAX_PENDING_RELAY_COMMANDS = 50;
-    processedSpawnCommands = new Set(); // Dedup spawn commands
-    processedReleaseCommands = new Set(); // Dedup release commands
-    pendingFencedSpawn = null; // Track multi-line spawn task
     receivedMessageIdSet = new Set();
     receivedMessageIdOrder = [];
     MAX_RECEIVED_MESSAGES = 2000;
@@ -87,12 +74,12 @@ export class TmuxWrapper {
     lastDetectedPhase; // Track last auto-detected PDERO phase
     seenToolCalls = new Set(); // Dedup tool call trajectory events
     seenErrors = new Set(); // Dedup error trajectory events
-    continuity; // Session continuity management
-    processedContinuityCommands = new Set(); // Dedup continuity commands
-    agentId; // Unique agent ID for resume functionality
-    injectionMetrics = createInjectionMetrics(); // Track injection reliability
+    authRevoked = false; // Track if auth has been revoked
+    lastAuthCheck = 0; // Timestamp of last auth check (throttle)
+    AUTH_CHECK_INTERVAL = 5000; // Check auth status every 5 seconds max
     constructor(config) {
-        this.config = {
+        // Merge defaults with config
+        const mergedConfig = {
             cols: process.stdout.columns || 120,
             rows: process.stdout.rows || 40,
             pollInterval: 200, // Slightly slower polling since we're not displaying
@@ -107,31 +94,9 @@ export class TmuxWrapper {
             streamLogs: true, // Stream output to daemon for dashboard
             ...config,
         };
-        // Detect CLI type from command for special handling
-        const cmdLower = config.command.toLowerCase();
-        if (config.cliType) {
-            this.cliType = config.cliType;
-        }
-        else if (cmdLower.includes('gemini')) {
-            this.cliType = 'gemini';
-        }
-        else if (cmdLower.includes('codex')) {
-            this.cliType = 'codex';
-        }
-        else if (cmdLower.includes('claude')) {
-            this.cliType = 'claude';
-        }
-        else if (cmdLower.includes('droid')) {
-            this.cliType = 'droid';
-        }
-        else if (cmdLower.includes('opencode')) {
-            this.cliType = 'opencode';
-        }
-        else {
-            this.cliType = 'other';
-        }
-        // Determine relay prefix: explicit config > auto-detect from CLI type
-        this.relayPrefix = config.relayPrefix ?? getDefaultPrefix(this.cliType);
+        // Call parent constructor (initializes client, cliType, relayPrefix, continuity)
+        super(mergedConfig);
+        this.config = mergedConfig;
         // Session name (one agent per name - starting a duplicate kills the existing one)
         this.sessionName = `relay-${config.name}`;
         // Resolve tmux path early so we fail fast if tmux isn't available
@@ -145,16 +110,6 @@ export class TmuxWrapper {
                 this.logStderr(`Auto-detected role: ${detectedTask.substring(0, 60)}...`, true);
             }
         }
-        this.client = new RelayClient({
-            agentName: config.name,
-            socketPath: config.socketPath,
-            cli: this.cliType,
-            program: this.config.program,
-            model: this.config.model,
-            task: detectedTask,
-            workingDirectory: this.config.cwd ?? process.cwd(),
-            quiet: true, // Keep stdout clean; we log to stderr via wrapper
-        });
         this.parser = new OutputParser({ prefix: this.relayPrefix });
         // Initialize inbox if using file-based messaging
         if (config.useInbox) {
@@ -174,12 +129,6 @@ export class TmuxWrapper {
         });
         // Initialize trajectory tracking via trail CLI
         this.trajectory = getTrajectoryIntegration(projectPaths.projectId, config.name);
-        // Initialize continuity manager for session persistence
-        this.continuity = getContinuityManager({ defaultCli: this.cliType });
-        // Handle incoming messages from relay
-        this.client.onMessage = (from, payload, messageId, meta, originalTo) => {
-            this.handleIncomingMessage(from, payload, messageId, meta, originalTo);
-        };
         this.client.onStateChange = (state) => {
             // Only log to stderr, never stdout (user is in tmux)
             if (state === 'READY') {
@@ -197,6 +146,21 @@ export class TmuxWrapper {
             }
         };
     }
+    // =========================================================================
+    // Abstract method implementations
+    // =========================================================================
+    /**
+     * Inject content into the tmux session via paste
+     */
+    async performInjection(content) {
+        await this.pasteLiteral(content);
+    }
+    /**
+     * Get cleaned output for parsing (strip ANSI codes)
+     */
+    getCleanOutput() {
+        return stripAnsi(this.lastCapturedOutput);
+    }
     /**
      * Log to stderr (safe - doesn't interfere with tmux display)
      */
@@ -417,7 +381,7 @@ export class TmuxWrapper {
         }
     }
     /**
-     * Initialize agent ID for continuity/resume functionality
+     * Initialize agent ID for continuity/resume functionality (uses logStderr for tmux)
      */
     async initializeAgentId() {
         if (!this.continuity)
@@ -445,12 +409,6 @@ export class TmuxWrapper {
             this.logStderr(`Failed to initialize agent ID: ${err.message}`, true);
         }
     }
-    /**
-     * Get the current agent ID
-     */
-    getAgentId() {
-        return this.agentId;
-    }
     /**
      * Inject usage instructions for the agent including persistence protocol
      */
@@ -464,6 +422,7 @@ export class TmuxWrapper {
             `[Agent Relay] You are "${this.config.name}" - connected for real-time messaging.`,
             `SEND: ${escapedPrefix}AgentName message`,
             `MULTI-LINE: ${escapedPrefix}AgentName <<<(newline)content(newline)>>> - ALWAYS end with >>> on its own line!`,
+            `IMPORTANT: Do NOT include self-identification or preamble in messages. Start with your actual response content.`,
             `PERSIST: Output [[SUMMARY]]{"currentTask":"...","context":"..."}[[/SUMMARY]] after major work.`,
             `END: Output [[SESSION_END]]{"summary":"..."}[[/SESSION_END]] when session complete.`,
         ].join(' | ');
@@ -654,6 +613,8 @@ export class TmuxWrapper {
             // Check for ->relay:spawn and ->relay:release commands (any agent can spawn)
             // Use joinedContent to handle multi-line output from TUIs like Claude Code
             this.parseSpawnReleaseCommands(joinedContent);
+            // Check for auth revocation (limited sessions scenario)
+            this.checkAuthRevocation(cleanContent);
             this.updateActivityState();
             // Also check for injection opportunity
             this.checkForInjectionOpportunity();
@@ -664,58 +625,6 @@ export class TmuxWrapper {
             }
         }
     }
-    /**
-     * Join continuation lines after ->relay commands.
-     * Claude Code and other TUIs insert real newlines in output, causing
-     * ->relay messages to span multiple lines. This joins indented
-     * continuation lines back to the ->relay line.
-     */
-    joinContinuationLines(content) {
-        const lines = content.split('\n');
-        const result = [];
-        // Pattern to detect relay command line (with optional bullet prefix)
-        const escapedPrefix = escapeRegex(this.relayPrefix);
-        const relayPattern = new RegExp(`^(?:\\s*(?:[>$%#→➜›»●•◦‣⁃\\-*⏺◆◇○□■]\\s*)*)?${escapedPrefix}`);
-        // Pattern to detect a continuation line (starts with spaces, no bullet/command)
-        const continuationPattern = /^[ \t]+[^>$%#→➜›»●•◦‣⁃\-*⏺◆◇○□■\s]/;
-        // Pattern to detect a new block/bullet (stops continuation)
-        const newBlockPattern = /^(?:\s*)?[>$%#→➜›»●•◦‣⁃\-*⏺◆◇○□■]/;
-        let i = 0;
-        while (i < lines.length) {
-            const line = lines[i];
-            // Check if this is a ->relay line
-            if (relayPattern.test(line)) {
-                let joined = line;
-                let j = i + 1;
-                // Look ahead for continuation lines
-                while (j < lines.length) {
-                    const nextLine = lines[j];
-                    // Empty line stops continuation
-                    if (nextLine.trim() === '')
-                        break;
-                    // New bullet/block stops continuation
-                    if (newBlockPattern.test(nextLine))
-                        break;
-                    // Check if it looks like a continuation (indented text)
-                    if (continuationPattern.test(nextLine)) {
-                        // Join with newline to preserve multi-line message content
-                        joined += '\n' + nextLine.trim();
-                        j++;
-                    }
-                    else {
-                        break;
-                    }
-                }
-                result.push(joined);
-                i = j; // Skip the lines we joined
-            }
-            else {
-                result.push(line);
-                i++;
-            }
-        }
-        return result.join('\n');
-    }
     /**
      * Record recent activity and transition back to active if needed.
      */
@@ -746,7 +655,61 @@ export class TmuxWrapper {
         }
     }
     /**
-     * Send relay command to daemon
+     * Check if the CLI output indicates auth has been revoked.
+     * This can happen when the user authenticates elsewhere (limited sessions).
+     */
+    checkAuthRevocation(output) {
+        // Don't check if already revoked or if we checked recently
+        if (this.authRevoked)
+            return;
+        const now = Date.now();
+        if (now - this.lastAuthCheck < this.AUTH_CHECK_INTERVAL)
+            return;
+        this.lastAuthCheck = now;
+        // Get the CLI type/provider from config
+        const provider = this.config.program || this.cliType || 'claude';
+        // Check for auth revocation patterns in recent output
+        const result = detectProviderAuthRevocation(output, provider);
+        if (result.detected && result.confidence !== 'low') {
+            this.authRevoked = true;
+            this.logStderr(`[AUTH] Auth revocation detected (${result.confidence} confidence): ${result.message}`);
+            // Send auth status message to daemon
+            if (this.client.state === 'READY') {
+                const authPayload = JSON.stringify({
+                    type: 'auth_revoked',
+                    agent: this.config.name,
+                    provider,
+                    message: result.message,
+                    confidence: result.confidence,
+                    timestamp: new Date().toISOString(),
+                });
+                this.client.sendMessage('#system', authPayload, 'message');
+            }
+            // Emit event for listeners
+            this.emit('auth_revoked', {
+                agent: this.config.name,
+                provider,
+                message: result.message,
+                confidence: result.confidence,
+            });
+        }
+    }
+    /**
+     * Reset auth revocation state (called after successful re-authentication)
+     */
+    resetAuthState() {
+        this.authRevoked = false;
+        this.lastAuthCheck = 0;
+        this.logStderr('[AUTH] Auth state reset');
+    }
+    /**
+     * Check if auth has been revoked
+     */
+    isAuthRevoked() {
+        return this.authRevoked;
+    }
+    /**
+     * Send relay command to daemon (overrides BaseWrapper for offline queue support)
      */
     sendRelayCommand(cmd) {
         const msgHash = `${cmd.to}:${cmd.body}`;
@@ -865,7 +828,7 @@ export class TmuxWrapper {
         });
     }
     /**
-     * Save a parsed summary to the continuity ledger.
+     * Save a parsed summary to the continuity ledger (uses logStderr for tmux).
      * Maps summary fields to ledger fields for session recovery.
      */
     async saveSummaryToLedger(summary) {
@@ -1402,10 +1365,9 @@ export class TmuxWrapper {
      * Call this when starting a new session with the same wrapper instance.
      */
     resetSessionState() {
-        this.sessionEndProcessed = false;
+        super.resetSessionState();
+        // TmuxWrapper-specific state
         this.lastSummaryHash = '';
-        this.lastSummaryRawContent = '';
-        this.sessionEndData = undefined;
     }
     /**
      * Get the prompt pattern for the current CLI type.
@@ -1581,11 +1543,5 @@ export class TmuxWrapper {
         // Disconnect relay
         this.client.destroy();
     }
-    get isRunning() {
-        return this.running;
-    }
-    get name() {
-        return this.config.name;
-    }
 }
 //# sourceMappingURL=tmux-wrapper.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay",
-  "version": "1.2.3",
+  "version": "1.3.0",
   "description": "Real-time agent-to-agent communication system",
   "type": "module",
   "main": "dist/index.js",
@@ -91,6 +91,7 @@
     "node-pty": "1.0.0",
     "pg": "^8.16.3",
     "redis": "^5.10.0",
+    "ssh2": "^1.17.0",
     "stripe": "^20.1.0",
     "uuid": "^10.0.0",
     "ws": "^8.18.3"
@@ -103,6 +104,7 @@
     "@types/helmet": "^0.0.48",
     "@types/node": "^22.19.3",
     "@types/pg": "^8.16.0",
+    "@types/ssh2": "^1.15.5",
     "@types/uuid": "^10.0.0",
     "@types/ws": "^8.18.1",
     "@typescript-eslint/eslint-plugin": "^8.18.2",
@@ -113,7 +115,7 @@
     "esbuild": "^0.24.0",
     "eslint": "^8.57.1",
     "jsdom": "^25.0.1",
-    "typescript": "^5.7.2",
+    "typescript": "^5.9.3",
     "vitest": "^2.1.8"
   },
   "engines": {