botmux 3.10.0 → 3.23.1

package/dist/features/codex-notifier/side-conversation-monitor.js

@@ -1,774 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { existsSync, readdirSync, statSync, } from 'node:fs';
-import { createConnection } from 'node:net';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { createCodexNotifierCompletionEvent } from './event.js';
-import { resolveCodexNotifierConfig } from './config.js';
-import { enqueueCodexNotifierEvent } from './outbox.js';
-import { detectScreenLock, shouldNotifyForLockState, } from './screen-lock.js';
-const THREAD_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-const IPC_MAX_FRAME_BYTES = 16 * 1024 * 1024;
-const MAX_TRACKED_STATE_BYTES = 32 * 1024 * 1024;
-const IPC_RETRY_MS = 1_000;
-const SCAN_INTERVAL_MS = 500;
-const IPC_CONNECT_TIMEOUT_MS = 5_000;
-const IPC_INITIALIZE_TIMEOUT_MS = 5_000;
-const MAX_RECENT_THREAD_IDS = 64;
-const MAX_TRACKED_CONVERSATIONS = 128;
-const MAX_PENDING_SIDE_EVENTS = 256;
-const MAX_PENDING_SIDE_BYTES = 2 * 1024 * 1024;
-const THREAD_STREAM_FOLLOWING_VERSION = 1;
-const MIN_DATE_MS = -8_640_000_000_000_000;
-const MAX_DATE_MS = 8_640_000_000_000_000;
-function plainObject(value) {
-    return !!value && typeof value === 'object' && !Array.isArray(value);
-}
-function forbiddenPatchSegment(value) {
-    return typeof value === 'string'
-        && (value === '__proto__' || value === 'prototype' || value === 'constructor');
-}
-/** 应用 Codex Desktop 发出的 Immer 风格 JSON Patch。 */
-export function applyCodexConversationPatches(state, patches) {
-    if (patches.length > 20_000)
-        throw new Error('codex_side_chat_patch_count_exceeded');
-    let root = state;
-    for (const patch of patches) {
-        if ((patch.op !== 'add' && patch.op !== 'replace' && patch.op !== 'remove')
-            || !Array.isArray(patch.path)
-            || patch.path.length > 64
-            || patch.path.some(forbiddenPatchSegment)) {
-            throw new Error('codex_side_chat_patch_path_invalid');
-        }
-        if (patch.path.length === 0) {
-            if (patch.op === 'remove' || !plainObject(patch.value)) {
-                throw new Error('codex_side_chat_root_patch_invalid');
-            }
-            root = patch.value;
-            continue;
-        }
-        let parent = root;
-        for (const segment of patch.path.slice(0, -1)) {
-            if (!parent || typeof parent !== 'object') {
-                throw new Error('codex_side_chat_patch_parent_invalid');
-            }
-            parent = parent[segment];
-        }
-        if (!parent || typeof parent !== 'object') {
-            throw new Error('codex_side_chat_patch_parent_invalid');
-        }
-        const key = patch.path.at(-1);
-        if (Array.isArray(parent)) {
-            const index = key === '-' ? parent.length : Number(key);
-            if (!Number.isSafeInteger(index) || index < 0 || index > parent.length) {
-                throw new Error('codex_side_chat_patch_index_invalid');
-            }
-            if (patch.op === 'add')
-                parent.splice(index, 0, patch.value);
-            else if (patch.op === 'replace' && index < parent.length)
-                parent[index] = patch.value;
-            else if (patch.op === 'remove' && index < parent.length)
-                parent.splice(index, 1);
-            else
-                throw new Error('codex_side_chat_patch_index_invalid');
-            continue;
-        }
-        if (typeof key !== 'string')
-            throw new Error('codex_side_chat_patch_key_invalid');
-        if (patch.op === 'remove')
-            delete parent[key];
-        else
-            parent[key] = patch.value;
-    }
-    if (!plainObject(root))
-        throw new Error('codex_side_chat_state_invalid');
-    return root;
-}
-function turnEntities(state) {
-    const entities = state.turnHistory?.history?.entitiesByKey;
-    if (!plainObject(entities))
-        return [];
-    return Object.values(entities).filter(plainObject);
-}
-function terminalStatus(value) {
-    if (value === 'completed')
-        return 'completed';
-    if (value === 'failed')
-        return 'failed';
-    if (value === 'interrupted' || value === 'cancelled')
-        return 'cancelled';
-    return undefined;
-}
-function turnStatusById(state) {
-    const result = new Map();
-    for (const turn of turnEntities(state)) {
-        if (typeof turn.turnId === 'string' && turn.turnId)
-            result.set(turn.turnId, turn.status);
-    }
-    return result;
-}
-function turnPrompt(turn) {
-    const input = turn.params?.input;
-    if (Array.isArray(input)) {
-        const text = input
-            .filter(item => plainObject(item) && item.type === 'text' && typeof item.text === 'string')
-            .map(item => item.text.trim())
-            .filter(Boolean)
-            .join('\n\n');
-        if (text)
-            return text;
-    }
-    for (const item of Array.isArray(turn.items) ? turn.items : []) {
-        if (!plainObject(item) || item.type !== 'userMessage' || !Array.isArray(item.content))
-            continue;
-        const text = item.content
-            .filter(part => plainObject(part) && part.type === 'text' && typeof part.text === 'string')
-            .map(part => part.text.trim())
-            .filter(Boolean)
-            .join('\n\n');
-        if (text)
-            return text;
-    }
-    return undefined;
-}
-function turnFinalPreview(turn) {
-    const items = Array.isArray(turn.items) ? turn.items : [];
-    for (let index = items.length - 1; index >= 0; index -= 1) {
-        const item = items[index];
-        if (plainObject(item)
-            && item.type === 'agentMessage'
-            && typeof item.text === 'string'
-            && item.text.trim()) {
-            return item.text;
-        }
-    }
-    return undefined;
-}
-function validDateMs(value) {
-    const number = Number(value);
-    return Number.isFinite(number) && number >= MIN_DATE_MS && number <= MAX_DATE_MS
-        ? number
-        : undefined;
-}
-function turnCompletionMs(turn) {
-    const startedAt = Number(turn.turnStartedAtMs);
-    const duration = Number(turn.durationMs);
-    const completedAt = Number.isFinite(startedAt) && Number.isFinite(duration)
-        ? startedAt + duration
-        : Number.NaN;
-    return validDateMs(completedAt);
-}
-function observedCompletionMs(state, turn) {
-    return turnCompletionMs(turn) ?? validDateMs(state.updatedAt);
-}
-function completedAt(state, turn, now) {
-    const value = observedCompletionMs(state, turn)
-        ?? validDateMs(now)
-        ?? validDateMs(Date.now())
-        ?? 0;
-    return new Date(value).toISOString();
-}
-/** 从 Side Chat 内存态提取跨进程完成事件；结构不完整时 fail closed。 */
-export function createSideConversationCompletionEvent(state, turn, now = Date.now()) {
-    if (state.sideConversation !== true || state.ephemeral !== true)
-        return undefined;
-    const status = terminalStatus(turn.status);
-    if (!status
-        || typeof state.id !== 'string'
-        || !THREAD_ID_PATTERN.test(state.id)
-        || typeof turn.turnId !== 'string'
-        || !turn.turnId) {
-        return undefined;
-    }
-    const cwd = typeof turn.params?.cwd === 'string' && turn.params.cwd.trim()
-        ? turn.params.cwd
-        : typeof state.cwd === 'string' && state.cwd.trim()
-            ? state.cwd
-            : undefined;
-    if (!cwd)
-        return undefined;
-    try {
-        return createCodexNotifierCompletionEvent({
-            threadId: state.id,
-            nativeTurnId: turn.turnId,
-            status,
-            cwd,
-            clientSurface: 'codex-app',
-            conversationKind: 'side',
-            title: turnPrompt(turn) ?? (typeof state.title === 'string' ? state.title : undefined),
-            finalPreview: turnFinalPreview(turn),
-            completedAt: completedAt(state, turn, now),
-        });
-    }
-    catch {
-        return undefined;
-    }
-}
-function transitionedEvents(previous, state, now) {
-    if (state.sideConversation !== true || state.ephemeral !== true)
-        return [];
-    const events = [];
-    for (const turn of turnEntities(state)) {
-        if (typeof turn.turnId !== 'string'
-            || previous.get(turn.turnId) !== 'inProgress'
-            || !terminalStatus(turn.status)) {
-            continue;
-        }
-        const event = createSideConversationCompletionEvent(state, turn, now);
-        if (event)
-            events.push(event);
-    }
-    return events;
-}
-function latestTerminalEvent(state, now, terminalNotBeforeMs) {
-    const turns = turnEntities(state)
-        .filter(turn => terminalStatus(turn.status))
-        .sort((left, right) => Number(left.turnStartedAtMs ?? 0) - Number(right.turnStartedAtMs ?? 0));
-    const latest = turns.at(-1);
-    if (latest
-        && terminalNotBeforeMs !== undefined
-        && (turnCompletionMs(latest) ?? Number.NEGATIVE_INFINITY) < terminalNotBeforeMs) {
-        return undefined;
-    }
-    return latest ? createSideConversationCompletionEvent(state, latest, now) : undefined;
-}
-/**
- * 维护 IPC snapshot + patch revision，并且只把 inProgress → 终态识别为新完成。
- * 首个 snapshot 默认只建立基线，避免 Dashboard 启动时补发历史 Side Chat。
- */
-export class CodexSideConversationTracker {
-    maxConversations;
-    maxStateBytes;
-    conversations = new Map();
-    totalStateBytes = 0;
-    constructor(maxConversations = MAX_TRACKED_CONVERSATIONS, maxStateBytes = MAX_TRACKED_STATE_BYTES) {
-        this.maxConversations = maxConversations;
-        this.maxStateBytes = maxStateBytes;
-        if (!Number.isSafeInteger(maxConversations) || maxConversations <= 0) {
-            throw new Error('codex_side_chat_tracker_limit_invalid');
-        }
-        if (!Number.isSafeInteger(maxStateBytes) || maxStateBytes <= 0) {
-            throw new Error('codex_side_chat_tracker_bytes_invalid');
-        }
-    }
-    has(conversationId) {
-        return this.conversations.has(conversationId);
-    }
-    clear() {
-        this.conversations.clear();
-        this.totalStateBytes = 0;
-    }
-    delete(conversationId) {
-        const tracked = this.conversations.get(conversationId);
-        if (!tracked)
-            return;
-        this.totalStateBytes -= tracked.bytes;
-        this.conversations.delete(conversationId);
-    }
-    save(conversationId, tracked) {
-        let bytes;
-        try {
-            bytes = Buffer.byteLength(JSON.stringify(tracked.state), 'utf8');
-        }
-        catch {
-            this.delete(conversationId);
-            return;
-        }
-        this.delete(conversationId);
-        if (bytes > this.maxStateBytes)
-            return;
-        this.conversations.set(conversationId, { ...tracked, bytes });
-        this.totalStateBytes += bytes;
-        while (this.conversations.size > this.maxConversations
-            || this.totalStateBytes > this.maxStateBytes) {
-            const oldest = this.conversations.keys().next().value;
-            if (!oldest)
-                break;
-            this.delete(oldest);
-        }
-    }
-    observeSnapshot(conversationId, revision, state, options = {}) {
-        if (!plainObject(state) || state.id !== conversationId || !Number.isSafeInteger(revision)) {
-            return { events: [], needsSnapshot: true };
-        }
-        if (state.sideConversation !== true || state.ephemeral !== true) {
-            this.delete(conversationId);
-            return { events: [], needsSnapshot: false };
-        }
-        const previous = this.conversations.get(conversationId);
-        const events = previous
-            ? transitionedEvents(turnStatusById(previous.state), state, options.now ?? Date.now())
-            : options.notifyTerminalOnFirstSnapshot
-                ? [latestTerminalEvent(state, options.now ?? Date.now(), options.terminalNotBeforeMs)].filter((event) => !!event)
-                : [];
-        this.save(conversationId, { revision, state });
-        return { events, needsSnapshot: false };
-    }
-    observePatches(conversationId, baseRevision, revision, patches, now = Date.now()) {
-        const tracked = this.conversations.get(conversationId);
-        if (!tracked
-            || tracked.revision !== baseRevision
-            || !Number.isSafeInteger(revision)
-            || !Array.isArray(patches)) {
-            return { events: [], needsSnapshot: true };
-        }
-        const previous = turnStatusById(tracked.state);
-        try {
-            const state = applyCodexConversationPatches(structuredClone(tracked.state), patches);
-            this.save(conversationId, { state, revision });
-            return {
-                events: transitionedEvents(previous, state, now),
-                needsSnapshot: false,
-            };
-        }
-        catch {
-            return { events: [], needsSnapshot: true };
-        }
-    }
-}
-function localDatePath(root, date) {
-    return join(root, String(date.getFullYear()).padStart(4, '0'), String(date.getMonth() + 1).padStart(2, '0'), String(date.getDate()).padStart(2, '0'));
-}
-/** 视觉产物目录由 Codex 为每个本地线程预创建，可用于发现不落 rollout 的 Side Chat。 */
-export function listRecentCodexVisualizationThreads(codexHome, now = Date.now(), limit = MAX_RECENT_THREAD_IDS) {
-    const root = join(codexHome, 'visualizations');
-    const datePaths = new Set([
-        localDatePath(root, new Date(now)),
-        localDatePath(root, new Date(now - 24 * 60 * 60_000)),
-    ]);
-    const result = [];
-    for (const path of datePaths) {
-        if (!existsSync(path))
-            continue;
-        let entries;
-        try {
-            entries = readdirSync(path, { withFileTypes: true });
-        }
-        catch {
-            continue;
-        }
-        for (const entry of entries) {
-            if (!entry.isDirectory() || !THREAD_ID_PATTERN.test(entry.name))
-                continue;
-            try {
-                result.push({ id: entry.name, mtimeMs: statSync(join(path, entry.name)).mtimeMs });
-            }
-            catch {
-                // 目录可能在扫描期间被 Codex 清理。
-            }
-        }
-    }
-    return result
-        .sort((left, right) => right.mtimeMs - left.mtimeMs || left.id.localeCompare(right.id))
-        .slice(0, Math.max(0, limit));
-}
-function delay(ms, signal) {
-    return new Promise(resolve => {
-        if (signal?.aborted)
-            return resolve();
-        const finish = () => {
-            clearTimeout(timer);
-            signal?.removeEventListener('abort', finish);
-            resolve();
-        };
-        const timer = setTimeout(finish, ms);
-        signal?.addEventListener('abort', finish, { once: true });
-    });
-}
-function encodeIpcFrame(message) {
-    const payload = Buffer.from(JSON.stringify(message));
-    const header = Buffer.allocUnsafe(4);
-    header.writeUInt32LE(payload.length);
-    return Buffer.concat([header, payload]);
-}
-/** 监听 Codex Desktop 内部线程流，补齐原生 Hook 不覆盖的 Side Chat。 */
-export class CodexSideConversationMonitor {
-    options;
-    platform;
-    codexHome;
-    socketPath;
-    now;
-    scanIntervalMs;
-    retryMs;
-    connectTimeoutMs;
-    initializeTimeoutMs;
-    maxPendingEvents;
-    maxPendingBytes;
-    logger;
-    readConfig;
-    detectLockState;
-    enqueue;
-    listThreads;
-    connect;
-    tracker = new CodexSideConversationTracker();
-    candidates = new Map();
-    pending = new Map();
-    pendingBytes = 0;
-    observationStartedAt;
-    constructor(options) {
-        this.options = options;
-        this.platform = options.platform ?? process.platform;
-        const env = options.env ?? process.env;
-        const userHome = options.userHome ?? homedir();
-        this.codexHome = typeof env.CODEX_HOME === 'string' && env.CODEX_HOME.trim()
-            ? env.CODEX_HOME.trim()
-            : join(userHome, '.codex');
-        this.socketPath = join(this.codexHome, 'ipc', 'ipc.sock');
-        this.now = options.now ?? Date.now;
-        this.scanIntervalMs = options.scanIntervalMs ?? SCAN_INTERVAL_MS;
-        this.retryMs = options.retryMs ?? IPC_RETRY_MS;
-        this.connectTimeoutMs = options.connectTimeoutMs ?? IPC_CONNECT_TIMEOUT_MS;
-        this.initializeTimeoutMs = options.initializeTimeoutMs ?? IPC_INITIALIZE_TIMEOUT_MS;
-        this.maxPendingEvents = options.maxPendingEvents ?? MAX_PENDING_SIDE_EVENTS;
-        this.maxPendingBytes = options.maxPendingBytes ?? MAX_PENDING_SIDE_BYTES;
-        if (!Number.isSafeInteger(this.maxPendingEvents) || this.maxPendingEvents <= 0) {
-            throw new Error('codex_side_chat_pending_limit_invalid');
-        }
-        if (!Number.isSafeInteger(this.maxPendingBytes) || this.maxPendingBytes <= 0) {
-            throw new Error('codex_side_chat_pending_bytes_invalid');
-        }
-        this.logger = options.logger ?? console;
-        this.readConfig = options.readConfig ?? resolveCodexNotifierConfig;
-        this.detectLockState = options.detectLockState ?? detectScreenLock;
-        this.enqueue = options.enqueue ?? enqueueCodexNotifierEvent;
-        this.listThreads = options.listThreads ?? listRecentCodexVisualizationThreads;
-        this.connect = options.connect ?? (path => createConnection(path));
-    }
-    enabled() {
-        const config = this.readConfig();
-        return config.enabled && !!config.targetBotAppId;
-    }
-    startObservation() {
-        if (this.observationStartedAt !== undefined)
-            return;
-        this.tracker.clear();
-        this.candidates.clear();
-        this.observationStartedAt = this.now();
-    }
-    stopObservation() {
-        this.tracker.clear();
-        this.candidates.clear();
-        this.observationStartedAt = undefined;
-    }
-    queueEvents(events) {
-        for (const event of events) {
-            const config = this.readConfig();
-            if (!config.enabled || !config.targetBotAppId)
-                continue;
-            const lockState = config.notifyWhen === 'always'
-                ? 'unlocked'
-                : this.detectLockState();
-            if (!shouldNotifyForLockState(config.notifyWhen, lockState))
-                continue;
-            if (this.pending.has(event.eventId))
-                continue;
-            const item = {
-                event,
-                targetBotAppId: config.targetBotAppId,
-            };
-            const bytes = Buffer.byteLength(JSON.stringify(item), 'utf8');
-            if (this.pending.size >= this.maxPendingEvents
-                || this.pendingBytes + bytes > this.maxPendingBytes) {
-                this.logger.warn(`[codex-notifier] Side Chat 内存待入队已达上限，跳过事件: ${event.eventId.slice(0, 12)}`);
-                continue;
-            }
-            this.pending.set(event.eventId, { ...item, bytes });
-            this.pendingBytes += bytes;
-        }
-        this.flushPending();
-    }
-    flushPending() {
-        for (const [eventId, item] of this.pending) {
-            try {
-                this.enqueue(this.options.dataDir, item.targetBotAppId, item.event);
-                this.pending.delete(eventId);
-                this.pendingBytes = Math.max(0, this.pendingBytes - item.bytes);
-                this.logger.debug(`[codex-notifier] Side Chat 完成事件已入队: ${eventId.slice(0, 12)}`);
-            }
-            catch (error) {
-                this.logger.warn(`[codex-notifier] Side Chat 完成事件入队失败，将重试: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
-    }
-    async connectOnce(signal) {
-        if (this.enabled())
-            this.startObservation();
-        await new Promise((resolve) => {
-            let socket;
-            try {
-                socket = this.connect(this.socketPath);
-            }
-            catch (error) {
-                this.logger.debug(`[codex-notifier] Codex Desktop IPC 连接失败: ${error instanceof Error ? error.message : String(error)}`);
-                resolve();
-                return;
-            }
-            const header = Buffer.allocUnsafe(4);
-            let headerOffset = 0;
-            let frame;
-            let frameOffset = 0;
-            let clientId;
-            let scanTimer;
-            let connectTimer;
-            let initializeTimer;
-            const followed = new Set();
-            const ignored = new Set();
-            let settled = false;
-            const finish = () => {
-                if (settled)
-                    return;
-                settled = true;
-                if (scanTimer)
-                    clearInterval(scanTimer);
-                if (connectTimer)
-                    clearTimeout(connectTimer);
-                if (initializeTimer)
-                    clearTimeout(initializeTimer);
-                signal?.removeEventListener('abort', abort);
-                if (!socket.destroyed)
-                    socket.destroy();
-                resolve();
-            };
-            const abort = () => finish();
-            const send = (message) => {
-                if (!socket.destroyed && socket.writable)
-                    socket.write(encodeIpcFrame(message));
-            };
-            const follow = (conversationId, force = false) => {
-                if (!clientId || !THREAD_ID_PATTERN.test(conversationId))
-                    return;
-                if (!force && followed.has(conversationId))
-                    return;
-                followed.add(conversationId);
-                send({
-                    type: 'broadcast',
-                    method: 'thread-stream-following-changed',
-                    sourceClientId: clientId,
-                    params: { conversationId, hostId: 'local', following: true },
-                    version: THREAD_STREAM_FOLLOWING_VERSION,
-                });
-            };
-            const unfollow = (conversationId) => {
-                if (!clientId || !followed.delete(conversationId))
-                    return;
-                send({
-                    type: 'broadcast',
-                    method: 'thread-stream-following-changed',
-                    sourceClientId: clientId,
-                    params: { conversationId, hostId: 'local', following: false },
-                    version: THREAD_STREAM_FOLLOWING_VERSION,
-                });
-            };
-            const ignore = (conversationId) => {
-                ignored.delete(conversationId);
-                ignored.add(conversationId);
-                while (ignored.size > MAX_TRACKED_CONVERSATIONS) {
-                    const oldest = ignored.values().next().value;
-                    if (!oldest)
-                        break;
-                    ignored.delete(oldest);
-                }
-            };
-            const scan = () => {
-                if (!this.enabled()) {
-                    this.stopObservation();
-                    finish();
-                    return;
-                }
-                this.startObservation();
-                this.flushPending();
-                for (const thread of this.listThreads(this.codexHome, this.now())) {
-                    if (ignored.has(thread.id))
-                        continue;
-                    if (!followed.has(thread.id)
-                        && !this.tracker.has(thread.id)
-                        && !this.candidates.has(thread.id)) {
-                        this.candidates.set(thread.id, {
-                            notifyTerminalOnFirstSnapshot: this.observationStartedAt !== undefined,
-                            ...(this.observationStartedAt !== undefined
-                                ? { terminalNotBeforeMs: this.observationStartedAt }
-                                : {}),
-                        });
-                    }
-                    follow(thread.id);
-                }
-            };
-            const handleState = (message) => {
-                if (!this.enabled()) {
-                    this.stopObservation();
-                    finish();
-                    return;
-                }
-                const params = message.params;
-                if (!params
-                    || params.hostId !== 'local'
-                    || typeof params.conversationId !== 'string'
-                    || !plainObject(params.change)) {
-                    return;
-                }
-                const change = params.change;
-                let result;
-                if (change.type === 'snapshot') {
-                    const candidate = this.candidates.get(params.conversationId);
-                    result = this.tracker.observeSnapshot(params.conversationId, change.revision, change.conversationState, {
-                        notifyTerminalOnFirstSnapshot: candidate?.notifyTerminalOnFirstSnapshot,
-                        terminalNotBeforeMs: candidate?.terminalNotBeforeMs,
-                        now: this.now(),
-                    });
-                    this.candidates.delete(params.conversationId);
-                    if (plainObject(change.conversationState)
-                        && (change.conversationState.sideConversation !== true
-                            || change.conversationState.ephemeral !== true)) {
-                        ignore(params.conversationId);
-                        unfollow(params.conversationId);
-                        return;
-                    }
-                }
-                else if (change.type === 'patches') {
-                    result = this.tracker.observePatches(params.conversationId, change.baseRevision, change.revision, change.patches, this.now());
-                }
-                else {
-                    return;
-                }
-                if (result.needsSnapshot)
-                    follow(params.conversationId, true);
-                this.queueEvents(result.events);
-            };
-            const handleMessage = (message) => {
-                if (message.type === 'response'
-                    && message.method === 'initialize'
-                    && message.resultType === 'success'
-                    && typeof message.result?.clientId === 'string') {
-                    if (initializeTimer) {
-                        clearTimeout(initializeTimer);
-                        initializeTimer = undefined;
-                    }
-                    clientId = message.result.clientId;
-                    scan();
-                    if (settled)
-                        return;
-                    for (const conversationId of this.candidates.keys())
-                        follow(conversationId);
-                    scanTimer = setInterval(scan, this.scanIntervalMs);
-                    return;
-                }
-                if (message.type === 'client-discovery-request' && typeof message.requestId === 'string') {
-                    send({
-                        type: 'client-discovery-response',
-                        requestId: message.requestId,
-                        response: { canHandle: false },
-                    });
-                    return;
-                }
-                if (message.type !== 'broadcast')
-                    return;
-                if (message.method === 'thread-stream-state-changed') {
-                    handleState(message);
-                    return;
-                }
-                if (message.method === 'thread-stream-following-changed'
-                    && message.params?.hostId === 'local'
-                    && message.params.following === true
-                    && typeof message.params.conversationId === 'string') {
-                    if (ignored.has(message.params.conversationId))
-                        return;
-                    if (!this.tracker.has(message.params.conversationId)
-                        && !this.candidates.has(message.params.conversationId)) {
-                        this.candidates.set(message.params.conversationId, {
-                            notifyTerminalOnFirstSnapshot: this.observationStartedAt !== undefined,
-                            ...(this.observationStartedAt !== undefined
-                                ? { terminalNotBeforeMs: this.observationStartedAt }
-                                : {}),
-                        });
-                    }
-                    follow(message.params.conversationId);
-                }
-            };
-            socket.on('connect', () => {
-                if (connectTimer) {
-                    clearTimeout(connectTimer);
-                    connectTimer = undefined;
-                }
-                initializeTimer = setTimeout(() => {
-                    this.logger.warn('[codex-notifier] Codex Desktop IPC 初始化超时，将重连');
-                    finish();
-                }, this.initializeTimeoutMs);
-                initializeTimer.unref?.();
-                send({
-                    type: 'request',
-                    requestId: randomUUID(),
-                    method: 'initialize',
-                    params: { clientType: 'botmux-codex-notifier' },
-                });
-            });
-            socket.on('data', (chunk) => {
-                let chunkOffset = 0;
-                while (chunkOffset < chunk.length && !settled) {
-                    if (!frame) {
-                        const headerBytes = Math.min(4 - headerOffset, chunk.length - chunkOffset);
-                        chunk.copy(header, headerOffset, chunkOffset, chunkOffset + headerBytes);
-                        headerOffset += headerBytes;
-                        chunkOffset += headerBytes;
-                        if (headerOffset < 4)
-                            continue;
-                        const frameLength = header.readUInt32LE(0);
-                        headerOffset = 0;
-                        if (frameLength === 0 || frameLength > IPC_MAX_FRAME_BYTES) {
-                            this.logger.warn(`[codex-notifier] Codex Desktop IPC 帧长度无效: ${frameLength}`);
-                            finish();
-                            return;
-                        }
-                        frame = Buffer.allocUnsafe(frameLength);
-                        frameOffset = 0;
-                    }
-                    const frameBytes = Math.min(frame.length - frameOffset, chunk.length - chunkOffset);
-                    chunk.copy(frame, frameOffset, chunkOffset, chunkOffset + frameBytes);
-                    frameOffset += frameBytes;
-                    chunkOffset += frameBytes;
-                    if (frameOffset < frame.length)
-                        continue;
-                    const completedFrame = frame;
-                    frame = undefined;
-                    frameOffset = 0;
-                    try {
-                        handleMessage(JSON.parse(completedFrame.toString('utf8')));
-                    }
-                    catch (error) {
-                        this.logger.warn(`[codex-notifier] Codex Desktop IPC 消息解析失败: ${error instanceof Error ? error.message : String(error)}`);
-                    }
-                }
-            });
-            socket.on('error', (error) => {
-                this.logger.debug(`[codex-notifier] Codex Desktop IPC 暂不可用: ${error.message}`);
-            });
-            socket.on('close', finish);
-            signal?.addEventListener('abort', abort, { once: true });
-            connectTimer = setTimeout(() => {
-                this.logger.warn('[codex-notifier] Codex Desktop IPC 连接超时，将重连');
-                finish();
-            }, this.connectTimeoutMs);
-            connectTimer.unref?.();
-            if (signal?.aborted)
-                abort();
-        });
-    }
-    async run() {
-        if (this.platform !== 'darwin')
-            return;
-        while (!this.options.signal?.aborted) {
-            if (!this.enabled()) {
-                this.stopObservation();
-                await delay(this.scanIntervalMs, this.options.signal);
-                continue;
-            }
-            this.startObservation();
-            await this.connectOnce(this.options.signal);
-            if (!this.options.signal?.aborted)
-                await delay(this.retryMs, this.options.signal);
-        }
-    }
-}
-export async function runCodexSideConversationMonitor(options) {
-    await new CodexSideConversationMonitor(options).run();
-}
-//# sourceMappingURL=side-conversation-monitor.js.map