@canonmsg/claude-code-plugin 0.21.1 → 0.22.0

package/README.md

@@ -1,4 +1,4 @@
-# Canon Plugin for Claude Code
+# Canon Host for Claude Code
 
 Connect Claude Code to [Canon](https://github.com/HeyBobChan/canon) — a messaging app where AI agents are first-class citizens. Control Claude Code from your phone.
 
@@ -67,22 +67,6 @@ canon-register --name "Frontend" --description "React work" --phone "+1..." --pr
 CANON_AGENT=frontend canon-claude --cwd ~/projects/frontend
 ```
 
-## Channel mode (alternative)
-
-For a lighter integration without session controls, run Canon as a channel plugin inside your own Claude Code session. The `canon-channel-server` binary (installed by this package) is an MCP stdio server that Claude Code launches.
-
-Register the channel server with Claude Code's MCP config and provide your Canon API key via the `CANON_API_KEY` environment variable:
-
-```bash
-# Register once per Claude Code project
-claude mcp add canon-channel canon-channel-server
-
-# Then start Claude Code with your Canon key in the environment
-CANON_API_KEY=agk_live_... claude
-```
-
-Channel mode forwards messages between Canon conversations and the embedded Claude Code session without managing session lifecycle. It is shown as non-revivable by `canon-necromance`. Use `canon-claude` host mode when you want phone-controlled runtime sessions with setup and live controls.
-
 ## Development
 
 ```bash

package/dist/host.js

@@ -36,7 +36,7 @@ import { ApprovalManager, readHostSessionConfig, resolveHostWorkspaceCwd, } from
 import { runCli } from './cli-entry.js';
 import { synthesizeClaudeApprovalDiff } from './approval-diff.js';
 import { decideClaudeToolPermissionForMode, parseAllowedNonOwnerClaudeTools, } from './tool-policy.js';
-import { applyClaudeSessionControl, buildClaudeFinalMessageId, buildClaudeInitialSessionState, createClaudeInputEnvelope, formatClaudeControlError, normalizeClaudeEffortLevel, parseClaudePermissionMode, resolveClaudeModelOptions, resetClaudeCompletedTurnState, shouldDeliverClaudeFinal, } from './session-state.js';
+import { applyClaudeSessionControl, buildClaudeFinalMessageId, buildClaudeInitialSessionState, claudeModelInfoToOption, createClaudeInputEnvelope, formatClaudeControlError, isClaudeCustomModelOption, normalizeClaudeEffortLevel, parseClaudePermissionMode, resolveClaudeModelOptions, resetClaudeCompletedTurnState, shouldDeliverClaudeFinal, } from './session-state.js';
 import { claudeThinkingToConfig, parseClaudeSessionDefaults, resolveEffectiveSessionSettings, } from './session-defaults.js';
 import { mapClaudeSubagentActivity } from './subagent-activity.js';
 function parseRuntimeVisibilityPreset(value) {
@@ -331,11 +331,20 @@ function resolveClaudeCliPath() {
     console.error('[canon-host] claude CLI not on PATH; using SDK-bundled binary');
     return undefined;
 }
+const CLAUDE_SUPPLEMENTAL_MODEL_PROBES = ['opus'];
+function mergeModelOptions(...groups) {
+    const byValue = new Map();
+    for (const group of groups) {
+        for (const option of group) {
+            if (!byValue.has(option.value)) {
+                byValue.set(option.value, option);
+            }
+        }
+    }
+    return [...byValue.values()];
+}
 function toModelOptions(models) {
-    return models.map((model) => ({
-        value: model.value,
-        label: model.displayName,
-    }));
+    return models.map(claudeModelInfoToOption);
 }
 async function publishAgentRuntime(port, runtime) {
     await port.publishHostAgentRuntime({
@@ -375,6 +384,21 @@ function resolveExecutionFallbackReason(environment) {
         : environment.reason;
 }
 async function detectRuntimeModels(cwd) {
+    const discovered = await detectRuntimeModelsForSelection(cwd, 'default');
+    const supplemental = await Promise.all(CLAUDE_SUPPLEMENTAL_MODEL_PROBES.map(async (model) => {
+        try {
+            const options = await detectRuntimeModelsForSelection(cwd, model);
+            const option = options.find((entry) => entry.value === model);
+            return option && !isClaudeCustomModelOption(option) ? [option] : [];
+        }
+        catch (error) {
+            console.error(`[canon-host] Supplemental Claude model probe failed for ${model}:`, error);
+            return [];
+        }
+    }));
+    return mergeModelOptions(discovered, ...supplemental);
+}
+async function detectRuntimeModelsForSelection(cwd, model) {
     const emptyPrompt = {
         async *[Symbol.asyncIterator]() { },
     };
@@ -384,7 +408,7 @@ async function detectRuntimeModels(cwd) {
         options: {
             systemPrompt: { type: 'preset', preset: 'claude_code' },
             tools: { type: 'preset', preset: 'claude_code' },
-            model: 'default',
+            model,
             permissionMode: 'default',
             cwd,
             settings: { forceLoginMethod: 'claudeai' },
@@ -1075,7 +1099,6 @@ function createSession(conversationId, environment, agentId, port, typingSignals
         cwd,
         environment,
         query: q,
-        controlApplySeq: new Map(),
         sendInput,
         enqueueInbound: (msg, intent = 'queue', sourceMessageId, markAccepted = false, isOwnerTurn = false, artifactRoutingMode = 'disabled') => enqueueInboundMessage(msg, intent, sourceMessageId, markAccepted, isOwnerTurn, artifactRoutingMode),
         state: buildClaudeInitialSessionState({

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/session-state.d.ts

@@ -54,7 +54,6 @@ export declare function buildClaudeInitialSessionState(input: {
 }): ClaudeHostSessionState;
 export interface ClaudeSessionControlTarget {
     state: ClaudeHostSessionState;
-    controlApplySeq: Map<string, number>;
     closed: boolean;
     query: Pick<Query, 'setModel' | 'setPermissionMode' | 'applyFlagSettings'>;
     writeState: () => void;
@@ -103,6 +102,13 @@ export declare function shouldDeliverClaudeFinal(input: {
     interruptedTurnKeys: ReadonlySet<string>;
 }): boolean;
 export declare function resetClaudeCompletedTurnState(session: ClaudeCompletedTurnState): void;
+export interface ClaudeModelInfoLike {
+    value: string;
+    displayName: string;
+    description?: string;
+}
+export declare function claudeModelInfoToOption(model: ClaudeModelInfoLike): ModelOption;
+export declare function isClaudeCustomModelOption(option: ModelOption | null | undefined): boolean;
 export declare function resolveClaudeModelOptions(input: {
     discovered: ReadonlyArray<ModelOption>;
     selectedModel?: string | null;

package/dist/session-state.js

@@ -29,21 +29,23 @@ export function buildClaudeInitialSessionState(input) {
         state: 'idle',
     };
 }
-function nextControlApplySeq(target, controlId) {
-    const nextSeq = (target.controlApplySeq.get(controlId) ?? 0) + 1;
-    target.controlApplySeq.set(controlId, nextSeq);
-    return nextSeq;
-}
-function applyOptimisticControl(input) {
-    const seq = nextControlApplySeq(input.target, input.controlId);
-    const applyPromise = (async () => input.apply())();
-    void applyPromise
-        .catch((error) => {
-        if (input.target.closed || input.target.controlApplySeq.get(input.controlId) !== seq) {
+/**
+ * Apply a control to the Claude SDK. W2-A2 deleted the seq-guarded optimistic
+ * revert machinery (commit c356bdf8) that masked the 2–11s control poll: the
+ * bridge is event-push now (~100ms), so the state is already published by the
+ * caller's writeState() and the SDK apply is fired without a revert dance. A
+ * failed apply surfaces as a runtime-control error (the display truth the app
+ * reads) — the same shape codex uses. `value` is the requested value for the
+ * error record; `controlId` scopes the error.
+ */
+function applyControl(input) {
+    // Fire the SDK apply SYNCHRONOUSLY (an async setter may still resolve later);
+    // wrap so a synchronous throw is caught in the same rejection path.
+    void (async () => input.apply())().catch((error) => {
+        if (input.target.closed)
             return;
-        }
-        input.revert();
         input.target.setRuntimeControlError(input.controlId, input.value, error);
+        input.target.writeState();
     });
 }
 function setRuntimeControlValue(state, controlId, value) {
@@ -58,20 +60,13 @@ export function applyClaudeSessionControl(target, ctrl) {
         target.setRuntimeControlError('model', String(ctrl.model), new Error('Unsupported Claude model.'));
     }
     else if (nextModel && nextModel !== target.state.model) {
-        const previous = target.state.model;
         target.state.model = nextModel;
         target.clearRuntimeControlError('model');
-        applyOptimisticControl({
+        applyControl({
             target,
             controlId: 'model',
             value: nextModel,
             apply: () => target.query.setModel(nextModel),
-            revert: () => {
-                if (previous === undefined)
-                    delete target.state.model;
-                else
-                    target.state.model = previous;
-            },
         });
     }
     const nextPermissionMode = parseClaudePermissionMode(ctrl.permissionMode);
@@ -79,41 +74,27 @@ export function applyClaudeSessionControl(target, ctrl) {
         target.setRuntimeControlError('permissionMode', ctrl.permissionMode, new Error(`Unsupported Claude permission mode: ${ctrl.permissionMode}`));
     }
     else if (nextPermissionMode && nextPermissionMode !== target.state.permissionMode) {
-        // Claude Code applies permission-mode changes asynchronously. We publish
-        // the requested value immediately so Canon does not show a stale "requested"
-        // state while the SDK catches up, then revert if the current apply fails.
-        const previous = target.state.permissionMode;
+        // Claude Code applies permission-mode changes asynchronously; publish the
+        // requested value immediately (writeState below) and surface an error if the
+        // apply fails.
         target.state.permissionMode = nextPermissionMode;
         target.clearRuntimeControlError('permissionMode');
-        applyOptimisticControl({
+        applyControl({
             target,
             controlId: 'permissionMode',
             value: nextPermissionMode,
             apply: () => target.query.setPermissionMode(nextPermissionMode),
-            revert: () => {
-                if (previous === undefined)
-                    delete target.state.permissionMode;
-                else
-                    target.state.permissionMode = previous;
-            },
         });
     }
     const nextEffort = normalizeClaudeEffortLevel(ctrl.effort);
     if (nextEffort && nextEffort !== target.state.effort) {
-        const previous = target.state.effort;
         target.state.effort = nextEffort;
         target.clearRuntimeControlError('effort');
-        applyOptimisticControl({
+        applyControl({
             target,
             controlId: 'effort',
             value: nextEffort,
             apply: () => target.query.applyFlagSettings({ effortLevel: nextEffort }),
-            revert: () => {
-                if (previous === undefined)
-                    delete target.state.effort;
-                else
-                    target.state.effort = previous;
-            },
         });
     }
     else if (ctrl.effort !== undefined && !nextEffort) {
@@ -126,20 +107,13 @@ export function applyClaudeSessionControl(target, ctrl) {
             target.setRuntimeControlError('thinking', String(runtimeControlValues.thinking), new Error('Unsupported Claude thinking mode.'));
         }
         else if (nextThinking !== target.state.runtimeControlValues?.thinking) {
-            const previous = target.state.runtimeControlValues?.thinking;
             setRuntimeControlValue(target.state, 'thinking', nextThinking);
             target.clearRuntimeControlError('thinking');
-            applyOptimisticControl({
+            applyControl({
                 target,
                 controlId: 'thinking',
                 value: nextThinking,
                 apply: () => target.query.applyFlagSettings({ alwaysThinkingEnabled: claudeThinkingToFlagValue(nextThinking) }),
-                revert: () => {
-                    if (previous === undefined)
-                        delete target.state.runtimeControlValues?.thinking;
-                    else
-                        setRuntimeControlValue(target.state, 'thinking', previous);
-                },
             });
         }
     }
@@ -149,20 +123,13 @@ export function applyClaudeSessionControl(target, ctrl) {
             target.setRuntimeControlError('ultracode', String(runtimeControlValues.ultracode), new Error('Unsupported Claude ultracode mode.'));
         }
         else if (nextUltracode !== target.state.runtimeControlValues?.ultracode) {
-            const previous = target.state.runtimeControlValues?.ultracode;
             setRuntimeControlValue(target.state, 'ultracode', nextUltracode);
             target.clearRuntimeControlError('ultracode');
-            applyOptimisticControl({
+            applyControl({
                 target,
                 controlId: 'ultracode',
                 value: nextUltracode,
                 apply: () => target.query.applyFlagSettings({ ultracode: nextUltracode === 'on' }),
-                revert: () => {
-                    if (previous === undefined)
-                        delete target.state.runtimeControlValues?.ultracode;
-                    else
-                        setRuntimeControlValue(target.state, 'ultracode', previous);
-                },
             });
         }
     }
@@ -215,6 +182,32 @@ export function resetClaudeCompletedTurnState(session) {
     session.toolInProgress = false;
     session.turnState = 'idle';
 }
+function normalizeModelDescription(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function displayLabelWithClaudeVersion(input) {
+    const label = input.displayName.trim() || input.value;
+    const description = normalizeModelDescription(input.description);
+    if (!description || label.includes('(') || /\d/.test(label))
+        return label;
+    const [summary] = description.split('·');
+    const versionedLabel = summary?.trim();
+    return versionedLabel
+        && versionedLabel.toLowerCase().startsWith(label.toLowerCase())
+        && /\d/.test(versionedLabel)
+        ? versionedLabel
+        : label;
+}
+export function claudeModelInfoToOption(model) {
+    return {
+        value: model.value,
+        label: displayLabelWithClaudeVersion(model),
+        ...(normalizeModelDescription(model.description) ? { description: normalizeModelDescription(model.description) } : {}),
+    };
+}
+export function isClaudeCustomModelOption(option) {
+    return option?.description?.trim().toLowerCase() === 'custom model';
+}
 export function resolveClaudeModelOptions(input) {
     const byValue = new Map();
     for (const option of input.discovered) {

package/dist/setup.d.ts

@@ -2,8 +2,7 @@
 /**
  * Setup script for the Canon Claude Code plugin.
  *
- * 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
+ * Run after `npm install -g @canonmsg/claude-code-plugin` to install the
+ * /canon-register and /canon-configure skills.
  */
 export declare function main(): void;

package/dist/setup.js

@@ -2,15 +2,14 @@
 /**
  * Setup script for the Canon Claude Code plugin.
  *
- * 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
+ * Run after `npm install -g @canonmsg/claude-code-plugin` to install the
+ * /canon-register and /canon-configure skills.
  */
 import { mkdirSync, writeFileSync, existsSync, readFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { runCli } from './cli-entry.js';
-const HELP = `canon-setup — install Claude Code Canon skills and print MCP setup
+const HELP = `canon-setup — install Claude Code Canon skills
 
 USAGE
   canon-setup
@@ -19,8 +18,7 @@ FLAGS
   --help, -h       Show this help
   --version, -V    Show package version
 
-This command writes Canon Claude Code skill files under ~/.claude/skills and
-prints the MCP server configuration for Claude Code channel mode.`;
+This command writes Canon Claude Code skill files under ~/.claude/skills.`;
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const home = process.env.HOME || process.env.USERPROFILE || '';
 const skillsDir = join(home, '.claude', 'skills');
@@ -45,27 +43,6 @@ function installSkills() {
         console.log(`  Installed /canon-${skill}`);
     }
 }
-// ── Show MCP config instructions ───────────────────────────────────────
-function showMcpInstructions() {
-    // Find the installed server.js path
-    const serverPath = join(__dirname, 'server.js');
-    console.log(`
-Add this to your project's .mcp.json (or ~/.mcp.json for global):
-
-{
-  "mcpServers": {
-    "canon-channel": {
-      "command": "node",
-      "args": ["${serverPath}"]
-    }
-  }
-}
-
-Then start Claude Code with:
-
-  claude --dangerously-load-development-channels server:canon-channel
-`);
-}
 // ── Main ───────────────────────────────────────────────────────────────
 export function main() {
     console.log('Canon Claude Code Plugin Setup');
@@ -75,8 +52,7 @@ export function main() {
     console.log('\nRegistering your agent...');
     console.log('  Run /canon-register in Claude Code to register a new agent');
     console.log('  Run /canon-configure if you already have an API key\n');
-    console.log('MCP server configuration:');
-    showMcpInstructions();
+    console.log('Run `canon-claude` to connect this agent to Canon.');
 }
 runCli(import.meta.url, main, (error) => {
     console.error('[canon-setup] Fatal error:', error);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@canonmsg/claude-code-plugin",
-  "version": "0.21.1",
-  "description": "Canon channel plugin for Claude Code — messaging where AI agents are first-class citizens",
+  "version": "0.22.0",
+  "description": "Canon host for Claude Code — messaging where AI agents are first-class citizens",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -12,15 +12,13 @@
     }
   },
   "bin": {
-    "canon-channel-server": "dist/server.js",
     "canon-claude": "dist/host.js",
     "canon-register": "dist/register.js",
     "canon-setup": "dist/setup.js"
   },
   "files": [
     "dist",
-    "skills",
-    ".claude-plugin"
+    "skills"
   ],
   "scripts": {
     "prepare:workspace-deps": "node ../../scripts/run-workspace-prep.mjs ../../packages/core ../../packages/agent-sdk ../../packages/framework ../../packages/bridge ../../packages/agent-host",
@@ -31,11 +29,11 @@
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.3.200",
-    "@canonmsg/agent-host": "^0.4.0",
-    "@canonmsg/agent-sdk": "^3.4.4",
-    "@canonmsg/bridge": "^0.2.0",
-    "@canonmsg/core": "^3.2.0",
-    "@canonmsg/framework": "^0.2.0",
+    "@canonmsg/agent-host": "^0.5.0",
+    "@canonmsg/agent-sdk": "^4.0.0",
+    "@canonmsg/bridge": "^0.3.0",
+    "@canonmsg/core": "^3.3.0",
+    "@canonmsg/framework": "^0.3.0",
     "@modelcontextprotocol/sdk": "^1.29.0"
   },
   "engines": {

package/skills/configure/SKILL.md

@@ -36,15 +36,9 @@ Add an existing Canon agent API key as a named profile.
 
 5. Write the updated profiles to `~/.canon/agents.json`.
 
-6. Tell the user: **"API key saved as profile '<profile>'. Restart Claude Code to connect."**
+6. Tell the user: **"API key saved as profile '<profile>'. Run `canon-claude` to connect."**
 
-   If they have multiple agents and want to pin one, add to `.mcp.json`:
-   ```json
-   {
-     "mcpServers": {
-       "canon-channel": {
-         "env": { "CANON_AGENT": "<profile>" }
-       }
-     }
-   }
+   If they have multiple agents and want to pin one, start the host with the profile name:
+   ```bash
+   CANON_AGENT=<profile> canon-claude
    ```

package/.claude-plugin/plugin.json

@@ -1,25 +0,0 @@
-{
-  "name": "Canon",
-  "description": "Connect Claude Code to Canon — messaging where AI agents are first-class citizens",
-  "version": "0.1.0",
-  "channels": [
-    {
-      "server": "canon-channel",
-      "userConfig": {
-        "api_key": {
-          "description": "Canon agent API key (agk_live_...)",
-          "sensitive": true
-        }
-      }
-    }
-  ],
-  "mcpServers": {
-    "canon-channel": {
-      "command": "node",
-      "args": ["${CLAUDE_PLUGIN_ROOT}/dist/server.js"],
-      "env": {
-        "CANON_PLUGIN_API_KEY": "${user_config.api_key}"
-      }
-    }
-  }
-}

package/dist/approval-server.d.ts

@@ -1,33 +0,0 @@
-import type { ApprovalManager } from '@canonmsg/core/host';
-/**
- * HTTP server that bridges Claude Code's PermissionRequest hook
- * to Canon's ApprovalManager.
- *
- * Listens on localhost for POST /approve from Claude Code hooks.
- */
-export declare class ApprovalHttpServer {
-    private server;
-    private manager;
-    private port;
-    private getConversationId;
-    private getIsOwnerTurn;
-    private token;
-    private maxBodyBytes;
-    private requestTimeoutMs;
-    constructor(manager: ApprovalManager, getConversationId: () => string | null, opts?: {
-        port?: number;
-        token?: string;
-        maxBodyBytes?: number;
-        requestTimeoutMs?: number;
-        getIsOwnerTurn?: () => boolean;
-    });
-    private static readonly MAX_PORT_RETRIES;
-    get authToken(): string;
-    start(): Promise<number>;
-    stop(): Promise<void>;
-    private handleRequest;
-    private hasValidToken;
-    private handleApproval;
-    private sendHookResponse;
-    private classifyRisk;
-}