@canonmsg/claude-code-plugin 0.21.2 → 0.23.0

package/dist/startup-recovery.js

@@ -0,0 +1,59 @@
+/**
+ * Startup recovery for inbound messages missed while the host was offline.
+ *
+ * The host persists a `lastInboundMessageId` cursor per conversation. On
+ * startup we paginate `getMessagesPage` (newest-first pages, older pages via
+ * its `before` message-id parameter) until the cursor is found or a hard
+ * per-conversation bound is hit, then replay everything after the cursor.
+ *
+ * This module is intentionally identical in packages/claude-code-plugin and
+ * packages/codex-plugin — keep both copies in sync (future consolidation
+ * candidate).
+ */
+export const STARTUP_RECOVERY_PAGE_SIZE = 25;
+export const STARTUP_RECOVERY_MAX_MESSAGES = 500;
+export async function collectMissedInboundMessages(input) {
+    const maxMessages = input.maxMessages ?? STARTUP_RECOVERY_MAX_MESSAGES;
+    const newestPage = await input.fetchPage();
+    const collected = [...newestPage.messages];
+    const seenIds = new Set(collected.map((message) => message.id));
+    const hasCursor = (messages) => input.cursor != null && messages.some((message) => message.id === input.cursor);
+    let cursorFound = hasCursor(collected);
+    if (input.cursor != null) {
+        while (!cursorFound && collected.length < maxMessages) {
+            // Pages are newest-first, so the last collected message is the oldest.
+            const before = collected[collected.length - 1]?.id;
+            if (!before)
+                break;
+            const page = await input.fetchPage(before);
+            const fresh = page.messages.filter((message) => !seenIds.has(message.id));
+            // No pagination progress (history exhausted, or the server ignored the
+            // `before` cursor because that message was hard-deleted) — stop here.
+            if (fresh.length === 0)
+                break;
+            for (const message of fresh)
+                seenIds.add(message.id);
+            collected.push(...fresh);
+            cursorFound = hasCursor(fresh);
+        }
+    }
+    const ascending = [...collected].sort((a, b) => String(a.createdAt ?? '').localeCompare(String(b.createdAt ?? '')));
+    const inboundOnly = (messages) => messages.filter((message) => message.senderId !== input.agentId);
+    let mode;
+    let missed;
+    if (cursorFound) {
+        const cursorIndex = ascending.findIndex((message) => message.id === input.cursor);
+        mode = 'after-cursor';
+        missed = inboundOnly(ascending.slice(cursorIndex + 1));
+    }
+    else if (input.cursor != null && collected.length >= maxMessages) {
+        mode = 'truncated-window';
+        missed = inboundOnly(ascending.slice(-maxMessages));
+    }
+    else {
+        mode = 'latest-only';
+        missed = inboundOnly(ascending).slice(-1);
+    }
+    // Safe: `missed` only holds elements of pages returned by `fetchPage`.
+    return { mode, messages: missed, newestPage };
+}

package/dist/streaming-buffer.d.ts

@@ -0,0 +1,16 @@
+export interface StreamingBufferOptions {
+    throttleMs: number;
+    getText: () => string;
+    setText: (text: string) => void;
+    getTimer: () => ReturnType<typeof setTimeout> | null;
+    setTimer: (timer: ReturnType<typeof setTimeout> | null) => void;
+    onWrite: (text: string) => void;
+    schedule?: typeof setTimeout;
+    cancel?: typeof clearTimeout;
+}
+export declare function createStreamingBuffer(options: StreamingBufferOptions): {
+    append(delta: string): void;
+    flush: () => void;
+    clear(): void;
+    replace(text: string): void;
+};

package/dist/streaming-buffer.js

