@canonmsg/codex-plugin 0.1.1 → 0.2.0

package/README.md

@@ -20,6 +20,8 @@ canon-codex-register --name "My Codex" --description "My local coding agent" --p
 canon-codex --cwd /path/to/project
 ```
 
+Registration saves a Canon profile in `~/.canon/agents.json`, the same shared profile store used by the Claude Code integration and supported by the OpenClaw plugin.
+
 ## What v1 supports
 
 - Canon messages routed into Codex turns

package/dist/host.js

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
 import { setDefaultResultOrder } from 'node:dns';
 setDefaultResultOrder('ipv4first');
+import { randomUUID } from 'node:crypto';
 import { parseArgs } from 'node:util';
 import { basename, resolve } from 'node:path';
-import { CanonClient, CanonStream, clearSessionState, getActiveProfile, initRTDBAuth, releaseLock, resolveCanonAgent, rtdbRead, rtdbWrite, writeSessionState, } from '@canonmsg/core';
+import { CanonClient, CanonStream, clearSessionState, clearTurnState, DEFAULT_RUNTIME_CAPABILITIES, getActiveProfile, initRTDBAuth, normalizeTurnMetadata, normalizeTurnState, releaseLock, resolveCanonAgent, rtdbRead, rtdbWrite, shouldTriggerAgentTurn, writeSessionState, writeTurnState, } from '@canonmsg/core';
 import { buildInboundContextLines, decideAutoReply, } from './inbound-policy.js';
 import { CodexConversationAdapter, } from './adapter.js';
 import { clearStoredThreadId, loadStoredThreadId, saveStoredThreadId, } from './session-store.js';
@@ -12,6 +13,12 @@ const IDLE_TIMEOUT_MS = 30 * 60 * 1000;
 const HEARTBEAT_MS = 30_000;
 const IDLE_CHECK_MS = 60_000;
 const CONTROL_POLL_MS = 2_000;
+const CODEX_RUNTIME_CAPABILITIES = {
+    ...DEFAULT_RUNTIME_CAPABILITIES,
+    supportsInterrupt: true,
+    supportsQueue: true,
+    supportsNonFinalPermanentMessages: true,
+};
 let workingDir = process.cwd();
 let workspaceOptions = [];
 function normalizeString(value) {
@@ -20,6 +27,22 @@ function normalizeString(value) {
     const trimmed = value.trim();
     return trimmed ? trimmed : undefined;
 }
+function normalizeRuntimeTurnState(value) {
+    const normalizedTurn = normalizeTurnState(value);
+    if (normalizedTurn) {
+        return { state: normalizedTurn.state };
+    }
+    if (!value || typeof value !== 'object')
+        return null;
+    const state = value.state;
+    if (state === 'running') {
+        return { state: 'streaming' };
+    }
+    if (state === 'requires_action') {
+        return { state: 'waiting_input' };
+    }
+    return null;
+}
 function buildWorkspaceOptions(primaryCwd, configured) {
     const uniqueDirs = Array.from(new Set([primaryCwd, ...configured].map((dir) => resolve(dir))));
     const seenLabels = new Map();
@@ -204,6 +227,18 @@ async function main() {
             return conversationCache.get(conversationId) ?? null;
         }
     }
+    async function loadSenderRuntimeState(conversationId, senderId) {
+        try {
+            const [turnState, sessionState] = await Promise.all([
+                rtdbRead(`/turn-state/${conversationId}/${senderId}`),
+                rtdbRead(`/session-state/${conversationId}/${senderId}`),
+            ]);
+            return normalizeRuntimeTurnState(turnState) ?? normalizeRuntimeTurnState(sessionState);
+        }
+        catch {
+            return null;
+        }
+    }
     async function loadParticipantContext(input) {
         const [conversation, recentMessages] = await Promise.all([
             getConversationMeta(input.conversationId),
@@ -242,6 +277,25 @@ async function main() {
             isActive: true,
         }).catch(() => { });
     }
+    function writeTurn(session) {
+        writeTurnState(session.conversationId, agentId, {
+            turnId: session.currentTurnId,
+            state: session.turnState,
+            queueDepth: session.queue.length,
+            currentSpeakerId: agentId,
+            lastAcceptedIntent: session.lastAcceptedIntent,
+            capabilities: CODEX_RUNTIME_CAPABILITIES,
+            ...(session.currentTurnOpenedAt ? { openedAt: session.currentTurnOpenedAt } : {}),
+            ...(session.turnState === 'idle' || session.turnState === 'completed' || session.turnState === 'interrupted'
+                ? { completedAt: { '.sv': 'timestamp' } }
+                : {}),
+        }).catch(() => { });
+    }
+    async function markQueuedMessageAccepted(conversationId, sourceMessageId, markAccepted) {
+        if (!markAccepted || !sourceMessageId)
+            return;
+        await client.updateMessageDisposition(conversationId, sourceMessageId, 'accepted_now').catch(() => { });
+    }
     function clearStreaming(conversationId) {
         rtdbWrite(`/streaming/${conversationId}/${agentId}`, null).catch(() => { });
     }
@@ -252,6 +306,7 @@ async function main() {
         session.closed = true;
         clearStreaming(conversationId);
         clearSessionState(conversationId, agentId).catch(() => { });
+        clearTurnState(conversationId, agentId).catch(() => { });
         client.setTyping(conversationId, false).catch(() => { });
         sessions.delete(conversationId);
     }
@@ -309,11 +364,16 @@ async function main() {
                     model: sessionModel,
                     state: 'idle',
                 },
+                turnState: 'idle',
+                currentTurnId: null,
+                currentTurnOpenedAt: null,
+                lastAcceptedIntent: null,
                 lastActivity: Date.now(),
                 closed: false,
             };
             sessions.set(conversationId, session);
             writeState(session);
+            writeTurn(session);
             return session;
         })();
         pendingSessionCreations.set(conversationId, creation);
@@ -324,9 +384,16 @@ async function main() {
             pendingSessionCreations.delete(conversationId);
         }
     }
-    function enqueuePrompt(session, prompt) {
-        session.queue.push(prompt);
+    function enqueuePrompt(session, prompt, intent = 'queue', toFront = false, sourceMessageId, markAccepted = false) {
+        const nextPrompt = { prompt, intent, sourceMessageId, markAccepted };
+        if (toFront) {
+            session.queue.unshift(nextPrompt);
+        }
+        else {
+            session.queue.push(nextPrompt);
+        }
         session.lastActivity = Date.now();
+        writeTurn(session);
         void runNextTurn(session);
     }
     async function enqueueInboundMessage(input) {
@@ -344,23 +411,41 @@ async function main() {
         }
         console.error(`[canon-codex] [${input.conversationId.slice(0, 8)}] Message from ${input.senderName}: "${content.slice(0, 80)}" (${autoReply.reason})`);
         const session = await getOrCreateSession(input.conversationId);
-        enqueuePrompt(session, buildCanonPrompt({
+        const turnMetadata = normalizeTurnMetadata(input.message.metadata);
+        const deliveryIntent = turnMetadata?.deliveryIntent ?? 'queue';
+        const shouldMarkAccepted = turnMetadata?.inboundDisposition === 'queued';
+        const prompt = buildCanonPrompt({
             content,
             conversationId: input.conversationId,
             participantContext,
-        }));
+        });
+        if (session.running && deliveryIntent === 'interrupt') {
+            enqueuePrompt(session, prompt, deliveryIntent, true, input.message.id, shouldMarkAccepted);
+            console.error(`[canon-codex] [${input.conversationId.slice(0, 8)}] Interrupting current turn for explicit human send-now`);
+            await session.adapter.interrupt().catch(() => { });
+            clearStreaming(input.conversationId);
+            client.setTyping(input.conversationId, false).catch(() => { });
+            return;
+        }
+        enqueuePrompt(session, prompt, deliveryIntent, false, input.message.id, shouldMarkAccepted);
     }
     async function runNextTurn(session) {
         if (session.running || session.closed)
             return;
-        const prompt = session.queue.shift();
-        if (!prompt)
+        const nextTurn = session.queue.shift();
+        if (!nextTurn)
             return;
         session.running = true;
         session.state.lastError = undefined;
         session.state.state = 'running';
+        session.currentTurnId = randomUUID();
+        session.currentTurnOpenedAt = Date.now();
+        session.lastAcceptedIntent = nextTurn.intent;
+        session.turnState = 'thinking';
         session.lastActivity = Date.now();
+        await markQueuedMessageAccepted(session.conversationId, nextTurn.sourceMessageId, nextTurn.markAccepted);
         writeState(session);
+        writeTurn(session);
         client.setTyping(session.conversationId, true, 'thinking').catch(() => { });
         rtdbWrite(`/streaming/${session.conversationId}/${agentId}`, {
             text: 'Thinking…',
@@ -368,7 +453,7 @@ async function main() {
             updatedAt: { '.sv': 'timestamp' },
         }).catch(() => { });
         try {
-            const result = await session.adapter.runTurn(prompt, (event) => {
+            const result = await session.adapter.runTurn(nextTurn.prompt, (event) => {
                 session.lastActivity = Date.now();
                 if (event.type === 'thread.started') {
                     saveStoredThreadId(agentId, session.conversationId, session.cwd, event.threadId);
@@ -376,6 +461,8 @@ async function main() {
                     return;
                 }
                 if (event.type === 'message') {
+                    session.turnState = 'streaming';
+                    writeTurn(session);
                     rtdbWrite(`/streaming/${session.conversationId}/${agentId}`, {
                         text: event.text,
                         status: 'streaming',
@@ -384,6 +471,8 @@ async function main() {
                     return;
                 }
                 if (event.type === 'command.started') {
+                    session.turnState = 'tool';
+                    writeTurn(session);
                     client.setTyping(session.conversationId, false).catch(() => { });
                     rtdbWrite(`/streaming/${session.conversationId}/${agentId}`, {
                         text: summarizeCommand(event.command),
@@ -393,6 +482,8 @@ async function main() {
                     return;
                 }
                 if (event.type === 'turn.completed') {
+                    session.turnState = 'completed';
+                    writeTurn(session);
                     writeState(session);
                 }
             }, (line) => {
@@ -404,19 +495,39 @@ async function main() {
             clearStreaming(session.conversationId);
             client.setTyping(session.conversationId, false).catch(() => { });
             if (!result.interrupted && result.finalMessage) {
-                await client.sendMessage(session.conversationId, result.finalMessage);
+                session.turnState = 'completed';
+                writeTurn(session);
+                await client.sendMessage(session.conversationId, result.finalMessage, {
+                    metadata: {
+                        turnId: session.currentTurnId,
+                        turnSemantics: 'turn_complete',
+                        turnComplete: true,
+                        deliveryIntent: session.lastAcceptedIntent ?? undefined,
+                    },
+                });
                 console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Sent reply (${result.finalMessage.length} chars)`);
             }
             else if (!result.interrupted && result.exitCode && result.exitCode !== 0) {
                 const userVisibleError = formatTurnFailure(result.errorText);
                 session.state.lastError = userVisibleError;
+                session.turnState = 'completed';
                 writeState(session);
+                writeTurn(session);
                 if (result.errorText) {
                     console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Turn exited ${result.exitCode}: ${result.errorText}`);
                 }
-                await client.sendMessage(session.conversationId, userVisibleError);
+                await client.sendMessage(session.conversationId, userVisibleError, {
+                    metadata: {
+                        turnId: session.currentTurnId,
+                        turnSemantics: 'turn_complete',
+                        turnComplete: true,
+                        deliveryIntent: session.lastAcceptedIntent ?? undefined,
+                    },
+                });
             }
             else if (result.interrupted) {
+                session.turnState = 'interrupted';
+                writeTurn(session);
                 console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Turn interrupted`);
             }
         }
