@canonmsg/claude-code-plugin 0.32.0 → 0.34.0

package/dist/inbound-reply-authority.d.ts

@@ -0,0 +1,42 @@
+import type { AgentReplyAuthorityV1 } from '@canonmsg/backend-contracts';
+export interface InboundReplySource {
+    conversationId: string;
+    sourceMessageId: string;
+    replyAuthority?: AgentReplyAuthorityV1;
+}
+export interface PendingInboundReplySource extends InboundReplySource {
+    readonly generation: number;
+}
+export declare class InboundReplyAuthorityError extends Error {
+    constructor();
+}
+/**
+ * One-shot authority for Claude channel replies.
+ *
+ * Every inbound message first supersedes the previous source. The caller then
+ * activates that exact source only after deciding the message is a real Claude
+ * turn (rather than, for example, an approval response consumed locally).
+ */
+export declare class InboundReplyAuthority {
+    private readonly ttlMs;
+    private readonly now;
+    private generation;
+    private active;
+    constructor(ttlMs?: number, now?: () => number);
+    /** Supersede any prior authority before filtering the new inbound message. */
+    beginInbound(source: InboundReplySource): PendingInboundReplySource;
+    /** Activate a pending source only if no newer inbound has superseded it. */
+    authorize(source: PendingInboundReplySource): boolean;
+    /** Revoke an exact source without disturbing a newer inbound message. */
+    revoke(source: PendingInboundReplySource): void;
+    /** Validate a non-final in-turn action without consuming reply authority. */
+    validate(source: InboundReplySource): boolean;
+    /** Consume the current source when the model deliberately chooses silence. */
+    consumeNoReply(source: InboundReplySource): boolean;
+    /**
+     * Atomically claim one visible reply. A failed operation restores the claim
+     * only while the same inbound is still current and unexpired.
+     */
+    sendVisibleReply<T>(source: InboundReplySource, operation: (replyAuthority: AgentReplyAuthorityV1 | undefined) => Promise<T>): Promise<T>;
+    private getLiveActive;
+}

package/dist/inbound-reply-authority.js

@@ -0,0 +1,107 @@
+const DEFAULT_REPLY_AUTHORITY_TTL_MS = 15 * 60 * 1000;
+export class InboundReplyAuthorityError extends Error {
+    constructor() {
+        super('This reply is not authorized for the current inbound Canon message.');
+        this.name = 'InboundReplyAuthorityError';
+    }
+}
+function validSource(source) {
+    return source.conversationId.length > 0 && source.sourceMessageId.length > 0;
+}
+function sameSource(a, b) {
+    return a.conversationId === b.conversationId
+        && a.sourceMessageId === b.sourceMessageId;
+}
+/**
+ * One-shot authority for Claude channel replies.
+ *
+ * Every inbound message first supersedes the previous source. The caller then
+ * activates that exact source only after deciding the message is a real Claude
+ * turn (rather than, for example, an approval response consumed locally).
+ */
+export class InboundReplyAuthority {
+    ttlMs;
+    now;
+    generation = 0;
+    active = null;
+    constructor(ttlMs = DEFAULT_REPLY_AUTHORITY_TTL_MS, now = Date.now) {
+        this.ttlMs = ttlMs;
+        this.now = now;
+        if (!Number.isFinite(ttlMs) || ttlMs <= 0) {
+            throw new TypeError('Reply authority TTL must be positive.');
+        }
+    }
+    /** Supersede any prior authority before filtering the new inbound message. */
+    beginInbound(source) {
+        if (!validSource(source)) {
+            throw new TypeError('Inbound reply authority requires a conversation and source message.');
+        }
+        this.generation += 1;
+        this.active = null;
+        return { ...source, generation: this.generation };
+    }
+    /** Activate a pending source only if no newer inbound has superseded it. */
+    authorize(source) {
+        if (source.generation !== this.generation)
+            return false;
+        this.active = {
+            ...source,
+            expiresAt: this.now() + this.ttlMs,
+            claimed: false,
+        };
+        return true;
+    }
+    /** Revoke an exact source without disturbing a newer inbound message. */
+    revoke(source) {
+        if (this.active?.generation === source.generation && sameSource(this.active, source)) {
+            this.active = null;
+        }
+    }
+    /** Validate a non-final in-turn action without consuming reply authority. */
+    validate(source) {
+        const active = this.getLiveActive();
+        return active !== null && sameSource(active, source);
+    }
+    /** Consume the current source when the model deliberately chooses silence. */
+    consumeNoReply(source) {
+        const active = this.getLiveActive();
+        if (!active || active.claimed || !sameSource(active, source))
+            return false;
+        this.active = null;
+        return true;
+    }
+    /**
+     * Atomically claim one visible reply. A failed operation restores the claim
+     * only while the same inbound is still current and unexpired.
+     */
+    async sendVisibleReply(source, operation) {
+        const active = this.getLiveActive();
+        if (!active || active.claimed || !sameSource(active, source)) {
+            throw new InboundReplyAuthorityError();
+        }
+        active.claimed = true;
+        try {
+            const result = await operation(active.replyAuthority);
+            if (this.active === active)
+                this.active = null;
+            return result;
+        }
+        catch (error) {
+            if (this.active === active) {
+                if (this.now() < active.expiresAt) {
+                    active.claimed = false;
+                }
+                else {
+                    this.active = null;
+                }
+            }
+            throw error;
+        }
+    }
+    getLiveActive() {
+        if (this.active && this.now() >= this.active.expiresAt) {
+            this.active = null;
+        }
+        return this.active;
+    }
+}