@@ -0,0 +1,52 @@
+export function createStreamingBuffer(options) {
+    const schedule = options.schedule ?? setTimeout;
+    const cancel = options.cancel ?? clearTimeout;
+    const flush = () => {
+        const timer = options.getTimer();
+        if (timer) {
+            cancel(timer);
+            options.setTimer(null);
+        }
+        const text = options.getText();
+        if (text) {
+            options.onWrite(text);
+        }
+    };
+    return {
+        append(delta) {
+            if (!delta)
+                return;
+            options.setText(`${options.getText()}${delta}`);
+            if (options.getTimer())
+                return;
+            const timer = schedule(() => {
+                options.setTimer(null);
+                const text = options.getText();
+                if (text) {
+                    options.onWrite(text);
+                }
+            }, options.throttleMs);
+            options.setTimer(timer);
+        },
+        flush,
+        clear() {
+            const timer = options.getTimer();
+            if (timer) {
+                cancel(timer);
+                options.setTimer(null);
+            }
+            options.setText('');
+        },
+        replace(text) {
+            const timer = options.getTimer();
+            if (timer) {
+                cancel(timer);
+                options.setTimer(null);
+            }
+            options.setText(text);
+            if (text) {
+                options.onWrite(text);
+            }
+        },
+    };
+}

package/dist/tool-policy.d.ts

