happy-mcp-server 0.1.0 → 0.1.1

package/dist/auth/credentials.js

@@ -12,12 +12,12 @@ export function readCredentials(path) {
         const raw = readFileSync(path, 'utf-8');
         const parsed = JSON.parse(raw);
         if (!parsed.token || !parsed.secret) {
-            logger.warn('Credentials file missing token or secret');
+            logger.debug('Credentials file missing token or secret');
             return null;
         }
         const secret = decodeBase64(parsed.secret);
         if (secret.length !== 32) {
-            logger.warn('Credentials secret is not 32 bytes');
+            logger.debug('Credentials secret is not 32 bytes');
             return null;
         }
         const contentKeyPair = deriveContentKeyPair(secret);
@@ -27,7 +27,7 @@ export function readCredentials(path) {
         if (err.code === 'ENOENT') {
             return null; // File doesn't exist, first run
         }
-        logger.warn('Failed to read credentials:', err.message);
+        logger.debug('Failed to read credentials:', err.message);
         return null;
     }
 }

package/dist/index.js

@@ -27,9 +27,14 @@ function sessionMatchesFilters(metadata, config) {
 async function initializeAuthenticatedState(config, credentials) {
     const sessionManager = new SessionManager(config.sessionCacheTtl);
     const api = new ApiClient(credentials, config);
-    // Fetch initial sessions
-    try {
-        const rawSessions = await api.listActiveSessions();
+    // Fetch initial data in parallel
+    const [sessionsResult, machinesResult] = await Promise.allSettled([
+        api.listActiveSessions(),
+        api.listMachines(),
+    ]);
+    // Process sessions
+    if (sessionsResult.status === 'fulfilled') {
+        const rawSessions = sessionsResult.value;
         logger.info(`Fetched ${rawSessions.length} active sessions`);
         for (const raw of rawSessions) {
             try {
@@ -47,17 +52,17 @@ async function initializeAuthenticatedState(config, credentials) {
                 sessionManager.loadSession(raw.id, encryption, metadata, raw.metadataVersion, agentState, raw.agentStateVersion, raw.active, raw.createdAt, raw.updatedAt);
             }
             catch (err) {
-                logger.warn(`Failed to load session ${raw.id}:`, err.message);
+                logger.debug(`Failed to load session ${raw.id}:`, err.message);
             }
         }
         logger.info(`Loaded ${sessionManager.getAll().length} sessions into cache`);
     }
-    catch (err) {
-        logger.error('Failed to fetch initial sessions:', err.message);
+    else {
+        logger.debug('Failed to fetch initial sessions:', sessionsResult.reason?.message ?? sessionsResult.reason);
     }
-    // Fetch machines
-    try {
-        const rawMachines = await api.listMachines();
+    // Process machines
+    if (machinesResult.status === 'fulfilled') {
+        const rawMachines = machinesResult.value;
         logger.info(`Fetched ${rawMachines.length} machines`);
         for (const raw of rawMachines) {
             try {
@@ -65,32 +70,29 @@ async function initializeAuthenticatedState(config, credentials) {
                 const metadata = raw.metadata
                     ? decryptFromBase64(encryption, raw.metadata)
                     : null;
+                const daemonState = raw.daemonState
+                    ? decryptFromBase64(encryption, raw.daemonState)
+                    : null;
                 sessionManager.loadMachine({
                     machineId: raw.id, metadata,
                     metadataVersion: raw.metadataVersion,
-                    daemonState: null,
+                    daemonState,
                     daemonStateVersion: raw.daemonStateVersion ?? 0,
                     encryption, active: raw.active, activeAt: raw.activeAt,
                 });
             }
             catch (err) {
-                logger.warn(`Failed to load machine ${raw.id}:`, err.message);
+                logger.debug(`Failed to load machine ${raw.id}:`, err.message);
             }
         }
         logger.info(`Loaded ${sessionManager.getAllMachines().length} machines into cache`);
     }
-    catch (err) {
-        logger.error('Failed to fetch machines:', err.message);
+    else {
+        logger.debug('Failed to fetch machines:', machinesResult.reason?.message ?? machinesResult.reason);
     }
-    // Connect relay
+    // Connect relay (non-blocking, fire-and-forget)
     const relay = new RelayClient(credentials, sessionManager, config);
-    try {
-        await relay.connect();
-        logger.info('Relay connected');
-    }
-    catch (err) {
-        logger.error('Failed to connect relay:', err.message);
-    }
+    relay.connect();
     // Reconnection catch-up
     relay.on('connected', async () => {
         try {
@@ -110,17 +112,39 @@ async function initializeAuthenticatedState(config, credentials) {
                     sessionManager.loadSession(raw.id, encryption, metadata, raw.metadataVersion, agentState, raw.agentStateVersion, raw.active, raw.createdAt, raw.updatedAt);
                 }
                 catch (err) {
-                    logger.warn(`Catch-up: failed to load session ${raw.id}:`, err.message);
+                    logger.debug(`Catch-up: failed to load session ${raw.id}:`, err.message);
                 }
             }
         }
         catch (err) {
-            logger.warn('Reconnect catch-up failed:', err.message);
+            logger.debug('Reconnect catch-up failed:', err.message);
         }
     });
     relay.on('disconnected', () => {
         relay.updateToken(credentials.token);
     });
+    // Handle new session events
+    relay.on('new_session', (body) => {
+        try {
+            const sessionBody = body;
+            const encryption = resolveSessionEncryptionCached(sessionBody.dataEncryptionKey, credentials);
+            const metadata = sessionBody.metadata
+                ? decryptFromBase64(encryption, sessionBody.metadata)
+                : null;
+            const agentState = sessionBody.agentState
+                ? decryptFromBase64(encryption, sessionBody.agentState)
+                : null;
+            if (!sessionMatchesFilters(metadata, config)) {
+                logger.debug(`Skipping new session ${sessionBody.id} -- doesn't match filters`);
+                return;
+            }
+            sessionManager.loadSession(sessionBody.id, encryption, metadata, sessionBody.metadataVersion, agentState, sessionBody.agentStateVersion, sessionBody.active, sessionBody.createdAt, sessionBody.updatedAt);
+            logger.info(`New session ${sessionBody.id} added to cache`);
+        }
+        catch (err) {
+            logger.debug('Failed to handle new_session event:', err.message);
+        }
+    });
     return { api, relay, sessionManager };
 }
 // ---------------------------------------------------------------------------
@@ -194,7 +218,7 @@ async function runServer() {
             validateFilePermissions(config.credentialsPath);
         }
         catch (err) {
-            logger.error('Credential file has unsafe permissions:', err.message);
+            logger.debug('Credential file has unsafe permissions:', err.message);
             return false;
         }
         authState.activatingPromise = (async () => {
@@ -208,7 +232,7 @@ async function runServer() {
                 return true;
             }
             catch (err) {
-                logger.error('Lazy auth failed:', err.message);
+                logger.debug('Lazy auth failed:', err.message);
                 return false;
             }
             finally {
@@ -219,29 +243,27 @@ async function runServer() {
     }
     const { server, activate } = createUnauthenticatedServer(config, tryActivate);
     activateFn = activate;
-    // Startup optimization: check for existing credentials
+    // Connect stdio transport FIRST (Issue 1: prevent blocking)
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    logger.info('MCP server stdio transport connected');
+    // Then initialize auth state via tryActivate() only (consolidate startup path)
     const initialCreds = readCredentials(config.credentialsPath);
     if (initialCreds) {
         try {
             validateFilePermissions(config.credentialsPath);
-            logger.info('Credentials found at startup');
-            const state = await initializeAuthenticatedState(config, initialCreds);
-            authState.relay = state.relay;
-            authState.sessionManager = state.sessionManager;
-            activate(state.api, state.relay, state.sessionManager);
-            authState.authenticated = true;
+            logger.info('Credentials found at startup, initializing...');
+            await tryActivate();
         }
         catch (err) {
-            logger.error('Failed to initialize with existing credentials:', err.message);
+            logger.debug('Failed to initialize with existing credentials:', err.message);
         }
     }
     else {
-        logger.warn('No credentials found. Tools will attempt auth on each call.');
-        logger.warn('Run `happy-mcp auth` to authenticate.');
+        logger.debug('No credentials found. Tools will attempt auth on each call.');
+        logger.debug('Run `happy-mcp auth` to authenticate.');
     }
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    logger.info(`MCP server started on stdio (${authState.authenticated ? 'authenticated' : 'unauthenticated'} mode)`);
+    logger.info(`MCP server started (${authState.authenticated ? 'authenticated' : 'unauthenticated'} mode)`);
     const shutdown = async () => {
         logger.info('Shutting down...');
         authState.relay?.disconnect();

package/dist/relay/client.d.ts

@@ -2,21 +2,24 @@ import { EventEmitter } from 'events';
 import type { Credentials } from '../auth/crypto.js';
 import type { SessionManager } from '../session/manager.js';
 import type { Config } from '../config.js';
+export type RelayState = 'disconnected' | 'connecting' | 'connected';
 export declare class RelayClient extends EventEmitter {
     private socket;
     private credentials;
     private sessionManager;
     private config;
-    private _connected;
+    private _state;
+    private connectErrorCount;
     constructor(credentials: Credentials, sessionManager: SessionManager, config: Config);
+    get state(): RelayState;
     get connected(): boolean;
-    connect(): Promise<void>;
-    private waitForConnect;
+    connect(): void;
     private handleUpdate;
     private handleNewMessage;
     private handleUpdateSession;
     private handleUpdateMachine;
     private handleDeleteSession;
+    private handleEphemeral;
     /**
      * Encrypted RPC call to a session.
      * Event: 'rpc-call' (NOT 'rpc-request' -- asymmetric names)

package/dist/relay/client.js

@@ -8,17 +8,25 @@ export class RelayClient extends EventEmitter {
     credentials;
     sessionManager;
     config;
-    _connected = false;
+    _state = 'disconnected';
+    connectErrorCount = 0;
     constructor(credentials, sessionManager, config) {
         super();
         this.credentials = credentials;
         this.sessionManager = sessionManager;
         this.config = config;
     }
+    get state() {
+        return this._state;
+    }
     get connected() {
-        return this._connected;
+        return this._state === 'connected';
     }
-    async connect() {
+    connect() {
+        // Idempotent guard
+        if (this.socket)
+            return;
+        this._state = 'connecting';
         this.socket = io(this.config.serverUrl, {
             path: '/v1/updates',
             transports: ['websocket'],
@@ -33,46 +41,49 @@ export class RelayClient extends EventEmitter {
             autoConnect: false,
         });
         this.socket.on('connect', () => {
-            this._connected = true;
+            this._state = 'connected';
+            this.connectErrorCount = 0;
             logger.info('Relay connected');
             this.emit('connected');
         });
         this.socket.on('disconnect', (reason) => {
-            this._connected = false;
-            logger.warn('Relay disconnected:', reason);
+            const wasConnected = this._state === 'connected';
+            this._state = 'connecting'; // socket.io auto-reconnects
+            if (wasConnected) {
+                logger.debug('Relay disconnected:', reason);
+            }
+            else {
+                logger.debug('Relay disconnected during connection attempt:', reason);
+            }
             // Session cache is PRESERVED -- do NOT clear sessionManager
             this.emit('disconnected', reason);
         });
         this.socket.on('connect_error', (err) => {
-            logger.error('Relay connection error:', err.message);
+            this.connectErrorCount++;
+            if (this.connectErrorCount === 1) {
+                logger.debug('Relay connection error:', err.message);
+            }
+            else {
+                logger.debug('Relay connection error (attempt', this.connectErrorCount, '):', err.message);
+            }
         });
         this.socket.on('update', (data) => {
             try {
                 this.handleUpdate(data);
             }
             catch (err) {
-                logger.error('Error handling update:', err.message);
+                logger.debug('Error handling update:', err.message);
             }
         });
-        this.socket.connect();
-        await this.waitForConnect(10_000);
-    }
-    async waitForConnect(timeoutMs) {
-        if (this._connected)
-            return;
-        return new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                reject(new RelayError(`Relay connection timed out after ${timeoutMs}ms`));
-            }, timeoutMs);
-            this.socket.once('connect', () => {
-                clearTimeout(timeout);
-                resolve();
-            });
-            this.socket.once('connect_error', (err) => {
-                clearTimeout(timeout);
-                reject(new RelayError(`Relay connection failed: ${err.message}`));
-            });
+        this.socket.on('ephemeral', (data) => {
+            try {
+                this.handleEphemeral(data);
+            }
+            catch (err) {
+                logger.debug('Error handling ephemeral:', err.message);
+            }
         });
+        this.socket.connect();
     }
     handleUpdate(data) {
         const container = data;
@@ -111,7 +122,7 @@ export class RelayClient extends EventEmitter {
             return;
         const decrypted = decrypt(session.encryption.key, session.encryption.variant, decodeBase64(message.content.c));
         if (decrypted === null) {
-            logger.warn(`Failed to decrypt message ${message.id} for session ${sessionId}`);
+            logger.debug(`Failed to decrypt message ${message.id} for session ${sessionId}`);
             return;
         }
         this.sessionManager.applyMessage(sessionId, message.id ?? '', message.seq ?? 0, decrypted, message.createdAt ?? Date.now());
@@ -168,12 +179,33 @@ export class RelayClient extends EventEmitter {
         this.emit('machine_update', machineId);
     }
     handleDeleteSession(body) {
-        const sessionId = body.id;
+        const sessionId = body.sid;
         if (sessionId) {
             this.sessionManager.remove(sessionId);
             this.emit('session_deleted', sessionId);
         }
     }
+    handleEphemeral(data) {
+        const event = data;
+        if (!event?.type)
+            return;
+        switch (event.type) {
+            case 'machine-activity':
+                if (event.id && event.active !== undefined) {
+                    const machine = this.sessionManager.getMachine(event.id);
+                    if (machine) {
+                        machine.active = event.active;
+                        if (event.activeAt !== undefined) {
+                            machine.activeAt = event.activeAt;
+                        }
+                        this.emit('machine_update', event.id);
+                    }
+                }
+                break;
+            default:
+                logger.debug('Unhandled ephemeral type:', event.type);
+        }
+    }
     /**
      * Encrypted RPC call to a session.
      * Event: 'rpc-call' (NOT 'rpc-request' -- asymmetric names)
@@ -181,7 +213,7 @@ export class RelayClient extends EventEmitter {
      * Response is encrypted with session key.
      */
     async sessionRpc(sessionId, method, params) {
-        if (!this._connected || !this.socket) {
+        if (!this.connected || !this.socket) {
             throw new RelayError('Relay not connected');
         }
         const session = this.sessionManager.get(sessionId);
@@ -206,7 +238,7 @@ export class RelayClient extends EventEmitter {
      * Used for start_session (spawn-happy-session).
      */
     async machineRpc(machineId, method, params) {
-        if (!this._connected || !this.socket) {
+        if (!this.connected || !this.socket) {
             throw new RelayError('Relay not connected');
         }
         const machine = this.sessionManager.getMachine(machineId);
@@ -237,6 +269,7 @@ export class RelayClient extends EventEmitter {
             this.socket.disconnect();
             this.socket = null;
         }
-        this._connected = false;
+        this._state = 'disconnected';
+        this.connectErrorCount = 0;
     }
 }

package/dist/session/types.d.ts

@@ -91,6 +91,14 @@ export interface RawMachine {
     createdAt: number;
     updatedAt: number;
 }
+export interface MachineMetadata {
+    host: string;
+    platform: string;
+    happyCliVersion: string;
+    homeDir: string;
+    happyHomeDir: string;
+    happyLibDir: string;
+}
 export type SessionStatus = 'active' | 'idle' | 'waiting_permission';
 export interface PermissionRequest {
     requestId: string;

package/dist/tools/answer_question.js

@@ -10,7 +10,13 @@ export function registerAnswerQuestion(server, api, relay, sessionManager) {
         try {
             // Check relay is connected (REQUIRED for answer_question)
             if (!relay.connected) {
-                return { isError: true, content: [{ type: 'text', text: JSON.stringify({ error: 'RelayDisconnected', message: 'Relay must be connected to answer questions' }) }] };
+                const msg = relay.state === 'connecting'
+                    ? 'Relay is still connecting. Please try again in a few seconds.'
+                    : 'Relay must be connected to answer questions.';
+                return { isError: true, content: [{ type: 'text', text: JSON.stringify({
+                                error: relay.state === 'connecting' ? 'RelayConnecting' : 'RelayDisconnected',
+                                message: msg,
+                            }) }] };
             }
             const session = sessionManager.get(sessionId);
             if (!session) {

package/dist/tools/approve_permission.js

@@ -12,7 +12,13 @@ export function registerApprovePermission(server, relay, sessionManager) {
     }, async ({ sessionId, requestId, mode, allowTools, decision }) => {
         try {
             if (!relay.connected) {
-                return { isError: true, content: [{ type: 'text', text: JSON.stringify({ error: 'RelayDisconnected', message: 'Relay is not connected' }) }] };
+                const msg = relay.state === 'connecting'
+                    ? 'Relay is still connecting. Please try again in a few seconds.'
+                    : 'Relay is disconnected.';
+                return { isError: true, content: [{ type: 'text', text: JSON.stringify({
+                                error: relay.state === 'connecting' ? 'RelayConnecting' : 'RelayDisconnected',
+                                message: msg,
+                            }) }] };
             }
             const session = sessionManager.get(sessionId);
             if (!session) {

package/dist/tools/deny_permission.js

@@ -9,7 +9,13 @@ export function registerDenyPermission(server, relay, sessionManager) {
     }, async ({ sessionId, requestId, reason, decision }) => {
         try {
             if (!relay.connected) {
-                return { isError: true, content: [{ type: 'text', text: JSON.stringify({ error: 'RelayDisconnected', message: 'Relay is not connected' }) }] };
+                const msg = relay.state === 'connecting'
+                    ? 'Relay is still connecting. Please try again in a few seconds.'
+                    : 'Relay is disconnected.';
+                return { isError: true, content: [{ type: 'text', text: JSON.stringify({
+                                error: relay.state === 'connecting' ? 'RelayConnecting' : 'RelayDisconnected',
+                                message: msg,
+                            }) }] };
             }
             const session = sessionManager.get(sessionId);
             if (!session) {

package/dist/tools/list_computers.js

@@ -1,16 +1,16 @@
 export function registerListComputers(server, sessionManager, config) {
     return server.tool('list_computers', 'List available computers filtered by HAPPY_MCP_COMPUTERS. Shows hostname, online status, and active session count. Use before start_session to find available machines.', {}, async () => {
         try {
-            const machines = sessionManager.getAllMachines()
-                .filter(m => m.active)
+            const allMachines = sessionManager.getAllMachines();
+            const machines = allMachines
                 .filter(m => {
                 const meta = m.metadata;
-                const hostname = (meta?.host ?? meta?.displayName ?? '').toLowerCase();
+                const hostname = (meta?.host ?? '').toLowerCase();
                 return config.computers.some(c => c === '*' || c.toLowerCase() === hostname);
             });
             const result = machines.map(m => {
                 const meta = m.metadata;
-                const hostname = (meta?.host ?? meta?.displayName ?? 'unknown');
+                const hostname = meta?.host ?? 'unknown';
                 // Count active sessions for this machine matching project paths
                 const activeSessions = sessionManager.getAll().filter(s => {
                     if (!s.active)
@@ -23,6 +23,7 @@ export function registerListComputers(server, sessionManager, config) {
                 return {
                     machineId: m.machineId,
                     hostname,
+                    online: m.active,
                     activeAt: new Date(m.activeAt).toISOString(),
                     activeSessions,
                 };

package/dist/tools/start_session.js

@@ -10,7 +10,13 @@ export function registerStartSession(server, _api, relay, sessionManager) {
     }, async ({ computer, projectPath, initialMessage, permissionMode, agent }) => {
         try {
             if (!relay.connected) {
-                return { isError: true, content: [{ type: 'text', text: JSON.stringify({ error: 'RelayDisconnected', message: 'Relay is not connected' }) }] };
+                const msg = relay.state === 'connecting'
+                    ? 'Relay is still connecting. Please try again in a few seconds.'
+                    : 'Relay is disconnected.';
+                return { isError: true, content: [{ type: 'text', text: JSON.stringify({
+                                error: relay.state === 'connecting' ? 'RelayConnecting' : 'RelayDisconnected',
+                                message: msg,
+                            }) }] };
             }
             const machine = sessionManager.getMachine(computer);
             if (!machine) {

package/dist/tools/watch_session.js

@@ -1,10 +1,11 @@
 import { z } from 'zod';
 const DEFAULT_TIMEOUT_SECONDS = 300; // 5 minutes
+const MAX_WAIT_MS = 30_000; // 30s, safely under 60s MCP timeout
 export function registerWatchSession(server, relay, sessionManager) {
-    return server.tool('watch_session', 'Watch one or more sessions until any becomes idle or has pending permissions. Returns final state of the triggering session. Use after send_message or approve_permission to wait for the agent to finish.', {
+    return server.tool('watch_session', 'Watch one or more sessions for state changes. Returns immediately if any session is idle or has pending permissions. Otherwise waits up to 30 seconds for a state change. If sessions are still active, returns current status -- call again to continue watching.', {
         sessionIds: z.array(z.string()).describe('One or more session IDs to watch'),
         timeoutSeconds: z.number().optional().default(DEFAULT_TIMEOUT_SECONDS).describe('Max wait time in seconds (default 300)'),
-    }, async ({ sessionIds, timeoutSeconds }) => {
+    }, async ({ sessionIds, timeoutSeconds }, extra) => {
         try {
             // Validate all session IDs exist
             const missing = sessionIds.filter(id => !sessionManager.get(id));
@@ -12,7 +13,13 @@ export function registerWatchSession(server, relay, sessionManager) {
                 return { isError: true, content: [{ type: 'text', text: JSON.stringify({ error: 'SessionNotFound', message: `Sessions not found: ${missing.join(', ')}` }) }] };
             }
             if (!relay.connected) {
-                return { isError: true, content: [{ type: 'text', text: JSON.stringify({ error: 'RelayDisconnected', message: 'Relay is not connected' }) }] };
+                const msg = relay.state === 'connecting'
+                    ? 'Relay is still connecting. Please try again in a few seconds.'
+                    : 'Relay is disconnected.';
+                return { isError: true, content: [{ type: 'text', text: JSON.stringify({
+                                error: relay.state === 'connecting' ? 'RelayConnecting' : 'RelayDisconnected',
+                                message: msg,
+                            }) }] };
             }
             const watchedSet = new Set(sessionIds);
             // Check if any session is already in a terminal state
@@ -38,12 +45,30 @@ export function registerWatchSession(server, relay, sessionManager) {
             }
             // Wait for state change on any watched session
             const startTime = Date.now();
-            const timeoutMs = timeoutSeconds * 1000;
+            const effectiveTimeout = Math.min(timeoutSeconds * 1000, MAX_WAIT_MS);
             const result = await new Promise((resolve) => {
                 const timeout = setTimeout(() => {
                     cleanup();
-                    resolve({ triggeredBy: sessionIds[0], status: 'timeout', timedOut: true });
-                }, timeoutMs);
+                    resolve({ triggeredBy: sessionIds[0], status: 'active', timedOut: false });
+                }, effectiveTimeout);
+                const progressToken = extra._meta?.progressToken;
+                const heartbeat = setInterval(async () => {
+                    if (progressToken) {
+                        try {
+                            await extra.sendNotification({
+                                method: 'notifications/progress',
+                                params: {
+                                    progressToken,
+                                    progress: Math.round((Date.now() - startTime) / 1000),
+                                    total: Math.round(effectiveTimeout / 1000),
+                                },
+                            });
+                        }
+                        catch {
+                            // Client may not support progress
+                        }
+                    }
+                }, 10_000);
                 const onSessionUpdate = (sid) => {
                     if (!watchedSet.has(sid))
                         return;
@@ -59,15 +84,44 @@ export function registerWatchSession(server, relay, sessionManager) {
                     cleanup();
                     resolve({ triggeredBy: sid, status: 'deleted', timedOut: false });
                 };
+                const onAbort = () => {
+                    cleanup();
+                    resolve({ triggeredBy: sessionIds[0], status: 'cancelled', timedOut: false });
+                };
                 const cleanup = () => {
                     clearTimeout(timeout);
+                    clearInterval(heartbeat);
                     relay.removeListener('session_update', onSessionUpdate);
                     relay.removeListener('session_deleted', onDeleted);
+                    extra.signal?.removeEventListener('abort', onAbort);
                 };
                 relay.on('session_update', onSessionUpdate);
                 relay.on('session_deleted', onDeleted);
+                extra.signal?.addEventListener('abort', onAbort);
             });
             const waitedSeconds = Math.round((Date.now() - startTime) / 1000);
+            // Handle "still active" case
+            if (result.status === 'active' || result.status === 'cancelled') {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                triggeredBy: null,
+                                status: result.status,
+                                waitedSeconds,
+                                timedOut: false,
+                                message: result.status === 'cancelled'
+                                    ? 'Watch cancelled by client.'
+                                    : 'Sessions are still active. Call watch_session again to continue watching.',
+                                sessions: sessionIds.map(sid => ({
+                                    sessionId: sid,
+                                    status: sessionManager.getSessionStatus(sid),
+                                })),
+                            }, null, 2),
+                        }],
+                };
+            }
+            // Handle triggered state change (idle, waiting_permission, deleted)
             const permissions = sessionManager.getPendingPermissions(result.triggeredBy);
             const messages = sessionManager.getMessages(result.triggeredBy, 5);
             return {

package/dist/types/wire.d.ts

@@ -36,11 +36,20 @@ export interface UpdateMachineBody {
 export interface NewSessionBody {
     t: 'new-session';
     id: string;
-    [key: string]: unknown;
+    seq: number;
+    metadata: string;
+    metadataVersion: number;
+    agentState: string | null;
+    agentStateVersion: number;
+    dataEncryptionKey: string | null;
+    active: boolean;
+    activeAt: number;
+    createdAt: number;
+    updatedAt: number;
 }
 export interface DeleteSessionBody {
     t: 'delete-session';
-    id: string;
+    sid: string;
 }
 export interface VersionedField {
     version: number;
@@ -70,6 +79,7 @@ export interface LegacyUserMessage {
 export interface LegacyMessageMeta {
     sentFrom: string;
     permissionMode?: PermissionMode;
+    displayText?: string;
     [key: string]: unknown;
 }
 export type PermissionMode = 'default' | 'acceptEdits' | 'bypassPermissions' | 'plan' | 'read-only' | 'safe-yolo' | 'yolo';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "happy-mcp-server",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "MCP server for observing and controlling Happy Coder sessions",
   "author": {
     "name": "Jared Spencer",