@someonegg/agent-hub 0.0.0-stage → 0.7.0

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

@@ -0,0 +1,173 @@
+import { normalizeSessionTitle, truncateText } from "../../domain/session-text.js";
+import { mergeBindingMetadata } from "../shared/binding-protocol.js";
+import { MAX_MESSAGE_CHARS, MAX_SESSION_DIAGNOSTICS } from "../shared/limits.js";
+import { appendClaudeIdentity } from "./identity.js";
+import { claudeRecordBindings } from "./interaction.js";
+import { normalizeQuestionResponse, normalizeQuestions } from "./user-input-normalizer.js";
+export const object = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const string = (value) => (typeof value === "string" ? value : null);
+/** Decoder codes are renamed to adapter-neutral session diagnostics. */
+export function claudeDecoderDiagnostics(diagnostics) {
+    return diagnostics.map((d) => d.code === "malformed_json" ? { ...d, code: "invalid_jsonl" } : d);
+}
+export function createClaudeState(nativeId) {
+    return {
+        timeline: [],
+        diagnostics: [],
+        questions: new Map(),
+        decoderDiagnostics: [],
+        normalizerDiagnostics: [],
+        line: 0,
+        nativeId,
+        firstCwd: null,
+        cwd: null,
+        project: null,
+        taskName: null,
+        customTitle: null,
+        aiTitle: null,
+        firstUser: null,
+        version: null,
+        createdAt: null,
+        updatedAt: null,
+        identityConflict: false,
+    };
+}
+export function appendClaudeRecords(previous, records, diagnostics = [], bindings = records.flatMap(claudeRecordBindings)) {
+    if (records.length === 0 &&
+        JSON.stringify(previous.decoderDiagnostics) === JSON.stringify(diagnostics))
+        return previous;
+    const state = {
+        ...previous,
+        diagnostics: [...previous.normalizerDiagnostics],
+    };
+    const newItems = [];
+    let pendingQuestions = previous.questions;
+    const mutableQuestions = () => {
+        if (pendingQuestions === previous.questions)
+            pendingQuestions = new Map(previous.questions);
+        return pendingQuestions;
+    };
+    const emit = (item) => {
+        const ordinal = previous.timeline.length + newItems.length + 1;
+        if (item.kind === "message")
+            item = { ...item, markdown: truncateText(item.markdown, MAX_MESSAGE_CHARS).text };
+        newItems.push({ ...item, id: `${state.nativeId}:${ordinal}`, ordinal });
+    };
+    const retainDiagnostic = (diagnostic) => {
+        const index = state.diagnostics.findIndex((existing) => (existing.ordinal ?? Infinity) > (diagnostic.ordinal ?? Infinity));
+        if (index >= 0)
+            state.diagnostics.splice(index, 0, diagnostic);
+        else if (state.diagnostics.length < MAX_SESSION_DIAGNOSTICS)
+            state.diagnostics.push(diagnostic);
+        state.diagnostics.length = Math.min(state.diagnostics.length, MAX_SESSION_DIAGNOSTICS);
+    };
+    for (const { ordinal, value: row } of records) {
+        state.line = ordinal;
+        if (!object(row) || row.isSidechain === true || row.parent_tool_use_id != null)
+            continue;
+        // API copies and progress/subagent notifications never supply conversation or bindings.
+        if (!["user", "assistant", "custom-title", "ai-title", "system"].includes(String(row.type)))
+            continue;
+        if (!appendClaudeIdentity(state, row, ordinal, retainDiagnostic))
+            continue;
+        const timestamp = string(row.timestamp);
+        if (row.type === "custom-title") {
+            state.customTitle = normalizeSessionTitle(string(row.customTitle)) || state.customTitle;
+            continue;
+        }
+        if (row.type === "ai-title") {
+            state.aiTitle = normalizeSessionTitle(string(row.aiTitle)) || state.aiTitle;
+            continue;
+        }
+        if (row.type !== "user" && row.type !== "assistant")
+            continue;
+        if (row.isMeta === true || row.isCompactSummary === true || row.subtype === "subagent")
+            continue;
+        const message = row.message;
+        if (!object(message) || message.role !== row.type)
+            continue;
+        const role = row.type;
+        let phase = null;
+        if (role === "assistant") {
+            if (message.stop_reason === "tool_use")
+                phase = "update";
+            else if (message.stop_reason === "end_turn")
+                phase = "response";
+        }
+        let blocks = [];
+        if (typeof message.content === "string")
+            blocks = [{ type: "text", text: message.content }];
+        else if (Array.isArray(message.content))
+            blocks = message.content;
+        let text = [];
+        const flush = () => {
+            const markdown = truncateText(text.join("\n\n"), MAX_MESSAGE_CHARS).text;
+            text = [];
+            if (!markdown.trim())
+                return;
+            if (role === "user")
+                state.firstUser ??= markdown;
+            emit({ kind: "message", role, phase, itemType: null, markdown, timestamp });
+        };
+        for (const block of blocks) {
+            if (!object(block)) {
+                flush();
+                continue;
+            }
+            if (block.type === "text" && typeof block.text === "string") {
+                const content = block.text;
+                if (role === "user" &&
+                    /^\s*(?:<bash-(?:input|stdout|stderr)>|<local-command-|<command-name>|<command-message>|<task-notification>|<subagent|<teammate-message|<system-reminder>|<system-context>|\[Request interrupted by user)/.test(content)) {
+                    flush();
+                    continue;
+                }
+                text.push(content);
+                continue;
+            }
+            flush();
+            if (role === "assistant" && block.type === "tool_use" && object(block.input)) {
+                const callId = string(block.id);
+                if (block.name === "ExitPlanMode" &&
+                    typeof block.input.plan === "string" &&
+                    block.input.plan.trim()) {
+                    emit({
+                        kind: "message",
+                        role,
+                        phase: "response",
+                        itemType: "plan",
+                        markdown: block.input.plan,
+                        timestamp,
+                    });
+                }
+                if (block.name === "AskUserQuestion" && callId && Array.isArray(block.input.questions)) {
+                    const questions = normalizeQuestions(callId, block.input.questions);
+                    mutableQuestions().set(callId, questions);
+                    emit({ kind: "user_input", stage: "request", callId, questions, timestamp });
+                }
+            }
+            if (role === "user" &&
+                block.type === "tool_result" &&
+                typeof block.tool_use_id === "string") {
+                const callId = block.tool_use_id;
+                const questions = pendingQuestions.get(callId);
+                if (!questions)
+                    continue;
+                emit(normalizeQuestionResponse(callId, questions, block.content, row.toolUseResult, timestamp));
+                mutableQuestions().delete(callId);
+            }
+        }
+        flush();
+    }
+    const metadata = mergeBindingMetadata({ projectDirectory: state.project, taskName: state.taskName }, bindings.map((event) => event.attempt));
+    return {
+        ...state,
+        timeline: newItems.length ? [...previous.timeline, ...newItems] : previous.timeline,
+        questions: pendingQuestions,
+        project: metadata.projectDirectory,
+        taskName: metadata.taskName,
+        decoderDiagnostics: diagnostics,
+        normalizerDiagnostics: state.diagnostics,
+        diagnostics: [...diagnostics, ...state.diagnostics].slice(0, MAX_SESSION_DIAGNOSTICS),
+    };
+}
+//# sourceMappingURL=session-normalizer.js.map

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

@@ -0,0 +1,71 @@
+const object = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const string = (value) => (typeof value === "string" ? value : null);
+export function normalizeQuestions(callId, values) {
+    return values.flatMap((value, index) => {
+        if (!object(value) || typeof value.question !== "string")
+            return [];
+        const options = [];
+        if (Array.isArray(value.options)) {
+            for (const option of value.options) {
+                if (!object(option) || typeof option.label !== "string")
+                    continue;
+                options.push({ label: option.label, description: string(option.description) ?? "" });
+            }
+        }
+        return [
+            {
+                id: `${callId}:${index}`,
+                header: string(value.header) ?? "",
+                question: value.question,
+                options,
+            },
+        ];
+    });
+}
+export function normalizeQuestionResponse(callId, questions, content, toolUseResult, timestamp) {
+    let result = content;
+    if (typeof result === "string") {
+        try {
+            result = JSON.parse(result);
+        }
+        catch {
+            /* Unstructured results are unavailable unless explicitly rejected. */
+        }
+    }
+    let structured = null;
+    if (object(toolUseResult))
+        structured = toolUseResult;
+    else if (object(result))
+        structured = result;
+    const values = structured && object(structured.answers) ? structured.answers : null;
+    const answers = questions.map((q) => {
+        const answer = values?.[q.question] ?? values?.[q.id];
+        let answerValues = [];
+        if (typeof answer === "string")
+            answerValues = [answer];
+        else if (Array.isArray(answer) && answer.every((v) => typeof v === "string"))
+            answerValues = [...answer];
+        return { questionId: q.id, answers: answerValues };
+    });
+    const rejected = structured?.denied === true ||
+        structured?.rejected === true ||
+        (typeof result === "string" &&
+            /^(?:The user (?:doesn't want to proceed|declined|rejected)|User (?:declined|rejected)|Request interrupted by user)/i.test(result));
+    const response = {
+        kind: "user_input",
+        stage: "response",
+        callId,
+        timestamp,
+    };
+    if (rejected)
+        return { ...response, outcome: "aborted" };
+    else if (answers.length > 0 && answers.every((a) => a.answers.length > 0))
+        return { ...response, outcome: "answered", answers };
+    else
+        return {
+            ...response,
+            outcome: "unavailable",
+            summary: "Answer could not be reliably interpreted",
+        };
+}
+//# sourceMappingURL=user-input-normalizer.js.map

package/dist/server/server/adapters/codex/catalog-source.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=catalog-source.js.map

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

@@ -0,0 +1,250 @@
+import { resolve } from "node:path";
+import { performance } from "node:perf_hooks";
+import { mergeBindingMetadata } from "../shared/binding-protocol.js";
+import { CheckpointedJsonlDecoder, } from "../shared/jsonl-decoder.js";
+import { MAX_SESSION_DIAGNOSTICS } from "../shared/limits.js";
+import { acceptedPathOrder, fingerprintOf, mutableTelemetry, sameFingerprint, } from "../shared/source-cache.js";
+import { IdentityResolver } from "./identity-resolver.js";
+import { codexBindingAttemptsFrom, codexInteraction } from "./interaction-parser.js";
+import { isExpectedIoError } from "./io-errors.js";
+import { JsonlCatalogSource } from "./jsonl-catalog-source.js";
+import { SessionIndexReader } from "./session-index-reader.js";
+import { DefaultSessionNormalizer, } from "./session-normalizer.js";
+export class CodexSessionSource {
+    configDirectory;
+    descriptor;
+    #cache = new Map();
+    #duplicates = new Map();
+    #snapshot = null;
+    #lastRefreshTelemetry = mutableTelemetry();
+    decoder;
+    identity;
+    normalizer;
+    sessionIndex;
+    constructor(configDirectory, instanceKey, { decoder = new CheckpointedJsonlDecoder(), identity = new IdentityResolver(), normalizer = new DefaultSessionNormalizer(), sessionIndex = new SessionIndexReader(configDirectory), agent = "default", } = {}) {
+        this.configDirectory = configDirectory;
+        this.decoder = decoder;
+        this.identity = identity;
+        this.normalizer = normalizer;
+        this.sessionIndex = sessionIndex;
+        this.descriptor = { sourceType: "codex-jsonl", instanceKey, agent, displayName: "Codex" };
+    }
+    async refresh() {
+        await this.sessionIndex.refresh();
+        const archivedDescriptors = new Map([...this.#cache.values()]
+            .filter((entry) => entry.descriptor.archived)
+            .map((entry) => [entry.descriptor.path, entry.descriptor]));
+        const discovery = await new JsonlCatalogSource(this.configDirectory, archivedDescriptors).discover();
+        const discoverySignature = JSON.stringify({
+            diagnostics: discovery.diagnostics,
+            entries: discovery.entries.map(({ descriptor }) => fingerprintOf(descriptor)),
+        });
+        const nextCache = new Map();
+        const nextDuplicates = new Map();
+        const binds = new Map();
+        const telemetry = mutableTelemetry();
+        const unavailableRollouts = [];
+        const loadDiagnostics = [];
+        const acceptedThreads = new Set();
+        const duplicateThreads = new Set();
+        // Previously accepted paths take precedence; discovery order breaks first-scan ties.
+        const candidates = [...discovery.entries].sort((left, right) => acceptedPathOrder(this.#cache, left.descriptor.sourceRelativePath, right.descriptor.sourceRelativePath));
+        for (const { descriptor } of candidates) {
+            const fingerprint = fingerprintOf(descriptor);
+            const duplicate = this.#duplicates.get(descriptor.sourceRelativePath);
+            if (duplicate &&
+                sameFingerprint(duplicate.fingerprint, fingerprint) &&
+                acceptedThreads.has(duplicate.threadId)) {
+                nextDuplicates.set(descriptor.sourceRelativePath, duplicate);
+                duplicateThreads.add(duplicate.threadId);
+                continue;
+            }
+            const cached = this.#cache.get(descriptor.sourceRelativePath);
+            let loaded;
+            if (cached !== undefined && sameFingerprint(cached.fingerprint, fingerprint)) {
+                loaded = cached;
+            }
+            else {
+                loaded = await this.#load(descriptor, fingerprint, cached, telemetry, binds);
+            }
+            if (loaded === null) {
+                unavailableRollouts.push(descriptor.sourceRelativePath);
+                loadDiagnostics.push(rolloutUnavailableDiagnostic());
+                continue;
+            }
+            if (loaded.threadId !== null) {
+                if (acceptedThreads.has(loaded.threadId)) {
+                    nextDuplicates.set(descriptor.sourceRelativePath, {
+                        fingerprint,
+                        threadId: loaded.threadId,
+                    });
+                    duplicateThreads.add(loaded.threadId);
+                    binds.delete(descriptor.id);
+                    continue;
+                }
+                acceptedThreads.add(loaded.threadId);
+            }
+            nextCache.set(descriptor.sourceRelativePath, loaded);
+        }
+        const sessions = sourceEntries(nextCache);
+        const diagnostics = [
+            ...discovery.diagnostics.map((item) => ({ ...item })),
+            ...loadDiagnostics,
+            ...[...duplicateThreads].map(() => ({
+                code: "duplicate_native_session_id",
+                severity: "warning",
+                message: "Multiple Codex rollouts declared the same native session ID; duplicate rollouts were ignored.",
+                ordinal: null,
+            })),
+        ].slice(0, MAX_SESSION_DIAGNOSTICS);
+        const bindings = sessions.flatMap((entry) => (binds.get(entry.normalized.session.id) ?? []).map((event) => ({
+            ...event,
+            localId: entry.localId,
+        })));
+        const signature = JSON.stringify({
+            discoverySignature,
+            unavailableRollouts,
+            projects: sessions.map((entry) => [
+                entry.localId,
+                entry.normalized.session.projectDirectory,
+                entry.normalized.session.taskName ?? null,
+            ]),
+        });
+        const snapshot = { signature, sessions, diagnostics, bindings };
+        this.#cache = nextCache;
+        this.#duplicates = nextDuplicates;
+        this.#lastRefreshTelemetry = telemetry;
+        if (this.#snapshot?.signature === signature)
+            return this.#snapshot;
+        this.#snapshot = snapshot;
+        return snapshot;
+    }
+    lastRefreshTelemetry() {
+        return { ...this.#lastRefreshTelemetry };
+    }
+    displayTitleFor(session) {
+        if (session.origin.agent !== this.descriptor.agent || session.sourceId === null)
+            return null;
+        return this.sessionIndex.threadName(session.sourceId);
+    }
+    async #load(descriptor, fingerprint, cached, telemetry, binds) {
+        try {
+            const decodeStartedAt = performance.now();
+            const decoded = await this.decoder.decode(descriptor, cached?.checkpoint);
+            telemetry.decodeMs += performance.now() - decodeStartedAt;
+            telemetry.probeBytes += decoded.telemetry.probeBytes;
+            telemetry.decodeBytes += decoded.telemetry.decodeBytes;
+            telemetry[decoded.mode === "append" ? "appendFiles" : "fullFiles"] += 1;
+            const normalizeStartedAt = performance.now();
+            const identityBase = decoded.mode === "append" && cached !== undefined
+                ? cached.identityState
+                : this.identity.create(descriptor);
+            const normalizerBase = decoded.mode === "append" && cached !== undefined
+                ? cached.normalizerState
+                : this.normalizer.create(descriptor);
+            const identityState = this.identity.append(identityBase, decoded.records);
+            const normalizerState = this.normalizer.append(normalizerBase, decoded.records, decoded.diagnostics);
+            const bindingEvents = decoded.records.flatMap((record) => {
+                const timestamp = typeof record.value.timestamp === "string" ? Date.parse(record.value.timestamp) : NaN;
+                return codexBindingAttemptsFrom(record).map((attempt, position) => ({
+                    time: Number.isFinite(timestamp) ? timestamp : 0,
+                    ordinal: record.ordinal,
+                    position,
+                    attempt,
+                }));
+            });
+            binds.set(descriptor.id, bindingEvents);
+            const metadata = this.identity.metadata(identityState);
+            const origin = this.#origin(metadata.runtimeVersion);
+            const baseNormalized = decoded.mode === "append" &&
+                cached !== undefined &&
+                identityState === cached.identityState &&
+                normalizerState === cached.normalizerState &&
+                sameOrigin(origin, cached.origin)
+                ? cached.normalized
+                : this.normalizer.materialize(normalizerState, metadata, origin);
+            const { projectDirectory: bindProjectDirectory, taskName } = mergeBindingMetadata({
+                projectDirectory: decoded.mode === "append" ? (cached?.bindProjectDirectory ?? null) : null,
+                taskName: decoded.mode === "append" ? (cached?.normalized.session.taskName ?? null) : null,
+            }, bindingEvents.map((event) => event.attempt));
+            const projectDirectory = bindProjectDirectory ?? baseNormalized.session.workingDirectory;
+            const normalized = baseNormalized === cached?.normalized &&
+                projectDirectory === cached.normalized.session.projectDirectory &&
+                (taskName ?? undefined) === cached.normalized.session.taskName
+                ? cached.normalized
+                : {
+                    ...baseNormalized,
+                    session: {
+                        ...baseNormalized.session,
+                        projectDirectory,
+                        taskName: taskName ?? undefined,
+                    },
+                    interaction: codexInteraction(projectDirectory, taskName ?? null),
+                };
+            telemetry.normalizeMs += performance.now() - normalizeStartedAt;
+            return {
+                descriptor,
+                fingerprint,
+                normalized,
+                threadId: metadata.threadId,
+                parentThreadId: metadata.parentThreadId,
+                origin,
+                checkpoint: decoded.checkpoint,
+                identityState,
+                normalizerState,
+                bindProjectDirectory,
+            };
+        }
+        catch (error) {
+            if (!isExpectedIoError(error))
+                throw error;
+            return null;
+        }
+    }
+    #origin(runtimeVersion) {
+        return {
+            sourceType: this.descriptor.sourceType,
+            agent: this.descriptor.agent,
+            runtimeName: this.descriptor.displayName,
+            runtimeVersion,
+        };
+    }
+}
+export async function createCodexSessionSource(configDirectory, options = {}) {
+    const configured = resolve(configDirectory);
+    return new CodexSessionSource(configured, `codex-jsonl\0${configured}`, options);
+}
+function sourceEntries(cache) {
+    const sessions = [];
+    for (const entry of cache.values()) {
+        const { threadId } = entry;
+        sessions.push({
+            localId: sourceLocalId(threadId, entry.fingerprint.sourceRelativePath),
+            nativeSessionId: threadId,
+            parentNativeSessionId: entry.parentThreadId,
+            origin: entry.origin,
+            normalized: entry.normalized,
+        });
+    }
+    return sessions;
+}
+function sourceLocalId(threadId, sourceRelativePath) {
+    if (threadId === null)
+        return `resource:${sourceRelativePath}`;
+    return `thread:${threadId}`;
+}
+function rolloutUnavailableDiagnostic() {
+    return {
+        code: "rollout_unavailable",
+        severity: "warning",
+        message: "A registered rollout could not be read.",
+        ordinal: null,
+    };
+}
+function sameOrigin(left, right) {
+    return (left.sourceType === right.sourceType &&
+        left.agent === right.agent &&
+        left.runtimeName === right.runtimeName &&
+        left.runtimeVersion === right.runtimeVersion);
+}
+//# sourceMappingURL=codex-session-source.js.map

package/dist/server/server/adapters/codex/identity-resolver.js

@@ -0,0 +1,104 @@
+import { basename } from "node:path";
+import { isObject } from "../shared/jsonl-decoder.js";
+import { nonEmptySubagentIdentity, taskNameFromSubagentPath } from "./subagent-identity.js";
+import { nonEmptyString } from "./value-readers.js";
+export class IdentityResolver {
+    create(descriptor) {
+        return {
+            fileName: basename(descriptor.path),
+            archived: descriptor.archived,
+            firstMetadata: null,
+            firstMatchingMetadata: null,
+            hasFirstRecord: false,
+            firstRecordTimestamp: null,
+            lastTimestamp: null,
+        };
+    }
+    append(state, records) {
+        if (records.length === 0)
+            return state;
+        let firstMetadata = state.firstMetadata;
+        let firstMatchingMetadata = state.firstMatchingMetadata;
+        let hasFirstRecord = state.hasFirstRecord;
+        let firstRecordTimestamp = state.firstRecordTimestamp;
+        let lastTimestamp = state.lastTimestamp;
+        for (const record of records) {
+            const timestamp = timestampOf(record.value);
+            if (!hasFirstRecord) {
+                hasFirstRecord = true;
+                firstRecordTimestamp = timestamp;
+            }
+            if (timestamp !== null)
+                lastTimestamp = timestamp;
+            if (record.value.type !== "session_meta")
+                continue;
+            const metadata = rawMetadata(record.value.payload);
+            if (metadata === null)
+                continue;
+            firstMetadata ??= metadata;
+            if (firstMatchingMetadata === null &&
+                metadata.id !== null &&
+                state.fileName.includes(metadata.id))
+                firstMatchingMetadata = metadata;
+        }
+        return {
+            ...state,
+            firstMetadata,
+            firstMatchingMetadata,
+            hasFirstRecord,
+            firstRecordTimestamp,
+            lastTimestamp,
+        };
+    }
+    metadata(state) {
+        const raw = state.firstMatchingMetadata ?? state.firstMetadata;
+        return {
+            threadId: raw?.id ?? null,
+            runtimeVersion: raw?.runtimeVersion ?? null,
+            title: raw?.title ?? null,
+            workingDirectory: raw?.cwd ?? null,
+            projectDirectory: raw?.cwd ?? null,
+            createdAt: raw?.timestamp ?? state.firstRecordTimestamp,
+            updatedAt: state.lastTimestamp,
+            parentThreadId: raw?.parentThreadId ?? null,
+            archived: state.archived,
+            subagent: raw?.subagent ?? null,
+        };
+    }
+}
+function rawMetadata(value) {
+    if (!isObject(value))
+        return null;
+    const spawn = threadSpawn(value);
+    return {
+        id: nonEmptyString(value.id),
+        runtimeVersion: nonEmptyString(value.cli_version ?? value.agent_version),
+        title: nonEmptyString(value.title),
+        cwd: nonEmptyString(value.cwd),
+        timestamp: nonEmptyString(value.timestamp),
+        parentThreadId: nonEmptyString(value.parent_thread_id) ??
+            nonEmptyString(value.parent_id) ??
+            nonEmptyString(spawn?.parent_thread_id),
+        subagent: rawSubagent(value, spawn),
+    };
+}
+function threadSpawn(value) {
+    const source = isObject(value.source) ? value.source : null;
+    const subagent = source?.subagent;
+    return isObject(subagent) && isObject(subagent.thread_spawn) ? subagent.thread_spawn : null;
+}
+function rawSubagent(value, spawn) {
+    const source = isObject(value.source) ? value.source : null;
+    const subagent = source?.subagent;
+    return nonEmptySubagentIdentity({
+        taskName: taskNameFromSubagentPath(nonEmptyString(value.agent_path) ?? nonEmptyString(spawn?.agent_path)),
+        nickname: nonEmptyString(value.agent_nickname) ?? nonEmptyString(spawn?.agent_nickname),
+        role: nonEmptyString(value.agent_role) ??
+            nonEmptyString(spawn?.agent_role) ??
+            (typeof subagent === "string" ? subagent : null),
+    });
+}
+function timestampOf(record) {
+    return record === undefined ? null : nonEmptyString(record.timestamp);
+}
+//# sourceMappingURL=identity-resolver.js.map

package/dist/server/server/adapters/codex/interaction-parser.js

@@ -0,0 +1,70 @@
+import { TASK_NAME_ERROR, validTaskName } from "../../../shared/task-name.js";
+import { validProjectDirectory } from "../../domain/project-directory.js";
+import { bindingAttempts } from "../shared/binding-protocol.js";
+import { isObject } from "../shared/jsonl-decoder.js";
+import { DEFAULT_KEY_BINDINGS, interruptSteps } from "../shared/session-management.js";
+const BINDING_MARKER = "AHUB_TMUX_BIND_V3";
+export function codexInteraction(projectDirectory, taskName) {
+    return {
+        transport: "tmux",
+        bindingCommand: codexBindingCommand(undefined, projectDirectory, taskName),
+        keyBindings: DEFAULT_KEY_BINDINGS,
+        interruptSteps,
+    };
+}
+export function codexBindingAttemptsFrom(record) {
+    if (record.value.type !== "response_item")
+        return [];
+    const metadata = record.value.metadata;
+    if (isObject(metadata) && metadata.inherited_user_message === true)
+        return [];
+    const payload = record.value.payload;
+    if (!isObject(payload) || payload.type !== "message" || payload.role !== "user") {
+        return [];
+    }
+    const text = contentText(payload.content);
+    if (text === null || !/^\s*<user_shell_command>/.test(text))
+        return [];
+    const shellBlocks = [...text.matchAll(/<user_shell_command>([\s\S]*?)<\/user_shell_command>/g)];
+    const found = [];
+    for (const block of shellBlocks) {
+        const lines = (block[1] ?? "").split("\n").map((line) => line.replace(/\r$/, ""));
+        found.push(...bindingAttempts(lines, record.ordinal, validOperationId));
+    }
+    const lastOpen = text.lastIndexOf("<user_shell_command>");
+    const lastClose = text.lastIndexOf("</user_shell_command>");
+    if (lastOpen > lastClose) {
+        const incomplete = text.slice(lastOpen + "<user_shell_command>".length);
+        const incompleteLines = incomplete.replace(/\r\n?/g, "\n").split("\n");
+        for (const line of incompleteLines) {
+            if (line === BINDING_MARKER)
+                found.push({ ordinal: record.ordinal, valid: false });
+        }
+    }
+    return found;
+}
+function contentText(value) {
+    if (!Array.isArray(value))
+        return null;
+    const parts = [];
+    for (const part of value) {
+        if (!isObject(part) || typeof part.text !== "string")
+            continue;
+        if (part.type === "input_text" || part.type === "text")
+            parts.push(part.text);
+    }
+    return parts.length === 0 ? null : parts.join("\n\n");
+}
+export function codexBindingCommand(operationId, projectDirectory, taskName) {
+    if (taskName !== undefined && taskName !== null && !validTaskName(taskName))
+        throw new Error(TASK_NAME_ERROR);
+    if (operationId !== undefined && !validOperationId(operationId))
+        throw new Error("Invalid operation ID");
+    const quote = (value) => "'" + value.replaceAll("'", "'\"'\"'") + "'";
+    const project = validProjectDirectory(projectDirectory) ? projectDirectory : "";
+    return `! printf '${BINDING_MARKER}\\n%s\\n%s\\n%s\\n%s\\n%s\\n' "\${TMUX%%,*}" "$AHUB_TMUX_SESSION_NAME" ${quote(operationId ?? "")} ${quote(project)} ${quote(JSON.stringify(taskName ?? null))}`;
+}
+function validOperationId(id) {
+    return /^[a-f0-9]{8}-(?:[a-f0-9]{4}-){3}[a-f0-9]{12}$/i.test(id);
+}
+//# sourceMappingURL=interaction-parser.js.map

package/dist/server/server/adapters/codex/io-errors.js

@@ -0,0 +1,2 @@
+export { isExpectedIoError } from "../shared/io-errors.js";
+//# sourceMappingURL=io-errors.js.map