@canonmsg/claude-code-plugin 0.5.0 → 0.7.0

package/dist/host.js

@@ -152,7 +152,7 @@ function renderInboundContent(message) {
     return content || '[Empty message]';
 }
 // ── Session factory ─────────────────────────────────────────────────
-function createSession(conversationId, environment, agentId, client, onSessionEnd, config, resumeSessionId) {
+function createSession(conversationId, environment, agentId, client, onSessionEnd, onRuntimeDescriptorUpdate, config, resumeSessionId) {
     const { cwd } = environment;
     // Per-session input stream with message queue
     let resolveInput = null;
@@ -649,13 +649,13 @@ function createSession(conversationId, environment, agentId, client, onSessionEn
             const modelList = toModelOptions(models);
             session.availableModels = modelList;
             runtimeModels = modelList;
-            await publishAgentRuntime(agentId, {
+            onRuntimeDescriptorUpdate({
                 defaultWorkspaceId: workspaceOptions[0]?.id,
                 defaultModel: session.state.model ?? modelList[0]?.value,
                 defaultPermissionMode: 'default',
                 availableModels: modelList,
                 availableWorkspaces: buildPublicWorkspaceOptions(workspaceOptions),
-            }).catch(() => { });
+            });
             writeSessionState(conversationId, agentId, {
                 ...session.state,
                 availableModels: modelList,
@@ -716,19 +716,36 @@ async function main() {
         }
         console.error(`[canon-host] Authenticated as ${agentId}`);
     }
+    let streamConnected = false;
+    let runtimeDescriptor = {
+        defaultWorkspaceId: workspaceOptions[0]?.id,
+        defaultPermissionMode: 'default',
+        availableWorkspaces: buildPublicWorkspaceOptions(workspaceOptions),
+    };
+    const publishRuntimeHeartbeat = async () => {
+        if (!streamConnected)
+            return;
+        await publishAgentRuntime(agentId, runtimeDescriptor).catch((error) => {
+            console.error('[canon-host] Failed to publish agent runtime:', error);
+        });
+    };
     // ── Load conversations (informational — sessions created on demand) ──
     try {
         runtimeModels = await detectRuntimeModels(workingDir);
-        await publishAgentRuntime(agentId, {
+        runtimeDescriptor = {
             defaultWorkspaceId: workspaceOptions[0]?.id,
             defaultModel: runtimeModels[0]?.value,
             defaultPermissionMode: 'default',
             availableModels: runtimeModels,
             availableWorkspaces: buildPublicWorkspaceOptions(workspaceOptions),
-        });
+        };
     }
-    catch (error) {
-        console.error('[canon-host] Failed to publish agent runtime:', error);
+    catch {
+        runtimeDescriptor = {
+            defaultWorkspaceId: workspaceOptions[0]?.id,
+            defaultPermissionMode: 'default',
+            availableWorkspaces: buildPublicWorkspaceOptions(workspaceOptions),
+        };
     }
     try {
         const convos = await client.getConversations();
@@ -869,6 +886,9 @@ async function main() {
                     sessions.delete(convoId);
                     clearSessionState(convoId, agentId).catch(() => { });
                     clearTurnState(convoId, agentId).catch(() => { });
+                }, (descriptor) => {
+                    runtimeDescriptor = descriptor;
+                    void publishRuntimeHeartbeat();
                 }, {
                     model: config?.model ?? runtimeModels[0]?.value,
                     permissionMode: config?.permissionMode ?? 'default',
@@ -959,8 +979,16 @@ async function main() {
                     }, deliveryIntent, m.id ?? null, shouldMarkAccepted);
                 })();
             },
-            onConnected: () => console.error('[canon-host] SSE connected'),
-            onDisconnected: () => console.error('[canon-host] SSE disconnected'),
+            onConnected: () => {
+                streamConnected = true;
+                void publishRuntimeHeartbeat();
+                console.error('[canon-host] SSE connected');
+            },
+            onDisconnected: () => {
+                streamConnected = false;
+                rtdbWrite(`/agent-runtime/${agentId}`, null).catch(() => { });
+                console.error('[canon-host] SSE disconnected');
+            },
             onError: (err) => console.error(`[canon-host] SSE error: ${err.message}`),
         },
     });
@@ -1095,6 +1123,7 @@ async function main() {
                     : {}),
             }).catch(() => { });
         }
