@canonmsg/claude-code-plugin 0.22.0 → 0.24.0

package/dist/inbound-policy.d.ts

@@ -0,0 +1,22 @@
+import { type CanonGroupContext, type CanonGroupContextMode, type CanonConversation, type ResolvedAgentBehaviorPolicy } from '@canonmsg/core';
+export interface InboundParticipantContext {
+    conversationType: CanonConversation['type'] | 'unknown';
+    memberCount: number | null;
+    senderType: 'human' | 'ai_agent';
+    senderName: string;
+    isOwner: boolean;
+    mentionedAgent: boolean;
+    groupContext?: CanonGroupContext;
+    groupContextMode?: CanonGroupContextMode;
+    recentSenderTypes: Array<'human' | 'ai_agent'>;
+    recentHumanCount: number;
+    recentAgentCount: number;
+    consecutiveAgentTurns: number;
+    currentAgentStreakStartedByHuman: boolean;
+}
+export interface AutoReplyDecision {
+    allow: boolean;
+    reason: string;
+}
+export declare function buildInboundContextLines(context: InboundParticipantContext): string[];
+export declare function decideAutoReply(context: InboundParticipantContext, behavior?: ResolvedAgentBehaviorPolicy | null): AutoReplyDecision;

package/dist/inbound-policy.js

@@ -0,0 +1,46 @@
+import { buildCompactGroupContextLines, evaluateParticipationPolicy, resolveAgentBehaviorPolicy, } from '@canonmsg/core';
+function formatRecentSenders(senderTypes) {
+    if (senderTypes.length === 0)
+        return 'none';
+    return senderTypes.map((senderType) => (senderType === 'ai_agent' ? 'agent' : 'human')).join(' -> ');
+}
+export function buildInboundContextLines(context) {
+    const conversationTypeLabel = context.conversationType === 'unknown'
+        ? 'unknown'
+        : `${context.conversationType}${context.memberCount ? ` (${context.memberCount} members)` : ''}`;
+    const senderRole = context.isOwner
+        ? 'The latest sender is the verified human owner of this Canon agent.'
+        : context.senderType === 'ai_agent'
+            ? 'The latest sender is another AI agent in Canon.'
+            : 'The latest sender is a human Canon participant.';
+    return [
+        senderRole,
+        `Latest sender name: ${context.senderName}`,
+        `Latest sender type: ${context.senderType}`,
+        `Conversation type: ${conversationTypeLabel}`,
+        ...(context.groupContext && context.groupContextMode
+            ? buildCompactGroupContextLines(context.groupContext, context.groupContextMode)
+            : []),
+        `Directly addressed to this agent: ${context.mentionedAgent ? 'yes' : 'no'}`,
+        `Recent sender pattern: ${formatRecentSenders(context.recentSenderTypes)}`,
+        `Recent human messages: ${context.recentHumanCount}`,
+        `Recent agent messages: ${context.recentAgentCount}`,
+        `Consecutive recent agent turns: ${context.consecutiveAgentTurns}`,
+        `Current agent streak started after a human message: ${context.currentAgentStreakStartedByHuman ? 'yes' : 'no'}`,
+    ];
+}
+export function decideAutoReply(context, behavior) {
+    const decision = evaluateParticipationPolicy(behavior ?? resolveAgentBehaviorPolicy(), {
+        conversationType: context.conversationType,
+        senderType: context.senderType,
+        isOwner: context.isOwner,
+        mentionedAgent: context.mentionedAgent,
+        recentHumanCount: context.recentHumanCount,
+        consecutiveAgentTurns: context.consecutiveAgentTurns,
+        currentAgentStreakStartedByHuman: context.currentAgentStreakStartedByHuman,
+    });
+    return {
+        allow: decision.allow,
+        reason: decision.reason,
+    };
+}

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export { main as serverMain } from './server.js';
 export { main as hostMain } from './host.js';
 export { main as registerMain } from './register.js';
 export { main as setupMain } from './setup.js';

package/dist/index.js

@@ -1,3 +1,4 @@
+export { main as serverMain } from './server.js';
 export { main as hostMain } from './host.js';
 export { main as registerMain } from './register.js';
 export { main as setupMain } from './setup.js';

package/dist/mcp-args.d.ts

