@canonmsg/codex-plugin 0.1.0

package/README.md

@@ -0,0 +1,56 @@
+# Canon Plugin for Codex
+
+Connect the local Codex CLI to [Canon](https://github.com/HeyBobChan/canon) so a Canon user can message your coding agent from the app.
+
+## Quick start
+
+```bash
+# Install
+npm install -g @canonmsg/codex-plugin
+
+# Register (approve in Canon when prompted)
+canon-codex-register --name "My Codex" --description "My local coding agent" --phone "+15551234567"
+
+# Run inside a project
+canon-codex --cwd /path/to/project
+```
+
+## What v1 supports
+
+- Canon messages routed into Codex turns
+- One Codex thread per Canon conversation
+- Resume by thread ID across turns
+- RTDB session state and activity heartbeat
+- Interrupt by terminating the active Codex turn
+- Tool/running status surfaced while Codex is working
+
+## Current limitation
+
+The stable `codex exec --json` surface exposes completed assistant messages and tool activity, but not token-by-token text deltas. v1 therefore reports live status and publishes the final reply when the turn completes, instead of true token streaming.
+
+## Working directory
+
+```bash
+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
+```
+
+## Multiple agents
+
+```bash
+canon-codex-register --name "Frontend" --description "React work" --phone "+1..." --profile frontend
+CANON_AGENT=frontend canon-codex --cwd ~/projects/frontend
+```
+
+## Development
+
+```bash
+cd packages/codex-plugin
+npm install
+npm run build
+```

package/dist/adapter.d.ts

@@ -0,0 +1,69 @@
+export type CodexSandboxMode = 'read-only' | 'workspace-write' | 'danger-full-access';
+export type CodexApprovalPolicy = 'untrusted' | 'on-request' | 'never';
+export type CodexEvent = {
+    type: 'thread.started';
+    threadId: string;
+} | {
+    type: 'turn.started';
+} | {
+    type: 'message';
+    text: string;
+} | {
+    type: 'command.started';
+    command: string;
+} | {
+    type: 'command.completed';
+    command: string;
+    output: string;
+    exitCode: number | null;
+} | {
+    type: 'turn.completed';
+    usage?: {
+        input_tokens?: number;
+        cached_input_tokens?: number;
+        output_tokens?: number;
+    };
+};
+export interface CodexTurnResult {
+    threadId: string | null;
+    finalMessage: string | null;
+    exitCode: number | null;
+    interrupted: boolean;
+    errorText: string | null;
+}
+export declare class CodexConversationAdapter {
+    private readonly cwd;
+    private readonly codexBin;
+    private model;
+    private readonly sandbox;
+    private readonly approvalPolicy;
+    private readonly codexProfile;
+    private readonly addDirs;
+    private readonly configOverrides;
+    private readonly fullAuto;
+    private readonly bypassApprovalsAndSandbox;
+    private child;
+    private threadId;
+    private interruptTimer;
+    private interrupted;
+    constructor(opts: {
+        cwd: string;
+        threadId?: string | null;
+        codexBin?: string;
+        model?: string | null;
+        sandbox?: CodexSandboxMode | null;
+        approvalPolicy?: CodexApprovalPolicy | null;
+        codexProfile?: string | null;
+        addDirs?: string[];
+        configOverrides?: string[];
+        fullAuto?: boolean;
+        bypassApprovalsAndSandbox?: boolean;
+    });
+    getThreadId(): string | null;
+    setModel(model: string | null): void;
+    isRunning(): boolean;
+    interrupt(): Promise<void>;
+    runTurn(prompt: string, onEvent: (event: CodexEvent) => void, onLog?: (line: string) => void): Promise<CodexTurnResult>;
+    private buildArgs;
+    private clearActiveProcess;
+}

package/dist/adapter.js

@@ -0,0 +1,221 @@
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+export class CodexConversationAdapter {
+    cwd;
+    codexBin;
+    model;
+    sandbox;
+    approvalPolicy;
+    codexProfile;
+    addDirs;
+    configOverrides;
+    fullAuto;
+    bypassApprovalsAndSandbox;
+    child = null;
+    threadId;
+    interruptTimer = null;
+    interrupted = false;
+    constructor(opts) {
+        this.cwd = opts.cwd;
+        this.threadId = opts.threadId ?? null;
+        this.codexBin = opts.codexBin ?? 'codex';
+        this.model = opts.model ?? null;
+        this.sandbox = opts.sandbox ?? null;
+        this.approvalPolicy = opts.approvalPolicy ?? null;
+        this.codexProfile = opts.codexProfile ?? null;
+        this.addDirs = opts.addDirs ?? [];
+        this.configOverrides = opts.configOverrides ?? [];
+        this.fullAuto = opts.fullAuto ?? false;
+        this.bypassApprovalsAndSandbox = opts.bypassApprovalsAndSandbox ?? false;
+    }
+    getThreadId() {
+        return this.threadId;
+    }
+    setModel(model) {
+        this.model = model;
+    }
+    isRunning() {
+        return this.child !== null;
+    }
+    async interrupt() {
+        if (!this.child)
+            return;
+        this.interrupted = true;
+        this.child.kill('SIGINT');
+        this.interruptTimer = setTimeout(() => {
+            if (this.child)
+                this.child.kill('SIGKILL');
+        }, 5_000);
+    }
+    async runTurn(prompt, onEvent, onLog) {
+        if (this.child) {
+            throw new Error('A Codex turn is already in progress for this conversation');
+        }
+        const args = this.buildArgs(prompt);
+        const child = spawn(this.codexBin, args, {
+            cwd: this.cwd,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        this.child = child;
+        this.interrupted = false;
+        let latestMessage = null;
+        let lastErrorText = null;
+        const stdout = createInterface({ input: child.stdout });
+        const stderr = createInterface({ input: child.stderr });
+        stdout.on('line', (line) => {
+            const event = parseEventLine(line);
+            if (!event)
+                return;
+            switch (event.type) {
+                case 'thread.started':
+                    this.threadId = event.thread_id;
+                    onEvent({ type: 'thread.started', threadId: event.thread_id });
+                    break;
+                case 'turn.started':
+                    onEvent({ type: 'turn.started' });
+                    break;
+                case 'item.started':
+                    if (event.item?.type === 'command_execution') {
+                        onEvent({
+                            type: 'command.started',
+                            command: String(event.item.command ?? ''),
+                        });
+                    }
+                    break;
+                case 'item.completed':
+                    if (event.item?.type === 'agent_message') {
+                        latestMessage = normalizeMessageText(event.item.text);
+                        if (latestMessage) {
+                            onEvent({ type: 'message', text: latestMessage });
+                        }
+                    }
+                    else if (event.item?.type === 'command_execution') {
+                        onEvent({
+                            type: 'command.completed',
+                            command: String(event.item.command ?? ''),
+                            output: String(event.item.aggregated_output ?? ''),
+                            exitCode: typeof event.item.exit_code === 'number' ? event.item.exit_code : null,
+                        });
+                    }
+                    break;
+                case 'turn.completed':
+                    onEvent({ type: 'turn.completed', usage: event.usage });
+                    break;
+                default:
+                    break;
+            }
+        });
+        stderr.on('line', (line) => {
+            const trimmed = line.trim();
+            if (!trimmed)
+                return;
+            if (isIgnorableCodexLog(trimmed))
+                return;
+            lastErrorText = trimmed;
+            onLog?.(trimmed);
+        });
+        return await new Promise((resolve, reject) => {
+            child.on('error', (error) => {
+                this.clearActiveProcess();
+                reject(error);
+            });
+            child.on('close', (code) => {
+                stdout.close();
+                stderr.close();
+                const interrupted = this.interrupted || code === 130;
+                const result = {
+                    threadId: this.threadId,
+                    finalMessage: latestMessage,
+                    exitCode: code,
+                    interrupted,
+                    errorText: interrupted ? null : lastErrorText,
+                };
+                this.clearActiveProcess();
+                resolve(result);
+            });
+        });
+    }
+    buildArgs(prompt) {
+        if (this.threadId) {
+            const args = ['exec', 'resume', '--json', '--skip-git-repo-check'];
+            if (this.model) {
+                args.push('-m', this.model);
+            }
+            if (this.codexProfile) {
+                args.push('-p', this.codexProfile);
+            }
+            for (const configOverride of this.configOverrides) {
+                args.push('-c', configOverride);
+            }
+            if (this.fullAuto) {
+                args.push('--full-auto');
+            }
+            if (this.bypassApprovalsAndSandbox) {
+                args.push('--dangerously-bypass-approvals-and-sandbox');
+            }
+            args.push(this.threadId, prompt);
+            return args;
+        }
+        const args = ['exec', '--json', '--color', 'never', '-C', this.cwd, '--skip-git-repo-check'];
+        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);
+        }
+        for (const addDir of this.addDirs) {
+            args.push('--add-dir', addDir);
+        }
+        for (const configOverride of this.configOverrides) {
+            args.push('-c', configOverride);
+        }
+        if (this.fullAuto) {
+            args.push('--full-auto');
+        }
+        if (this.bypassApprovalsAndSandbox) {
+            args.push('--dangerously-bypass-approvals-and-sandbox');
+        }
+        args.push(prompt);
+        return args;
+    }
+    clearActiveProcess() {
+        if (this.interruptTimer) {
+            clearTimeout(this.interruptTimer);
+            this.interruptTimer = null;
+        }
+        this.child = null;
+    }
+}
+function parseEventLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith('{'))
+        return null;
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeMessageText(value) {
+    if (typeof value !== 'string')
+        return null;
+    const text = value.trim();
+    return text ? text : null;
+}
+function isIgnorableCodexLog(line) {
+    return [
+        'Reading additional input from stdin...',
+        'ignoring interface.defaultPrompt',
+        'state db discrepancy during find_thread_path_by_id_str_in_subdir',
+        'failed to open state db',
+        'failed to initialize state runtime',
+        'Failed to delete shell snapshot',
+    ].some((pattern) => line.includes(pattern));
+}