@@ -425,16 +536,30 @@ async function main() {
             client.setTyping(session.conversationId, false).catch(() => { });
             const message = `The Codex host failed to start a turn: ${error instanceof Error ? error.message : String(error)}`;
             session.state.lastError = message;
+            session.turnState = 'completed';
             writeState(session);
-            await client.sendMessage(session.conversationId, message).catch(() => { });
+            writeTurn(session);
+            await client.sendMessage(session.conversationId, message, {
+                metadata: {
+                    turnId: session.currentTurnId,
+                    turnSemantics: 'turn_complete',
+                    turnComplete: true,
+                    deliveryIntent: session.lastAcceptedIntent ?? undefined,
+                },
+            }).catch(() => { });
             clearStoredThreadId(agentId, session.conversationId);
             console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Turn failed:`, error);
         }
         finally {
             session.running = false;
             session.state.state = 'idle';
+            session.turnState = 'idle';
+            session.currentTurnId = null;
+            session.currentTurnOpenedAt = null;
+            session.lastAcceptedIntent = null;
             session.lastActivity = Date.now();
             writeState(session);
+            writeTurn(session);
             if (session.queue.length > 0) {
                 void runNextTurn(session);
             }
@@ -475,6 +600,7 @@ async function main() {
         for (const conversation of conversations) {
             clearStreaming(conversation.id);
             clearSessionState(conversation.id, agentId).catch(() => { });
+            clearTurnState(conversation.id, agentId).catch(() => { });
         }
         for (const conversation of conversations) {
             if (!conversation.lastMessage || conversation.lastMessage.senderId === agentId)
@@ -483,6 +609,18 @@ async function main() {
             const latestMessage = latestMessages[0];
             if (!latestMessage || latestMessage.senderId === agentId)
                 continue;
+            const senderTurnState = latestMessage.senderType === 'ai_agent'
+                ? await loadSenderRuntimeState(conversation.id, latestMessage.senderId)
+                : null;
+            const triggerDecision = shouldTriggerAgentTurn({
+                senderType: latestMessage.senderType ?? 'human',
+                metadata: latestMessage.metadata,
+                senderTurnState,
+            });
+            if (!triggerDecision.allow) {
+                console.error(`[canon-codex] [${conversation.id.slice(0, 8)}] Skipping startup recovery for suppressed message (${triggerDecision.reason})`);
+                continue;
+            }
             console.error(`[canon-codex] [${conversation.id.slice(0, 8)}] Recovering latest inbound message on startup`);
             await enqueueInboundMessage({
                 conversationId: conversation.id,
@@ -533,16 +671,21 @@ async function main() {
                         continue;
                     const signal = raw;
                     const timestamp = signal.updatedAt ?? 0;
-                    if (signal.type !== 'interrupt' || timestamp <= (lastSeenSignal.get(conversationId) ?? 0)) {
+                    if ((signal.type !== 'interrupt' && signal.type !== 'stop_and_drop')
+                        || timestamp <= (lastSeenSignal.get(conversationId) ?? 0)) {
                         continue;
                     }
                     lastSeenSignal.set(conversationId, timestamp);
                     const session = sessions.get(conversationId);
                     if (!session || session.closed)
                         continue;
-                    console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Interrupt signal`);
+                    console.error(`[canon-codex] [${conversationId.slice(0, 8)}] ${signal.type} signal`);
                     await session.adapter.interrupt();
