@canonmsg/claude-code-plugin 0.22.0 → 0.23.0

package/dist/server.js

@@ -0,0 +1,699 @@
+#!/usr/bin/env node
+import { setDefaultResultOrder } from 'node:dns';
+/**
+ * Canon channel MCP server for Claude Code.
+ *
+ * Connects to Canon's SSE stream for real-time inbound messages and exposes
+ * tools for Claude to reply, send messages, list conversations, and set
+ * typing indicators.
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { CanonClient, CanonStream, ApprovalManager, buildLocalRuntimeId, getActiveProfileLock, markLocalRuntimeStopped, loadProfiles, isProfileLocked, resolveCanonAgent, getActiveProfile, releaseLock, upsertLocalRuntimeEntry, initRTDBAuth, writeSessionState, clearSessionState, renderCanonHostInboundContent, } from '@canonmsg/core';
+import { materializeMessageMedia, sendMediaFileMessage, } from '@canonmsg/agent-sdk';
+import { ApprovalHttpServer } from './approval-server.js';
+import { runCli } from './cli-entry.js';
+import { parseReplyArgs, parseSendContextualMessageArgs, parseSendMessageArgs, parseSetTypingArgs, } from './mcp-args.js';
+const HELP = `canon-channel-server — Claude Code MCP channel server for Canon
+
+USAGE
+  canon-channel-server
+
+FLAGS
+  --help, -h       Show this help
+  --version, -V    Show package version
+
+This command is normally launched by Claude Code as an MCP stdio server. For
+phone-controlled local sessions, use canon-claude instead.`;
+// ── MCP server ─────────────────────────────────────────────────────────
+const server = new Server({ name: 'canon-channel', version: '0.1.0' }, {
+    capabilities: {
+        tools: {},
+        experimental: { 'claude/channel': {} },
+    },
+});
+let client = null;
+let stream = null;
+let agentContext = null;
+let approvalManager = null;
+let approvalServer = null;
+const conversationCache = new Map();
+const TURN_COMPLETE_METADATA = {
+    turnSemantics: 'turn_complete',
+};
+/** Last owner-visible conversation to route approval cards into. */
+let approvalConversationId = null;
+/** Whether the message that most recently triggered work came from the owner. */
+let triggerIsOwner = true;
+function getPrimaryAttachment(message) {
+    const attachment = message.attachments?.[0];
+    if (attachment?.url)
+        return attachment;
+    return null;
+}
+function renderInboundContent(message, materialized) {
+    return renderCanonHostInboundContent(message, materialized);
+}
+function toolArgumentError(error) {
+    return {
+        content: [{ type: 'text', text: `Invalid arguments: ${error}` }],
+        isError: true,
+    };
+}
+// ── Tool definitions ───────────────────────────────────────────────────
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+        {
+            name: 'reply',
+            description: 'Reply to a Canon conversation',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    conversation_id: {
+                        type: 'string',
+                        description: 'The conversation ID to reply to',
+                    },
+                    text: {
+                        type: 'string',
+                        description: 'Message text to send',
+                    },
+                },
+                required: ['conversation_id', 'text'],
+            },
+        },
+        {
+            name: 'send_message',
+            description: 'Send a message to a Canon conversation (supports text, images, audio, video, files)',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    conversation_id: {
+                        type: 'string',
+                        description: 'The conversation ID',
+                    },
+                    text: {
+                        type: 'string',
+                        description: 'Message text',
+                    },
+                    content_type: {
+                        type: 'string',
+                        enum: ['text', 'image', 'audio', 'video', 'file'],
+                        description: 'Content type (default: text)',
+                    },
+                    image_url: {
+                        type: 'string',
+                        description: 'Image URL (when content_type is image)',
+                    },
+                    audio_url: {
+                        type: 'string',
+                        description: 'Audio URL (when content_type is audio)',
+                    },
+                    video_url: {
+                        type: 'string',
+                        description: 'Video URL (when content_type is video)',
+                    },
+                    file_url: {
+                        type: 'string',
+                        description: 'File URL (when content_type is file)',
+                    },
+                    media_path: {
+                        type: 'string',
+                        description: 'Local image/audio/video/file path to upload and send',
+                    },
+                    file_name: {
+                        type: 'string',
+                        description: 'Optional display filename for file attachments',
+                    },
+                    mime_type: {
+                        type: 'string',
+                        description: 'Optional MIME type for media_path uploads',
+                    },
+                    duration_ms: {
+                        type: 'number',
+                        description: 'Optional audio duration in milliseconds for media_path uploads',
+                    },
+                },
+                required: ['conversation_id'],
+            },
+        },
+        {
+            name: 'send_contextual_message',
+            description: 'Send a message into another Canon conversation or contact with private cross-session self-context',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    source_conversation_id: {
+                        type: 'string',
+                        description: 'The Canon conversation where this cross-session intent originated',
+                    },
+                    target_conversation_id: {
+                        type: 'string',
+                        description: 'The destination Canon conversation to send into',
+                    },
+                    target_user_id: {
+                        type: 'string',
+                        description: 'The destination Canon user/contact to reach out to',
+                    },
+                    text: {
+                        type: 'string',
+                        description: 'Message text to send',
+                    },
+                    self_context: {
+                        type: 'object',
+                        description: 'Required { type: "cross_session", context: "why I am saying this here" }',
+                    },
+                    session_selection: {
+                        type: 'string',
+                        enum: ['new', 'continue_latest', 'continue_or_create'],
+                        description: 'Optional direct-agent session behavior when target_user_id is used',
+                    },
+                    message_options: {
+                        type: 'object',
+                        description: 'Optional Canon send options for the contextual outbound message',
+                    },
+                },
+                required: ['source_conversation_id', 'text', 'self_context'],
+            },
+        },
+        {
+            name: 'list_conversations',
+            description: "List Canon conversations this agent participates in",
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    limit: {
+                        type: 'number',
+                        description: 'Max conversations to return (default: 20)',
+                    },
+                },
+            },
+        },
+        {
+            name: 'list_agents',
+            description: 'List registered Canon agent profiles and their lock status',
+            inputSchema: {
+                type: 'object',
+                properties: {},
+            },
+        },
+        {
+            name: 'set_typing',
+            description: 'Show or hide typing indicator in a Canon conversation',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    conversation_id: {
+                        type: 'string',
+                        description: 'The conversation ID',
+                    },
+                    typing: {
+                        type: 'boolean',
+                        description: 'Whether to show typing indicator',
+                    },
+                    status: {
+                        type: 'string',
+                        enum: ['typing', 'thinking'],
+                        description: 'Typing status (default: typing). Use "thinking" when processing/reasoning.',
+                    },
+                },
+                required: ['conversation_id', 'typing'],
+            },
+        },
+    ],
+}));
+// ── Tool handlers ──────────────────────────────────────────────────────
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    if (!client) {
+        return {
+            content: [{ type: 'text', text: 'Canon not connected' }],
+            isError: true,
+        };
+    }
+    const args = request.params.arguments;
+    switch (request.params.name) {
+        case 'reply': {
+            const parsed = parseReplyArgs(args);
+            if (!parsed.ok)
+                return toolArgumentError(parsed.error);
+            const { conversationId, text } = parsed.value;
+            const result = await client.sendMessage(conversationId, text, {
+                metadata: TURN_COMPLETE_METADATA,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Message sent (${result.messageId})`,
+                    },
+                ],
+            };
+        }
+        case 'send_message': {
+            const parsed = parseSendMessageArgs(args);
+            if (!parsed.ok)
+                return toolArgumentError(parsed.error);
+            const { conversationId, text, contentType, imageUrl, audioUrl, videoUrl, fileUrl, mediaPath, fileName, mimeType, durationMs, } = parsed.value;
+            const opts = {};
+            const metadata = TURN_COMPLETE_METADATA;
+            if (mediaPath) {
+                const result = await sendMediaFileMessage(client, conversationId, mediaPath, text, {
+                    ...(fileName ? { fileName } : {}),
+                    ...(mimeType ? { mimeType } : {}),
+                    ...(durationMs != null ? { durationMs } : {}),
+                    metadata,
+                });
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Message sent (${result.messageId})`,
+                        },
+                    ],
+                };
+            }
+            if (contentType === 'image' && imageUrl) {
+                opts.contentType = 'image';
+                opts.attachments = [{ kind: 'image', url: imageUrl }];
+            }
+            else if (contentType === 'audio' && audioUrl) {
+                opts.contentType = 'audio';
+                opts.attachments = [{
+                        kind: 'audio',
+                        url: audioUrl,
+                        ...(durationMs != null ? { durationMs } : {}),
+                        ...(mimeType ? { mimeType } : {}),
+                    }];
+            }
+            else if (contentType === 'video' && videoUrl) {
+                opts.contentType = 'video';
+                opts.attachments = [{
+                        kind: 'video',
+                        url: videoUrl,
+                        ...(mimeType ? { mimeType } : {}),
+                        ...(durationMs != null ? { durationMs } : {}),
+                    }];
+            }
+            else if (contentType === 'file' || fileUrl) {
+                opts.contentType = 'file';
+                if (fileUrl) {
+                    opts.attachments = [{
+                            kind: 'file',
+                            url: fileUrl,
+                            ...(fileName ? { fileName } : {}),
+                            ...(mimeType ? { mimeType } : {}),
+                        }];
+                }
+            }
+            else {
+                opts.contentType = contentType;
+            }
+            opts.metadata = {
+                ...(opts.metadata ?? {}),
+                ...metadata,
+            };
+            const result = await client.sendMessage(conversationId, text, opts);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Message sent (${result.messageId})`,
+                    },
+                ],
+            };
+        }
+        case 'send_contextual_message': {
+            const parsed = parseSendContextualMessageArgs(args);
+            if (!parsed.ok)
+                return toolArgumentError(parsed.error);
+            const { sourceConversationId, targetConversationId, targetUserId, text, selfContext, sessionSelection, messageOptions, } = parsed.value;
+            const contextualMessageOptions = messageOptions;
+            const result = await client.sendContextualMessage({
+                sourceConversationId,
+                ...(targetConversationId ? { targetConversationId } : {}),
+                ...(targetUserId ? { targetUserId } : {}),
+                text,
+                selfContext,
+                ...(sessionSelection ? { sessionSelection } : {}),
+                ...(contextualMessageOptions
+                    ? {
+                        messageOptions: {
+                            ...contextualMessageOptions,
+                            metadata: {
+                                ...(contextualMessageOptions.metadata ?? {}),
+                                ...TURN_COMPLETE_METADATA,
+                            },
+                        },
+                    }
+                    : { messageOptions: { metadata: TURN_COMPLETE_METADATA } }),
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: result.status === 'messaged'
+                            ? `Contextual message sent (${result.messageId}) via self-context ${result.selfContextId}`
+                            : `Contextual message not sent: ${result.status}`,
+                    },
+                ],
+            };
+        }
+        case 'list_conversations': {
+            const rawArgs = args && typeof args === 'object' ? args : {};
+            const limit = typeof rawArgs.limit === 'number' && Number.isFinite(rawArgs.limit)
+                ? Math.max(1, Math.min(100, Math.floor(rawArgs.limit)))
+                : 20;
+            const convos = await client.getConversations();
+            const slice = convos.slice(0, limit);
+            const summary = slice.map((c) => ({
+                id: c.id,
+                type: c.type,
+                name: c.name,
+                members: c.memberIds.length,
+                lastMessage: c.lastMessage?.text?.slice(0, 100) || null,
+            }));
+            return {
+                content: [
+                    { type: 'text', text: JSON.stringify(summary, null, 2) },
+                ],
+            };
+        }
+        case 'list_agents': {
+            const profiles = loadProfiles();
+            const entries = Object.entries(profiles).map(([name, p]) => {
+                const lock = isProfileLocked(name);
+                return {
+                    profile: name,
+                    agentName: p.agentName,
+                    agentId: p.agentId,
+                    status: getActiveProfile() === name ? 'active (this session)' : lock.locked ? `in use (PID ${lock.pid})` : 'available',
+                };
+            });
+            if (entries.length === 0) {
+                return {
+                    content: [{ type: 'text', text: 'No agents registered. Run /canon-register to register one.' }],
+                };
+            }
+            return {
+                content: [{ type: 'text', text: JSON.stringify(entries, null, 2) }],
+            };
+        }
+        case 'set_typing': {
+            const parsed = parseSetTypingArgs(args);
+            if (!parsed.ok)
+                return toolArgumentError(parsed.error);
+            const { conversationId, typing, status } = parsed.value;
+            await client.setTyping(conversationId, typing, status);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: typing ? 'Typing indicator shown' : 'Typing indicator hidden',
+                    },
+                ],
+            };
+        }
+        default:
+            return {
+                content: [
+                    { type: 'text', text: `Unknown tool: ${request.params.name}` },
+                ],
+                isError: true,
+            };
+    }
+});
+// ── Inbound message handler ────────────────────────────────────────────
+async function handleInboundMessage(payload) {
+    const m = payload.message;
+    const convo = conversationCache.get(payload.conversationId);
+    // Track turn provenance separately from the owner-visible approval route.
+    // Non-owner direct chats do not include the owner, so approval cards still go
+    // to the last owner conversation while the hook bypasses cached session rules.
+    triggerIsOwner = m.isOwner === true;
+    if (triggerIsOwner) {
+        approvalConversationId = payload.conversationId;
+    }
+    // Route to approval manager first — if consumed, don't forward to Claude
+    if (approvalManager) {
+        const consumed = approvalManager.handleMessage(payload.conversationId, {
+            senderId: m.senderId,
+            metadata: m.metadata,
+        });
+        if (consumed) {
+            console.error(`[canon] Approval reply consumed from ${m.senderName || m.senderId}`);
+            return;
+        }
+    }
+    // meta must be Record<string, string> — non-string values cause silent drops
+    const meta = {
+        conversation_id: payload.conversationId,
+        sender_id: m.senderId,
+        sender_name: m.senderName || m.senderId,
+        sender_type: m.senderType || 'human',
+        is_owner: String(m.isOwner ?? false),
+        chat_type: convo?.type || 'direct',
+        content_type: m.contentType || 'text',
+        ts: new Date().toISOString(),
+    };
+    if (payload.behavior) {
+        meta.behavior_style = payload.behavior.participation.style;
+        meta.behavior_allow_agent_to_agent = String(payload.behavior.participation.allowAgentToAgent);
+        meta.behavior_allow_long_running = String(payload.behavior.participation.allowLongRunningCollaboration);
+        meta.behavior_require_group_mention = String(payload.behavior.participation.requireMentionForGroupReplies);
+        if (payload.behavior.participation.maxConsecutiveAgentTurns != null) {
+            meta.behavior_max_consecutive_agent_turns = String(payload.behavior.participation.maxConsecutiveAgentTurns);
+        }
+        if (payload.behavior.instructions.length > 0) {
+            meta.behavior_instructions = payload.behavior.instructions.join('\n\n');
+        }
+    }
+    if (Array.isArray(payload.selfContexts) && payload.selfContexts.length > 0) {
+        if (payload.activeSelfContextId) {
+            meta.active_self_context_id = payload.activeSelfContextId;
+        }
+        meta.self_context_ids = payload.selfContexts
+            .map((selfContext) => selfContext.id)
+            .join('\n');
+        meta.self_context_types = payload.selfContexts
+            .map((selfContext) => selfContext.type)
+            .join('\n');
+        meta.self_context = payload.selfContexts
+            .map((selfContext) => selfContext.context)
+            .join('\n\n');
+    }
+    let materialized = [];
+    if (m.id && m.attachments?.length) {
+        try {
+            materialized = await materializeMessageMedia({
+                id: m.id,
+                attachments: m.attachments ?? [],
+            }, {
+                agentId: agentContext?.agentId ?? 'claude-code',
+                conversationId: payload.conversationId,
+            });
+        }
+        catch (error) {
+            console.error(`[canon] Failed to materialize inbound media: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+    const primaryAttachment = getPrimaryAttachment(m);
+    if (m.attachments?.length) {
+        meta.attachments_json = JSON.stringify(m.attachments);
+    }
+    if (primaryAttachment?.url) {
+        meta.attachment_kind = primaryAttachment.kind;
+        meta.attachment_url = primaryAttachment.url;
+    }
+    if (primaryAttachment?.fileName)
+        meta.attachment_file_name = primaryAttachment.fileName;
+    if (primaryAttachment?.mimeType)
+        meta.attachment_mime_type = primaryAttachment.mimeType;
+    if (primaryAttachment?.durationMs != null)
+        meta.attachment_duration_ms = String(primaryAttachment.durationMs);
+    const primaryMaterialized = materialized.find((attachment) => attachment.index === 0);
+    if (primaryMaterialized?.path)
+        meta.attachment_path = primaryMaterialized.path;
+    if (materialized.length > 0) {
+        meta.attachment_paths = materialized
+            .map((attachment) => attachment.path)
+            .join('\n');
+    }
+    const renderedContent = renderInboundContent(m, materialized);
+    console.error(`[canon] Inbound message from ${meta.sender_name}: "${renderedContent}"`);
+    try {
+        await server.notification({
+            method: 'notifications/claude/channel',
+            params: {
+                content: renderedContent,
+                meta,
+            },
+        });
+        console.error('[canon] Notification sent to Claude Code');
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`[canon] Failed to send notification: ${msg}`);
+    }
+}
+// ── Start ──────────────────────────────────────────────────────────────
+async function startChannel() {
+    let apiKey;
+    let profile;
+    let baseUrl;
+    let profileAgentName;
+    try {
+        const resolved = resolveCanonAgent({ logPrefix: '[canon]', expectedClientType: 'claude-code' });
+        apiKey = resolved.apiKey;
+        profile = resolved.profile;
+        baseUrl = resolved.baseUrl;
+        profileAgentName = resolved.agentName;
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : err);
+        return;
+    }
+    if (profile) {
+        console.error(`[canon] Using agent profile: ${profile}`);
+    }
+    client = new CanonClient(apiKey, baseUrl);
+    // Get agent identity — try /agents/me first, fall back to /agents/auth-token
+    let agentId;
+    try {
+        agentContext = await client.getAgentMe();
+        agentId = agentContext.agentId;
+        console.error(`[canon] Connected as ${agentContext.displayName || agentId}`);
+    }
+    catch {
+        // /agents/me may not be deployed — fall back to auth-token exchange
+        try {
+            const auth = await client.getAuthToken();
+            agentId = auth.agentId;
+            console.error(`[canon] Authenticated as ${agentId}`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`[canon] Failed to authenticate: ${msg}`);
+            return;
+        }
+    }
+    // Initialize RTDB auth for session state reporting
+    initRTDBAuth(client);
+    const runtimeId = buildLocalRuntimeId({
+        runtime: 'claude-code',
+        profile,
+        cwd: process.cwd(),
+        launchCommand: ['canon-channel-server'],
+    });
+    upsertLocalRuntimeEntry({
+        id: runtimeId,
+        runtime: 'claude-code',
+        profile,
+        agentId,
+        agentName: agentContext?.displayName ?? profileAgentName,
+        cwd: process.cwd(),
+        launchCommand: ['canon-channel-server'],
+        pid: process.pid,
+        status: 'embedded',
+        reviveCapability: 'embedded',
+        surfaceMode: 'channel',
+        lastStartedAt: new Date().toISOString(),
+        lastHeartbeatAt: new Date().toISOString(),
+    });
+    // Populate conversation cache
+    try {
+        const convos = await client.getConversations();
+        for (const c of convos)
+            conversationCache.set(c.id, c);
+        console.error(`[canon] Loaded ${convos.length} conversations`);
+    }
+    catch {
+        // Non-fatal — will be populated as messages arrive
+    }
+    // Write initial session state
+    const initialState = { cwd: process.cwd(), isActive: true };
+    for (const convoId of conversationCache.keys()) {
+        writeSessionState(convoId, agentId, initialState).catch((err) => console.error(`[canon] Failed to write initial state for ${convoId}:`, err));
+    }
+    // Start SSE stream
+    stream = new CanonStream({
+        apiKey,
+        agentId,
+        handler: {
+            onMessage: handleInboundMessage,
+            onAgentContext: (ctx) => {
+                agentContext = ctx;
+            },
+            onConnected: () => {
+                console.error('[canon] SSE stream connected');
+            },
+            onDisconnected: () => {
+                console.error('[canon] SSE stream disconnected');
+            },
+            onError: (err) => {
+                console.error(`[canon] SSE error: ${err.message}`);
+            },
+        },
+    });
+    stream.start().catch((err) => {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`[canon] SSE start error: ${msg}`);
+    });
+    // Start approval system
+    if (agentContext?.ownerId) {
+        approvalManager = new ApprovalManager(client, agentId, agentContext.ownerId);
+        approvalServer = new ApprovalHttpServer(approvalManager, () => approvalConversationId, {
+            token: process.env.CANON_CLAUDE_APPROVAL_TOKEN,
+            getIsOwnerTurn: () => triggerIsOwner,
+        });
+        approvalServer.start().catch((err) => {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`[canon] Approval server error: ${msg}`);
+        });
+        console.error('[canon] Approval hooks must send Authorization: Bearer <token> or x-canon-approval-token.');
+        if (!process.env.CANON_CLAUDE_APPROVAL_TOKEN) {
+            console.error(`[canon] Generated local approval token: ${approvalServer.authToken}`);
+        }
+    }
+}
+// ── Main ───────────────────────────────────────────────────────────────
+export async function main() {
+    setDefaultResultOrder('ipv4first');
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    // Start the Canon channel after MCP connection is established
+    await startChannel();
+    // Graceful shutdown — release agent lock and clear session state
+    const shutdown = () => {
+        // Mark all conversations as inactive
+        if (agentContext) {
+            for (const convoId of conversationCache.keys()) {
+                clearSessionState(convoId, agentContext.agentId).catch(() => { });
+            }
+        }
+        approvalManager?.dispose();
+        approvalServer?.stop().catch(() => { });
+        stream?.stop();
+        const runtimeId = buildLocalRuntimeId({
+            runtime: 'claude-code',
+            profile: getActiveProfile(),
+            cwd: process.cwd(),
+            launchCommand: ['canon-channel-server'],
+        });
+        markLocalRuntimeStopped(runtimeId);
+        const ap = getActiveProfile();
+        if (ap)
+            releaseLock(ap);
+        getActiveProfileLock()?.release();
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+    process.on('SIGHUP', shutdown);
+}
+runCli(import.meta.url, main, (err) => {
+    console.error('[canon] Fatal error:', err);
+    process.exit(1);
+}, {
+    name: 'canon-channel-server',
+    help: HELP,
+});