happy-mcp-server 0.1.0

package/dist/tools/get_session.js

@@ -0,0 +1,106 @@
+import { z } from 'zod';
+import { decodeBase64, decrypt } from '../auth/crypto.js';
+function renderMessage(msg) {
+    const envelope = msg.content;
+    if (!envelope)
+        return null;
+    // Handle SessionEnvelope format: { id, time, role, ev: { t, text, ... } }
+    const ev = envelope.ev;
+    if (ev && typeof ev.t === 'string') {
+        const role = envelope.role === 'user' ? 'user' : 'assistant';
+        let text = '';
+        switch (ev.t) {
+            case 'text':
+                text = (ev.text ?? '');
+                break;
+            case 'service':
+                text = `[service] ${(ev.text ?? '')}`;
+                break;
+            case 'tool-call-start': return { id: (envelope.id ?? msg.id), role: 'tool_use', content: `${ev.name}: ${(ev.description ?? ev.title ?? '')}`, timestamp: new Date((envelope.time ?? msg.createdAt)).toISOString() };
+            case 'tool-call-end': return { id: (envelope.id ?? msg.id), role: 'tool_result', content: `[tool completed: ${ev.call}]`, timestamp: new Date((envelope.time ?? msg.createdAt)).toISOString() };
+            case 'turn-start':
+                text = '[turn started]';
+                break;
+            case 'turn-end':
+                text = `[turn ended: ${ev.status}]`;
+                break;
+            case 'start':
+                text = ev.title ? `[session started: ${ev.title}]` : '[session started]';
+                break;
+            case 'stop':
+                text = '[session stopped]';
+                break;
+            default: text = JSON.stringify(ev);
+        }
+        return { id: (envelope.id ?? msg.id), role, content: text, timestamp: new Date((envelope.time ?? msg.createdAt)).toISOString() };
+    }
+    // Handle legacy flat format: { role, content }
+    const role = (envelope.role ?? 'unknown');
+    const rawContent = envelope.content;
+    let text = '';
+    if (typeof rawContent === 'string')
+        text = rawContent;
+    else if (rawContent && typeof rawContent === 'object' && 'text' in rawContent)
+        text = rawContent.text;
+    else
+        text = JSON.stringify(rawContent);
+    return { id: msg.id, role, content: text, timestamp: new Date(msg.createdAt).toISOString() };
+}
+export function registerGetSession(server, api, sessionManager) {
+    return server.tool('get_session', 'Get detailed information about a specific session including recent messages, metadata, and pending permissions.', {
+        sessionId: z.string().describe('The session ID to get details for'),
+        includeMessages: z.boolean().optional().default(true).describe('Whether to include messages'),
+        lastN: z.number().optional().default(20).describe('Number of recent messages to include'),
+        after: z.string().optional().describe('ISO 8601 timestamp — only return messages after this time'),
+    }, async ({ sessionId, includeMessages, lastN, after }) => {
+        try {
+            const session = sessionManager.get(sessionId);
+            if (!session) {
+                return { isError: true, content: [{ type: 'text', text: JSON.stringify({ error: 'SessionNotFound', message: `Session ${sessionId} not found` }) }] };
+            }
+            // Fetch messages from REST if we don't have enough cached
+            if (includeMessages && session.messages.length < lastN) {
+                try {
+                    const { messages } = await api.getSessionMessages(sessionId, 0, lastN);
+                    for (const msg of messages) {
+                        if (msg.content?.t === 'encrypted' && msg.content?.c) {
+                            const decrypted = decrypt(session.encryption.key, session.encryption.variant, decodeBase64(msg.content.c));
+                            if (decrypted !== null) {
+                                sessionManager.applyMessage(sessionId, msg.id, msg.seq, decrypted, msg.createdAt);
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // Use cached messages if REST fails
+                }
+            }
+            const meta = session.metadata;
+            const status = sessionManager.getSessionStatus(sessionId);
+            const permissions = sessionManager.getPendingPermissions(sessionId);
+            let renderedMessages;
+            if (includeMessages) {
+                let rawMessages = sessionManager.getMessages(sessionId, lastN);
+                if (after) {
+                    const afterTime = new Date(after).getTime();
+                    rawMessages = rawMessages.filter(m => m.createdAt > afterTime);
+                }
+                renderedMessages = rawMessages.map(renderMessage).filter((m) => m !== null);
+            }
+            const result = {
+                sessionId: session.id,
+                computer: (meta?.host ?? 'unknown'),
+                projectPath: (meta?.path ?? 'unknown'),
+                status,
+                startedAt: new Date(session.createdAt).toISOString(),
+                lastActivity: new Date(session.lastActivity).toISOString(),
+                pendingPermissions: permissions.length > 0 ? permissions : undefined,
+                messages: includeMessages ? renderedMessages : undefined,
+            };
+            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: JSON.stringify({ error: 'GetSessionFailed', message: err.message }) }] };
+        }
+    });
+}