package/dist/mcp-args.d.ts

@@ -8,11 +8,13 @@ export type McpParseResult<T> = {
 type ContentType = 'text' | 'image' | 'audio' | 'video' | 'file';
 export interface ReplyArgs {
     conversationId: string;
+    sourceMessageId: string;
     text: string;
 }
 export declare function parseReplyArgs(value: unknown): McpParseResult<ReplyArgs>;
 export interface SendMessageArgs {
     conversationId: string;
+    sourceMessageId: string;
     text: string;
     contentType: ContentType;
     imageUrl?: string;
@@ -27,6 +29,7 @@ export interface SendMessageArgs {
 export declare function parseSendMessageArgs(value: unknown): McpParseResult<SendMessageArgs>;
 export interface SetTypingArgs {
     conversationId: string;
+    sourceMessageId: string;
     typing: boolean;
     status?: 'typing' | 'thinking';
 }

package/dist/mcp-args.js

@@ -42,6 +42,9 @@ export function parseReplyArgs(value) {
     const conversationId = requiredString(value, 'conversation_id', 256);
     if (!conversationId.ok)
         return conversationId;
+    const sourceMessageId = requiredString(value, 'source_message_id', 256);
+    if (!sourceMessageId.ok)
+        return sourceMessageId;
     const text = requiredString(value, 'text');
     if (!text.ok)
         return text;
@@ -49,6 +52,7 @@ export function parseReplyArgs(value) {
         ok: true,
         value: {
             conversationId: conversationId.value,
+            sourceMessageId: sourceMessageId.value,
             text: text.value,
         },
     };
@@ -59,6 +63,9 @@ export function parseSendMessageArgs(value) {
     const conversationId = requiredString(value, 'conversation_id', 256);
     if (!conversationId.ok)
         return conversationId;
+    const sourceMessageId = requiredString(value, 'source_message_id', 256);
+    if (!sourceMessageId.ok)
+        return sourceMessageId;
     const contentType = parseContentType(value.content_type);
     if (!contentType.ok)
         return contentType;
@@ -74,6 +81,7 @@ export function parseSendMessageArgs(value) {
         ok: true,
         value: {
             conversationId: conversationId.value,
+            sourceMessageId: sourceMessageId.value,
             text: optionalString(value, 'text') ?? '',
             contentType: contentType.value,
             ...(imageUrl ? { imageUrl } : {}),
@@ -93,6 +101,9 @@ export function parseSetTypingArgs(value) {
     const conversationId = requiredString(value, 'conversation_id', 256);
     if (!conversationId.ok)
         return conversationId;
+    const sourceMessageId = requiredString(value, 'source_message_id', 256);
+    if (!sourceMessageId.ok)
+        return sourceMessageId;
     if (typeof value.typing !== 'boolean') {
         return { ok: false, error: 'typing must be a boolean' };
     }
@@ -104,6 +115,7 @@ export function parseSetTypingArgs(value) {
         ok: true,
         value: {
             conversationId: conversationId.value,
+            sourceMessageId: sourceMessageId.value,
             typing: value.typing,
             ...(status ? { status } : {}),
         },

package/dist/register.js

@@ -21,6 +21,7 @@ REQUIRED
 
 FLAGS
   --profile <name>           Local profile name in ~/.canon/agents.json
+  --agent-id <id>            Reconnect this exact transferred agent identity
   --environment <id>        Canon environment ID (or CANON_ENVIRONMENT_ID; default: canon-prod-v1)
   --base-url <url>           Canon API base URL override
   --stream-url <url>         Canon stream URL override
@@ -32,12 +33,12 @@ FLAGS
 EXAMPLES
   canon-register --name "My Claude" --description "Claude Code agent" --phone "+15551234567"
   canon-register --name "Frontend" --description "React work" --phone "+15551234567" --profile frontend
+  canon-register --name "Sold Agent" --description "Existing agent" --phone "+15551234567" --agent-id <id>
 
 After approval, start it with CANON_AGENT=<profile> canon-claude --cwd /path/to/project.`;
 const OPTIONS = {
     moduleUrl: import.meta.url,
     clientType: 'claude-code',
-    sessionSetupPolicy: 'runtime_descriptor_required',
     cliName: 'canon-register',
     hostBinName: 'canon-claude',
     developerInfo: 'Claude Code plugin',