handmux 0.23.0 → 0.25.0

package/dist/src/codexStreamProtocol.js

@@ -0,0 +1,207 @@
+import { parseCodexConversationMutation, parseCodexConversationMutationValue, projectCodexConversationMutation, } from './codexConversationProjection.js';
+const GOAL_STATUSES = [
+    'active', 'paused', 'blocked', 'usageLimited', 'budgetLimited', 'complete',
+];
+const GOAL_EVENTS = [
+    'set', 'restarted', 'active', 'paused', 'blocked', 'usageLimited', 'budgetLimited', 'complete',
+];
+function recordOf(value) {
+    return value != null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : null;
+}
+function nonEmptyString(value) {
+    return typeof value === 'string' && value ? value : null;
+}
+function nullableString(value) {
+    if (value == null)
+        return null;
+    return nonEmptyString(value) ?? undefined;
+}
+function optionalFiniteNumber(record, key) {
+    if (!Object.hasOwn(record, key))
+        return undefined;
+    const value = record[key];
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function parseConversationSnapshotMessages(value) {
+    if (!Array.isArray(value) || value.length > 100)
+        return null;
+    const allowedTypes = new Set([
+        'text', 'thinking', 'tool', 'plan', 'goal', 'compact', 'interrupt', 'slash',
+    ]);
+    const messages = [];
+    for (const candidate of value) {
+        const message = recordOf(candidate);
+        if (!message || typeof message.k !== 'number' || !Number.isSafeInteger(message.k) || message.k < 0
+            || typeof message.type !== 'string' || !allowedTypes.has(message.type)
+            || (message.id != null && !nonEmptyString(message.id)))
+            return null;
+        messages.push(message);
+    }
+    return messages;
+}
+export function parseCodexGoal(value) {
+    const record = recordOf(value);
+    if (!record)
+        return null;
+    const objective = nonEmptyString(record.objective);
+    const status = GOAL_STATUSES.find((candidate) => candidate === record.status);
+    if (!objective || !status)
+        return null;
+    const threadId = record.threadId == null ? undefined : nonEmptyString(record.threadId) ?? undefined;
+    if (record.threadId != null && !threadId)
+        return null;
+    const numericKeys = ['createdAt', 'updatedAt', 'tokensUsed', 'timeUsedSeconds'];
+    const numeric = Object.fromEntries(numericKeys.map((key) => [key, optionalFiniteNumber(record, key)]));
+    if (numericKeys.some((key) => Object.hasOwn(record, key) && numeric[key] === undefined))
+        return null;
+    const tokenBudget = record.tokenBudget;
+    if (Object.hasOwn(record, 'tokenBudget') && tokenBudget !== null
+        && (typeof tokenBudget !== 'number' || !Number.isFinite(tokenBudget)))
+        return null;
+    return {
+        ...record,
+        objective,
+        status,
+        ...(threadId ? { threadId } : {}),
+        ...Object.fromEntries(Object.entries(numeric).filter(([, field]) => field !== undefined)),
+        ...(Object.hasOwn(record, 'tokenBudget') ? { tokenBudget: tokenBudget } : {}),
+    };
+}
+function parseAgentEvent(record) {
+    const type = record.type;
+    if (type !== 'started' && type !== 'snapshot' && type !== 'delta' && type !== 'completed')
+        return null;
+    const threadId = nonEmptyString(record.threadId);
+    const turnId = nonEmptyString(record.turnId);
+    const itemId = nonEmptyString(record.itemId);
+    if (!threadId || !turnId || !itemId)
+        return null;
+    if (type === 'delta' && typeof record.delta !== 'string')
+        return null;
+    if (type !== 'delta' && typeof record.text !== 'string')
+        return null;
+    if (record.completed != null && typeof record.completed !== 'boolean')
+        return null;
+    return { ...record, type, threadId, turnId, itemId };
+}
+export function parseCodexStreamEvent(value) {
+    const record = recordOf(value);
+    if (!record)
+        return null;
+    const agentEvent = parseAgentEvent(record);
+    if (agentEvent)
+        return agentEvent;
+    const type = record.type;
+    if (type === 'error') {
+        const message = nonEmptyString(record.message);
+        return message ? { ...record, type, message } : null;
+    }
+    const threadId = nonEmptyString(record.threadId);
+    if (!threadId)
+        return null;
+    if (type === 'conversation') {
+        const mutation = parseCodexConversationMutationValue(record.mutation);
+        if (!mutation || mutation.operation !== 'upsert')
+            return null;
+        const turnId = mutation.message.turnId;
+        const itemId = mutation.message.type === 'text' ? mutation.message.itemId : null;
+        if (record.turnId !== turnId || record.itemId !== itemId)
+            return null;
+        return { ...record, type, threadId, turnId, itemId, mutation };
+    }
+    if (type === 'conversationSnapshot') {
+        const cursor = record.cursor;
+        const messages = parseConversationSnapshotMessages(record.messages);
+        return typeof cursor === 'number' && Number.isSafeInteger(cursor) && cursor >= 0 && messages
+            ? { ...record, type, threadId, cursor, messages }
+            : null;
+    }
+    if (type === 'ready' || type === 'disconnected')
+        return { ...record, type, threadId };
+    if (type === 'cursorReset') {
+        const cursor = record.cursor;
+        return typeof cursor === 'number' && Number.isSafeInteger(cursor) && cursor >= 0
+            ? { ...record, type, threadId, cursor }
+            : null;
+    }
+    if (type === 'turnCompleted') {
+        const turnId = nullableString(record.turnId);
+        const status = nullableString(record.status);
+        if (turnId === undefined || status === undefined)
+            return null;
+        return { ...record, type, threadId, turnId, status };
+    }
+    if (type === 'goalCleared') {
+        const turnId = nullableString(record.turnId);
+        return turnId === undefined ? null : { ...record, type, threadId, turnId };
+    }
+    if (type === 'goal') {
+        const turnId = nullableString(record.turnId);
+        const event = GOAL_EVENTS.find((candidate) => candidate === record.event);
+        const goal = parseCodexGoal(record.goal);
+        if (turnId === undefined || !event || !goal)
+            return null;
+        return { ...record, type, threadId, turnId, event, goal };
+    }
+    return null;
+}
+function projectionFields(event) {
+    if (event.type === 'started' || event.type === 'snapshot'
+        || event.type === 'delta' || event.type === 'completed') {
+        return { kind: 'assistantMessage', lifecycle: event.type };
+    }
+    if (event.type === 'conversation') {
+        return {
+            kind: event.mutation.operation === 'upsert' && event.mutation.message.type === 'goal'
+                ? 'goal' : 'assistantMessage',
+            lifecycle: 'persisted',
+        };
+    }
+    if (event.type === 'turnCompleted')
+        return { kind: 'turn', lifecycle: 'completed' };
+    if (event.type === 'goal')
+        return { kind: 'goal', lifecycle: event.event };
+    return { kind: 'goal', lifecycle: 'cleared' };
+}
+function isDomainEvent(event) {
+    return event.type !== 'ready' && event.type !== 'cursorReset' && event.type !== 'conversationSnapshot'
+        && event.type !== 'disconnected' && event.type !== 'error';
+}
+export function projectCodexStreamEvent(value, sequence) {
+    if (!Number.isSafeInteger(sequence) || sequence <= 0)
+        return null;
+    const event = parseCodexStreamEvent(value);
+    if (!event || !isDomainEvent(event))
+        return null;
+    return {
+        ...event,
+        eventId: `${event.threadId}:${sequence}`,
+        sequence,
+        itemId: 'itemId' in event ? event.itemId : null,
+        ...projectionFields(event),
+        mutation: projectCodexConversationMutation(event),
+    };
+}
+export function parseCodexProjectedStreamEvent(value) {
+    const record = recordOf(value);
+    if (!record)
+        return null;
+    const event = parseCodexStreamEvent(record);
+    if (!event || !isDomainEvent(event))
+        return null;
+    const sequence = record.sequence;
+    const eventId = nonEmptyString(record.eventId);
+    if (typeof sequence !== 'number' || !Number.isSafeInteger(sequence) || sequence <= 0
+        || eventId !== `${event.threadId}:${sequence}`)
+        return null;
+    const fields = projectionFields(event);
+    const itemId = 'itemId' in event ? event.itemId : null;
+    if (record.itemId !== itemId || record.kind !== fields.kind || record.lifecycle !== fields.lifecycle)
+        return null;
+    const mutation = parseCodexConversationMutation(record.mutation, event);
+    if (mutation === undefined)
+        return null;
+    return { ...event, eventId, sequence, itemId, ...fields, mutation };
+}

package/dist/src/codexToolProtocol.js

@@ -0,0 +1,68 @@
+function recordOf(value) {
+    return value != null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : null;
+}
+function positionOf(value) {
+    return value === null ? null : Number.isInteger(value) ? value : undefined;
+}
+export function parseCodexDiff(value) {
+    const record = recordOf(value);
+    if (!record || !Number.isInteger(record.added) || !Number.isInteger(record.removed)
+        || record.added < 0 || record.removed < 0)
+        return null;
+    let hunks = null;
+    if (record.hunks !== null) {
+        if (!Array.isArray(record.hunks))
+            return null;
+        hunks = [];
+        for (const candidate of record.hunks) {
+            const hunk = recordOf(candidate);
+            if (!hunk)
+                return null;
+            const oldStart = positionOf(hunk.oldStart);
+            const newStart = positionOf(hunk.newStart);
+            if (oldStart === undefined || newStart === undefined
+                || !Array.isArray(hunk.lines) || hunk.lines.some((line) => typeof line !== 'string'))
+                return null;
+            hunks.push({ oldStart, newStart, lines: hunk.lines });
+        }
+    }
+    if (record.created != null && record.created !== true)
+        return null;
+    return {
+        ...record,
+        added: record.added,
+        removed: record.removed,
+        hunks,
+        ...(record.created === true ? { created: true } : {}),
+    };
+}
+export function parseCodexToolProjection(value) {
+    const record = recordOf(value);
+    if (!record || typeof record.name !== 'string' || !record.name
+        || typeof record.isError !== 'boolean'
+        || (record.result !== null && typeof record.result !== 'string'))
+        return null;
+    const input = Array.isArray(record.input) ? record.input : recordOf(record.input);
+    if (!input)
+        return null;
+    const outcomes = ['running', 'success', 'failed', 'declined', 'completed'];
+    const outcome = record.outcome == null
+        ? undefined
+        : outcomes.find((candidate) => candidate === record.outcome);
+    if (record.outcome != null && !outcome)
+        return null;
+    const diff = record.diff == null ? undefined : parseCodexDiff(record.diff);
+    if (record.diff != null && !diff)
+        return null;
+    return {
+        ...record,
+        name: record.name,
+        input,
+        result: record.result,
+        isError: record.isError,
+        ...(outcome ? { outcome } : {}),
+        ...(diff ? { diff } : {}),
+    };
+}