package/dist/tools/list_computers.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { SessionManager } from '../session/manager.js';
+import type { Config } from '../config.js';
+export declare function registerListComputers(server: McpServer, sessionManager: SessionManager, config: Config): RegisteredTool;

package/dist/tools/list_computers.js

@@ -0,0 +1,36 @@
+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)
+                .filter(m => {
+                const meta = m.metadata;
+                const hostname = (meta?.host ?? meta?.displayName ?? '').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');
+                // Count active sessions for this machine matching project paths
+                const activeSessions = sessionManager.getAll().filter(s => {
+                    if (!s.active)
+                        return false;
+                    const sMeta = s.metadata;
+                    if ((sMeta?.host ?? '').toLowerCase() !== hostname.toLowerCase())
+                        return false;
+                    return config.projectPaths.some(p => p === '*' || (sMeta?.path ?? '').startsWith(p));
+                }).length;
+                return {
+                    machineId: m.machineId,
+                    hostname,
+                    activeAt: new Date(m.activeAt).toISOString(),
+                    activeSessions,
+                };
+            });
+            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: JSON.stringify({ error: 'ListComputersFailed', message: err.message }) }] };
+        }
+    });
+}

package/dist/tools/list_sessions.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { SessionManager } from '../session/manager.js';
+import type { Config } from '../config.js';
+export declare function registerListSessions(server: McpServer, sessionManager: SessionManager, config: Config): RegisteredTool;

package/dist/tools/list_sessions.js

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+export function registerListSessions(server, sessionManager, config) {
+    return server.tool('list_sessions', 'List all active Happy Coder sessions. Shows session ID, project path, hostname, status (active/idle/waiting_permission), and pending permissions.', {
+        filter: z.object({
+            status: z.enum(['active', 'idle', 'waiting_permission']).optional().describe('Filter by session status'),
+            computer: z.string().optional().describe('Filter by computer hostname'),
+            projectPath: z.string().optional().describe('Filter by project path prefix'),
+        }).optional(),
+    }, async ({ filter }) => {
+        try {
+            const computerFilter = filter?.computer ? [filter.computer] : config.computers;
+            const pathFilter = filter?.projectPath ? [filter.projectPath] : config.projectPaths;
+            const sessions = sessionManager.getAll().filter(s => {
+                if (!s.active)
+                    return false;
+                const meta = s.metadata;
+                const matchesComputer = computerFilter.some(c => c === '*' || c.toLowerCase() === (meta?.host ?? '').toLowerCase());
+                const matchesPath = pathFilter.some(p => p === '*' || (meta?.path ?? '').startsWith(p));
+                if (!matchesComputer || !matchesPath)
+                    return false;
+                if (filter?.status && sessionManager.getSessionStatus(s.id) !== filter.status)
+                    return false;
+                return true;
+            });
+            const result = sessions.map(s => {
+                const meta = s.metadata;
+                const status = sessionManager.getSessionStatus(s.id);
+                const permissions = sessionManager.getPendingPermissions(s.id);
+                return {
+                    sessionId: s.id,
+                    computer: (meta?.host ?? 'unknown'),
+                    projectPath: (meta?.path ?? 'unknown'),
+                    status,
+                    lastActivity: new Date(s.lastActivity).toISOString(),
+                    messageCount: s.messages.length,
+                    currentTask: meta?.summary?.text,
+                    pendingPermissions: permissions.length > 0 ? permissions : undefined,
+                };
+            });
+            return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: JSON.stringify({ error: 'ListSessionsFailed', message: err.message }) }] };
+        }
+    });
+}

package/dist/tools/send_message.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { ApiClient } from '../api/client.js';
+import type { SessionManager } from '../session/manager.js';
+export declare function registerSendMessage(server: McpServer, api: ApiClient, sessionManager: SessionManager): RegisteredTool;