@@ -0,0 +1,45 @@
+import type { DirectSessionSelection, SendContextualMessageOptions } from '@canonmsg/core';
+export type McpParseResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+type ContentType = 'text' | 'image' | 'audio' | 'video' | 'file';
+export interface ReplyArgs {
+    conversationId: string;
+    text: string;
+}
+export declare function parseReplyArgs(value: unknown): McpParseResult<ReplyArgs>;
+export interface SendMessageArgs {
+    conversationId: string;
+    text: string;
+    contentType: ContentType;
+    imageUrl?: string;
+    audioUrl?: string;
+    videoUrl?: string;
+    fileUrl?: string;
+    mediaPath?: string;
+    fileName?: string;
+    mimeType?: string;
+    durationMs?: number;
+}
+export declare function parseSendMessageArgs(value: unknown): McpParseResult<SendMessageArgs>;
+export interface SendContextualMessageArgs {
+    sourceConversationId: string;
+    targetConversationId?: string;
+    targetUserId?: string;
+    text: string;
+    selfContext: SendContextualMessageOptions['selfContext'];
+    sessionSelection?: DirectSessionSelection;
+    messageOptions?: SendContextualMessageOptions['messageOptions'];
+}
+export declare function parseSendContextualMessageArgs(value: unknown): McpParseResult<SendContextualMessageArgs>;
+export interface SetTypingArgs {
+    conversationId: string;
+    typing: boolean;
+    status?: 'typing' | 'thinking';
+}
+export declare function parseSetTypingArgs(value: unknown): McpParseResult<SetTypingArgs>;
+export {};

package/dist/mcp-args.js

