@canonmsg/claude-code-plugin 0.9.4 → 0.9.6

package/dist/host-runtime.d.ts

@@ -37,6 +37,12 @@ interface HostWorkspaceResolverOption {
     id: string;
     cwd: string;
 }
+export declare const HOST_ADMISSION_ACTION_CAPABILITIES: Readonly<{
+    canStartDirectConversation: false;
+    canSendContactRequest: false;
+    canApprovePendingContactRequests: false;
+    canRejectPendingContactRequests: false;
+}>;
 export declare function buildCanonHostPrompt(input: {
     hostLabel: string;
     content: string;
@@ -82,6 +88,21 @@ export declare function buildHydratedInboundContext(input: {
     hydratedFromPage: boolean;
 };
 export declare function publishHostAgentRuntime(agentId: string, clientType: AgentClientType, runtime: AgentRuntime): Promise<void>;
+export declare function publishHostSessionSnapshots(input: {
+    conversationIds: string[];
+    agentId: string;
+    clientType: AgentClientType;
+    runtime: AgentRuntime;
+    workspaceOptions: HostWorkspaceResolverOption[];
+    defaultCwd: string;
+    liveSessionConfigByConversation?: ReadonlyMap<string, {
+        model?: string;
+        permissionMode?: string;
+        workspaceId?: string;
+        executionMode?: SessionWorkspaceConfig['executionMode'];
+        executionBranch?: string | null;
+    }>;
+}): Promise<void>;
 export declare function readHostSessionConfig<TExtra extends string = never>(raw: unknown, extraStringFields?: readonly TExtra[]): (SessionWorkspaceConfig & Partial<Record<TExtra, string>>) | null;
 export declare function loadHostSessionConfig<TExtra extends string = never>(input: {
     conversationId: string;

package/dist/host-runtime.js

@@ -11,7 +11,13 @@
  * behavior here, update that copy too and adjust the shared golden
  * fixture test (`packages/claude-code-plugin/src/host-runtime.test.ts`).
  */
-import { buildBehaviorPolicyLines, buildParticipationHistorySnapshot, buildWorkSessionsPromptLines, mergeWorkSessionContexts, normalizeOptionalString, readSessionWorkspaceConfig, resolveConfiguredWorkspaceCwd, rtdbRead, rtdbWrite, } from '@canonmsg/core';
+import { buildAgentSessionSnapshot, buildConversationWorktreeSpec, buildBehaviorPolicyLines, buildParticipationHistorySnapshot, buildWorkSessionsPromptLines, mergeWorkSessionContexts, normalizeOptionalString, patchAgentSessionSnapshot, readSessionWorkspaceConfig, resolveConfiguredWorkspaceCwd, rtdbRead, rtdbWrite, } from '@canonmsg/core';
+export const HOST_ADMISSION_ACTION_CAPABILITIES = Object.freeze({
+    canStartDirectConversation: false,
+    canSendContactRequest: false,
+    canApprovePendingContactRequests: false,
+    canRejectPendingContactRequests: false,
+});
 export function buildCanonHostPrompt(input) {
     const resolvedWorkSessions = mergeWorkSessionContexts(input.workSession, input.workSessions);
     return [
@@ -70,7 +76,21 @@ function describeContactCard(card) {
     if (card.about)
         parts.push(`about: ${card.about}`);
     const identity = `📇 Contact card: "${card.displayName}" (${parts.join(' · ')}).`;
-    const hint = `This card is informational only in host mode. Canon does not currently expose a host-side tool here for starting a new direct conversation or sending a contact request to userId ${card.userId}.`;
+    const missingCapabilities = [
+        !HOST_ADMISSION_ACTION_CAPABILITIES.canStartDirectConversation
+            ? 'start a direct conversation'
+            : null,
+        !HOST_ADMISSION_ACTION_CAPABILITIES.canSendContactRequest
+            ? 'send a contact request'
+            : null,
+        !HOST_ADMISSION_ACTION_CAPABILITIES.canApprovePendingContactRequests
+            ? 'approve pending requests'
+            : null,
+        !HOST_ADMISSION_ACTION_CAPABILITIES.canRejectPendingContactRequests
+            ? 'reject pending requests'
+            : null,
+    ].filter(Boolean).join(', ');
+    const hint = `This host can inspect the card, but Canon admission actions are missing here. Missing capabilities: ${missingCapabilities}. Use another Canon surface for userId ${card.userId}.`;
     return `${identity}\n${hint}`;
 }
 function describeAttachment(attachment, materialized) {
@@ -117,6 +137,64 @@ export async function publishHostAgentRuntime(agentId, clientType, runtime) {
         updatedAt: { '.sv': 'timestamp' },
     });
 }
+export async function publishHostSessionSnapshots(input) {
+    if (input.conversationIds.length === 0) {
+        return;
+    }
+    await Promise.all(input.conversationIds.map(async (conversationId) => {
+        const persistedConfig = await loadHostSessionConfig({
+            conversationId,
+            agentId: input.agentId,
+            extraStringFields: ['permissionMode'],
+        });
+        const liveConfig = input.liveSessionConfigByConversation?.get(conversationId) ?? null;
+        const mergedConfig = {
+            ...(persistedConfig ?? {}),
+            ...(liveConfig ?? {}),
+        };
+        const snapshot = buildAgentSessionSnapshot({
+            conversationId,
+            agentId: input.agentId,
+            runtime: {
+                ...input.runtime,
+                clientType: input.clientType,
+                hostMode: true,
+            },
+            sessionConfig: {
+                ...(mergedConfig.model ? { model: mergedConfig.model } : {}),
+                ...(mergedConfig.permissionMode ? { permissionMode: mergedConfig.permissionMode } : {}),
+                ...(mergedConfig.workspaceId ? { workspaceId: mergedConfig.workspaceId } : {}),
+                ...(mergedConfig.executionMode ? { executionMode: mergedConfig.executionMode } : {}),
+            },
+            lastHeartbeatAt: undefined,
+        });
+        let executionBranch = liveConfig?.executionBranch ?? null;
+        if (!executionBranch && snapshot.executionMode === 'worktree' && snapshot.workspaceId) {
+            const workspace = input.workspaceOptions.find((option) => option.id === snapshot.workspaceId);
+            if (workspace) {
+                executionBranch = buildConversationWorktreeSpec({
+                    agentId: input.agentId,
+                    conversationId,
+                    workspaceCwd: workspace.cwd,
+                }).branch;
+            }
+        }
+        return patchAgentSessionSnapshot(conversationId, input.agentId, {
+            clientType: input.clientType,
+            hostMode: true,
+            model: snapshot.model ?? null,
+            permissionMode: snapshot.permissionMode ?? null,
+            workspaceId: snapshot.workspaceId ?? null,
+            executionMode: snapshot.executionMode ?? null,
+            executionBranch,
+            modelOptions: snapshot.modelOptions,
+            permissionModeOptions: snapshot.permissionModeOptions,
+            workspaceOptions: snapshot.workspaceOptions,
+            availableExecutionModes: snapshot.availableExecutionModes,
+            lastHeartbeatAt: { '.sv': 'timestamp' },
+        });
+    }));
+}
 export function readHostSessionConfig(raw, extraStringFields = []) {
     const baseConfig = readSessionWorkspaceConfig(raw);
     if (!raw || typeof raw !== 'object') {

package/dist/host.js

@@ -26,8 +26,8 @@ import { execFileSync } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import { isAnthropicImageAttachment, materializeMessageMedia, toAnthropicImageBlock, } from '@canonmsg/agent-sdk';
-import { buildConfiguredWorkspaceOptions, buildConversationEnvironmentKey, buildPublicWorkspaceOptions, EXECUTION_ENVIRONMENT_MODES, CanonClient, CanonStream, clearTurnState, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, DEFAULT_RUNTIME_CAPABILITIES, ExecutionEnvironmentError, FINAL_MESSAGE_HANDOFF_MS, normalizeTurnMetadata, prepareConversationEnvironment, resolveCanonAgent, getActiveProfile, releaseLock, initRTDBAuth, rtdbRead, rtdbWrite, writeSessionState, clearSessionState, writeTurnState, releaseConversationEnvironment, } from '@canonmsg/core';
-import { buildCanonHostPrompt, buildHydratedInboundContext, createConversationMetadataLoader, loadHostSessionConfig, publishHostAgentRuntime, renderCanonHostInboundContent, resolveHostWorkspaceCwd, } from './host-runtime.js';
+import { CLAUDE_PERMISSION_MODE_OPTIONS, buildConfiguredWorkspaceOptions, buildConversationEnvironmentKey, buildPlanApprovalRequest, buildQuestionRequest, buildPublicWorkspaceOptions, EXECUTION_ENVIRONMENT_MODES, CanonClient, CanonStream, clearTurnState, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, DEFAULT_RUNTIME_CAPABILITIES, ExecutionEnvironmentError, FINAL_MESSAGE_HANDOFF_MS, normalizeTurnMetadata, prepareConversationEnvironment, resolveCanonAgent, getActiveProfile, releaseLock, initRTDBAuth, rtdbRead, rtdbWrite, writeSessionState, clearSessionState, writeTurnState, releaseConversationEnvironment, } from '@canonmsg/core';
+import { buildCanonHostPrompt, buildHydratedInboundContext, createConversationMetadataLoader, loadHostSessionConfig, publishHostAgentRuntime, publishHostSessionSnapshots, renderCanonHostInboundContent, resolveHostWorkspaceCwd, } from './host-runtime.js';
 import { buildInboundContextLines, decideAutoReply, } from './inbound-policy.js';
 import { createStreamingBuffer } from './streaming-buffer.js';
 import { runCli } from './cli-entry.js';
@@ -222,7 +222,7 @@ function createSession(conversationId, environment, agentId, client, onSessionEn
     // eslint-disable-next-line prefer-const -- session must be declared before queryOptions but assigned after query()
     let session;
     const REPLY_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
-    function waitForReply() {
+    function waitForReply(type, requestId) {
         // Keep session alive while waiting for user input
         session.lastActivity = Date.now();
         return new Promise((resolve, reject) => {
@@ -231,6 +231,8 @@ function createSession(conversationId, environment, agentId, client, onSessionEn
                 reject(new Error('Timed out waiting for user reply'));
             }, REPLY_TIMEOUT_MS);
             session.pendingReply = {
+                type,
+                requestId,
                 resolve: (metadata) => {
                     clearTimeout(timer);
                     resolve(metadata);
@@ -260,17 +262,16 @@ function createSession(conversationId, environment, agentId, client, onSessionEn
                 try {
                     const questionId = randomUUID();
                     const questions = input.questions ?? [];
-                    await client.sendMessage(conversationId, '', {
+                    const questionCard = buildQuestionRequest(questionId, questions);
+                    await client.sendMessage(conversationId, questionCard.text, {
                         metadata: {
-                            type: 'claude_question',
-                            questionId,
-                            questions,
+                            ...questionCard.metadata,
                             turnSemantics: 'control',
                             replyBehavior: 'suppress_auto_reply',
                         },
                     });
                     console.error(`[canon-host] [${conversationId.slice(0, 8)}] Question sent (${questionId.slice(0, 8)})`);
-                    const reply = await waitForReply();
+                    const reply = await waitForReply('question_reply', questionId);
                     return {
                         behavior: 'allow',
                         updatedInput: { ...input, answers: reply.answers },
@@ -283,16 +284,16 @@ function createSession(conversationId, environment, agentId, client, onSessionEn
             if (toolName === 'ExitPlanMode') {
                 try {
                     const planId = randomUUID();
-                    await client.sendMessage(conversationId, 'Plan ready for review.', {
+                    const planApproval = buildPlanApprovalRequest(planId);
+                    await client.sendMessage(conversationId, planApproval.text, {
                         metadata: {
-                            type: 'plan_approval',
-                            planId,
+                            ...planApproval.metadata,
                             turnSemantics: 'control',
                             replyBehavior: 'suppress_auto_reply',
                         },
                     });
                     console.error(`[canon-host] [${conversationId.slice(0, 8)}] Plan approval sent (${planId.slice(0, 8)})`);
-                    const reply = await waitForReply();
+                    const reply = await waitForReply('plan_approval_reply', planId);
                     if (reply.decision === 'approve') {
                         return { behavior: 'allow' };
                     }
@@ -755,15 +756,45 @@ export async function main() {
     let runtimeDescriptor = {
         defaultWorkspaceId: workspaceOptions[0]?.id,
         defaultPermissionMode: 'default',
+        availablePermissionModes: [...CLAUDE_PERMISSION_MODE_OPTIONS],
         availableWorkspaces: buildPublicWorkspaceOptions(workspaceOptions),
         availableExecutionModes: hostAvailableExecutionModes,
     };
+    const conversationCache = new Map();
+    const knownConversationIds = new Set();
+    let lastKnownConversationRefreshAt = 0;
     const publishRuntimeHeartbeat = async () => {
         if (!streamConnected)
             return;
+        await refreshKnownConversationIds().catch((error) => {
+            console.error('[canon-host] Failed to refresh known conversations:', error);
+        });
         await publishAgentRuntime(agentId, runtimeDescriptor).catch((error) => {
             console.error('[canon-host] Failed to publish agent runtime:', error);
         });
+        await publishHostSessionSnapshots({
+            conversationIds: Array.from(knownConversationIds),
+            agentId,
+            clientType: 'claude-code',
+            runtime: runtimeDescriptor,
+            workspaceOptions,
+            defaultCwd: workingDir,
+            liveSessionConfigByConversation: new Map(Array.from(sessions.values()).map((session) => {
+                const workspaceId = resolveWorkspaceIdForBaseCwd(session.environment.baseCwd);
+                return [
+                    session.conversationId,
+                    {
+                        ...(session.state.model ? { model: session.state.model } : {}),
+                        ...(session.state.permissionMode ? { permissionMode: session.state.permissionMode } : {}),
+                        ...(workspaceId ? { workspaceId } : {}),
+                        executionMode: session.environment.mode,
+                        executionBranch: session.environment.branch ?? null,
+                    },
+                ];
+            })),
+        }).catch((error) => {
+            console.error('[canon-host] Failed to publish session snapshots:', error);
+        });
     };
     // ── Load conversations (informational — sessions created on demand) ──
     try {
@@ -772,6 +803,7 @@ export async function main() {
             defaultWorkspaceId: workspaceOptions[0]?.id,
             defaultModel: runtimeModels[0]?.value,
             defaultPermissionMode: 'default',
+            availablePermissionModes: [...CLAUDE_PERMISSION_MODE_OPTIONS],
             availableModels: runtimeModels,
             availableWorkspaces: buildPublicWorkspaceOptions(workspaceOptions),
             availableExecutionModes: hostAvailableExecutionModes,
@@ -781,12 +813,18 @@ export async function main() {
         runtimeDescriptor = {
             defaultWorkspaceId: workspaceOptions[0]?.id,
             defaultPermissionMode: 'default',
+            availablePermissionModes: [...CLAUDE_PERMISSION_MODE_OPTIONS],
             availableWorkspaces: buildPublicWorkspaceOptions(workspaceOptions),
             availableExecutionModes: hostAvailableExecutionModes,
         };
     }
     try {
         const convos = await client.getConversations();
+        lastKnownConversationRefreshAt = Date.now();
+        for (const conversation of convos) {
+            knownConversationIds.add(conversation.id);
+            conversationCache.set(conversation.id, conversation);
+        }
         console.error(`[canon-host] ${convos.length} conversations`);
     }
     catch {
@@ -797,11 +835,25 @@ export async function main() {
     const pendingSessionCreations = new Map();
     /** Saved SDK session IDs for resume after idle eviction, keyed by conversation + workspace */
     const savedSessionIds = new Map();
-    const conversationCache = new Map();
     const { getConversationMeta } = createConversationMetadataLoader({
         client,
         conversationCache,
     });
+    function resolveWorkspaceIdForBaseCwd(baseCwd) {
+        return workspaceOptions.find((option) => option.cwd === baseCwd)?.id;
+    }
+    async function refreshKnownConversationIds(force = false) {
+        if (!force && Date.now() - lastKnownConversationRefreshAt < HEARTBEAT_MS) {
+            return;
+        }
+        const conversations = await client.getConversations();
+        knownConversationIds.clear();
+        for (const conversation of conversations) {
+            knownConversationIds.add(conversation.id);
+            conversationCache.set(conversation.id, conversation);
+        }
+        lastKnownConversationRefreshAt = Date.now();
+    }
     async function loadHydratedInboundContext(input) {
         const [conversation, page] = await Promise.all([
             getConversationMeta(input.conversationId),
@@ -862,6 +914,7 @@ export async function main() {
         }
     }
     async function getOrCreateSession(conversationId) {
+        knownConversationIds.add(conversationId);
         const existing = sessions.get(conversationId);
         if (existing && !existing.closed) {
             existing.lastActivity = Date.now();
@@ -934,15 +987,33 @@ export async function main() {
                 if (m.senderId === agentId)
                     return;
                 const convoId = payload.conversationId;
+                knownConversationIds.add(convoId);
                 // Check for metadata replies (question answers, plan approvals)
                 if (m.metadata?.type === 'question_reply' || m.metadata?.type === 'plan_approval_reply') {
                     const existingSession = sessions.get(convoId);
+                    const pendingReply = existingSession?.pendingReply;
+                    const isOwnerReply = m.isOwner ?? (ownerId != null && m.senderId === ownerId);
+                    const replyRequestId = m.metadata.type === 'question_reply'
+                        ? m.metadata.questionId
+                        : m.metadata.planId;
+                    if (!pendingReply) {
+                        console.error(`[canon-host] [${convoId.slice(0, 8)}] Ignoring stale ${m.metadata.type} with no pending request`);
+                        return;
+                    }
+                    if (!isOwnerReply) {
+                        console.error(`[canon-host] [${convoId.slice(0, 8)}] Ignoring ${m.metadata.type} from non-owner ${m.senderId}`);
+                        return;
+                    }
+                    if (pendingReply.type !== m.metadata.type || pendingReply.requestId !== replyRequestId) {
+                        console.error(`[canon-host] [${convoId.slice(0, 8)}] Ignoring mismatched ${m.metadata.type} (${String(replyRequestId ?? 'missing-id')})`);
+                        return;
+                    }
                     if (existingSession?.pendingReply) {
                         const { resolve } = existingSession.pendingReply;
                         existingSession.pendingReply = null;
                         existingSession.lastActivity = Date.now();
                         resolve(m.metadata);
-                        console.error(`[canon-host] [${convoId.slice(0, 8)}] Reply received (${m.metadata.type})`);
+                        console.error(`[canon-host] [${convoId.slice(0, 8)}] Reply received (${m.metadata.type}:${pendingReply.requestId.slice(0, 8)})`);
                         return;
                     }
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/claude-code-plugin",
-  "version": "0.9.4",
+  "version": "0.9.6",
   "description": "Canon channel plugin for Claude Code — messaging where AI agents are first-class citizens",
   "type": "module",
   "main": "dist/index.js",
@@ -23,15 +23,16 @@
     ".claude-plugin"
   ],
   "scripts": {
-    "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc",
-    "dev": "tsc --watch",
+    "prepare:workspace-deps": "npm --prefix ../core run build && npm --prefix ../agent-sdk run build",
+    "build": "npm run prepare:workspace-deps && node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc",
+    "dev": "npm run prepare:workspace-deps && tsc --watch",
     "prepack": "npm run build",
     "test": "vitest run"
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.101",
-    "@canonmsg/agent-sdk": "^0.8.2",
-    "@canonmsg/core": "^0.7.3",
+    "@canonmsg/agent-sdk": "^0.8.3",
+    "@canonmsg/core": "^0.7.5",
     "@modelcontextprotocol/sdk": "^1.12.0"
   },
   "engines": {