package/dist/tools/send_message.js

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+import { randomUUID } from 'crypto';
+import { encryptToBase64 } from '../auth/crypto.js';
+const PERMISSION_MODES = ['default', 'acceptEdits', 'bypassPermissions', 'plan', 'read-only', 'safe-yolo', 'yolo'];
+export function registerSendMessage(server, api, sessionManager) {
+    return server.tool('send_message', 'Send a message to a Happy Coder session. The message will appear as a user message in the session. Can optionally change the permission mode.', {
+        sessionId: z.string().describe('The session ID to send the message to'),
+        message: z.string().describe('The message text to send'),
+        meta: z.object({
+            permissionMode: z.enum(PERMISSION_MODES).optional(),
+            allowedTools: z.array(z.string()).optional(),
+            disallowedTools: z.array(z.string()).optional(),
+        }).optional(),
+    }, async ({ sessionId, message, meta }) => {
+        try {
+            const session = sessionManager.get(sessionId);
+            if (!session) {
+                return { isError: true, content: [{ type: 'text', text: JSON.stringify({ error: 'SessionNotFound', message: `Session ${sessionId} not found` }) }] };
+            }
+            const status = sessionManager.getSessionStatus(sessionId);
+            if (status === 'active') {
+                return { isError: true, content: [{ type: 'text', text: JSON.stringify({ error: 'SessionNotIdle', message: 'Cannot send message while session is actively generating' }) }] };
+            }
+            // Build message in legacy format (verified against upstream)
+            const content = {
+                role: 'user',
+                content: { type: 'text', text: message },
+                meta: {
+                    sentFrom: 'happy-mcp',
+                    ...(meta?.permissionMode ? { permissionMode: meta.permissionMode } : {}),
+                    ...(meta?.allowedTools ? { allowedTools: meta.allowedTools } : {}),
+                    ...(meta?.disallowedTools ? { disallowedTools: meta.disallowedTools } : {}),
+                },
+            };
+            // Encrypt and send via V3 REST API
+            const encrypted = encryptToBase64(session.encryption, content);
+            const localId = randomUUID();
+            const result = await api.sendMessages(sessionId, [{ content: encrypted, localId }]);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            messageId: result.messages?.[0]?.id,
+                            seq: result.messages?.[0]?.seq,
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: JSON.stringify({ error: 'SendMessageFailed', message: err.message }) }] };
+        }
+    });
+}

package/dist/tools/start_session.d.ts

@@ -0,0 +1,5 @@
+import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { ApiClient } from '../api/client.js';
+import type { RelayClient } from '../relay/client.js';
+import type { SessionManager } from '../session/manager.js';
+export declare function registerStartSession(server: McpServer, _api: ApiClient, relay: RelayClient, sessionManager: SessionManager): RegisteredTool;

package/dist/tools/start_session.js

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+const PERMISSION_MODES = ['default', 'acceptEdits', 'bypassPermissions', 'plan', 'read-only', 'safe-yolo', 'yolo'];
+export function registerStartSession(server, _api, relay, sessionManager) {
+    return server.tool('start_session', 'Start a new Happy Coder session on a remote machine. Requires the machine to be online. Use list_computers to find available machines.', {
+        computer: z.string().describe('The machine ID (from list_computers)'),
+        projectPath: z.string().describe('The working directory for the new session'),
+        initialMessage: z.string().optional().describe('Initial message to send after session starts'),
+        permissionMode: z.enum(PERMISSION_MODES).optional().describe('Permission mode for the session'),
+        agent: z.enum(['claude', 'codex', 'gemini']).optional().default('claude').describe('The AI agent to use'),
+    }, 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 machine = sessionManager.getMachine(computer);
+            if (!machine) {
+                return { isError: true, content: [{ type: 'text', text: JSON.stringify({ error: 'MachineNotFound', message: `Machine ${computer} not found` }) }] };
+            }
+            if (!machine.active) {
+                return { isError: true, content: [{ type: 'text', text: JSON.stringify({ error: 'MachineOffline', message: `Machine ${computer} is not online` }) }] };
+            }
+            const result = await relay.machineRpc(computer, 'spawn-happy-session', {
+                type: 'spawn-in-directory',
+                directory: projectPath,
+                agent: agent ?? 'claude',
+                ...(permissionMode ? { permissionMode } : {}),
+            });
+            if (result?.type === 'success' && result.sessionId) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                sessionId: result.sessionId,
+                                status: 'starting',
+                                ...(initialMessage ? { note: 'Use send_message to send the initial message after session becomes active' } : {}),
+                            }, null, 2),
+                        }],
+                };
+            }
+            if (result?.type === 'error') {
+                return { isError: true, content: [{ type: 'text', text: JSON.stringify({ error: 'SpawnFailed', message: result.errorMessage ?? 'Unknown error' }) }] };
+            }
+            return { isError: true, content: [{ type: 'text', text: JSON.stringify({ error: 'UnexpectedResponse', message: JSON.stringify(result) }) }] };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: JSON.stringify({ error: 'StartSessionFailed', message: err.message }) }] };
+        }
+    });
+}

