@canonmsg/claude-code-plugin 0.21.2 → 0.22.0

package/dist/server.js

@@ -1,711 +0,0 @@
-#!/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, markLocalRuntimeStopped, loadProfiles, isProfileLocked, resolveCanonAgent, releaseLock, upsertLocalRuntimeEntry, initRTDBAuth, 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;
-// Scoped RTDB handle for this channel server's single agent. Held alongside
-// the other per-process singletons (client, stream, ...) so both startChannel
-// and the shutdown handler in main() write session state as this agent — not
-// through any module-global default.
-let rtdb = null;
-// The one agent profile this server resolved+locked, and its lock handle.
-// Held here (not via a core module-global) so the list_agents tool handler and
-// the shutdown/error paths — all outside startChannel's scope — can read them.
-let activeProfile = null;
-let activeLockHandle = 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: activeProfile === 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;
-        activeProfile = resolved.profile;
-        activeLockHandle = resolved.lockHandle ?? null;
-    }
-    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
-    rtdb = 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()) {
-        rtdb.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 && rtdb) {
-            const scopedRtdb = rtdb;
-            for (const convoId of conversationCache.keys()) {
-                scopedRtdb.clearSessionState(convoId, agentContext.agentId).catch(() => { });
-            }
-        }
-        approvalManager?.dispose();
-        approvalServer?.stop().catch(() => { });
-        stream?.stop();
-        const runtimeId = buildLocalRuntimeId({
-            runtime: 'claude-code',
-            profile: activeProfile,
-            cwd: process.cwd(),
-            launchCommand: ['canon-channel-server'],
-        });
-        markLocalRuntimeStopped(runtimeId);
-        if (activeProfile)
-            releaseLock(activeProfile);
-        activeLockHandle?.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,
-});