package/dist/host.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/host.js

@@ -0,0 +1,501 @@
+#!/usr/bin/env node
+import { setDefaultResultOrder } from 'node:dns';
+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 { CodexConversationAdapter, } from './adapter.js';
+import { clearStoredThreadId, loadStoredThreadId, saveStoredThreadId, } from './session-store.js';
+const MAX_SESSIONS = 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;
+let workingDir = process.cwd();
+let workspaceOptions = [];
+function normalizeString(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed ? trimmed : undefined;
+}
+function buildWorkspaceOptions(primaryCwd, configured) {
+    const uniqueDirs = Array.from(new Set([primaryCwd, ...configured].map((dir) => resolve(dir))));
+    const seenLabels = new Map();
+    return uniqueDirs.map((cwd, index) => {
+        const baseLabel = basename(cwd) || cwd;
+        const seenCount = (seenLabels.get(baseLabel) ?? 0) + 1;
+        seenLabels.set(baseLabel, seenCount);
+        return {
+            id: index === 0 ? 'default' : `workspace-${index + 1}`,
+            label: seenCount === 1 ? baseLabel : `${baseLabel} (${seenCount})`,
+            cwd,
+        };
+    });
+}
+async function publishAgentRuntime(agentId, runtime) {
+    await rtdbWrite(`/agent-runtime/${agentId}`, {
+        clientType: 'codex',
+        hostMode: true,
+        ...runtime,
+        updatedAt: { '.sv': 'timestamp' },
+    });
+}
+async function loadSessionConfig(conversationId, agentId) {
+    const raw = await rtdbRead(`/session-config/${conversationId}/${agentId}`);
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const data = raw;
+    return {
+        workspaceId: normalizeString(data.workspaceId),
+        legacyCwd: normalizeString(data.cwd),
+        model: normalizeString(data.model),
+    };
+}
+function resolveWorkspaceCwd(config) {
+    if (config?.workspaceId) {
+        const workspace = workspaceOptions.find((option) => option.id === config.workspaceId);
+        if (workspace)
+            return workspace.cwd;
+    }
+    if (config?.legacyCwd) {
+        const workspace = workspaceOptions.find((option) => option.cwd === config.legacyCwd);
+        if (workspace)
+            return workspace.cwd;
+    }
+    return workspaceOptions[0]?.cwd ?? workingDir;
+}
+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.',
+        '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,
+        `Conversation ID: ${input.conversationId}`,
+        `Sender: ${input.senderName}`,
+        '',
+        'New Canon message:',
+        input.content,
+    ].join('\n');
+}
+function renderInboundContent(message) {
+    let content = message.text || '';
+    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}`
+            : `[Voice message${duration}: ${message.audioUrl}]`;
+    }
+    else if (message.contentType === 'image' && message.imageUrl) {
+        content = content
+            ? `[Image: ${message.imageUrl}]\n${content}`
+            : `[Image: ${message.imageUrl}]`;
+    }
+    return content || '[Empty message]';
+}
+function summarizeCommand(command) {
+    const trimmed = command.trim();
+    if (!trimmed)
+        return 'Running a command';
+    const shortened = trimmed.length > 140 ? `${trimmed.slice(0, 137)}...` : trimmed;
+    return `Running: ${shortened}`;
+}
+async function main() {
+    const { values: args } = parseArgs({
+        options: {
+            cwd: { type: 'string' },
+            model: { type: 'string' },
+            sandbox: { type: 'string' },
+            'ask-for-approval': { type: 'string' },
+            'codex-profile': { type: 'string' },
+            'add-dir': { type: 'string', multiple: true },
+            workspace: { type: 'string', multiple: true },
+            config: { type: 'string', multiple: true },
+            'codex-bin': { type: 'string' },
+            'full-auto': { type: 'boolean' },
+            'dangerously-bypass-approvals-and-sandbox': { type: 'boolean' },
+        },
+        strict: true,
+    });
+    workingDir = (typeof args.cwd === 'string' ? args.cwd : null) || process.cwd();
+    workspaceOptions = buildWorkspaceOptions(workingDir, args.workspace ?? []);
+    const { apiKey, agentId: profileAgentId, profile } = resolveCanonAgent({ logPrefix: '[canon-codex]' });
+    console.error(`[canon-codex] Starting${profile ? ` (profile: ${profile})` : ''} in ${workingDir}`);
+    const client = new CanonClient(apiKey);
+    initRTDBAuth(client);
+    let agentId;
+    let ownerId = null;
+    try {
+        const ctx = await client.getAgentMe();
+        agentId = ctx.agentId;
+        ownerId = ctx.ownerId;
+        console.error(`[canon-codex] Connected as ${ctx.displayName || agentId}`);
+    }
+    catch {
+        if (profileAgentId) {
+            agentId = profileAgentId;
+        }
+        else {
+            const auth = await client.getAuthToken();
+            agentId = auth.agentId;
+        }
+        console.error(`[canon-codex] Authenticated as ${agentId}`);
+    }
+    const sessions = new Map();
+    const pendingSessionCreations = new Map();
+    function writeState(session) {
+        writeSessionState(session.conversationId, agentId, {
+            model: session.state.model,
+            cwd: session.cwd,
+            hostMode: true,
+            clientType: 'codex',
+            state: session.state.state,
+            isActive: true,
+        }).catch(() => { });
+    }
+    function clearStreaming(conversationId) {
+        rtdbWrite(`/streaming/${conversationId}/${agentId}`, null).catch(() => { });
+    }
+    function closeSession(conversationId) {
+        const session = sessions.get(conversationId);
+        if (!session)
+            return;
+        session.closed = true;
+        clearStreaming(conversationId);
+        clearSessionState(conversationId, agentId).catch(() => { });
+        client.setTyping(conversationId, false).catch(() => { });
+        sessions.delete(conversationId);
+    }
+    function evictOldestIdle() {
+        let oldest = null;
+        for (const session of sessions.values()) {
+            if (session.running)
+                continue;
+            if (!oldest || session.lastActivity < oldest.lastActivity)
+                oldest = session;
+        }
+        if (oldest) {
+            console.error(`[canon-codex] [${oldest.conversationId.slice(0, 8)}] Evicting idle session`);
+            closeSession(oldest.conversationId);
+        }
+    }
+    async function getOrCreateSession(conversationId) {
+        const existing = sessions.get(conversationId);
+        if (existing && !existing.closed) {
+            existing.lastActivity = Date.now();
+            return existing;
+        }
+        const pending = pendingSessionCreations.get(conversationId);
+        if (pending)
+            return pending;
+        if (sessions.size >= MAX_SESSIONS) {
+            evictOldestIdle();
+        }
+        const creation = (async () => {
+            const config = await loadSessionConfig(conversationId, agentId);
+            const sessionCwd = resolveWorkspaceCwd(config);
+            const sessionModel = config?.model ?? (typeof args.model === 'string' ? args.model : undefined);
+            const storedThreadId = loadStoredThreadId(agentId, conversationId, sessionCwd);
+            const session = {
+                conversationId,
+                cwd: sessionCwd,
+                adapter: new CodexConversationAdapter({
+                    cwd: sessionCwd,
+                    threadId: storedThreadId,
+                    codexBin: typeof args['codex-bin'] === 'string' ? args['codex-bin'] : 'codex',
+                    model: sessionModel ?? null,
+                    sandbox: (typeof args.sandbox === 'string' ? args.sandbox : null),
+                    approvalPolicy: (typeof args['ask-for-approval'] === 'string'
+                        ? args['ask-for-approval']
+                        : null),
+                    codexProfile: typeof args['codex-profile'] === 'string' ? args['codex-profile'] : null,
+                    addDirs: args['add-dir'] ?? [],
+                    configOverrides: args.config ?? [],
+                    fullAuto: Boolean(args['full-auto']),
+                    bypassApprovalsAndSandbox: Boolean(args['dangerously-bypass-approvals-and-sandbox']),
+                }),
+                queue: [],
+                running: false,
+                state: {
+                    model: sessionModel,
+                    state: 'idle',
+                },
+                lastActivity: Date.now(),
+                closed: false,
+            };
+            sessions.set(conversationId, session);
+            writeState(session);
+            return session;
+        })();
+        pendingSessionCreations.set(conversationId, creation);
+        try {
+            return await creation;
+        }
+        finally {
+            pendingSessionCreations.delete(conversationId);
+        }
+    }
+    function enqueuePrompt(session, prompt) {
+        session.queue.push(prompt);
+        session.lastActivity = Date.now();
+        void runNextTurn(session);
+    }
+    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 session = await getOrCreateSession(input.conversationId);
+        enqueuePrompt(session, buildCanonPrompt({
+            content,
+            conversationId: input.conversationId,
+            isOwner: input.isOwner,
+            senderName: input.senderName,
+        }));
+    }
+    async function runNextTurn(session) {
+        if (session.running || session.closed)
+            return;
+        const prompt = session.queue.shift();
+        if (!prompt)
+            return;
+        session.running = true;
+        session.state.state = 'running';
+        session.lastActivity = Date.now();
+        writeState(session);
+        client.setTyping(session.conversationId, true, 'thinking').catch(() => { });
+        rtdbWrite(`/streaming/${session.conversationId}/${agentId}`, {
+            text: 'Thinking…',
+            status: 'thinking',
+            updatedAt: { '.sv': 'timestamp' },
+        }).catch(() => { });
+        try {
+            const result = await session.adapter.runTurn(prompt, (event) => {
+                session.lastActivity = Date.now();
+                if (event.type === 'thread.started') {
+                    saveStoredThreadId(agentId, session.conversationId, session.cwd, event.threadId);
+                    console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Thread ${event.threadId}`);
+                    return;
+                }
+                if (event.type === 'message') {
+                    rtdbWrite(`/streaming/${session.conversationId}/${agentId}`, {
+                        text: event.text,
+                        status: 'streaming',
+                        updatedAt: { '.sv': 'timestamp' },
+                    }).catch(() => { });
+                    return;
+                }
+                if (event.type === 'command.started') {
+                    client.setTyping(session.conversationId, false).catch(() => { });
+                    rtdbWrite(`/streaming/${session.conversationId}/${agentId}`, {
+                        text: summarizeCommand(event.command),
+                        status: 'tool',
+                        updatedAt: { '.sv': 'timestamp' },
+                    }).catch(() => { });
+                    return;
+                }
+                if (event.type === 'turn.completed') {
+                    writeState(session);
+                }
+            }, (line) => {
+                console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] ${line}`);
+            });
+            if (result.threadId) {
+                saveStoredThreadId(agentId, session.conversationId, session.cwd, result.threadId);
+            }
+            clearStreaming(session.conversationId);
+            client.setTyping(session.conversationId, false).catch(() => { });
+            if (!result.interrupted && result.finalMessage) {
+                await client.sendMessage(session.conversationId, result.finalMessage);
+                console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Sent reply (${result.finalMessage.length} chars)`);
+            }
+            else if (!result.interrupted && result.exitCode && result.exitCode !== 0) {
+                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.');
+            }
+            else if (result.interrupted) {
+                console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Turn interrupted`);
+            }
+        }
+        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(() => { });
+            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.lastActivity = Date.now();
+            writeState(session);
+            if (session.queue.length > 0) {
+                void runNextTurn(session);
+            }
+        }
+    }
+    const stream = new CanonStream({
+        apiKey,
+        agentId,
+        handler: {
+            onMessage: (payload) => {
+                const message = payload.message;
+                if (message.senderId === agentId)
+                    return;
+                void enqueueInboundMessage({
+                    conversationId: payload.conversationId,
+                    message,
+                    senderName: message.senderName || message.senderId,
+                    isOwner: Boolean(message.isOwner),
+                });
+            },
+            onConnected: () => console.error('[canon-codex] SSE connected'),
+            onDisconnected: () => console.error('[canon-codex] SSE disconnected'),
+            onError: (error) => console.error(`[canon-codex] SSE error: ${error.message}`),
+        },
+    });
+    try {
+        await publishAgentRuntime(agentId, {
+            defaultWorkspaceId: workspaceOptions[0]?.id,
+            ...(typeof args.model === 'string' ? { defaultModel: args.model } : {}),
+            availableWorkspaces: toPublicWorkspaceOptions(),
+        });
+    }
+    catch (error) {
+        console.error('[canon-codex] Failed to publish agent runtime:', error);
+    }
+    try {
+        const conversations = await client.getConversations();
+        for (const conversation of conversations) {
+            clearStreaming(conversation.id);
+            clearSessionState(conversation.id, agentId).catch(() => { });
+        }
+        for (const conversation of conversations) {
+            if (!conversation.lastMessage || conversation.lastMessage.senderId === agentId)
+                continue;
+            const latestMessages = await client.getMessages(conversation.id, 1);
+            const latestMessage = latestMessages[0];
+            if (!latestMessage || latestMessage.senderId === agentId)
+                continue;
+            console.error(`[canon-codex] [${conversation.id.slice(0, 8)}] Recovering latest inbound message on startup`);
+            await enqueueInboundMessage({
+                conversationId: conversation.id,
+                message: latestMessage,
+                senderName: latestMessage.senderId,
+                isOwner: ownerId != null && latestMessage.senderId === ownerId,
+            });
+        }
+    }
+    catch (error) {
+        console.error('[canon-codex] Failed to load startup conversations:', error);
+    }
+    await stream.start().catch((error) => {
+        console.error('[canon-codex] SSE start error:', error instanceof Error ? error.message : error);
+    });
+    let controlStopped = false;
+    const lastSeenControl = new Map();
+    const lastSeenSignal = new Map();
+    const pollControl = async () => {
+        while (!controlStopped) {
+            for (const conversationId of [...sessions.keys()]) {
+                try {
+                    const controlRaw = await rtdbRead(`/control/${conversationId}/${agentId}/session`);
+                    if (controlRaw && typeof controlRaw === 'object') {
+                        const control = controlRaw;
+                        const timestamp = control.updatedAt ?? 0;
+                        if (timestamp > (lastSeenControl.get(conversationId) ?? 0)) {
+                            lastSeenControl.set(conversationId, timestamp);
+                            const session = sessions.get(conversationId);
+                            if (session && !session.closed) {
+                                if (control.model && control.model !== session.state.model) {
+                                    session.adapter.setModel(control.model);
+                                    session.state.model = control.model;
+                                    console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Model set for next turn -> ${control.model}`);
+                                    writeState(session);
+                                }
+                                if (control.permissionMode) {
+                                    console.error(`[canon-codex] [${conversationId.slice(0, 8)}] permissionMode control is not mapped yet (${control.permissionMode})`);
+                                }
+                                if (control.effort) {
+                                    console.error(`[canon-codex] [${conversationId.slice(0, 8)}] effort control is not mapped yet (${control.effort})`);
+                                }
+                            }
+                        }
+                    }
+                    const raw = await rtdbRead(`/control/${conversationId}/${agentId}/signal`);
+                    if (!raw || typeof raw !== 'object')
+                        continue;
+                    const signal = raw;
+                    const timestamp = signal.updatedAt ?? 0;
+                    if (signal.type !== 'interrupt' || 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`);
+                    await session.adapter.interrupt();
+                    session.queue.length = 0;
+                    clearStreaming(conversationId);
+                    client.setTyping(conversationId, false).catch(() => { });
+                }
+                catch {
+                    // Ignore transient RTDB failures.
+                }
+            }
+            await new Promise((resolve) => setTimeout(resolve, CONTROL_POLL_MS));
+        }
+    };
+    void pollControl();
+    const heartbeat = setInterval(() => {
+        for (const session of sessions.values()) {
+            writeState(session);
+        }
+    }, HEARTBEAT_MS);
+    const idleCheck = setInterval(() => {
+        const now = Date.now();
+        for (const conversationId of [...sessions.keys()]) {
+            const session = sessions.get(conversationId);
+            if (!session || session.running)
+                continue;
+            if (now - session.lastActivity > IDLE_TIMEOUT_MS) {
+                console.error(`[canon-codex] [${conversationId.slice(0, 8)}] Idle timeout`);
+                closeSession(conversationId);
+            }
+        }
+    }, IDLE_CHECK_MS);
+    const shutdown = async () => {
+        console.error('[canon-codex] Shutting down...');
+        controlStopped = true;
+        clearInterval(heartbeat);
+        clearInterval(idleCheck);
+        stream.stop();
+        for (const session of [...sessions.values()]) {
+            await session.adapter.interrupt().catch(() => { });
+            closeSession(session.conversationId);
+        }
+        const activeProfile = getActiveProfile();
+        if (activeProfile)
+            releaseLock(activeProfile);
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+    console.error('[canon-codex] Ready — sessions created on demand');
+    await new Promise(() => { });
+}
+main().catch((error) => {
+    console.error('[canon-codex] Fatal error:', error);
+    const activeProfile = getActiveProfile();
+    if (activeProfile)
+        releaseLock(activeProfile);
+    process.exit(1);
+});

package/dist/register.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/register.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+import { setDefaultResultOrder } from 'node:dns';
+setDefaultResultOrder('ipv4first');
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { parseArgs } from 'node:util';
+import { registerAndWaitForApproval } from '@canonmsg/core';
+const CANON_DIR = join(homedir(), '.canon');
+const AGENTS_PATH = join(CANON_DIR, 'agents.json');
+const { values } = parseArgs({
+    options: {
+        name: { type: 'string' },
+        description: { type: 'string' },
+        phone: { type: 'string' },
+        profile: { type: 'string' },
+        'base-url': { type: 'string' },
+    },
+    strict: true,
+});
+if (!values.name || !values.description || !values.phone) {
+    console.error('Usage: canon-codex-register --name "Agent Name" --description "Description" --phone "+15551234567" [--profile "my-agent"]');
+    process.exit(1);
+}
+const profileName = values.profile || values.name.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-');
+console.log(`Registering Codex agent "${values.name}" (profile: ${profileName})...`);
+const result = await registerAndWaitForApproval({
+    name: values.name,
+    description: values.description,
+    ownerPhone: values.phone,
+    developerInfo: 'Codex host plugin',
+    clientType: 'codex',
+    baseUrl: values['base-url'],
+}, {
+    onSubmitted: (requestId) => {
+        console.log(`Registration submitted (request ID: ${requestId}).`);
+        console.log('Waiting for approval in Canon app...');
+    },
+    onPollUpdate: () => {
+        process.stdout.write('.');
+    },
+});
+console.log('');
+switch (result.status) {
+    case 'approved': {
+        mkdirSync(CANON_DIR, { recursive: true });
+        let profiles = {};
+        try {
+            profiles = JSON.parse(readFileSync(AGENTS_PATH, 'utf-8'));
+        }
+        catch {
+            // File does not exist yet.
+        }
+        profiles[profileName] = {
+            apiKey: result.apiKey,
+            agentId: result.agentId,
+            agentName: result.agentName,
+            registeredAt: new Date().toISOString(),
+        };
+        writeFileSync(AGENTS_PATH, JSON.stringify(profiles, null, 2));
+        console.log(`Approved! Agent: ${result.agentName} (${result.agentId})`);
+        console.log(`Saved as profile "${profileName}" in ~/.canon/agents.json`);
+        console.log('Start it with: canon-codex --cwd /path/to/project');
+        break;
+    }
+    case 'rejected':
+        console.log('Registration was rejected.');
+        process.exit(1);
+        break;
+    case 'timeout':
+        console.log('Registration timed out (5 minutes). Try again later.');
+        process.exit(1);
+        break;
+}

package/dist/session-store.d.ts

@@ -0,0 +1,3 @@
+export declare function loadStoredThreadId(agentId: string, conversationId: string, cwd: string): string | null;
+export declare function saveStoredThreadId(agentId: string, conversationId: string, cwd: string, threadId: string): void;
+export declare function clearStoredThreadId(agentId: string, conversationId: string): void;

package/dist/session-store.js

@@ -0,0 +1,43 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { CANON_DIR } from '@canonmsg/core';
+const STORE_PATH = join(CANON_DIR, 'codex-sessions.json');
+function loadStore() {
+    try {
+        return JSON.parse(readFileSync(STORE_PATH, 'utf-8'));
+    }
+    catch {
+        return { agents: {} };
+    }
+}
+function saveStore(store) {
+    mkdirSync(CANON_DIR, { recursive: true });
+    writeFileSync(STORE_PATH, JSON.stringify(store, null, 2));
+}
+export function loadStoredThreadId(agentId, conversationId, cwd) {
+    const store = loadStore();
+    const record = store.agents[agentId]?.[conversationId];
+    if (!record || record.cwd !== cwd)
+        return null;
+    return record.threadId;
+}
+export function saveStoredThreadId(agentId, conversationId, cwd, threadId) {
+    const store = loadStore();
+    store.agents[agentId] ??= {};
+    store.agents[agentId][conversationId] = {
+        threadId,
+        cwd,
+        updatedAt: new Date().toISOString(),
+    };
+    saveStore(store);
+}
+export function clearStoredThreadId(agentId, conversationId) {
+    const store = loadStore();
+    if (!store.agents[agentId]?.[conversationId])
+        return;
+    delete store.agents[agentId][conversationId];
+    if (Object.keys(store.agents[agentId]).length === 0) {
+        delete store.agents[agentId];
+    }
+    saveStore(store);
+}

package/dist/setup.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/setup.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+console.log('Canon Codex Plugin Setup');
+console.log('========================\n');
+const version = spawnSync('codex', ['--version'], { encoding: 'utf-8' });
+if (version.status === 0) {
+    console.log(`Detected Codex CLI: ${version.stdout.trim()}\n`);
+}
+else {
+    console.log('Codex CLI was not detected on PATH.');
+    console.log('Install Codex first, then rerun this setup.\n');
+}
+console.log('Next steps:');
+console.log('  1. Register your agent');
+console.log('     canon-codex-register --name "My Codex" --description "My local coding agent" --phone "+15551234567"');
+console.log('');
+console.log('  2. Start the host in a project directory');
+console.log('     canon-codex --cwd /path/to/project');
+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');

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@canonmsg/codex-plugin",
+  "version": "0.1.0",
+  "description": "Canon host integration for Codex CLI",
+  "type": "module",
+  "main": "dist/host.js",
+  "types": "dist/host.d.ts",
+  "bin": {
+    "canon-codex": "dist/host.js",
+    "canon-codex-register": "dist/register.js",
+    "canon-codex-setup": "dist/setup.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@canonmsg/core": "^0.2.2"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "canon",
+    "codex",
+    "coding-agent",
+    "messaging",
+    "host-mode"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/HeyBobChan/canon",
+    "directory": "packages/codex-plugin"
+  },
+  "homepage": "https://github.com/HeyBobChan/canon/tree/main/packages/codex-plugin",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "~5.7.0"
+  },
+  "license": "MIT"
+}