@@ -0,0 +1,179 @@
+function isRecord(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+function requiredString(record, key, maxLength = 4096) {
+    const value = record[key];
+    if (typeof value !== 'string') {
+        return { ok: false, error: `Missing ${key}` };
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return { ok: false, error: `Missing ${key}` };
+    }
+    if (trimmed.length > maxLength) {
+        return { ok: false, error: `${key} is too long` };
+    }
+    return { ok: true, value: trimmed };
+}
+function optionalString(record, key, maxLength = 4096) {
+    const value = record[key];
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed && trimmed.length <= maxLength ? trimmed : undefined;
+}
+function optionalNumber(record, key) {
+    const value = record[key];
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0
+        ? value
+        : undefined;
+}
+function parseContentType(value) {
+    if (value == null)
+        return { ok: true, value: 'text' };
+    if (value === 'text' || value === 'image' || value === 'audio' || value === 'video' || value === 'file') {
+        return { ok: true, value };
+    }
+    return { ok: false, error: 'Invalid content_type' };
+}
+export function parseReplyArgs(value) {
+    if (!isRecord(value))
+        return { ok: false, error: 'Arguments must be an object' };
+    const conversationId = requiredString(value, 'conversation_id', 256);
+    if (!conversationId.ok)
+        return conversationId;
+    const text = requiredString(value, 'text');
+    if (!text.ok)
+        return text;
+    return {
+        ok: true,
+        value: {
+            conversationId: conversationId.value,
+            text: text.value,
+        },
+    };
+}
+export function parseSendMessageArgs(value) {
+    if (!isRecord(value))
+        return { ok: false, error: 'Arguments must be an object' };
+    const conversationId = requiredString(value, 'conversation_id', 256);
+    if (!conversationId.ok)
+        return conversationId;
+    const contentType = parseContentType(value.content_type);
+    if (!contentType.ok)
+        return contentType;
+    const imageUrl = optionalString(value, 'image_url', 4096);
+    const audioUrl = optionalString(value, 'audio_url', 4096);
+    const videoUrl = optionalString(value, 'video_url', 4096);
+    const fileUrl = optionalString(value, 'file_url', 4096);
+    const mediaPath = optionalString(value, 'media_path', 4096);
+    const fileName = optionalString(value, 'file_name', 512);
+    const mimeType = optionalString(value, 'mime_type', 256);
+    const durationMs = optionalNumber(value, 'duration_ms');
+    return {
+        ok: true,
+        value: {
+            conversationId: conversationId.value,
+            text: optionalString(value, 'text') ?? '',
+            contentType: contentType.value,
+            ...(imageUrl ? { imageUrl } : {}),
+            ...(audioUrl ? { audioUrl } : {}),
+            ...(videoUrl ? { videoUrl } : {}),
+            ...(fileUrl ? { fileUrl } : {}),
+            ...(mediaPath ? { mediaPath } : {}),
+            ...(fileName ? { fileName } : {}),
+            ...(mimeType ? { mimeType } : {}),
+            ...(durationMs != null ? { durationMs } : {}),
+        },
+    };
+}
+function parseSessionSelection(value) {
+    if (value == null)
+        return { ok: true, value: undefined };
+    const raw = typeof value === 'string'
+        ? value
+        : isRecord(value) && typeof value.mode === 'string'
+            ? value.mode
+            : null;
+    const mode = raw?.trim().toLowerCase().replace(/-/g, '_');
+    if (!mode)
+        return { ok: false, error: 'Invalid session_selection' };
+    if (mode === 'new' || mode === 'fresh' || mode === 'start_new') {
+        return { ok: true, value: { mode: 'new' } };
+    }
+    if (mode === 'continue_latest' || mode === 'latest' || mode === 'continue') {
+        return { ok: true, value: { mode: 'continue_latest' } };
+    }
+    if (mode === 'continue_or_create' || mode === 'auto' || mode === 'reuse_or_create') {
+        return { ok: true, value: { mode: 'continue_or_create' } };
+    }
+    return { ok: false, error: 'session_selection must be new, continue_latest, or continue_or_create' };
+}
+export function parseSendContextualMessageArgs(value) {
+    if (!isRecord(value))
+        return { ok: false, error: 'Arguments must be an object' };
+    const sourceConversationId = requiredString(value, 'source_conversation_id', 256);
+    if (!sourceConversationId.ok)
+        return sourceConversationId;
+    const text = requiredString(value, 'text');
+    if (!text.ok)
+        return text;
+    const targetConversationId = optionalString(value, 'target_conversation_id', 256);
+    const targetUserId = optionalString(value, 'target_user_id', 256);
+    if (Boolean(targetConversationId) === Boolean(targetUserId)) {
+        return { ok: false, error: 'Provide exactly one target_conversation_id or target_user_id' };
+    }
+    if (!isRecord(value.self_context)) {
+        return { ok: false, error: 'Missing self_context' };
+    }
+    const type = value.self_context.type;
+    const context = requiredString(value.self_context, 'context');
+    if (!context.ok)
+        return context;
+    if (type !== 'cross_session') {
+        return { ok: false, error: 'self_context.type must be cross_session' };
+    }
+    const sessionSelection = parseSessionSelection(value.session_selection);
+    if (!sessionSelection.ok)
+        return sessionSelection;
+    const messageOptions = isRecord(value.message_options)
+        ? value.message_options
+        : undefined;
+    return {
+        ok: true,
+        value: {
+            sourceConversationId: sourceConversationId.value,
+            ...(targetConversationId ? { targetConversationId } : {}),
+            ...(targetUserId ? { targetUserId } : {}),
+            text: text.value,
+            selfContext: {
+                type: 'cross_session',
+                context: context.value,
+            },
+            ...(sessionSelection.value ? { sessionSelection: sessionSelection.value } : {}),
+            ...(messageOptions ? { messageOptions } : {}),
+        },
+    };
+}
+export function parseSetTypingArgs(value) {
+    if (!isRecord(value))
+        return { ok: false, error: 'Arguments must be an object' };
+    const conversationId = requiredString(value, 'conversation_id', 256);
+    if (!conversationId.ok)
+        return conversationId;
+    if (typeof value.typing !== 'boolean') {
+        return { ok: false, error: 'typing must be a boolean' };
+    }
+    const status = value.status;
+    if (status !== undefined && status !== 'typing' && status !== 'thinking') {
+        return { ok: false, error: 'Invalid status' };
+    }
+    return {
+        ok: true,
+        value: {
+            conversationId: conversationId.value,
+            typing: value.typing,
+            ...(status ? { status } : {}),
+        },
+    };
+}

package/dist/register.js

@@ -9,47 +9,10 @@ import { setDefaultResultOrder } from 'node:dns';
  *
  * On approval, saves the agent to ~/.canon/agents.json under the profile name.
  */
-import { ackRegistrationApprovalWith, resolveCanonBaseUrl, runRegistrationFlow, } from '@canonmsg/core/contract';
-import { clearPendingRegistration, getOrCreatePendingRegistration, updatePendingRegistration, upsertAgentProfile, AGENTS_PATH, } from '@canonmsg/core/local';
-import { resolvePackagedBridgeBin } from './bridge-bin.js';
-import { connectBridge } from '@canonmsg/framework';
+import { ackRegistrationApproval, clearPendingRegistration, getOrCreatePendingRegistration, registerAndWaitForApproval, updatePendingRegistration, upsertAgentProfile, AGENTS_PATH, } from '@canonmsg/core';
 import { readFileSync } from 'node:fs';
 import { parseArgs } from 'node:util';
 import { runCli } from './cli-entry.js';
-/**
- * Registration rides the bridge (Phase 6, same shape as the Hermes port): a
- * short-lived PRE-IDENTITY registration daemon (offline stub +
- * CANON_BRIDGE_REGISTRATION_BASE_URL, managed-child so it dies with this
- * process) serves the three unauthenticated §B10 routes over JSON-RPC.
- */
-async function openRegistrationBridge(baseUrl) {
-    return connectBridge({
-        profile: 'registration',
-        mode: 'managed-child',
-        ...(resolvePackagedBridgeBin() ? { binPath: resolvePackagedBridgeBin() } : {}),
-        env: {
-            ...process.env,
-            CANON_BRIDGE_AGENT_ID: 'canon-registration',
-            CANON_BRIDGE_REGISTRATION_BASE_URL: baseUrl,
-        },
-        hello: { clientType: 'claude-code', wantFamilies: [] },
-    });
-}
-function bridgeRegistrationTransport(bridge) {
-    return {
-        register: (_baseUrl, body) => bridge.client.call('register', body),
-        checkStatus: (_baseUrl, requestId, pollToken) => bridge.client.call('getRegistrationStatus', {
-            requestId,
-            ...(pollToken ? { pollToken } : {}),
-        }),
-        ackRegistrationStatus: async (_baseUrl, requestId, pollToken) => {
-            await bridge.client.call('ackRegistrationStatus', {
-                requestId,
-                ...(pollToken ? { pollToken } : {}),
-            });
-        },
-    };
-}
 const HELP = `canon-register — register or reconnect a Claude Code agent in Canon
 
 USAGE
@@ -99,39 +62,29 @@ export async function main() {
     }
     console.log(`Registering agent "${values.name}" (profile: ${profileName})...`);
     const pending = getOrCreatePendingRegistration(profileName, 'claude-code');
-    const baseUrl = resolveCanonBaseUrl(values['base-url']);
-    const bridge = await openRegistrationBridge(baseUrl);
-    const transport = bridgeRegistrationTransport(bridge);
-    let result;
-    try {
-        result = await runRegistrationFlow({
-            name: values.name,
-            description: values.description,
-            ownerPhone: values.phone,
-            developerInfo: 'Claude Code plugin',
-            clientType: 'claude-code',
-            baseUrl: values['base-url'],
-            requestedAgentId: existingAgentId,
-            localRegistrationId: pending.localRegistrationId,
-        }, transport, {
-            onSubmitted: (requestId, pollToken) => {
-                updatePendingRegistration(profileName, {
-                    requestId,
-                    pollToken,
-                    clientType: 'claude-code',
-                });
-                console.log(`Registration submitted (request ID: ${requestId}).`);
-                console.log('Waiting for approval in Canon app...');
-            },
-            onPollUpdate: () => {
-                process.stdout.write('.');
-            },
-        });
-    }
-    catch (error) {
-        bridge.client.close();
-        throw error;
-    }
+    const result = await registerAndWaitForApproval({
+        name: values.name,
+        description: values.description,
+        ownerPhone: values.phone,
+        developerInfo: 'Claude Code plugin',
+        clientType: 'claude-code',
+        baseUrl: values['base-url'],
+        requestedAgentId: existingAgentId,
+        localRegistrationId: pending.localRegistrationId,
+    }, {
+        onSubmitted: (requestId, pollToken) => {
+            updatePendingRegistration(profileName, {
+                requestId,
+                pollToken,
+                clientType: 'claude-code',
+            });
+            console.log(`Registration submitted (request ID: ${requestId}).`);
+            console.log('Waiting for approval in Canon app...');
+        },
+        onPollUpdate: () => {
+            process.stdout.write('.');
+        },
+    });
     console.log(''); // newline after dots
     switch (result.status) {
         case 'approved': {
@@ -148,7 +101,7 @@ export async function main() {
                 ...(typeof values['base-url'] === 'string' ? { baseUrl: values['base-url'] } : {}),
             });
             if (result.requestId) {
-                await ackRegistrationApprovalWith(transport, values['base-url'], result.requestId, result.pollToken);
+                await ackRegistrationApproval(values['base-url'], result.requestId, result.pollToken);
             }
             clearPendingRegistration(profileName);
             console.log(`Approved! Agent: ${result.agentName} (${result.agentId})`);
@@ -168,7 +121,6 @@ export async function main() {
             process.exit(1);
             break;
     }
-    bridge.client.close();
 }
 runCli(import.meta.url, main, (error) => {
     console.error('[canon-register] Fatal error:', error);

package/dist/server.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function main(): Promise<void>;