+        void publishRuntimeHeartbeat();
     }, HEARTBEAT_MS);
     // ── Idle session cleanup ──
     const idleCheck = setInterval(() => {
@@ -1116,6 +1145,7 @@ async function main() {
         clearInterval(heartbeat);
         clearInterval(idleCheck);
         stream.stop();
+        await rtdbWrite(`/agent-runtime/${agentId}`, null).catch(() => { });
         for (const convoId of [...sessions.keys()]) {
             closeSession(convoId);
         }

package/dist/register.js

@@ -33,6 +33,14 @@ if (!values.name || !values.description || !values.phone) {
 }
 // Default profile name: sanitized agent name
 const profileName = values.profile || values.name.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-');
+let existingAgentId;
+try {
+    const profiles = JSON.parse(readFileSync(AGENTS_PATH, 'utf-8'));
+    existingAgentId = profiles[profileName]?.agentId;
+}
+catch {
+    // File doesn't exist yet
+}
 console.log(`Registering agent "${values.name}" (profile: ${profileName})...`);
 const result = await registerAndWaitForApproval({
     name: values.name,
@@ -41,6 +49,7 @@ const result = await registerAndWaitForApproval({
     developerInfo: 'Claude Code plugin',
     clientType: 'claude-code',
     baseUrl: values['base-url'],
+    requestedAgentId: existingAgentId,
 }, {
     onSubmitted: (requestId) => {
         console.log(`Registration submitted (request ID: ${requestId}).`);

package/dist/server.js

@@ -337,6 +337,60 @@ async function handleInboundMessage(payload) {
             meta.behavior_instructions = payload.behavior.instructions.join('\n\n');
         }
     }
+    if (m.workSession) {
+        meta.work_session_id = m.workSession.id;
+        if (m.workSession.title)
+            meta.work_session_title = m.workSession.title;
+        if (m.workSession.objective)
+            meta.work_session_objective = m.workSession.objective;
+        if (m.workSession.status)
+            meta.work_session_status = m.workSession.status;
+        if (m.workSession.currentConversationRole) {
+            meta.work_session_role = m.workSession.currentConversationRole;
+        }
+        if (m.workSession.representation) {
+            meta.work_session_representation = m.workSession.representation;
+        }
+        if (m.workSession.disclosure) {
+            meta.work_session_disclosure = m.workSession.disclosure;
+        }
+        if (m.workSession.summary)
+            meta.work_session_summary = m.workSession.summary;
+        if (m.workSession.sourceConversationLabel) {
+            meta.work_session_source_conversation = m.workSession.sourceConversationLabel;
+        }
+        else if (m.workSession.sourceConversationId) {
+            meta.work_session_source_conversation = m.workSession.sourceConversationId;
+        }
+        if (m.workSession.sourceParticipantLabel) {
+            meta.work_session_source_participant = m.workSession.sourceParticipantLabel;
+        }
+        else if (m.workSession.sourceParticipantId) {
+            meta.work_session_source_participant = m.workSession.sourceParticipantId;
+        }
+        if (Array.isArray(m.workSession.visibleFacts) && m.workSession.visibleFacts.length > 0) {
+            meta.work_session_visible_facts = m.workSession.visibleFacts.join('\n\n');
+        }
+        if (Array.isArray(m.workSession.pendingQuestions)
+            && m.workSession.pendingQuestions.length > 0) {
+            meta.work_session_pending_questions = m.workSession.pendingQuestions.join('\n\n');
+        }
+        if (Array.isArray(m.workSession.disclosureNotes)
+            && m.workSession.disclosureNotes.length > 0) {
+            meta.work_session_disclosure_notes = m.workSession.disclosureNotes.join('\n\n');
+        }
+    }
+    if (Array.isArray(payload.workSessions) && payload.workSessions.length > 0) {
+        meta.active_work_session_ids = payload.workSessions
+            .map((workSession) => workSession.id)
+            .join('\n');
+        const titled = payload.workSessions
+            .map((workSession) => workSession.title || workSession.id)
+            .filter((value) => value.length > 0);
+        if (titled.length > 0) {
+            meta.active_work_session_titles = titled.join('\n');
+        }
+    }
     const primaryAttachment = getPrimaryAttachment(m);
     if (m.imageUrl)
         meta.image_url = m.imageUrl;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/claude-code-plugin",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "Canon channel plugin for Claude Code — messaging where AI agents are first-class citizens",
   "type": "module",
   "main": "dist/server.js",
@@ -22,7 +22,7 @@
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.101",
-    "@canonmsg/core": "^0.4.0",
+    "@canonmsg/core": "^0.6.0",
     "@modelcontextprotocol/sdk": "^1.12.0"
   },
   "engines": {