-                    session.queue.length = 0;
+                    session.turnState = 'interrupted';
+                    if (signal.type === 'stop_and_drop') {
+                        session.queue.length = 0;
+                    }
+                    writeTurn(session);
                     clearStreaming(conversationId);
                     client.setTyping(conversationId, false).catch(() => { });
                 }
@@ -557,6 +700,7 @@ async function main() {
     const heartbeat = setInterval(() => {
         for (const session of sessions.values()) {
             writeState(session);
+            writeTurn(session);
         }
     }, HEARTBEAT_MS);
     const idleCheck = setInterval(() => {

package/dist/inbound-policy.js

@@ -34,10 +34,10 @@ export function decideAutoReply(context) {
     if (context.mentionedAgent) {
         return { allow: true, reason: 'another agent explicitly addressed this agent' };
     }
-    if (context.conversationType === 'group' && context.recentHumanCount === 0) {
+    if (context.conversationType === 'group') {
         return {
             allow: false,
-            reason: 'suppressing agent-only group auto-reply without a direct mention',
+            reason: 'suppressing group agent auto-reply without a direct mention',
         };
     }
     if (context.consecutiveAgentTurns >= 2 && context.recentHumanCount === 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/codex-plugin",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Canon host integration for Codex CLI",
   "type": "module",
   "main": "dist/host.js",
@@ -15,14 +15,14 @@
     "scripts"
   ],
   "scripts": {
-    "build": "tsc",
+    "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc",
     "dev": "tsc --watch",
     "smoke": "node scripts/smoke-test.mjs",
     "test": "vitest run",
-    "prepublishOnly": "npm run build"
+    "prepack": "npm run build"
   },
   "dependencies": {
-    "@canonmsg/core": "^0.2.2"
+    "@canonmsg/core": "^0.3.0"
   },
   "engines": {
     "node": ">=18.0.0"

package/dist/adapter.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/adapter.test.js

@@ -1,59 +0,0 @@
-import { EventEmitter } from 'node:events';
-import { PassThrough } from 'node:stream';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-const { spawnMock } = vi.hoisted(() => ({
-    spawnMock: vi.fn(),
-}));
-vi.mock('node:child_process', () => ({
-    spawn: spawnMock,
-}));
-import { CodexConversationAdapter } from './adapter.js';
-class MockChildProcess extends EventEmitter {
-    stdout = new PassThrough();
-    stderr = new PassThrough();
-}
-describe('CodexConversationAdapter', () => {
-    beforeEach(() => {
-        spawnMock.mockReset();
-    });
-    it('translates legacy non-interactive approval flags into --full-auto', () => {
-        const adapter = new CodexConversationAdapter({
-            cwd: '/tmp/project',
-            sandbox: 'workspace-write',
-            approvalPolicy: 'never',
-        });
-        const args = adapter.buildArgs('hello');
-        expect(args).toContain('--full-auto');
-        expect(args).not.toContain('-a');
-        expect(args).not.toContain('--ask-for-approval');
-    });
-    it('does not force --full-auto for read-only sessions', () => {
-        const adapter = new CodexConversationAdapter({
-            cwd: '/tmp/project',
-            sandbox: 'read-only',
-            approvalPolicy: 'never',
-        });
-        const args = adapter.buildArgs('hello');
-        expect(args).toContain('-s');
-        expect(args).toContain('read-only');
-        expect(args).not.toContain('--full-auto');
-    });
-    it('preserves structured turn failure text from Codex JSON output', async () => {
-        const child = new MockChildProcess();
-        spawnMock.mockReturnValue(child);
-        const adapter = new CodexConversationAdapter({
-            cwd: '/tmp/project',
-        });
-        const turnPromise = adapter.runTurn('hello', () => { });
-        child.stdout.write('{"type":"thread.started","thread_id":"thread-123"}\n');
-        child.stdout.write('{"type":"turn.started"}\n');
-        child.stdout.write('{"type":"error","message":"Quota exceeded. Check your plan and billing details."}\n');
-        child.stdout.write('{"type":"turn.failed","error":{"message":"Quota exceeded. Check your plan and billing details."}}\n');
-        child.emit('close', 1);
-        const result = await turnPromise;
-        expect(result.threadId).toBe('thread-123');
-        expect(result.exitCode).toBe(1);
-        expect(result.finalMessage).toBeNull();
-        expect(result.errorText).toBe('Quota exceeded. Check your plan and billing details.');
-    });
-});

package/dist/inbound-policy.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/inbound-policy.test.js

@@ -1,97 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { buildInboundContextLines, decideAutoReply } from './inbound-policy.js';
-function makeContext(overrides = {}) {
-    return {
-        conversationType: 'direct',
-        memberCount: 2,
-        senderType: 'human',
-        senderName: 'Alice',
-        isOwner: false,
-        mentionedAgent: false,
-        recentSenderTypes: ['human'],
-        recentHumanCount: 1,
-        recentAgentCount: 0,
-        consecutiveAgentTurns: 0,
-        ...overrides,
-    };
-}
-describe('decideAutoReply', () => {
-    it('allows human senders', () => {
-        const decision = decideAutoReply(makeContext());
-        expect(decision).toEqual({
-            allow: true,
-            reason: 'latest sender is human',
-        });
-    });
-    it('suppresses group messages from another agent without a mention', () => {
-        const decision = decideAutoReply(makeContext({
-            conversationType: 'group',
-            memberCount: 3,
-            senderType: 'ai_agent',
-            recentSenderTypes: ['ai_agent', 'ai_agent'],
-            recentHumanCount: 0,
-            recentAgentCount: 2,
-            consecutiveAgentTurns: 2,
-        }));
-        expect(decision.allow).toBe(false);
-    });
-    it('allows group agent replies while a human is still active in the recent window', () => {
-        const decision = decideAutoReply(makeContext({
-            conversationType: 'group',
-            memberCount: 3,
-            senderType: 'ai_agent',
-            recentSenderTypes: ['ai_agent', 'human'],
-            recentHumanCount: 1,
-            recentAgentCount: 1,
-            consecutiveAgentTurns: 1,
-        }));
-        expect(decision).toEqual({
-            allow: true,
-            reason: 'direct agent message allowed',
-        });
-    });
-    it('allows explicitly addressed agent messages in groups', () => {
-        const decision = decideAutoReply(makeContext({
-            conversationType: 'group',
-            memberCount: 3,
-            senderType: 'ai_agent',
-            mentionedAgent: true,
-            recentSenderTypes: ['ai_agent', 'human'],
-            recentHumanCount: 1,
-            recentAgentCount: 1,
-            consecutiveAgentTurns: 1,
-        }));
-        expect(decision).toEqual({
-            allow: true,
-            reason: 'another agent explicitly addressed this agent',
-        });
-    });
-    it('suppresses likely direct agent loops with no recent human activity', () => {
-        const decision = decideAutoReply(makeContext({
-            senderType: 'ai_agent',
-            recentSenderTypes: ['ai_agent', 'ai_agent'],
-            recentHumanCount: 0,
-            recentAgentCount: 2,
-            consecutiveAgentTurns: 2,
-        }));
-        expect(decision.allow).toBe(false);
-    });
-});
-describe('buildInboundContextLines', () => {
-    it('includes sender and recent activity context', () => {
-        const lines = buildInboundContextLines(makeContext({
-            conversationType: 'group',
-            memberCount: 4,
-            senderType: 'ai_agent',
-            senderName: 'Ernest',
-            recentSenderTypes: ['ai_agent', 'human', 'ai_agent'],
-            recentHumanCount: 1,
-            recentAgentCount: 2,
-            consecutiveAgentTurns: 1,
-        }));
-        expect(lines).toContain('Latest sender name: Ernest');
-        expect(lines).toContain('Latest sender type: ai_agent');
-        expect(lines).toContain('Conversation type: group (4 members)');
-        expect(lines).toContain('Recent sender pattern: agent -> human -> agent');
-    });
-});