@canonmsg/codex-plugin 0.1.0 → 0.1.1

package/README.md

@@ -2,12 +2,17 @@
 
 Connect the local Codex CLI to [Canon](https://github.com/HeyBobChan/canon) so a Canon user can message your coding agent from the app.
 
+The plugin uses the local user's existing Codex authentication by default. That means Canon follows whatever plan or login mode the user has configured in Codex itself, instead of asking for a separate Canon-side OpenAI credential.
+
 ## Quick start
 
 ```bash
 # Install
 npm install -g @canonmsg/codex-plugin
 
+# Make sure Codex itself is logged in the way you want Canon to use
+codex login status
+
 # Register (approve in Canon when prompted)
 canon-codex-register --name "My Codex" --description "My local coding agent" --phone "+15551234567"
 
@@ -37,9 +42,35 @@ canon-codex --cwd /path/to/project
 Useful flags:
 
 ```bash
-canon-codex --cwd /path/to/project --model gpt-5.4 --sandbox workspace-write --ask-for-approval never
+canon-codex --cwd /path/to/project --model gpt-5.4 --full-auto
 ```
 
+Recent Codex CLI releases no longer accept `--ask-for-approval` with `codex exec`. If you previously launched Canon with `--sandbox workspace-write --ask-for-approval never`, switch to `--full-auto`.
+
+Local smoke test:
+
+```bash
+npm run smoke -- /path/to/project
+```
+
+## Troubleshooting
+
+If Codex reports API-key quota errors while another local tool on the same machine uses OpenAI API keys, check Codex's own stored login state:
+
+```bash
+codex login status
+```
+
+Codex stores its credential mode in `~/.codex/auth.json`. If it says it is logged in using an API key, switch Codex back to ChatGPT/device auth without changing your other tools:
+
+```bash
+codex logout
+codex login --device-auth
+codex login status
+```
+
+Restart `canon-codex` after changing the Codex login state.
+
 ## Multiple agents
 
 ```bash

package/dist/adapter.js

@@ -101,6 +101,12 @@ export class CodexConversationAdapter {
                 case 'turn.completed':
                     onEvent({ type: 'turn.completed', usage: event.usage });
                     break;
+                case 'error':
+                    lastErrorText = normalizeErrorText(event.message) ?? lastErrorText;
+                    break;
+                case 'turn.failed':
+                    lastErrorText = normalizeErrorText(event.error?.message ?? event.message) ?? lastErrorText;
+                    break;
                 default:
                     break;
             }
@@ -157,15 +163,18 @@ export class CodexConversationAdapter {
             return args;
         }
         const args = ['exec', '--json', '--color', 'never', '-C', this.cwd, '--skip-git-repo-check'];
+        const execMode = resolveExecMode({
+            sandbox: this.sandbox,
+            approvalPolicy: this.approvalPolicy,
+            fullAuto: this.fullAuto,
+            bypassApprovalsAndSandbox: this.bypassApprovalsAndSandbox,
+        });
         if (this.model) {
             args.push('-m', this.model);
         }
         if (this.sandbox) {
             args.push('-s', this.sandbox);
         }
-        if (this.approvalPolicy) {
-            args.push('-a', this.approvalPolicy);
-        }
         if (this.codexProfile) {
             args.push('-p', this.codexProfile);
         }
@@ -175,10 +184,10 @@ export class CodexConversationAdapter {
         for (const configOverride of this.configOverrides) {
             args.push('-c', configOverride);
         }
-        if (this.fullAuto) {
+        if (execMode.fullAuto) {
             args.push('--full-auto');
         }
-        if (this.bypassApprovalsAndSandbox) {
+        if (execMode.bypassApprovalsAndSandbox) {
             args.push('--dangerously-bypass-approvals-and-sandbox');
         }
         args.push(prompt);
@@ -209,6 +218,28 @@ function normalizeMessageText(value) {
     const text = value.trim();
     return text ? text : null;
 }
+function normalizeErrorText(value) {
+    if (typeof value !== 'string')
+        return null;
+    const text = value.trim();
+    return text ? text : null;
+}
+function resolveExecMode(input) {
+    if (input.bypassApprovalsAndSandbox) {
+        return { fullAuto: false, bypassApprovalsAndSandbox: true };
+    }
+    if (input.fullAuto) {
+        return { fullAuto: true, bypassApprovalsAndSandbox: false };
+    }
+    // Newer Codex CLI releases no longer accept --ask-for-approval for `exec`.
+    // Preserve the old Canon example (`--sandbox workspace-write --ask-for-approval never`)
+    // by translating it to the supported `--full-auto` mode.
+    if (input.approvalPolicy === 'never' &&
+        (input.sandbox === 'workspace-write' || input.sandbox == null)) {
+        return { fullAuto: true, bypassApprovalsAndSandbox: false };
+    }
+    return { fullAuto: false, bypassApprovalsAndSandbox: false };
+}
 function isIgnorableCodexLog(line) {
     return [
         'Reading additional input from stdin...',

package/dist/adapter.test.d.ts

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

package/dist/adapter.test.js

@@ -0,0 +1,59 @@
+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/host.js

@@ -4,6 +4,7 @@ setDefaultResultOrder('ipv4first');
 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 { buildInboundContextLines, decideAutoReply, } from './inbound-policy.js';
 import { CodexConversationAdapter, } from './adapter.js';
 import { clearStoredThreadId, loadStoredThreadId, saveStoredThreadId, } from './session-store.js';
 const MAX_SESSIONS = 12;
@@ -69,17 +70,15 @@ function toPublicWorkspaceOptions() {
     return workspaceOptions.map(({ id, label }) => ({ id, label }));
 }
 function buildCanonPrompt(input) {
-    const ownerLine = input.isOwner
-        ? 'The sender is the verified human owner of this Canon agent.'
-        : 'The sender is a Canon user in this conversation.';
     return [
         'You are connected to Canon messaging through a Codex host wrapper.',
-        'Reply naturally to the Canon user.',
+        'Reply naturally to Canon participants.',
         'Only the last assistant message from this turn will be delivered as the permanent Canon reply.',
         'Short intermediate assistant messages may be shown as ephemeral status while you work.',
-        ownerLine,
+        ...buildInboundContextLines(input.participantContext),
+        'Canon participants may be humans or AI agents.',
+        'If the latest message came from another AI agent, avoid agent-only ping-pong and only reply when directly addressed, when a human is clearly steering, or when a reply is genuinely necessary.',
         `Conversation ID: ${input.conversationId}`,
-        `Sender: ${input.senderName}`,
         '',
         'New Canon message:',
         input.content,
@@ -87,7 +86,25 @@ function buildCanonPrompt(input) {
 }
 function renderInboundContent(message) {
     let content = message.text || '';
-    if (message.contentType === 'audio' && message.audioUrl) {
+    const attachment = message.attachments?.[0];
+    if (attachment?.kind === 'audio' && attachment.url) {
+        const duration = attachment.durationMs ? ` (${Math.round(attachment.durationMs / 1000)}s)` : '';
+        content = content
+            ? `[Voice message${duration}: ${attachment.url}]\n${content}`
+            : `[Voice message${duration}: ${attachment.url}]`;
+    }
+    else if (attachment?.kind === 'image' && attachment.url) {
+        content = content
+            ? `[Image: ${attachment.url}]\n${content}`
+            : `[Image: ${attachment.url}]`;
+    }
+    else if (attachment?.kind === 'file' && attachment.url) {
+        const label = attachment.fileName || 'File';
+        content = content
+            ? `[File: ${label} ${attachment.url}]\n${content}`
+            : `[File: ${label} ${attachment.url}]`;
+    }
+    else if (message.contentType === 'audio' && message.audioUrl) {
         const duration = message.audioDurationMs ? ` (${Math.round(message.audioDurationMs / 1000)}s)` : '';
         content = content
             ? `[Voice message${duration}: ${message.audioUrl}]\n${content}`
@@ -107,6 +124,14 @@ function summarizeCommand(command) {
     const shortened = trimmed.length > 140 ? `${trimmed.slice(0, 137)}...` : trimmed;
     return `Running: ${shortened}`;
 }
+function formatTurnFailure(errorText) {
+    if (!errorText) {
+        return 'The Codex session stopped unexpectedly before sending a final reply.';
+    }
+    const normalized = errorText.replace(/^error:\s*/i, '').trim();
+    const shortened = normalized.length > 280 ? `${normalized.slice(0, 277)}...` : normalized;
+    return `Codex failed before sending a final reply: ${shortened}`;
+}
 async function main() {
     const { values: args } = parseArgs({
         options: {
@@ -126,6 +151,9 @@ async function main() {
     });
     workingDir = (typeof args.cwd === 'string' ? args.cwd : null) || process.cwd();
     workspaceOptions = buildWorkspaceOptions(workingDir, args.workspace ?? []);
+    if (typeof args['ask-for-approval'] === 'string') {
+        console.error('[canon-codex] Note: newer Codex CLI releases do not accept --ask-for-approval for `codex exec`; Canon will translate compatible legacy usage when possible.');
+    }
     const { apiKey, agentId: profileAgentId, profile } = resolveCanonAgent({ logPrefix: '[canon-codex]' });
     console.error(`[canon-codex] Starting${profile ? ` (profile: ${profile})` : ''} in ${workingDir}`);
     const client = new CanonClient(apiKey);
@@ -150,8 +178,62 @@ async function main() {
     }
     const sessions = new Map();
     const pendingSessionCreations = new Map();
+    const conversationCache = new Map();
+    let conversationCacheLoadedAt = 0;
+    async function refreshConversationCache(force = false) {
+        if (!force && conversationCache.size > 0 && Date.now() - conversationCacheLoadedAt < 10_000) {
+            return;
+        }
+        const conversations = await client.getConversations();
+        conversationCache.clear();
+        for (const conversation of conversations) {
+            conversationCache.set(conversation.id, conversation);
+        }
+        conversationCacheLoadedAt = Date.now();
+    }
+    async function getConversationMeta(conversationId) {
+        try {
+            await refreshConversationCache();
+            const cached = conversationCache.get(conversationId);
+            if (cached)
+                return cached;
+            await refreshConversationCache(true);
+            return conversationCache.get(conversationId) ?? null;
+        }
+        catch {
+            return conversationCache.get(conversationId) ?? null;
+        }
+    }
+    async function loadParticipantContext(input) {
+        const [conversation, recentMessages] = await Promise.all([
+            getConversationMeta(input.conversationId),
+            client.getMessages(input.conversationId, 6).catch(() => []),
+        ]);
+        const recentSenderTypes = recentMessages
+            .filter((message) => message.senderId !== agentId)
+            .map((message) => message.senderType);
+        let consecutiveAgentTurns = 0;
+        for (const senderType of recentSenderTypes) {
+            if (senderType !== 'ai_agent')
+                break;
+            consecutiveAgentTurns += 1;
+        }
+        return {
+            conversationType: conversation?.type ?? 'unknown',
+            memberCount: conversation?.memberIds?.length ?? null,
+            senderType: input.message.senderType ?? 'human',
+            senderName: input.senderName,
+            isOwner: input.isOwner,
+            mentionedAgent: Array.isArray(input.message.mentions) && input.message.mentions.includes(agentId),
+            recentSenderTypes,
+            recentHumanCount: recentSenderTypes.filter((senderType) => senderType === 'human').length,
+            recentAgentCount: recentSenderTypes.filter((senderType) => senderType === 'ai_agent').length,
+            consecutiveAgentTurns,
+        };
+    }
     function writeState(session) {
         writeSessionState(session.conversationId, agentId, {
+            lastError: session.state.lastError,
             model: session.state.model,
             cwd: session.cwd,
             hostMode: true,
@@ -249,13 +331,23 @@ async function main() {
     }
     async function enqueueInboundMessage(input) {
         const content = renderInboundContent(input.message);
-        console.error(`[canon-codex] [${input.conversationId.slice(0, 8)}] Message from ${input.senderName}: "${content.slice(0, 80)}"`);
+        const participantContext = await loadParticipantContext({
+            conversationId: input.conversationId,
+            message: input.message,
+            senderName: input.senderName,
+            isOwner: input.isOwner,
+        });
+        const autoReply = decideAutoReply(participantContext);
+        if (!autoReply.allow) {
+            console.error(`[canon-codex] [${input.conversationId.slice(0, 8)}] Suppressed auto-reply: ${autoReply.reason}`);
+            return;
+        }
+        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({
             content,
             conversationId: input.conversationId,
-            isOwner: input.isOwner,
-            senderName: input.senderName,
+            participantContext,
         }));
     }
     async function runNextTurn(session) {
@@ -265,6 +357,7 @@ async function main() {
         if (!prompt)
             return;
         session.running = true;
+        session.state.lastError = undefined;
         session.state.state = 'running';
         session.lastActivity = Date.now();
         writeState(session);
@@ -315,10 +408,13 @@ async function main() {
                 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;
+                writeState(session);
                 if (result.errorText) {
                     console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Turn exited ${result.exitCode}: ${result.errorText}`);
                 }
-                await client.sendMessage(session.conversationId, 'The Codex session stopped unexpectedly before sending a final reply.');
+                await client.sendMessage(session.conversationId, userVisibleError);
             }
             else if (result.interrupted) {
                 console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Turn interrupted`);
@@ -327,7 +423,10 @@ async function main() {
         catch (error) {
             clearStreaming(session.conversationId);
             client.setTyping(session.conversationId, false).catch(() => { });
-            await client.sendMessage(session.conversationId, `The Codex host failed to start a turn: ${error instanceof Error ? error.message : String(error)}`).catch(() => { });
+            const message = `The Codex host failed to start a turn: ${error instanceof Error ? error.message : String(error)}`;
+            session.state.lastError = message;
+            writeState(session);
+            await client.sendMessage(session.conversationId, message).catch(() => { });
             clearStoredThreadId(agentId, session.conversationId);
             console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Turn failed:`, error);
         }

package/dist/inbound-policy.d.ts

@@ -0,0 +1,19 @@
+import type { CanonConversation } from '@canonmsg/core';
+export interface InboundParticipantContext {
+    conversationType: CanonConversation['type'] | 'unknown';
+    memberCount: number | null;
+    senderType: 'human' | 'ai_agent';
+    senderName: string;
+    isOwner: boolean;
+    mentionedAgent: boolean;
+    recentSenderTypes: Array<'human' | 'ai_agent'>;
+    recentHumanCount: number;
+    recentAgentCount: number;
+    consecutiveAgentTurns: number;
+}
+export interface AutoReplyDecision {
+    allow: boolean;
+    reason: string;
+}
+export declare function buildInboundContextLines(context: InboundParticipantContext): string[];
+export declare function decideAutoReply(context: InboundParticipantContext): AutoReplyDecision;

package/dist/inbound-policy.js

@@ -0,0 +1,50 @@
+function formatRecentSenders(senderTypes) {
+    if (senderTypes.length === 0)
+        return 'none';
+    return senderTypes.map((senderType) => (senderType === 'ai_agent' ? 'agent' : 'human')).join(' -> ');
+}
+export function buildInboundContextLines(context) {
+    const conversationTypeLabel = context.conversationType === 'unknown'
+        ? 'unknown'
+        : `${context.conversationType}${context.memberCount ? ` (${context.memberCount} members)` : ''}`;
+    const senderRole = context.isOwner
+        ? 'The latest sender is the verified human owner of this Canon agent.'
+        : context.senderType === 'ai_agent'
+            ? 'The latest sender is another AI agent in Canon.'
+            : 'The latest sender is a human Canon participant.';
+    return [
+        senderRole,
+        `Latest sender name: ${context.senderName}`,
+        `Latest sender type: ${context.senderType}`,
+        `Conversation type: ${conversationTypeLabel}`,
+        `Directly addressed to this agent: ${context.mentionedAgent ? 'yes' : 'no'}`,
+        `Recent sender pattern: ${formatRecentSenders(context.recentSenderTypes)}`,
+        `Recent human messages: ${context.recentHumanCount}`,
+        `Recent agent messages: ${context.recentAgentCount}`,
+        `Consecutive recent agent turns: ${context.consecutiveAgentTurns}`,
+    ];
+}
+export function decideAutoReply(context) {
+    if (context.senderType !== 'ai_agent') {
+        return { allow: true, reason: 'latest sender is human' };
+    }
+    if (context.isOwner) {
+        return { allow: true, reason: 'owner messages always pass through' };
+    }
+    if (context.mentionedAgent) {
+        return { allow: true, reason: 'another agent explicitly addressed this agent' };
+    }
+    if (context.conversationType === 'group' && context.recentHumanCount === 0) {
+        return {
+            allow: false,
+            reason: 'suppressing agent-only group auto-reply without a direct mention',
+        };
+    }
+    if (context.consecutiveAgentTurns >= 2 && context.recentHumanCount === 0) {
+        return {
+            allow: false,
+            reason: 'suppressing likely agent-only loop in a direct conversation',
+        };
+    }
+    return { allow: true, reason: 'direct agent message allowed' };
+}

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

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

package/dist/inbound-policy.test.js

@@ -0,0 +1,97 @@
+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');
+    });
+});

package/dist/setup.js

@@ -11,6 +11,9 @@ else {
     console.log('Install Codex first, then rerun this setup.\n');
 }
 console.log('Next steps:');
+console.log('  0. Confirm Codex is logged in the way you want Canon to use');
+console.log('     codex login status');
+console.log('');
 console.log('  1. Register your agent');
 console.log('     canon-codex-register --name "My Codex" --description "My local coding agent" --phone "+15551234567"');
 console.log('');
@@ -20,5 +23,7 @@ console.log('');
 console.log('Optional flags:');
 console.log('  --model gpt-5.4');
 console.log('  --sandbox workspace-write');
-console.log('  --ask-for-approval never');
 console.log('  --full-auto');
+console.log('');
+console.log('Note: recent Codex CLI versions use --full-auto for non-interactive write access.');
+console.log('Note: Canon uses the local Codex login state by default (for example ChatGPT/device auth or API-key auth).');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/codex-plugin",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Canon host integration for Codex CLI",
   "type": "module",
   "main": "dist/host.js",
@@ -11,11 +11,14 @@
     "canon-codex-setup": "dist/setup.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "scripts"
   ],
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch",
+    "smoke": "node scripts/smoke-test.mjs",
+    "test": "vitest run",
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
@@ -42,7 +45,8 @@
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
-    "typescript": "~5.7.0"
+    "typescript": "~5.7.0",
+    "vitest": "^3.0.0"
   },
   "license": "MIT"
 }

package/scripts/smoke-test.mjs

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+
+import { spawn } from 'node:child_process';
+import { resolve } from 'node:path';
+
+const targetCwd = resolve(process.argv[2] || process.cwd());
+const prompt = 'Reply with exactly OK.';
+
+function run(command, args) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    const child = spawn(command, args, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', (chunk) => {
+      stdout += chunk.toString();
+    });
+
+    child.stderr.on('data', (chunk) => {
+      stderr += chunk.toString();
+    });
+
+    child.on('error', rejectPromise);
+    child.on('close', (code) => {
+      resolvePromise({ code, stdout, stderr });
+    });
+  });
+}
+
+function parseJsonLines(text) {
+  return text
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((line) => line.startsWith('{'))
+    .map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean);
+}
+
+const version = await run('codex', ['--version']);
+if (version.code !== 0) {
+  console.error('codex --version failed');
+  process.exit(version.code ?? 1);
+}
+
+console.log(version.stdout.trim());
+console.log(`Workspace: ${targetCwd}`);
+
+const result = await run('codex', [
+  'exec',
+  '--json',
+  '--color',
+  'never',
+  '-C',
+  targetCwd,
+  '--skip-git-repo-check',
+  prompt,
+]);
+
+const events = parseJsonLines(result.stdout);
+const threadStarted = events.find((event) => event?.type === 'thread.started');
+const turnFailed = events.find((event) => event?.type === 'turn.failed');
+const messageEvent = [...events].reverse().find(
+  (event) => event?.type === 'item.completed' && event?.item?.type === 'agent_message',
+);
+
+if (threadStarted) {
+  console.log(`Thread started: ${threadStarted.thread_id}`);
+}
+
+if (messageEvent?.item?.text) {
+  console.log(`Final message: ${String(messageEvent.item.text).trim()}`);
+}
+
+if (turnFailed?.error?.message) {
+  console.error(`Turn failed: ${turnFailed.error.message}`);
+}
+
+if (result.stderr.trim()) {
+  console.error('stderr:');
+  console.error(result.stderr.trim());
+}
+
+process.exit(result.code ?? 1);