package/dist/tools/watch_session.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { RelayClient } from '../relay/client.js';
+import type { SessionManager } from '../session/manager.js';
+export declare function registerWatchSession(server: McpServer, relay: RelayClient, sessionManager: SessionManager): RegisteredTool;

package/dist/tools/watch_session.js

@@ -0,0 +1,91 @@
+import { z } from 'zod';
+const DEFAULT_TIMEOUT_SECONDS = 300; // 5 minutes
+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.', {
+        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 }) => {
+        try {
+            // Validate all session IDs exist
+            const missing = sessionIds.filter(id => !sessionManager.get(id));
+            if (missing.length > 0) {
+                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 watchedSet = new Set(sessionIds);
+            // Check if any session is already in a terminal state
+            for (const sid of sessionIds) {
+                const status = sessionManager.getSessionStatus(sid);
+                if (status === 'idle' || status === 'waiting_permission') {
+                    const permissions = sessionManager.getPendingPermissions(sid);
+                    const messages = sessionManager.getMessages(sid, 5);
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({
+                                    triggeredBy: sid,
+                                    status,
+                                    waitedSeconds: 0,
+                                    timedOut: false,
+                                    pendingPermissions: permissions,
+                                    lastMessages: messages.map(m => ({ id: m.id, content: m.content, createdAt: new Date(m.createdAt).toISOString() })),
+                                }, null, 2),
+                            }],
+                    };
+                }
+            }
+            // Wait for state change on any watched session
+            const startTime = Date.now();
+            const timeoutMs = timeoutSeconds * 1000;
+            const result = await new Promise((resolve) => {
+                const timeout = setTimeout(() => {
+                    cleanup();
+                    resolve({ triggeredBy: sessionIds[0], status: 'timeout', timedOut: true });
+                }, timeoutMs);
+                const onSessionUpdate = (sid) => {
+                    if (!watchedSet.has(sid))
+                        return;
+                    const status = sessionManager.getSessionStatus(sid);
+                    if (status === 'idle' || status === 'waiting_permission') {
+                        cleanup();
+                        resolve({ triggeredBy: sid, status, timedOut: false });
+                    }
+                };
+                const onDeleted = (sid) => {
+                    if (!watchedSet.has(sid))
+                        return;
+                    cleanup();
+                    resolve({ triggeredBy: sid, status: 'deleted', timedOut: false });
+                };
+                const cleanup = () => {
+                    clearTimeout(timeout);
+                    relay.removeListener('session_update', onSessionUpdate);
+                    relay.removeListener('session_deleted', onDeleted);
+                };
+                relay.on('session_update', onSessionUpdate);
+                relay.on('session_deleted', onDeleted);
+            });
+            const waitedSeconds = Math.round((Date.now() - startTime) / 1000);
+            const permissions = sessionManager.getPendingPermissions(result.triggeredBy);
+            const messages = sessionManager.getMessages(result.triggeredBy, 5);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            triggeredBy: result.triggeredBy,
+                            status: result.status,
+                            waitedSeconds,
+                            timedOut: result.timedOut,
+                            pendingPermissions: permissions,
+                            lastMessages: messages.map(m => ({ id: m.id, content: m.content, createdAt: new Date(m.createdAt).toISOString() })),
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (err) {
+            return { isError: true, content: [{ type: 'text', text: JSON.stringify({ error: 'WatchSessionFailed', message: err.message }) }] };
+        }
+    });
+}