@@ -1,5 +1,4 @@
-import type { ApprovalRequestCategory, ApprovalRequestDetail, ApprovalRisk, CanonUnifiedDiff } from '@canonmsg/core/contract';
-import type { ApprovalManager } from '@canonmsg/core/host';
+import type { ApprovalManager, ApprovalRequestCategory, ApprovalRequestDetail, ApprovalRisk, CanonUnifiedDiff } from '@canonmsg/core';
 export type ClaudeToolPolicyDecision = {
     behavior: 'allow';
 } | {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/claude-code-plugin",
-  "version": "0.21.2",
+  "version": "0.23.0",
   "description": "Canon channel plugin for Claude Code — messaging where AI agents are first-class citizens",
   "type": "module",
   "main": "dist/index.js",
@@ -23,19 +23,17 @@
     ".claude-plugin"
   ],
   "scripts": {
-    "prepare:workspace-deps": "node ../../scripts/run-workspace-prep.mjs ../../packages/core ../../packages/agent-sdk ../../packages/framework ../../packages/bridge ../../packages/agent-host",
+    "prepare:workspace-deps": "node ../../scripts/run-workspace-prep.mjs ../core ../agent-sdk ../coding-agent-host",
     "build": "npm run prepare:workspace-deps && node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc",
     "dev": "npm run prepare:workspace-deps && tsc --watch",
     "prepack": "npm run build",
     "test": "vitest run"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.3.200",
-    "@canonmsg/agent-host": "^0.4.0",
-    "@canonmsg/agent-sdk": "^3.4.4",
-    "@canonmsg/bridge": "^0.2.3",
-    "@canonmsg/core": "^3.2.1",
-    "@canonmsg/framework": "^0.2.0",
+    "@anthropic-ai/claude-agent-sdk": "^0.2.141",
+    "@canonmsg/agent-sdk": "^5.0.0",
+    "@canonmsg/coding-agent-host": "^0.2.2",
+    "@canonmsg/core": "^4.0.0",
     "@modelcontextprotocol/sdk": "^1.29.0"
   },
   "engines": {
@@ -52,9 +50,9 @@
   "repository": {
     "type": "git",
     "url": "https://github.com/HeyBobChan/canon",
-    "directory": "adapters/claude-code-plugin"
+    "directory": "packages/claude-code-plugin"
   },
-  "homepage": "https://github.com/HeyBobChan/canon/tree/main/adapters/claude-code-plugin",
+  "homepage": "https://github.com/HeyBobChan/canon/tree/main/packages/claude-code-plugin",
   "publishConfig": {
     "access": "public"
   },

package/dist/bridge-bin.d.ts

@@ -1,14 +0,0 @@
-/**
- * Packaged canon-bridge daemon resolution (bridge plan Phase 6, §F3).
- *
- * On a fresh npm install nothing has populated ~/.canon/bin yet, so
- * connectBridge()'s fallback chain (explicit binPath → $CANON_BRIDGE_BIN →
- * the shared install) has nothing to spawn. The plugin therefore ships the
- * daemon as its own @canonmsg/bridge dependency and passes the packaged
- * dist entry as binPath.
- *
- * $CANON_BRIDGE_BIN still wins: when the env override is set we return
- * undefined and let connectBridge()'s own env resolution take it (an
- * options.binPath would out-rank the env var otherwise).
- */
-export declare function resolvePackagedBridgeBin(env?: NodeJS.ProcessEnv): string | undefined;

package/dist/bridge-bin.js

@@ -1,27 +0,0 @@
-/**
- * Packaged canon-bridge daemon resolution (bridge plan Phase 6, §F3).
- *
- * On a fresh npm install nothing has populated ~/.canon/bin yet, so
- * connectBridge()'s fallback chain (explicit binPath → $CANON_BRIDGE_BIN →
- * the shared install) has nothing to spawn. The plugin therefore ships the
- * daemon as its own @canonmsg/bridge dependency and passes the packaged
- * dist entry as binPath.
- *
- * $CANON_BRIDGE_BIN still wins: when the env override is set we return
- * undefined and let connectBridge()'s own env resolution take it (an
- * options.binPath would out-rank the env var otherwise).
- */
-import { createRequire } from 'node:module';
-import { dirname, join as joinPath } from 'node:path';
-export function resolvePackagedBridgeBin(env = process.env) {
-    if (env.CANON_BRIDGE_BIN)
-        return undefined;
-    try {
-        const require = createRequire(import.meta.url);
-        const manifestPath = require.resolve('@canonmsg/bridge/package.json');
-        return joinPath(dirname(manifestPath), 'dist', 'main.js');
-    }
-    catch {
-        return undefined;
-    }
-}

package/dist/session-defaults.d.ts

@@ -1,35 +0,0 @@
-import type { AgentDefinition, EffortLevel, ThinkingConfig } from '@anthropic-ai/claude-agent-sdk';
-export type ClaudeThinkingMode = 'adaptive' | 'off';
-export type ClaudeUltracodeMode = 'on' | 'off';
-export type ClaudeEffortLevel = Extract<EffortLevel, 'low' | 'medium' | 'high' | 'xhigh' | 'max'>;
-export interface ClaudeSessionDefaults {
-    model?: string;
-    effort?: ClaudeEffortLevel;
-    thinking?: ClaudeThinkingMode;
-    ultracode?: ClaudeUltracodeMode;
-    fallbackModel?: string;
-    agentProgressSummaries?: boolean;
-    agents?: Record<string, AgentDefinition>;
-}
-export interface ClaudeSessionControlValues {
-    thinking?: ClaudeThinkingMode;
-    ultracode?: ClaudeUltracodeMode;
-}
-export interface ClaudeEffectiveSessionSettings extends ClaudeSessionDefaults {
-    runtimeControlValues: Record<string, string>;
-}
-export declare const CLAUDE_EFFORT_LEVELS: readonly ClaudeEffortLevel[];
-export declare function parseClaudeThinkingMode(value: unknown): ClaudeThinkingMode | undefined;
-export declare function parseClaudeUltracodeMode(value: unknown): ClaudeUltracodeMode | undefined;
-export declare function parseClaudeSessionDefaults(raw: unknown): ClaudeSessionDefaults;
-export declare function parseClaudeSessionControlValues(values: Record<string, string> | null | undefined): ClaudeSessionControlValues;
-export declare function claudeThinkingToConfig(mode: ClaudeThinkingMode | undefined): ThinkingConfig | undefined;
-export declare function claudeThinkingToFlagValue(mode: ClaudeThinkingMode): boolean;
-export declare function resolveEffectiveSessionSettings(input: {
-    profileDefaults?: ClaudeSessionDefaults;
-    sessionConfig?: {
-        model?: string;
-        effort?: ClaudeEffortLevel;
-        runtimeControlValues?: Record<string, string>;
-    } | null;
-}): ClaudeEffectiveSessionSettings;

package/dist/session-defaults.js

@@ -1,124 +0,0 @@
-export const CLAUDE_EFFORT_LEVELS = ['low', 'medium', 'high', 'xhigh', 'max'];
-const CLAUDE_EFFORT_VALUES = new Set(CLAUDE_EFFORT_LEVELS);
-function optionalString(value) {
-    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
-}
-function optionalBoolean(value) {
-    return typeof value === 'boolean' ? value : undefined;
-}
-export function parseClaudeThinkingMode(value) {
-    if (value === false || value === 'off' || value === 'disabled')
-        return 'off';
-    if (value === true || value === 'on' || value === 'adaptive' || value === 'enabled')
-        return 'adaptive';
-    return undefined;
-}
-export function parseClaudeUltracodeMode(value) {
-    if (value === true || value === 'on' || value === 'enabled')
-        return 'on';
-    if (value === false || value === 'off' || value === 'disabled')
-        return 'off';
-    return undefined;
-}
-function parseEffort(value) {
-    const normalized = optionalString(value);
-    if (!normalized)
-        return undefined;
-    return CLAUDE_EFFORT_VALUES.has(normalized)
-        ? normalized
-        : undefined;
-}
-function parseStringArray(value) {
-    if (!Array.isArray(value))
-        return undefined;
-    const out = value
-        .map((entry) => optionalString(entry))
-        .filter((entry) => Boolean(entry));
-    return out.length > 0 ? out : undefined;
-}
-function parseAgentDefinition(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return null;
-    const data = value;
-    const description = optionalString(data.description);
-    const prompt = optionalString(data.prompt);
-    if (!description || !prompt)
-        return null;
-    return {
-        description,
-        prompt,
-        ...(parseStringArray(data.tools) ? { tools: parseStringArray(data.tools) } : {}),
-        ...(parseStringArray(data.disallowedTools) ? { disallowedTools: parseStringArray(data.disallowedTools) } : {}),
-        ...(optionalString(data.model) ? { model: optionalString(data.model) } : {}),
-        ...(parseStringArray(data.skills) ? { skills: parseStringArray(data.skills) } : {}),
-        ...(typeof data.maxTurns === 'number' && Number.isFinite(data.maxTurns) && data.maxTurns > 0
-            ? { maxTurns: Math.floor(data.maxTurns) }
-            : {}),
-        ...(typeof data.background === 'boolean' ? { background: data.background } : {}),
-        ...(parseEffort(data.effort) ? { effort: parseEffort(data.effort) } : {}),
-    };
-}
-function parseAgents(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return undefined;
-    const out = {};
-    for (const [rawName, rawAgent] of Object.entries(value)) {
-        const name = rawName.trim();
-        if (!name)
-            continue;
-        const agent = parseAgentDefinition(rawAgent);
-        if (agent)
-            out[name] = agent;
-    }
-    return Object.keys(out).length > 0 ? out : undefined;
-}
-export function parseClaudeSessionDefaults(raw) {
-    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
-        return {};
-    const data = raw;
-    return {
-        ...(optionalString(data.model) ? { model: optionalString(data.model) } : {}),
-        ...(parseEffort(data.effort) ? { effort: parseEffort(data.effort) } : {}),
-        ...(parseClaudeThinkingMode(data.thinking) ? { thinking: parseClaudeThinkingMode(data.thinking) } : {}),
-        ...(parseClaudeUltracodeMode(data.ultracode) ? { ultracode: parseClaudeUltracodeMode(data.ultracode) } : {}),
-        ...(optionalString(data.fallbackModel) ? { fallbackModel: optionalString(data.fallbackModel) } : {}),
-        ...(optionalBoolean(data.agentProgressSummaries) !== undefined
-            ? { agentProgressSummaries: optionalBoolean(data.agentProgressSummaries) }
-            : {}),
-        ...(parseAgents(data.agents) ? { agents: parseAgents(data.agents) } : {}),
-    };
-}
-export function parseClaudeSessionControlValues(values) {
-    return {
-        ...(parseClaudeThinkingMode(values?.thinking) ? { thinking: parseClaudeThinkingMode(values?.thinking) } : {}),
-        ...(parseClaudeUltracodeMode(values?.ultracode) ? { ultracode: parseClaudeUltracodeMode(values?.ultracode) } : {}),
-    };
-}
-export function claudeThinkingToConfig(mode) {
-    if (mode === 'adaptive')
-        return { type: 'adaptive' };
-    if (mode === 'off')
-        return { type: 'disabled' };
-    return undefined;
-}
-export function claudeThinkingToFlagValue(mode) {
-    return mode !== 'off';
-}
-export function resolveEffectiveSessionSettings(input) {
-    const controlValues = parseClaudeSessionControlValues(input.sessionConfig?.runtimeControlValues);
-    const runtimeControlValues = {
-        ...(input.profileDefaults?.thinking ? { thinking: input.profileDefaults.thinking } : {}),
-        ...(input.profileDefaults?.ultracode ? { ultracode: input.profileDefaults.ultracode } : {}),
-        ...(input.sessionConfig?.runtimeControlValues ?? {}),
-        ...(controlValues.thinking ? { thinking: controlValues.thinking } : {}),
-        ...(controlValues.ultracode ? { ultracode: controlValues.ultracode } : {}),
-    };
-    return {
-        ...(input.profileDefaults ?? {}),
-        ...(input.sessionConfig?.model ? { model: input.sessionConfig.model } : {}),
-        ...(input.sessionConfig?.effort ? { effort: input.sessionConfig.effort } : {}),
-        ...(controlValues.thinking ? { thinking: controlValues.thinking } : {}),
-        ...(controlValues.ultracode ? { ultracode: controlValues.ultracode } : {}),
-        runtimeControlValues,
-    };
-}

package/dist/subagent-activity.d.ts

@@ -1,11 +0,0 @@
-import type { SDKTaskNotificationMessage, SDKTaskProgressMessage, SDKTaskStartedMessage, SDKTaskUpdatedMessage } from '@anthropic-ai/claude-agent-sdk';
-type ClaudeTaskMessage = SDKTaskNotificationMessage | SDKTaskProgressMessage | SDKTaskStartedMessage | SDKTaskUpdatedMessage;
-export interface ClaudeSubagentActivityBlock {
-    id: string;
-    kind: 'status';
-    status: 'running' | 'completed' | 'failed';
-    title: string;
-    text?: string;
-}
-export declare function mapClaudeSubagentActivity(message: ClaudeTaskMessage): ClaudeSubagentActivityBlock | null;
-export {};

package/dist/subagent-activity.js

@@ -1,51 +0,0 @@
-function titleForMessage(message) {
-    const subtype = message.subtype;
-    if (subtype === 'task_started') {
-        return message.subagent_type
-            ? `Subagent started: ${message.subagent_type}`
-            : 'Subagent started';
-    }
-    if (subtype === 'task_progress') {
-        return message.subagent_type
-            ? `Subagent progress: ${message.subagent_type}`
-            : 'Subagent progress';
-    }
-    if (subtype === 'task_updated')
-        return 'Subagent updated';
-    return `Subagent ${message.status}`;
-}
-function textForMessage(message) {
-    if (message.subtype === 'task_started')
-        return message.description;
-    if (message.subtype === 'task_progress')
-        return message.summary ?? message.description;
-    if (message.subtype === 'task_updated')
-        return message.patch.description ?? message.patch.error;
-    return message.summary;
-}
-function statusForMessage(message) {
-    if (message.subtype === 'task_notification') {
-        if (message.status === 'completed')
-            return 'completed';
-        return 'failed';
-    }
-    if (message.subtype === 'task_updated') {
-        if (message.patch.status === 'completed')
-            return 'completed';
-        if (message.patch.status === 'failed' || message.patch.status === 'killed')
-            return 'failed';
-    }
-    return 'running';
-}
-export function mapClaudeSubagentActivity(message) {
-    if ('skip_transcript' in message && message.skip_transcript)
-        return null;
-    const text = textForMessage(message);
-    return {
-        id: `task:${message.task_id}`,
-        kind: 'status',
-        status: statusForMessage(message),
-        title: titleForMessage(message),
-        ...(text ? { text } : {}),
-    };
-}