@someonegg/codex-hub 0.0.0-stage → 0.1.0

package/dist/server/server/adapters/codex/session-normalizer.js

@@ -0,0 +1,257 @@
+import { normalizeSessionTitle, sessionTitleFromMarkdown } from "../../domain/session-text.js";
+import { codexInteraction } from "./interaction-parser.js";
+import { internalDetail, internalItem, internalItemFromPayload } from "./internal-event-parser.js";
+import { MAX_SESSION_DIAGNOSTICS } from "./limits.js";
+import { eventMessage } from "./message-normalizer.js";
+import { parseResponseItem } from "./response-item-parser.js";
+import { isObject } from "./rollout-decoder.js";
+import { normalizeToolCall, normalizeToolOutput, } from "./tool-normalizer.js";
+import { normalizeUserInputRequest, normalizeUserInputResponse, } from "./user-input-normalizer.js";
+export class DefaultSessionNormalizer {
+    create(descriptor) {
+        return {
+            descriptor,
+            timeline: [],
+            directiveDetails: new Map(),
+            internalDetails: new Map(),
+            toolDetails: new Map(),
+            pendingToolCalls: new Map(),
+            pendingUserInputRequests: new Map(),
+            decoderDiagnostics: [],
+            normalizerDiagnostics: [],
+            hasFirstUserMessage: false,
+            firstUserTitle: null,
+            messageCount: 0,
+            toolCount: 0,
+        };
+    }
+    append(state, records, decoderDiagnostics) {
+        const nextDecoderDiagnostics = decoderDiagnostics.slice(0, MAX_SESSION_DIAGNOSTICS);
+        const decoderDiagnosticsUnchanged = sameDiagnostics(state.decoderDiagnostics, nextDecoderDiagnostics);
+        if (records.length === 0 && decoderDiagnosticsUnchanged) {
+            return state;
+        }
+        const items = [];
+        const directiveDetails = new Map(state.directiveDetails);
+        const internalDetails = new Map(state.internalDetails);
+        const toolDetails = new Map(state.toolDetails);
+        const pendingToolCalls = new Map(state.pendingToolCalls);
+        const pendingUserInputRequests = new Map(state.pendingUserInputRequests);
+        const normalizerDiagnostics = [...state.normalizerDiagnostics];
+        for (const record of records) {
+            consumeRecord(record, items, directiveDetails, internalDetails, toolDetails, pendingToolCalls, pendingUserInputRequests, normalizerDiagnostics);
+        }
+        let hasFirstUserMessage = state.hasFirstUserMessage;
+        let firstTitle = state.firstUserTitle;
+        let messageCount = state.messageCount;
+        let toolCount = state.toolCount;
+        for (const item of items) {
+            if (item.kind === "message") {
+                messageCount += 1;
+                if (!hasFirstUserMessage && item.role === "user") {
+                    hasFirstUserMessage = true;
+                    firstTitle = sessionTitleFromMarkdown(item.markdown);
+                }
+            }
+            else if (item.kind === "tool" && item.stage === "call") {
+                toolCount += 1;
+            }
+        }
+        return {
+            ...state,
+            timeline: items.length === 0 ? state.timeline : [...state.timeline, ...items],
+            directiveDetails: sameMapEntries(state.directiveDetails, directiveDetails)
+                ? state.directiveDetails
+                : directiveDetails,
+            internalDetails: sameMapEntries(state.internalDetails, internalDetails)
+                ? state.internalDetails
+                : internalDetails,
+            toolDetails: sameMapEntries(state.toolDetails, toolDetails) ? state.toolDetails : toolDetails,
+            pendingToolCalls,
+            pendingUserInputRequests,
+            decoderDiagnostics: decoderDiagnosticsUnchanged
+                ? state.decoderDiagnostics
+                : nextDecoderDiagnostics,
+            normalizerDiagnostics,
+            hasFirstUserMessage,
+            firstUserTitle: firstTitle,
+            messageCount,
+            toolCount,
+        };
+    }
+    materialize(state, metadata, origin = DEFAULT_SESSION_ORIGIN) {
+        const diagnostics = combinedDiagnostics(state);
+        const warningCount = diagnostics.filter((diagnostic) => diagnostic.severity !== "info").length;
+        const title = normalizeSessionTitle(metadata.title) ?? state.firstUserTitle ?? "Untitled session";
+        const session = {
+            id: state.descriptor.id,
+            sourceId: metadata.threadId,
+            origin,
+            title,
+            workingDirectory: metadata.workingDirectory,
+            projectDirectory: metadata.projectDirectory,
+            createdAt: metadata.createdAt,
+            updatedAt: metadata.updatedAt,
+            archived: metadata.archived,
+            parentId: metadata.parentThreadId,
+            childIds: [],
+            agent: metadata.agent ?? null,
+            messageCount: state.messageCount,
+            toolCount: state.toolCount,
+            warningCount,
+            diagnostics,
+            itemCount: state.timeline.length,
+        };
+        return {
+            session,
+            timeline: state.timeline,
+            toolDetails: state.toolDetails,
+            directiveDetails: state.directiveDetails,
+            internalDetails: state.internalDetails,
+            interaction: codexInteraction(),
+        };
+    }
+    normalize(decoded, metadata, origin = DEFAULT_SESSION_ORIGIN) {
+        const state = this.append(this.create(decoded.descriptor), decoded.records, decoded.diagnostics);
+        return this.materialize(state, metadata, origin);
+    }
+}
+function combinedDiagnostics(state) {
+    const remaining = MAX_SESSION_DIAGNOSTICS - state.decoderDiagnostics.length;
+    return [...state.decoderDiagnostics, ...state.normalizerDiagnostics.slice(0, remaining)];
+}
+function sameDiagnostics(left, right) {
+    return (left.length === right.length &&
+        left.every((item, index) => {
+            const candidate = right[index];
+            return (candidate !== undefined &&
+                item.code === candidate.code &&
+                item.severity === candidate.severity &&
+                item.message === candidate.message &&
+                item.ordinal === candidate.ordinal);
+        }));
+}
+function sameMapEntries(left, right) {
+    if (left.size !== right.size)
+        return false;
+    for (const [key, value] of right) {
+        if (left.get(key) !== value)
+            return false;
+    }
+    return true;
+}
+const DEFAULT_SESSION_ORIGIN = {
+    sourceType: "test",
+    sourceInstanceId: "test",
+    agentName: "Test",
+    agentVersion: null,
+    formatVersion: null,
+};
+function consumeRecord(record, items, directiveDetails, internalDetails, toolDetails, pendingToolCalls, pendingUserInputRequests, diagnostics) {
+    const timestamp = string(record.value.timestamp);
+    const payload = record.value.payload;
+    if (record.value.type === "response_item" && isObject(payload)) {
+        consumeParsedResponse(parseResponseItem(record.ordinal, timestamp, payload), items, directiveDetails, toolDetails, pendingToolCalls, pendingUserInputRequests, diagnostics);
+        const item = items.at(-1);
+        if (item?.kind === "internal" && item.ordinal === record.ordinal) {
+            addInternalDetail(item, record, internalDetails);
+        }
+        return;
+    }
+    if (record.value.type === "event_msg" && isObject(payload)) {
+        const message = eventMessage(record.ordinal, timestamp, payload);
+        if (message !== null)
+            items.push(message);
+        else {
+            const item = internalItemFromPayload(record.ordinal, timestamp, payload);
+            items.push(item);
+            if (item.kind === "internal") {
+                addInternalDetail(item, record, internalDetails);
+            }
+        }
+        return;
+    }
+    if (record.value.type === "session_meta")
+        return;
+    if (record.value.type === "turn_context") {
+        const item = internalItem(record.ordinal, timestamp, "turn_context");
+        items.push(item);
+        addInternalDetail(item, record, internalDetails);
+        return;
+    }
+    const eventType = string(record.value.type);
+    if (eventType !== null) {
+        const item = internalItem(record.ordinal, timestamp, eventType);
+        items.push(item);
+        addInternalDetail(item, record, internalDetails);
+        return;
+    }
+    appendDiagnostic(diagnostics, {
+        code: "unknown_record",
+        severity: "info",
+        message: "A record without a recognized type was reduced to a safe diagnostic.",
+        ordinal: record.ordinal,
+    });
+}
+function addInternalDetail(item, record, details) {
+    const detail = internalDetail(record.value);
+    details.set(item.id, detail);
+}
+function appendDiagnostic(diagnostics, diagnostic) {
+    if (diagnostics.length < MAX_SESSION_DIAGNOSTICS) {
+        diagnostics.push(diagnostic);
+    }
+}
+function consumeParsedResponse(parsed, items, directiveDetails, toolDetails, pendingToolCalls, pendingUserInputRequests, diagnostics) {
+    switch (parsed.kind) {
+        case "directive":
+            items.push(parsed.value.item);
+            if (parsed.value.detail !== null) {
+                directiveDetails.set(parsed.value.item.id, parsed.value.detail);
+            }
+            break;
+        case "timeline":
+            items.push(parsed.value);
+            break;
+        case "tool_call":
+            pendingToolCalls.set(parsed.value.callId, parsed.value);
+            addTool(normalizeToolCall(parsed.value), items, toolDetails);
+            break;
+        case "tool_output": {
+            if (pendingUserInputRequests.delete(parsed.value.callId)) {
+                addUserInput(normalizeUserInputResponse(parsed.value), items, diagnostics);
+            }
+            else {
+                const call = pendingToolCalls.get(parsed.value.callId);
+                pendingToolCalls.delete(parsed.value.callId);
+                addTool(normalizeToolOutput(parsed.value, call), items, toolDetails);
+            }
+            break;
+        }
+        case "user_input_request":
+            pendingUserInputRequests.set(parsed.value.callId, parsed.value);
+            addUserInput(normalizeUserInputRequest(parsed.value), items, diagnostics);
+            break;
+        case "ignored":
+            break;
+    }
+}
+function addUserInput(accumulated, items, diagnostics) {
+    items.push(accumulated.item);
+    if (accumulated.malformed) {
+        appendDiagnostic(diagnostics, {
+            code: "invalid_user_input",
+            severity: "warning",
+            message: "A request_user_input call or output had an unsupported payload shape.",
+            ordinal: accumulated.item.ordinal,
+        });
+    }
+}
+function addTool(tool, items, details) {
+    items.push(tool.item);
+    details.set(tool.item.id, tool.detail);
+}
+function string(value) {
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+//# sourceMappingURL=session-normalizer.js.map

package/dist/server/server/adapters/codex/tool-normalizer.js

@@ -0,0 +1,58 @@
+import { MAX_PREVIEW_CHARS, truncateText } from "../../domain/session-text.js";
+import { MAX_TOOL_DETAIL_CHARS } from "./limits.js";
+export function normalizeToolCall(call) {
+    const input = truncateNullable(call.input);
+    const preview = previewText(call.input);
+    const detailTruncated = input.truncated;
+    return {
+        item: {
+            kind: "tool",
+            stage: "call",
+            id: `tool-${call.ordinal}`,
+            ordinal: call.ordinal,
+            timestamp: call.timestamp,
+            callId: call.callId,
+            toolName: call.toolName,
+            preview: preview.text,
+            charCount: call.input?.length ?? 0,
+            hasDetail: call.input !== null,
+        },
+        detail: { input: input.text, output: null, truncated: detailTruncated },
+    };
+}
+export function normalizeToolOutput(output, call) {
+    const input = truncateNullable(call?.input ?? null);
+    const result = truncateNullable(output.output);
+    const preview = previewText(output.output !== null && output.output.length > 0 ? output.output : (call?.input ?? null));
+    const detailTruncated = input.truncated || result.truncated;
+    return {
+        item: {
+            kind: "tool",
+            stage: "output",
+            id: `tool-${output.ordinal}`,
+            ordinal: output.ordinal,
+            timestamp: output.timestamp,
+            callId: output.callId,
+            toolName: call?.toolName ?? "unknown tool",
+            status: output.failed ? "failed" : "completed",
+            preview: preview.text,
+            charCount: (call?.input?.length ?? 0) + (output.output?.length ?? 0),
+            hasDetail: (call?.input !== null && call?.input !== undefined) || output.output !== null,
+        },
+        detail: {
+            input: input.text,
+            output: result.text,
+            truncated: detailTruncated,
+        },
+    };
+}
+function previewText(value) {
+    return value === null ? { text: null, truncated: false } : truncateText(value, MAX_PREVIEW_CHARS);
+}
+function truncateNullable(value) {
+    if (value === null)
+        return { text: null, truncated: false };
+    const result = truncateText(value, MAX_TOOL_DETAIL_CHARS);
+    return { text: result.text, truncated: result.truncated };
+}
+//# sourceMappingURL=tool-normalizer.js.map

package/dist/server/server/adapters/codex/user-input-normalizer.js

@@ -0,0 +1,123 @@
+import { MAX_PREVIEW_CHARS, truncateText } from "../../domain/session-text.js";
+import { isObject } from "./rollout-decoder.js";
+export function normalizeUserInputRequest(request) {
+    return {
+        item: {
+            kind: "user_input",
+            stage: "request",
+            id: `user-input-${request.ordinal}`,
+            ordinal: request.ordinal,
+            timestamp: request.timestamp,
+            callId: request.callId,
+            questions: request.questions,
+        },
+        malformed: request.malformed,
+    };
+}
+export function normalizeUserInputResponse(output) {
+    const parsed = parseResponse(output.output);
+    const base = {
+        kind: "user_input",
+        stage: "response",
+        id: `user-input-${output.ordinal}`,
+        ordinal: output.ordinal,
+        timestamp: output.timestamp,
+        callId: output.callId,
+    };
+    if (parsed.kind === "answered") {
+        return {
+            item: { ...base, outcome: "answered", answers: parsed.answers },
+            malformed: false,
+        };
+    }
+    if (parsed.kind === "aborted") {
+        return {
+            item: { ...base, outcome: "aborted" },
+            malformed: false,
+        };
+    }
+    return {
+        item: {
+            ...base,
+            outcome: "unavailable",
+            summary: truncateText(output.output ?? "User input response was unavailable.", MAX_PREVIEW_CHARS).text,
+        },
+        malformed: true,
+    };
+}
+export function parseUserInputQuestions(value) {
+    const object = parseObject(value);
+    if (object === null || !Array.isArray(object.questions))
+        return null;
+    if (object.questions.length < 1 || object.questions.length > 3)
+        return null;
+    const questions = object.questions.map(parseQuestion);
+    if (!questions.every((question) => question !== null))
+        return null;
+    const parsed = questions;
+    return new Set(parsed.map((question) => question.id)).size === parsed.length ? parsed : null;
+}
+function parseQuestion(value) {
+    if (!isObject(value) || !Array.isArray(value.options))
+        return null;
+    if (value.options.length < 2 || value.options.length > 3)
+        return null;
+    const id = string(value.id);
+    const header = string(value.header);
+    const question = string(value.question);
+    const options = value.options.map((option) => {
+        if (!isObject(option))
+            return null;
+        const label = string(option.label);
+        const description = string(option.description);
+        return label === null || description === null ? null : { label, description };
+    });
+    if (id === null ||
+        header === null ||
+        question === null ||
+        !options.every((option) => option !== null))
+        return null;
+    const parsedOptions = options;
+    if (new Set(parsedOptions.map((option) => option.label)).size !== parsedOptions.length) {
+        return null;
+    }
+    return { id, header, question, options: parsedOptions };
+}
+function parseResponse(value) {
+    if (value === null)
+        return { kind: "unavailable" };
+    if (value.trim().toLocaleLowerCase("en-US").startsWith("aborted by user")) {
+        return { kind: "aborted" };
+    }
+    const object = parseObject(value);
+    if (object === null || !isObject(object.answers))
+        return { kind: "unavailable" };
+    const answers = [];
+    for (const [questionId, rawAnswer] of Object.entries(object.answers)) {
+        if (!isObject(rawAnswer) || !Array.isArray(rawAnswer.answers)) {
+            return { kind: "unavailable" };
+        }
+        const values = rawAnswer.answers.filter((answer) => typeof answer === "string");
+        if (values.length !== rawAnswer.answers.length)
+            return { kind: "unavailable" };
+        answers.push({ questionId, answers: values });
+    }
+    return { kind: "answered", answers };
+}
+function parseObject(value) {
+    if (isObject(value))
+        return value;
+    if (typeof value !== "string")
+        return null;
+    try {
+        const parsed = JSON.parse(value);
+        return isObject(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function string(value) {
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+//# sourceMappingURL=user-input-normalizer.js.map

package/dist/server/server/api/session-api-mapper.js

@@ -0,0 +1,194 @@
+import { createHash } from "node:crypto";
+import { opaqueIdForParts } from "../security/opaque-id.js";
+export class SessionApiMapper {
+    resolveNickname;
+    homes;
+    constructor(resolveNickname = () => null, homes = []) {
+        this.resolveNickname = resolveNickname;
+        this.homes = homes;
+    }
+    list(sessions) {
+        const projects = new Map();
+        const summaries = sessions
+            .map((session) => {
+            const directory = session.projectDirectory;
+            const projectId = directory === null ? null : opaqueIdForParts("project", directory);
+            const isChild = session.isChild ?? session.parentId !== null;
+            if (!isChild && directory !== null && projectId !== null)
+                projects.set(projectId, { id: projectId, directory });
+            return {
+                id: session.id,
+                sourceInstanceId: session.origin.sourceInstanceId,
+                title: this.resolveNickname(session) ?? session.title,
+                projectId,
+                status: session.archived ? "archived" : "normal",
+                parentId: session.parentId,
+                isChild,
+                updatedAt: session.updatedAt,
+            };
+        })
+            .sort((a, b) => compareIds(a.id, b.id));
+        const structure = {
+            homes: [...this.homes].sort((a, b) => compareIds(a.sourceInstanceId, b.sourceInstanceId)),
+            projects: [...projects.values()].sort((a, b) => compareIds(a.id, b.id)),
+            sessions: summaries.map(({ updatedAt, ...summary }) => summary),
+        };
+        return {
+            revision: createHash("sha256").update(JSON.stringify(structure)).digest("base64url"),
+            homes: structure.homes,
+            projects: structure.projects,
+            sessions: summaries,
+        };
+    }
+    detail(result) {
+        return { session: this.sessionDetail(result) };
+    }
+    itemPage(result) {
+        return {
+            session: this.sessionDetail(result.context.session),
+            cursor: result.context.cursor,
+            hasMore: result.context.hasMore,
+            items: result.items.map((item) => this.timelineItem(item)),
+        };
+    }
+    toolDetail(result) {
+        return {
+            input: result.detail.input,
+            output: result.detail.output,
+            truncated: result.detail.truncated,
+        };
+    }
+    directiveDetail(result) {
+        return {
+            text: result.detail.text,
+            truncated: result.detail.truncated,
+        };
+    }
+    internalDetail(result) {
+        return {
+            json: result.detail.json,
+            truncated: result.detail.truncated,
+        };
+    }
+    sessionDetail(session) {
+        return {
+            resume: { allowed: false, reason: "Runtime validation unavailable" },
+            id: session.id,
+            origin: { ...session.origin },
+            title: session.title,
+            nickname: this.resolveNickname(session),
+            workingDirectory: session.workingDirectory,
+            projectDirectory: session.projectDirectory,
+            createdAt: session.createdAt,
+            updatedAt: session.updatedAt,
+            status: session.archived ? "archived" : "normal",
+            parentId: session.parentId,
+            childIds: [...session.childIds],
+            agent: session.agent === null ? null : { ...session.agent },
+            messageCount: session.messageCount,
+            toolCount: session.toolCount,
+            sourceId: session.sourceId,
+            itemCount: session.itemCount,
+        };
+    }
+    timelineItem(item) {
+        const base = { id: item.id, ordinal: item.ordinal, timestamp: item.timestamp };
+        switch (item.kind) {
+            case "message":
+                return {
+                    ...base,
+                    kind: "message",
+                    role: item.role,
+                    phase: item.phase,
+                    itemType: item.itemType,
+                    markdown: item.markdown,
+                };
+            case "directive":
+                return item.hasDetail
+                    ? {
+                        ...base,
+                        kind: "directive",
+                        hasDetail: true,
+                        summary: item.summary,
+                        charCount: item.charCount,
+                    }
+                    : { ...base, kind: "directive", hasDetail: false, text: item.text };
+            case "tool": {
+                const tool = {
+                    ...base,
+                    kind: "tool",
+                    callId: item.callId,
+                    toolName: item.toolName,
+                    preview: item.preview,
+                    charCount: item.charCount,
+                    hasDetail: item.hasDetail,
+                };
+                return item.stage === "call"
+                    ? { ...tool, stage: "call" }
+                    : { ...tool, stage: "output", status: item.status };
+            }
+            case "user_input":
+                if (item.stage === "request") {
+                    return {
+                        ...base,
+                        kind: "user_input",
+                        stage: "request",
+                        callId: item.callId,
+                        questions: item.questions.map((question) => ({
+                            id: question.id,
+                            header: question.header,
+                            question: question.question,
+                            options: question.options.map((option) => ({
+                                label: option.label,
+                                description: option.description,
+                            })),
+                        })),
+                    };
+                }
+                if (item.outcome === "answered") {
+                    return {
+                        ...base,
+                        kind: "user_input",
+                        stage: "response",
+                        callId: item.callId,
+                        outcome: "answered",
+                        answers: item.answers.map((answer) => ({
+                            questionId: answer.questionId,
+                            answers: [...answer.answers],
+                        })),
+                    };
+                }
+                return item.outcome === "unavailable"
+                    ? {
+                        ...base,
+                        kind: "user_input",
+                        stage: "response",
+                        callId: item.callId,
+                        outcome: "unavailable",
+                        summary: item.summary,
+                    }
+                    : {
+                        ...base,
+                        kind: "user_input",
+                        stage: "response",
+                        callId: item.callId,
+                        outcome: "aborted",
+                    };
+            case "token":
+                return {
+                    ...base,
+                    kind: "token",
+                    tokenUsage: {
+                        total: item.tokenUsage.total === null ? null : { ...item.tokenUsage.total },
+                        last: item.tokenUsage.last === null ? null : { ...item.tokenUsage.last },
+                    },
+                };
+            case "internal":
+                return { ...base, kind: "internal", eventType: item.eventType };
+        }
+    }
+}
+function compareIds(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+//# sourceMappingURL=session-api-mapper.js.map