package/dist/types/wire.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Wire protocol types inlined from @slopus/happy-wire.
+ * These mirror the canonical schemas from packages/happy-wire/src/messages.ts
+ * and packages/happy-wire/src/messageMeta.ts.
+ *
+ * When @slopus/happy-wire is published as an npm package, replace these
+ * with imports from the package.
+ */
+export interface CoreUpdateContainer {
+    id: string;
+    seq: number;
+    body: UpdateBody;
+    createdAt: number;
+}
+export type UpdateBody = NewMessageBody | UpdateSessionBody | UpdateMachineBody | NewSessionBody | DeleteSessionBody;
+export interface NewMessageBody {
+    t: 'new-message';
+    sid: string;
+    message: WireMessage;
+}
+export interface UpdateSessionBody {
+    t: 'update-session';
+    id: string;
+    metadata?: VersionedField;
+    agentState?: VersionedField;
+    active?: boolean;
+}
+export interface UpdateMachineBody {
+    t: 'update-machine';
+    machineId: string;
+    metadata?: VersionedField;
+    daemonState?: VersionedField;
+    active?: boolean;
+    activeAt?: number;
+}
+export interface NewSessionBody {
+    t: 'new-session';
+    id: string;
+    [key: string]: unknown;
+}
+export interface DeleteSessionBody {
+    t: 'delete-session';
+    id: string;
+}
+export interface VersionedField {
+    version: number;
+    value: string | null;
+}
+export interface WireMessage {
+    id: string;
+    seq: number;
+    content: WireMessageContent;
+    localId?: string;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface WireMessageContent {
+    t: 'encrypted';
+    c: string;
+}
+/** User message format (legacy protocol, verified against upstream) */
+export interface LegacyUserMessage {
+    role: 'user';
+    content: {
+        type: 'text';
+        text: string;
+    };
+    meta: LegacyMessageMeta;
+}
+export interface LegacyMessageMeta {
+    sentFrom: string;
+    permissionMode?: PermissionMode;
+    [key: string]: unknown;
+}
+export type PermissionMode = 'default' | 'acceptEdits' | 'bypassPermissions' | 'plan' | 'read-only' | 'safe-yolo' | 'yolo';
+/** RPC call sent via Socket.io emitWithAck('rpc-call', ...) */
+export interface RpcCall {
+    method: string;
+    params: string;
+}
+/** RPC response from server */
+export interface RpcResponse {
+    ok: boolean;
+    result?: string;
+    error?: string;
+}
+/** Permission RPC params (decrypted) */
+export interface PermissionRpcParams {
+    id: string;
+    approved: boolean;
+    mode?: PermissionMode;
+    allowTools?: string[];
+    decision?: 'approved' | 'approved_for_session' | 'denied' | 'abort';
+}
+/** Machine RPC spawn params */
+export interface SpawnSessionParams {
+    type: 'spawn-in-directory';
+    directory: string;
+    agent?: 'claude' | 'codex' | 'gemini';
+}
+/** Machine RPC spawn response */
+export interface SpawnSessionResponse {
+    type: 'success' | 'error';
+    sessionId?: string;
+    errorMessage?: string;
+}
+/** POST /v3/sessions/:id/messages request body */
+export interface SendMessagesRequest {
+    messages: Array<{
+        content: string;
+        localId: string;
+    }>;
+}
+/** POST /v3/sessions/:id/messages response */
+export interface SendMessagesResponse {
+    messages: Array<{
+        id: string;
+        seq: number;
+        localId: string;
+        createdAt: number;
+        updatedAt: number;
+    }>;
+}
+/** GET /v3/sessions/:id/messages response */
+export interface GetMessagesResponse {
+    messages: WireMessage[];
+    hasMore: boolean;
+}
+/** POST /v1/auth request/response */
+export interface AuthChallengeRequest {
+    challenge: string;
+    publicKey: string;
+    signature: string;
+}
+export interface AuthChallengeResponse {
+    success: boolean;
+    token: string;
+}
+/** POST /v1/auth/account/request response */
+export interface PairingResponse {
+    state: 'pending' | 'authorized' | 'rejected';
+    token?: string;
+    response?: string;
+}
+export interface SocketAuth {
+    token: string;
+    clientType: 'user-scoped';
+}

package/dist/types/wire.js

@@ -0,0 +1,9 @@
+/**
+ * Wire protocol types inlined from @slopus/happy-wire.
+ * These mirror the canonical schemas from packages/happy-wire/src/messages.ts
+ * and packages/happy-wire/src/messageMeta.ts.
+ *
+ * When @slopus/happy-wire is published as an npm package, replace these
+ * with imports from the package.
+ */
+export {};

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "happy-mcp-server",
+  "version": "0.1.0",
+  "description": "MCP server for observing and controlling Happy Coder sessions",
+  "author": {
+    "name": "Jared Spencer",
+    "email": "jared@jklz.dev"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jklz/happy-mcp-server.git"
+  },
+  "bugs": {
+    "url": "https://github.com/jklz/happy-mcp-server/issues"
+  },
+  "homepage": "https://github.com/jklz/happy-mcp-server#readme",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "happy-coder",
+    "ai",
+    "claude",
+    "session-management"
+  ],
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "happy-mcp": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc && chmod +x dist/index.js",
+    "dev": "tsx src/index.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest --coverage",
+    "lint": "eslint src",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.6.0",
+    "axios": "^1.7.0",
+    "qrcode-terminal": "^0.12.0",
+    "socket.io-client": "^4.7.0",
+    "tweetnacl": "^1.0.3",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.0.0",
+    "@types/node": "^20.0.0",
+    "@types/qrcode-terminal": "^0.12.0",
+    "@vitest/coverage-v8": "^2.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.5.0",
+    "typescript-eslint": "^8.0.0",
+    "vitest": "^2.0.0"
+  }
+}