@canonmsg/claude-code-plugin 0.3.0 → 0.5.0

package/dist/host.js

@@ -23,32 +23,12 @@ setDefaultResultOrder('ipv4first');
  */
 import { parseArgs } from 'node:util';
 import { randomUUID } from 'node:crypto';
-import { basename, resolve } from 'node:path';
 import { query } from '@anthropic-ai/claude-agent-sdk';
-import { CanonClient, CanonStream, resolveCanonAgent, getActiveProfile, releaseLock, initRTDBAuth, rtdbRead, rtdbWrite, writeSessionState, clearSessionState, } from '@canonmsg/core';
+import { buildParticipationHistorySnapshot, buildBehaviorPolicyLines, buildConfiguredWorkspaceOptions, buildConversationEnvironmentKey, buildPublicWorkspaceOptions, isEnabledFlag, normalizeOptionalString, readSessionWorkspaceConfig, resolveConfiguredWorkspaceCwd, 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 { buildInboundContextLines, decideAutoReply, } from './inbound-policy.js';
 let workingDir = process.cwd();
 let workspaceOptions = [];
 let runtimeModels = [];
-function normalizeString(value) {
-    if (typeof value !== 'string')
-        return undefined;
-    const trimmed = value.trim();
-    return trimmed ? trimmed : undefined;
-}
-function buildWorkspaceOptions(primaryCwd, configured) {
-    const uniqueDirs = Array.from(new Set([primaryCwd, ...configured].map((dir) => resolve(dir))));
-    const seenLabels = new Map();
-    return uniqueDirs.map((cwd, index) => {
-        const baseLabel = basename(cwd) || cwd;
-        const seenCount = (seenLabels.get(baseLabel) ?? 0) + 1;
-        seenLabels.set(baseLabel, seenCount);
-        return {
-            id: index === 0 ? 'default' : `workspace-${index + 1}`,
-            label: seenCount === 1 ? baseLabel : `${baseLabel} (${seenCount})`,
-            cwd,
-        };
-    });
-}
 function toModelOptions(models) {
     return models.map((model) => ({
         value: model.value,
@@ -65,32 +45,22 @@ async function publishAgentRuntime(agentId, runtime) {
 }
 async function loadSessionConfig(conversationId, agentId) {
     const raw = await rtdbRead(`/session-config/${conversationId}/${agentId}`);
+    const baseConfig = readSessionWorkspaceConfig(raw);
     if (!raw || typeof raw !== 'object')
-        return null;
+        return baseConfig;
     const data = raw;
-    const permissionMode = normalizeString(data.permissionMode);
+    const permissionMode = normalizeOptionalString(data.permissionMode);
     return {
-        workspaceId: normalizeString(data.workspaceId),
-        legacyCwd: normalizeString(data.cwd),
-        model: normalizeString(data.model),
+        ...baseConfig,
         permissionMode: permissionMode,
     };
 }
 function resolveWorkspaceCwd(config) {
-    if (config?.workspaceId) {
-        const workspace = workspaceOptions.find((option) => option.id === config.workspaceId);
-        if (workspace)
-            return workspace.cwd;
-    }
-    if (config?.legacyCwd) {
-        const workspace = workspaceOptions.find((option) => option.cwd === config.legacyCwd);
-        if (workspace)
-            return workspace.cwd;
-    }
-    return workspaceOptions[0]?.cwd ?? workingDir;
-}
-function toPublicWorkspaceOptions() {
-    return workspaceOptions.map(({ id, label }) => ({ id, label }));
+    return resolveConfiguredWorkspaceCwd({
+        workspaceOptions,
+        config,
+        defaultCwd: workingDir,
+    });
 }
 async function detectRuntimeModels(cwd) {
     const emptyPrompt = {
@@ -124,18 +94,25 @@ const STREAMING_THROTTLE_MS = 250;
 const HEARTBEAT_MS = 30_000;
 const IDLE_CHECK_MS = 60_000;
 const CONTROL_POLL_MS = 2000;
+const FINAL_DELIVERY_RETRY_MS = 2_000;
+const CLAUDE_RUNTIME_CAPABILITIES = {
+    ...DEFAULT_RUNTIME_CAPABILITIES,
+    supportsInterrupt: true,
+    supportsQueue: true,
+    supportsInterleave: true,
+    supportsRequiresAction: true,
+    supportsNonFinalPermanentMessages: false,
+};
 function buildCanonPrompt(input) {
-    const ownerLine = input.isOwner
-        ? 'The sender is the verified human owner of this Canon agent.'
-        : 'The sender is a Canon user in this conversation.';
     return [
         'You are connected to Canon messaging through a Claude Code host wrapper.',
-        'Reply naturally to the Canon user.',
         'Only the last assistant message from this turn will be delivered as the permanent Canon reply.',
         'Short intermediate assistant messages may be shown as ephemeral status while you work.',
-        ownerLine,
+        ...buildInboundContextLines(input.participantContext),
+        ...buildBehaviorPolicyLines(input.behavior),
+        'Canon participants may be humans or AI agents.',
+        'Honor the Canon behavior policy above when deciding how proactively to participate.',
         `Conversation ID: ${input.conversationId}`,
-        `Sender: ${input.senderName}`,
         '',
         'New Canon message:',
         input.content,
@@ -143,7 +120,25 @@ function buildCanonPrompt(input) {
 }
 function renderInboundContent(message) {
     let content = message.text || '';
-    if (message.contentType === 'audio' && message.audioUrl) {
+    const attachment = message.attachments?.[0];
+    if (attachment?.kind === 'audio' && attachment.url) {
+        const duration = attachment.durationMs ? ` (${Math.round(attachment.durationMs / 1000)}s)` : '';
+        content = content
+            ? `[Voice message${duration}: ${attachment.url}]\n${content}`
+            : `[Voice message${duration}: ${attachment.url}]`;
+    }
+    else if (attachment?.kind === 'image' && attachment.url) {
+        content = content
+            ? `[Image: ${attachment.url}]\n${content}`
+            : `[Image: ${attachment.url}]`;
+    }
+    else if (attachment?.kind === 'file' && attachment.url) {
+        const label = attachment.fileName || 'File';
+        content = content
+            ? `[File: ${label} ${attachment.url}]\n${content}`
+            : `[File: ${label} ${attachment.url}]`;
+    }
+    else if (message.contentType === 'audio' && message.audioUrl) {
         const duration = message.audioDurationMs ? ` (${Math.round(message.audioDurationMs / 1000)}s)` : '';
         content = content
             ? `[Voice message${duration}: ${message.audioUrl}]\n${content}`
@@ -157,7 +152,8 @@ function renderInboundContent(message) {
     return content || '[Empty message]';
 }
 // ── Session factory ─────────────────────────────────────────────────
-function createSession(conversationId, cwd, agentId, client, onSessionEnd, config, resumeSessionId) {
+function createSession(conversationId, environment, agentId, client, onSessionEnd, config, resumeSessionId) {
+    const { cwd } = environment;
     // Per-session input stream with message queue
     let resolveInput = null;
     let inputDone = false;
@@ -173,6 +169,9 @@ function createSession(conversationId, cwd, agentId, client, onSessionEnd, confi
             messageQueue.push(msg);
         }
     };
+    let enqueueInboundMessage = (msg, _intent = 'queue', _sourceMessageId, _markAccepted = false) => {
+        sendInput(msg);
+    };
     const inputStream = {
         [Symbol.asyncIterator]() {
             return {
@@ -232,6 +231,8 @@ function createSession(conversationId, cwd, agentId, client, onSessionEnd, confi
                             type: 'claude_question',
                             questionId,
                             questions,
+                            turnSemantics: 'control',
+                            replyBehavior: 'suppress_auto_reply',
                         },
                     });
                     console.error(`[canon-host] [${conversationId.slice(0, 8)}] Question sent (${questionId.slice(0, 8)})`);
@@ -249,7 +250,12 @@ function createSession(conversationId, cwd, agentId, client, onSessionEnd, confi
                 try {
                     const planId = randomUUID();
                     await client.sendMessage(conversationId, 'Plan ready for review.', {
-                        metadata: { type: 'plan_approval', planId },
+                        metadata: {
+                            type: 'plan_approval',
+                            planId,
+                            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();
@@ -279,8 +285,10 @@ function createSession(conversationId, cwd, agentId, client, onSessionEnd, confi
     session = {
         conversationId,
         cwd,
+        environment,
         query: q,
         sendInput,
+        enqueueInbound: (msg, intent = 'queue', sourceMessageId, markAccepted = false) => enqueueInboundMessage(msg, intent, sourceMessageId, markAccepted),
         state: {
             model: config.model,
             permissionMode: config.permissionMode,
@@ -289,7 +297,17 @@ function createSession(conversationId, cwd, agentId, client, onSessionEnd, confi
         availableModels: config.availableModels,
         streamingText: '',
         streamingTimer: null,
+        idleResetTimer: null,
+        finalDeliveryTimer: null,
         seedResponseHandled: !!resumeSessionId, // Resumed sessions don't need seed handling
+        pendingInputs: [],
+        pendingFinalText: null,
+        pendingFinalDeliveryText: null,
+        toolInProgress: false,
+        turnState: 'idle',
+        currentTurnId: null,
+        currentTurnOpenedAt: null,
+        lastAcceptedIntent: null,
         lastActivity: Date.now(),
         closed: false,
         sdkSessionId: resumeSessionId || null,
@@ -322,15 +340,157 @@ function createSession(conversationId, cwd, agentId, client, onSessionEnd, confi
         session.streamingText = '';
         rtdbWrite(`/streaming/${conversationId}/${agentId}`, null).catch(() => { });
     }
+    function clearIdleResetTimer() {
+        if (!session.idleResetTimer)
+            return;
+        clearTimeout(session.idleResetTimer);
+        session.idleResetTimer = null;
+    }
+    function clearFinalDeliveryTimer() {
+        if (!session.finalDeliveryTimer)
+            return;
+        clearTimeout(session.finalDeliveryTimer);
+        session.finalDeliveryTimer = null;
+    }
+    function resetTurnToIdle() {
+        if (session.closed)
+            return;
+        clearFinalDeliveryTimer();
+        session.currentTurnId = null;
+        session.currentTurnOpenedAt = null;
+        session.lastAcceptedIntent = null;
+        session.pendingFinalText = null;
+        session.pendingFinalDeliveryText = null;
+        session.toolInProgress = false;
+        session.turnState = 'idle';
+        writeTurn();
+        drainPendingInput();
+    }
+    function scheduleFinalHandoffReset() {
+        clearIdleResetTimer();
+        session.idleResetTimer = setTimeout(() => {
+            session.idleResetTimer = null;
+            client.setTyping(conversationId, false).catch(() => { });
+            clearStreaming();
+            resetTurnToIdle();
+        }, FINAL_MESSAGE_HANDOFF_MS);
+    }
+    function markPendingFinalDelivery(finalText) {
+        clearIdleResetTimer();
+        session.pendingFinalText = finalText;
+        session.pendingFinalDeliveryText = finalText;
+        session.state.state = 'running';
+        session.turnState = 'streaming';
+        session.streamingText = finalText;
+        flushStreaming();
+        writeState();
+        writeTurn();
+        client.setTyping(conversationId, true, 'typing').catch(() => { });
+    }
+    async function deliverFinalReply(finalText) {
+        try {
+            await client.sendMessage(conversationId, finalText, {
+                metadata: {
+                    turnId: session.currentTurnId,
+                    turnSemantics: 'turn_complete',
+                    turnComplete: true,
+                    deliveryIntent: session.lastAcceptedIntent ?? undefined,
+                },
+            });
+            session.state.state = 'idle';
+            session.pendingFinalDeliveryText = null;
+            clearFinalDeliveryTimer();
+            writeState();
+            console.error(`[canon-host] [${conversationId.slice(0, 8)}] Sent final reply (${finalText.length} chars)`);
+            return true;
+        }
+        catch (err) {
+            markPendingFinalDelivery(finalText);
+            console.error(`[canon-host] [${conversationId.slice(0, 8)}] Failed to send final reply:`, err);
+            return false;
+        }
+    }
+    function scheduleFinalDeliveryRetry(finalText) {
+        if (session.closed || session.pendingFinalDeliveryText !== finalText)
+            return;
+        clearFinalDeliveryTimer();
+        session.finalDeliveryTimer = setTimeout(() => {
+            session.finalDeliveryTimer = null;
+            void deliverFinalReply(finalText).then((sent) => {
+                if (sent) {
+                    scheduleFinalHandoffReset();
+                    return;
+                }
+                scheduleFinalDeliveryRetry(finalText);
+            });
+        }, FINAL_DELIVERY_RETRY_MS);
+    }
     function writeState() {
         writeSessionState(conversationId, agentId, {
             ...session.state,
             ...(session.availableModels.length ? { availableModels: session.availableModels } : {}),
             cwd,
+            executionMode: session.environment.mode,
+            ...(session.environment.branch ? { executionBranch: session.environment.branch } : {}),
             hostMode: true,
             isActive: true,
         }).catch(() => { });
     }
+    function writeTurn() {
+        writeTurnState(conversationId, agentId, {
+            turnId: session.currentTurnId,
+            state: session.turnState,
+            queueDepth: session.pendingInputs.length,
+            currentSpeakerId: agentId,
+            lastAcceptedIntent: session.lastAcceptedIntent,
+            capabilities: CLAUDE_RUNTIME_CAPABILITIES,
+            ...(session.currentTurnOpenedAt ? { openedAt: session.currentTurnOpenedAt } : {}),
+            ...(session.turnState === 'idle' || session.turnState === 'completed' || session.turnState === 'interrupted'
+                ? { completedAt: { '.sv': 'timestamp' } }
+                : {}),
+        }).catch(() => { });
+    }
+    async function markQueuedMessageAccepted(sourceMessageId, markAccepted) {
+        if (!markAccepted || !sourceMessageId)
+            return;
+        await client.updateMessageDisposition(conversationId, sourceMessageId, 'accepted_now').catch(() => { });
+    }
+    function drainPendingInput() {
+        if (session.closed || session.state.state === 'running' || session.pendingInputs.length === 0)
+            return;
+        const next = session.pendingInputs.shift();
+        if (!next)
+            return;
+        session.lastAcceptedIntent = next.intent;
+        writeTurn();
+        void markQueuedMessageAccepted(next.sourceMessageId, next.markAccepted)
+            .finally(() => sendInput(next.msg));
+    }
+    enqueueInboundMessage = (msg, intent = 'queue', sourceMessageId = null, markAccepted = false) => {
+        session.lastActivity = Date.now();
+        if (session.pendingFinalDeliveryText) {
+            session.pendingInputs.push({ msg, intent, sourceMessageId, markAccepted });
+            writeTurn();
+            return;
+        }
+        if (session.state.state === 'running' && intent !== 'interrupt') {
+            session.pendingInputs.push({ msg, intent, sourceMessageId, markAccepted });
+            writeTurn();
+            return;
+        }
+        if (session.state.state === 'running' && intent === 'interrupt') {
+            session.pendingInputs.unshift({ msg, intent, sourceMessageId, markAccepted });
+            session.turnState = 'interrupted';
+            writeTurn();
+            void session.query.interrupt().catch(() => { });
+            return;
+        }
+        session.lastAcceptedIntent = intent;
+        writeTurn();
+        void markQueuedMessageAccepted(sourceMessageId, markAccepted)
+            .finally(() => sendInput(msg));
+    };
+    writeTurn();
     // ── Process SDK output messages ──
     const processMessages = async () => {
         try {
@@ -351,21 +511,29 @@ function createSession(conversationId, cwd, agentId, client, onSessionEnd, confi
                             .filter((b) => b.type === 'text')
                             .map((b) => b.text);
                         const fullText = textBlocks.join('\n').trim();
-                        clearStreaming();
                         if (fullText) {
-                            try {
-                                await client.sendMessage(conversationId, fullText);
-                                console.error(`[canon-host] [${conversationId.slice(0, 8)}] Sent reply (${fullText.length} chars)`);
-                            }
-                            catch (err) {
-                                console.error(`[canon-host] [${conversationId.slice(0, 8)}] Failed to send reply:`, err);
-                            }
+                            session.pendingFinalText = fullText;
                         }
                         break;
                     }
                     case 'stream_event': {
                         const event = msg.event;
-                        if (event?.type === 'content_block_delta' && event.delta?.type === 'text_delta') {
+                        if (event?.type === 'content_block_start' && event.content_block?.type === 'tool_use') {
+                            session.toolInProgress = true;
+                            session.turnState = 'tool';
+                            writeTurn();
+                        }
+                        else if (event?.type === 'content_block_stop' && session.toolInProgress) {
+                            session.toolInProgress = false;
+                            if (session.state.state === 'running') {
+                                session.turnState = 'thinking';
+                                writeTurn();
+                            }
+                        }
+                        else if (event?.type === 'content_block_delta' && event.delta?.type === 'text_delta') {
+                            session.toolInProgress = false;
+                            session.turnState = 'streaming';
+                            writeTurn();
                             onStreamDelta(event.delta.text);
                         }
                         break;
@@ -376,16 +544,32 @@ function createSession(conversationId, cwd, agentId, client, onSessionEnd, confi
                             const state = msg.state;
                             session.state.state = state;
                             if (state === 'running') {
+                                clearIdleResetTimer();
+                                if (!session.currentTurnId) {
+                                    session.currentTurnId = randomUUID();
+                                    session.currentTurnOpenedAt = Date.now();
+                                }
+                                session.state.contextUsage = undefined;
+                                session.pendingFinalText = null;
+                                session.toolInProgress = false;
+                                session.turnState = 'thinking';
                                 client.setTyping(conversationId, true, 'thinking').catch(() => { });
                             }
                             else if (state === 'idle') {
                                 client.setTyping(conversationId, false).catch(() => { });
-                                clearStreaming();
                             }
                             else if (state === 'requires_action') {
+                                clearIdleResetTimer();
+                                if (!session.currentTurnId) {
+                                    session.currentTurnId = randomUUID();
+                                    session.currentTurnOpenedAt = Date.now();
+                                }
+                                session.toolInProgress = false;
+                                session.turnState = 'waiting_input';
                                 client.setTyping(conversationId, false).catch(() => { });
                             }
                             writeState();
+                            writeTurn();
                         }
                         break;
                     }
@@ -395,24 +579,30 @@ function createSession(conversationId, cwd, agentId, client, onSessionEnd, confi
                         if (resultSessionId)
                             session.sdkSessionId = resultSessionId;
                         console.error(`[canon-host] [${conversationId.slice(0, 8)}] Turn complete (${msg.subtype})`);
+                        const resultText = typeof msg.result === 'string'
+                            ? msg.result.trim()
+                            : '';
+                        const finalText = resultText || session.pendingFinalText?.trim() || null;
+                        const finalDelivered = finalText ? await deliverFinalReply(finalText) : true;
                         try {
                             const usage = await q.getContextUsage();
-                            writeSessionState(conversationId, agentId, {
-                                ...session.state,
-                                state: 'idle',
-                                contextUsage: {
-                                    percentage: usage.percentage,
-                                    totalTokens: usage.totalTokens,
-                                    maxTokens: usage.maxTokens,
-                                },
-                                cwd,
-                                hostMode: true,
-                                isActive: true,
-                            }).catch(() => { });
+                            session.state.contextUsage = {
+                                percentage: usage.percentage,
+                                totalTokens: usage.totalTokens,
+                                maxTokens: usage.maxTokens,
+                            };
+                            session.state.state = finalDelivered ? 'idle' : session.state.state;
+                            writeState();
                         }
                         catch {
                             // Non-fatal
                         }
+                        if (finalDelivered) {
+                            scheduleFinalHandoffReset();
+                        }
+                        else if (finalText) {
+                            scheduleFinalDeliveryRetry(finalText);
+                        }
                         break;
                     }
                     default:
@@ -448,7 +638,7 @@ function createSession(conversationId, cwd, agentId, client, onSessionEnd, confi
                 type: 'user',
                 message: {
                     role: 'user',
-                    content: 'You are connected to Canon messaging. Messages from users will arrive as follow-up messages. Respond naturally — your text responses will be sent back to the conversation. You have full Claude Code capabilities (file read/write, bash, etc).',
+                    content: 'You are connected to Canon messaging. Follow-up messages in this session come from Canon participants, and your text responses will be sent back to the conversation. You have full Claude Code capabilities (file read/write, bash, etc).',
                 },
                 parent_tool_use_id: null,
             });
@@ -464,12 +654,14 @@ function createSession(conversationId, cwd, agentId, client, onSessionEnd, confi
                 defaultModel: session.state.model ?? modelList[0]?.value,
                 defaultPermissionMode: 'default',
                 availableModels: modelList,
-                availableWorkspaces: toPublicWorkspaceOptions(),
+                availableWorkspaces: buildPublicWorkspaceOptions(workspaceOptions),
             }).catch(() => { });
             writeSessionState(conversationId, agentId, {
                 ...session.state,
                 availableModels: modelList,
                 cwd,
+                executionMode: session.environment.mode,
+                ...(session.environment.branch ? { executionBranch: session.environment.branch } : {}),
                 hostMode: true,
                 isActive: true,
             }).catch(() => { });
@@ -478,7 +670,8 @@ function createSession(conversationId, cwd, agentId, client, onSessionEnd, confi
         catch {
             writeState();
         }
-        console.error(`[canon-host] [${conversationId.slice(0, 8)}] Session ${resumeSessionId ? 'resumed' : 'started'} (cwd: ${cwd})`);
+        console.error(`[canon-host] [${conversationId.slice(0, 8)}] Session ${resumeSessionId ? 'resumed' : 'started'} `
+            + `(mode: ${environment.mode}, cwd: ${cwd})`);
     };
     init().catch((err) => console.error(`[canon-host] [${conversationId.slice(0, 8)}] Init failed:`, err));
     return session;
@@ -489,12 +682,17 @@ async function main() {
         options: {
             cwd: { type: 'string' },
             workspace: { type: 'string', multiple: true },
+            'enable-worktrees': { type: 'boolean' },
         },
         strict: false,
     });
     workingDir = (typeof args.cwd === 'string' ? args.cwd : null) || process.cwd();
     const configuredWorkspaces = (args.workspace ?? []).filter((value) => typeof value === 'string');
-    workspaceOptions = buildWorkspaceOptions(workingDir, configuredWorkspaces);
+    workspaceOptions = buildConfiguredWorkspaceOptions(workingDir, configuredWorkspaces);
+    const allowWorktrees = isEnabledFlag(args['enable-worktrees'] ?? process.env.CANON_ENABLE_WORKTREES);
+    if (!allowWorktrees) {
+        console.error('[canon-host] Worktree isolation is disabled; sessions will lock their selected workspace unless explicitly enabled.');
+    }
     const { apiKey, agentId: profileAgentId, profile } = resolveCanonAgent({ logPrefix: '[canon-host]' });
     console.error(`[canon-host] Starting${profile ? ` (profile: ${profile})` : ''} in ${workingDir}`);
     // ── Canon API client + RTDB auth ──
@@ -526,7 +724,7 @@ async function main() {
             defaultModel: runtimeModels[0]?.value,
             defaultPermissionMode: 'default',
             availableModels: runtimeModels,
-            availableWorkspaces: toPublicWorkspaceOptions(),
+            availableWorkspaces: buildPublicWorkspaceOptions(workspaceOptions),
         });
     }
     catch (error) {
@@ -542,21 +740,77 @@ async function main() {
     // ── Session manager ──
     const sessions = new Map();
     const pendingSessionCreations = new Map();
-    /** Saved SDK session IDs for resume after idle eviction */
+    /** Saved SDK session IDs for resume after idle eviction, keyed by conversation + workspace */
     const savedSessionIds = new Map();
+    const conversationCache = new Map();
+    let conversationCacheLoadedAt = 0;
+    async function refreshConversationCache(force = false) {
+        if (!force && conversationCache.size > 0 && Date.now() - conversationCacheLoadedAt < 10_000) {
+            return;
+        }
+        const conversations = await client.getConversations();
+        conversationCache.clear();
+        for (const conversation of conversations) {
+            conversationCache.set(conversation.id, conversation);
+        }
+        conversationCacheLoadedAt = Date.now();
+    }
+    async function getConversationMeta(conversationId) {
+        try {
+            await refreshConversationCache();
+            const cached = conversationCache.get(conversationId);
+            if (cached)
+                return cached;
+            await refreshConversationCache(true);
+            return conversationCache.get(conversationId) ?? null;
+        }
+        catch {
+            return conversationCache.get(conversationId) ?? null;
+        }
+    }
+    async function loadParticipantContext(input) {
+        const [conversation, recentMessages] = await Promise.all([
+            getConversationMeta(input.conversationId),
+            client.getMessages(input.conversationId, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT).catch(() => []),
+        ]);
+        const history = buildParticipationHistorySnapshot(recentMessages, agentId);
+        return {
+            conversationType: conversation?.type ?? 'unknown',
+            memberCount: conversation?.memberIds?.length ?? null,
+            senderType: input.message.senderType ?? 'human',
+            senderName: input.senderName,
+            isOwner: input.isOwner,
+            mentionedAgent: Array.isArray(input.message.mentions) && input.message.mentions.includes(agentId),
+            recentSenderTypes: history.recentSenderTypes,
+            recentHumanCount: history.recentHumanCount,
+            recentAgentCount: history.recentAgentCount,
+            consecutiveAgentTurns: history.consecutiveAgentTurns,
+            currentAgentStreakStartedByHuman: history.currentAgentStreakStartedByHuman,
+        };
+    }
     function closeSession(conversationId) {
         const session = sessions.get(conversationId);
         if (!session)
             return;
         session.closed = true;
+        releaseConversationEnvironment(session.environment);
         // Save SDK session ID for future resume
         if (session.sdkSessionId) {
-            savedSessionIds.set(conversationId, session.sdkSessionId);
+            savedSessionIds.set(buildConversationEnvironmentKey(conversationId, session.environment.baseCwd), session.sdkSessionId);
         }
         if (session.streamingTimer)
             clearTimeout(session.streamingTimer);
+        if (session.idleResetTimer) {
+            clearTimeout(session.idleResetTimer);
+            session.idleResetTimer = null;
+        }
+        if (session.finalDeliveryTimer) {
+            clearTimeout(session.finalDeliveryTimer);
+            session.finalDeliveryTimer = null;
+        }
         rtdbWrite(`/streaming/${conversationId}/${agentId}`, null).catch(() => { });
         clearSessionState(conversationId, agentId).catch(() => { });
+        clearTurnState(conversationId, agentId).catch(() => { });
         client.setTyping(conversationId, false).catch(() => { });
         try {
             session.query.close();
@@ -593,20 +847,40 @@ async function main() {
         }
         const creation = (async () => {
             const config = await loadSessionConfig(conversationId, agentId);
-            const resumeId = savedSessionIds.get(conversationId);
-            const session = createSession(conversationId, resolveWorkspaceCwd(config), agentId, client, (convoId, sdkSessionId) => {
-                // Called when session processing loop ends — save session ID for resume
-                if (sdkSessionId)
-                    savedSessionIds.set(convoId, sdkSessionId);
-                sessions.delete(convoId);
-                clearSessionState(convoId, agentId).catch(() => { });
-            }, {
-                model: config?.model ?? runtimeModels[0]?.value,
-                permissionMode: config?.permissionMode ?? 'default',
-                availableModels: runtimeModels,
-            }, resumeId);
-            sessions.set(conversationId, session);
-            return session;
+            const workspaceCwd = resolveWorkspaceCwd(config);
+            const environment = prepareConversationEnvironment({
+                agentId,
+                conversationId,
+                workspaceCwd,
+                allowWorktrees,
+            });
+            try {
+                const resumeKey = buildConversationEnvironmentKey(conversationId, environment.baseCwd);
+                const resumeId = savedSessionIds.get(resumeKey);
+                const session = createSession(conversationId, environment, agentId, client, (convoId, sdkSessionId) => {
+                    // Called when session processing loop ends — save session ID for resume
+                    const existing = sessions.get(convoId);
+                    if (existing) {
+                        releaseConversationEnvironment(existing.environment);
+                        if (sdkSessionId) {
+                            savedSessionIds.set(buildConversationEnvironmentKey(convoId, existing.environment.baseCwd), sdkSessionId);
+                        }
+                    }
+                    sessions.delete(convoId);
+                    clearSessionState(convoId, agentId).catch(() => { });
+                    clearTurnState(convoId, agentId).catch(() => { });
+                }, {
+                    model: config?.model ?? runtimeModels[0]?.value,
+                    permissionMode: config?.permissionMode ?? 'default',
+                    availableModels: runtimeModels,
+                }, resumeId);
+                sessions.set(conversationId, session);
+                return session;
+            }
+            catch (error) {
+                releaseConversationEnvironment(environment);
+                throw error;
+            }
         })();
         pendingSessionCreations.set(conversationId, creation);
         try {
@@ -641,22 +915,48 @@ async function main() {
                 const sender = m.senderName || m.senderId;
                 const content = renderInboundContent(m);
                 const isOwner = m.isOwner ?? (ownerId != null && m.senderId === ownerId);
-                console.error(`[canon-host] [${convoId.slice(0, 8)}] Message from ${sender}: "${content.slice(0, 80)}"`);
                 void (async () => {
-                    const session = await getOrCreateSession(convoId);
-                    session.sendInput({
+                    const conversation = await getConversationMeta(convoId);
+                    const behavior = payload.behavior ?? conversation?.behavior;
+                    const participantContext = await loadParticipantContext({
+                        conversationId: convoId,
+                        message: m,
+                        senderName: sender,
+                        isOwner,
+                    });
+                    const autoReply = decideAutoReply(participantContext, behavior);
+                    if (!autoReply.allow) {
+                        console.error(`[canon-host] [${convoId.slice(0, 8)}] Suppressed auto-reply: ${autoReply.reason}`);
+                        return;
+                    }
+                    console.error(`[canon-host] [${convoId.slice(0, 8)}] Message from ${sender}: "${content.slice(0, 80)}" (${autoReply.reason})`);
+                    let session;
+                    try {
+                        session = await getOrCreateSession(convoId);
+                    }
+                    catch (error) {
+                        const message = error instanceof Error ? error.message : String(error);
+                        const userMessage = error instanceof ExecutionEnvironmentError ? error.userMessage : message;
+                        console.error(`[canon-host] [${convoId.slice(0, 8)}] Failed to create session: ${message}`);
+                        await client.sendMessage(convoId, `I couldn't start a coding session for this workspace: ${userMessage}`).catch(() => { });
+                        return;
+                    }
+                    const turnMetadata = normalizeTurnMetadata(m.metadata);
+                    const deliveryIntent = turnMetadata?.deliveryIntent ?? 'queue';
+                    const shouldMarkAccepted = turnMetadata?.inboundDisposition === 'queued';
+                    session.enqueueInbound({
                         type: 'user',
                         message: {
                             role: 'user',
                             content: buildCanonPrompt({
                                 content,
                                 conversationId: convoId,
-                                isOwner,
-                                senderName: sender,
+                                participantContext,
+                                behavior,
                             }),
                         },
                         parent_tool_use_id: null,
-                    });
+                    }, deliveryIntent, m.id ?? null, shouldMarkAccepted);
                 })();
             },
             onConnected: () => console.error('[canon-host] SSE connected'),
@@ -716,6 +1016,8 @@ async function main() {
                                     ...session.state,
                                     ...(session.availableModels.length ? { availableModels: session.availableModels } : {}),
                                     cwd: session.cwd,
+                                    executionMode: session.environment.mode,
+                                    ...(session.environment.branch ? { executionBranch: session.environment.branch } : {}),
                                     hostMode: true,
                                     isActive: true,
                                 }).catch(() => { });
@@ -733,6 +1035,17 @@ async function main() {
                             if (session && !session.closed) {
                                 console.error(`[canon-host] [${convoId.slice(0, 8)}] Interrupt signal`);
                                 try {
+                                    session.turnState = 'interrupted';
+                                    writeTurnState(convoId, agentId, {
+                                        turnId: session.currentTurnId,
+                                        state: 'interrupted',
+                                        queueDepth: session.pendingInputs.length,
+                                        currentSpeakerId: agentId,
+                                        lastAcceptedIntent: session.lastAcceptedIntent,
+                                        capabilities: CLAUDE_RUNTIME_CAPABILITIES,
+                                        ...(session.currentTurnOpenedAt ? { openedAt: session.currentTurnOpenedAt } : {}),
+                                        completedAt: { '.sv': 'timestamp' },
+                                    }).catch(() => { });
                                     await session.query.interrupt();
                                     if (session.streamingTimer) {
                                         clearTimeout(session.streamingTimer);
@@ -764,9 +1077,23 @@ async function main() {
                 ...session.state,
                 ...(session.availableModels.length ? { availableModels: session.availableModels } : {}),
                 cwd: session.cwd,
+                executionMode: session.environment.mode,
+                ...(session.environment.branch ? { executionBranch: session.environment.branch } : {}),
                 hostMode: true,
                 isActive: true,
             }).catch(() => { });
+            writeTurnState(session.conversationId, agentId, {
+                turnId: session.currentTurnId,
+                state: session.turnState,
+                queueDepth: session.pendingInputs.length,
+                currentSpeakerId: agentId,
+                lastAcceptedIntent: session.lastAcceptedIntent,
+                capabilities: CLAUDE_RUNTIME_CAPABILITIES,
+                ...(session.currentTurnOpenedAt ? { openedAt: session.currentTurnOpenedAt } : {}),
+                ...(session.turnState === 'idle' || session.turnState === 'completed' || session.turnState === 'interrupted'
+                    ? { completedAt: { '.sv': 'timestamp' } }
+                    : {}),
+            }).catch(() => { });
         }
     }, HEARTBEAT_MS);
     // ── Idle session cleanup ──

package/dist/inbound-policy.d.ts

@@ -0,0 +1,20 @@
+import { 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;
+    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,43 @@
+import { 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}`,
+        `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/server.js

@@ -28,6 +28,43 @@ let approvalServer = null;
 const conversationCache = new Map();
 /** The conversation that most recently triggered work (for approval routing) */
 let triggerConversationId = null;
+function getPrimaryAttachment(message) {
+    const attachment = message.attachments?.[0];
+    if (attachment?.url)
+        return attachment;
+    if (message.audioUrl) {
+        return {
+            kind: 'audio',
+            url: message.audioUrl,
+            durationMs: message.audioDurationMs,
+        };
+    }
+    if (message.imageUrl) {
+        return {
+            kind: 'image',
+            url: message.imageUrl,
+        };
+    }
+    return null;
+}
+function renderInboundContent(message) {
+    let content = message.text || '';
+    const attachment = getPrimaryAttachment(message);
+    if (attachment?.kind === 'audio') {
+        const duration = attachment.durationMs ? ` (${Math.round(attachment.durationMs / 1000)}s)` : '';
+        return content
+            ? `[Voice message${duration}: ${attachment.url}]\n${content}`
+            : `[Voice message${duration}: ${attachment.url}]`;
+    }
+    if (attachment?.kind === 'image') {
+        return content ? `[Image: ${attachment.url}]\n${content}` : `[Image: ${attachment.url}]`;
+    }
+    if (attachment?.kind === 'file') {
+        const label = attachment.fileName || 'File';
+        return content ? `[File: ${label} ${attachment.url}]\n${content}` : `[File: ${label} ${attachment.url}]`;
+    }
+    return content;
+}
 // ── Tool definitions ───────────────────────────────────────────────────
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: [
@@ -51,7 +88,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         },
         {
             name: 'send_message',
-            description: 'Send a message to a Canon conversation (supports text, images, audio)',
+            description: 'Send a message to a Canon conversation (supports text, images, audio, files)',
             inputSchema: {
                 type: 'object',
                 properties: {
@@ -65,7 +102,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                     },
                     content_type: {
                         type: 'string',
-                        enum: ['text', 'image', 'audio'],
+                        enum: ['text', 'image', 'audio', 'file'],
                         description: 'Content type (default: text)',
                     },
                     image_url: {
@@ -76,8 +113,16 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                         type: 'string',
                         description: 'Audio URL (when content_type is audio)',
                     },
+                    file_url: {
+                        type: 'string',
+                        description: 'File URL (when content_type is file)',
+                    },
+                    file_name: {
+                        type: 'string',
+                        description: 'Optional display filename for file attachments',
+                    },
                 },
-                required: ['conversation_id', 'text'],
+                required: ['conversation_id'],
             },
         },
         {
@@ -151,15 +196,34 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         }
         case 'send_message': {
             const conversationId = args.conversation_id;
-            const text = args.text;
+            const text = typeof args.text === 'string' ? args.text : '';
             const contentType = args.content_type || 'text';
-            const opts = {
-                contentType: contentType,
-            };
-            if (args.image_url)
-                opts.imageUrl = args.image_url;
-            if (args.audio_url)
-                opts.audioUrl = args.audio_url;
+            const opts = {};
+            const imageUrl = typeof args.image_url === 'string' ? args.image_url : null;
+            const audioUrl = typeof args.audio_url === 'string' ? args.audio_url : null;
+            const fileUrl = typeof args.file_url === 'string' ? args.file_url : null;
+            const fileName = typeof args.file_name === 'string' ? args.file_name : null;
+            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 }];
+            }
+            else if (contentType === 'file' || fileUrl) {
+                opts.contentType = 'file';
+                if (fileUrl) {
+                    opts.attachments = [{
+                            kind: 'file',
+                            url: fileUrl,
+                            ...(fileName ? { fileName } : {}),
+                        }];
+                }
+            }
+            else {
+                opts.contentType = contentType;
+            }
             const result = await client.sendMessage(conversationId, text, opts);
             return {
                 content: [
@@ -261,16 +325,36 @@ async function handleInboundMessage(payload) {
         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');
+        }
+    }
+    const primaryAttachment = getPrimaryAttachment(m);
     if (m.imageUrl)
         meta.image_url = m.imageUrl;
     if (m.audioUrl)
         meta.audio_url = m.audioUrl;
-    console.error(`[canon] Inbound message from ${meta.sender_name}: "${m.text}"`);
+    if (primaryAttachment?.url) {
+        meta.attachment_kind = primaryAttachment.kind;
+        meta.attachment_url = primaryAttachment.url;
+    }
+    if (primaryAttachment?.fileName)
+        meta.attachment_file_name = primaryAttachment.fileName;
+    const renderedContent = renderInboundContent(m);
+    console.error(`[canon] Inbound message from ${meta.sender_name}: "${renderedContent}"`);
     try {
         await server.notification({
             method: 'notifications/claude/channel',
             params: {
-                content: m.text || '',
+                content: renderedContent,
                 meta,
             },
         });

package/dist/setup.d.ts

@@ -2,7 +2,7 @@
 /**
  * Setup script for the Canon Claude Code plugin.
  *
- * Run after `npm install -g @canon/claude-code-plugin` to:
+ * Run after `npm install -g @canonmsg/claude-code-plugin` to:
  * 1. Install the /canon-register and /canon-configure skills
  * 2. Show the user how to add the MCP server to their .mcp.json
  */

package/dist/setup.js

@@ -2,7 +2,7 @@
 /**
  * Setup script for the Canon Claude Code plugin.
  *
- * Run after `npm install -g @canon/claude-code-plugin` to:
+ * Run after `npm install -g @canonmsg/claude-code-plugin` to:
  * 1. Install the /canon-register and /canon-configure skills
  * 2. Show the user how to add the MCP server to their .mcp.json
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/claude-code-plugin",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Canon channel plugin for Claude Code — messaging where AI agents are first-class citizens",
   "type": "module",
   "main": "dist/server.js",
@@ -16,13 +16,13 @@
     ".claude-plugin"
   ],
   "scripts": {
-    "build": "tsc",
+    "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc",
     "dev": "tsc --watch",
-    "prepublishOnly": "npm run build"
+    "prepack": "npm run build"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.92",
-    "@canonmsg/core": "^0.2.2",
+    "@anthropic-ai/claude-agent-sdk": "^0.2.101",
+    "@canonmsg/core": "^0.4.0",
     "@modelcontextprotocol/sdk": "^1.12.0"
   },
   "engines": {

package/dist/agent-profiles.d.ts

@@ -1,21 +0,0 @@
-/**
- * Shared agent profile management — loading, locking, and resolution.
- * Used by both host.ts and server.ts.
- */
-export interface AgentProfile {
-    apiKey: string;
-    agentId: string;
-    agentName: string;
-    registeredAt: string;
-}
-export declare const CANON_DIR: string;
-export declare const AGENTS_PATH: string;
-export declare const LOCKS_DIR: string;
-export declare function loadProfiles(): Record<string, AgentProfile>;
-export declare function isProcessAlive(pid: number): boolean;
-export declare function isProfileLocked(profile: string): {
-    locked: boolean;
-    pid?: number;
-};
-export declare function acquireLock(profile: string): void;
-export declare function releaseLock(profile: string): void;

package/dist/agent-profiles.js

@@ -1,63 +0,0 @@
-/**
- * Shared agent profile management — loading, locking, and resolution.
- * Used by both host.ts and server.ts.
- */
-import { readFileSync, writeFileSync, unlinkSync, mkdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
-// ── Paths ────────────────────────────────────────────────────────────
-export const CANON_DIR = join(homedir(), '.canon');
-export const AGENTS_PATH = join(CANON_DIR, 'agents.json');
-export const LOCKS_DIR = join(CANON_DIR, 'locks');
-// ── Profile loading ──────────────────────────────────────────────────
-export function loadProfiles() {
-    try {
-        return JSON.parse(readFileSync(AGENTS_PATH, 'utf-8'));
-    }
-    catch {
-        return {};
-    }
-}
-// ── Process locking ──────────────────────────────────────────────────
-export function isProcessAlive(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export function isProfileLocked(profile) {
-    const lockPath = join(LOCKS_DIR, `${profile}.lock`);
-    try {
-        const pid = parseInt(readFileSync(lockPath, 'utf-8').trim());
-        if (isProcessAlive(pid))
-            return { locked: true, pid };
-        // Stale lock — clean it up
-        try {
-            unlinkSync(lockPath);
-        }
-        catch { }
-    }
-    catch {
-        // No lock file
-    }
-    return { locked: false };
-}
-export function acquireLock(profile) {
-    mkdirSync(LOCKS_DIR, { recursive: true });
-    const lockPath = join(LOCKS_DIR, `${profile}.lock`);
-    const check = isProfileLocked(profile);
-    if (check.locked) {
-        throw new Error(`Agent "${profile}" is in use by another session (PID ${check.pid})`);
-    }
-    writeFileSync(lockPath, String(process.pid));
-}
-export function releaseLock(profile) {
-    const lockPath = join(LOCKS_DIR, `${profile}.lock`);
-    try {
-        unlinkSync(lockPath);
-    }
-    catch { }
-}

package/dist/rtdb-rest.d.ts

@@ -1,34 +0,0 @@
-/**
- * Lightweight RTDB REST helper for session state.
- *
- * Uses Firebase Realtime Database REST API to avoid adding firebase-admin
- * as a dependency to the MCP plugin. The custom token from /agents/auth-token
- * is exchanged for a Firebase ID token before use with RTDB REST.
- */
-import { type CanonClient } from '@canonapp/core';
-export interface SessionStatePayload {
-    model?: string;
-    permissionMode?: string;
-    effort?: string;
-    cwd?: string;
-    hostMode?: boolean;
-    isActive: boolean;
-    updatedAt: {
-        '.sv': 'timestamp';
-    };
-}
-/** Must be called once before any RTDB operations. */
-export declare function initRTDBAuth(client: CanonClient): void;
-/** Generic RTDB REST write (PUT). */
-export declare function rtdbWrite(path: string, data: unknown): Promise<void>;
-/** Generic RTDB REST read (GET). */
-export declare function rtdbRead(path: string): Promise<unknown>;
-/**
- * Write session state to RTDB via REST API.
- * Path: /session-state/{conversationId}/{agentId}
- */
-export declare function writeSessionState(conversationId: string, agentId: string, state: Omit<SessionStatePayload, 'updatedAt'>): Promise<void>;
-/**
- * Clear session state from RTDB (full overwrite with isActive: false).
- */
-export declare function clearSessionState(conversationId: string, agentId: string): Promise<void>;

package/dist/rtdb-rest.js

@@ -1,128 +0,0 @@
-/**
- * Lightweight RTDB REST helper for session state.
- *
- * Uses Firebase Realtime Database REST API to avoid adding firebase-admin
- * as a dependency to the MCP plugin. The custom token from /agents/auth-token
- * is exchanged for a Firebase ID token before use with RTDB REST.
- */
-import { DEFAULT_RTDB_URL, FIREBASE_WEB_API_KEY } from '@canonapp/core';
-const RTDB_BASE = process.env.CANON_RTDB_URL || DEFAULT_RTDB_URL;
-const FIREBASE_API_KEY = process.env.CANON_FIREBASE_API_KEY || FIREBASE_WEB_API_KEY;
-// ── Token management ──────────────────────────────────────────────────
-let cachedIdToken = null;
-let idTokenExpiresAt = 0;
-let tokenClient = null;
-/** Must be called once before any RTDB operations. */
-export function initRTDBAuth(client) {
-    tokenClient = client;
-}
-/**
- * Exchange a Firebase custom token for an ID token via the Identity Toolkit API.
- */
-async function exchangeCustomTokenForIdToken(customToken) {
-    const url = `https://identitytoolkit.googleapis.com/v1/accounts:signInWithCustomToken?key=${FIREBASE_API_KEY}`;
-    const res = await fetch(url, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ token: customToken, returnSecureToken: true }),
-    });
-    if (!res.ok) {
-        const text = await res.text();
-        throw new Error(`Token exchange failed (${res.status}): ${text}`);
-    }
-    const data = await res.json();
-    return { idToken: data.idToken, expiresIn: parseInt(data.expiresIn, 10) };
-}
-/** Get a valid ID token for RTDB REST, refreshing if expired or expiring soon. */
-async function getToken() {
-    // Refresh if missing, expired, or expiring within 5 minutes
-    if (!cachedIdToken || Date.now() > idTokenExpiresAt - 5 * 60 * 1000) {
-        if (!tokenClient)
-            return null;
-        try {
-            const auth = await tokenClient.getAuthToken();
-            const { idToken, expiresIn } = await exchangeCustomTokenForIdToken(auth.token);
-            cachedIdToken = idToken;
-            idTokenExpiresAt = Date.now() + expiresIn * 1000;
-        }
-        catch (err) {
-            console.error('[canon] RTDB token refresh failed:', err);
-            return cachedIdToken; // Return stale token as fallback
-        }
-    }
-    return cachedIdToken;
-}
-// ── RTDB operations ───────────────────────────────────────────────────
-/** Generic RTDB REST write (PUT). */
-export async function rtdbWrite(path, data) {
-    const token = await getToken();
-    if (!token)
-        return;
-    const url = `${RTDB_BASE}${path}.json?auth=${token}`;
-    const res = await fetch(url, {
-        method: 'PUT',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(data),
-    });
-    if (!res.ok) {
-        const text = await res.text();
-        throw new Error(`RTDB write failed (${res.status}): ${text}`);
-    }
-}
-/** Generic RTDB REST read (GET). */
-export async function rtdbRead(path) {
-    const token = await getToken();
-    if (!token)
-        return null;
-    const url = `${RTDB_BASE}${path}.json?auth=${token}`;
-    const res = await fetch(url);
-    if (!res.ok)
-        return null;
-    return res.json();
-}
-/**
- * Write session state to RTDB via REST API.
- * Path: /session-state/{conversationId}/{agentId}
- */
-export async function writeSessionState(conversationId, agentId, state) {
-    const token = await getToken();
-    if (!token)
-        return;
-    const url = `${RTDB_BASE}/session-state/${conversationId}/${agentId}.json?auth=${token}`;
-    const body = {
-        ...state,
-        updatedAt: { '.sv': 'timestamp' },
-    };
-    const res = await fetch(url, {
-        method: 'PUT',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(body),
-    });
-    if (!res.ok) {
-        const text = await res.text();
-        throw new Error(`RTDB write failed (${res.status}): ${text}`);
-    }
-}
-/**
- * Clear session state from RTDB (full overwrite with isActive: false).
- */
-export async function clearSessionState(conversationId, agentId) {
-    const token = await getToken();
-    if (!token)
-        return;
-    const url = `${RTDB_BASE}/session-state/${conversationId}/${agentId}.json?auth=${token}`;
-    const body = {
-        isActive: false,
-        updatedAt: { '.sv': 'timestamp' },
-    };
-    // Use PUT (not PATCH) to clear stale fields like model/cwd
-    const res = await fetch(url, {
-        method: 'PUT',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(body),
-    });
-    if (!res.ok) {
-        const text = await res.text();
-        console.error(`[canon] RTDB clear failed (${res.status}): ${text}`);
-    }
-}