@pasko70/pibo 1.16.6 → 2.0.0

package/dist/agent-runtimes/codex-native/requests.js

@@ -0,0 +1,378 @@
+import { randomUUID } from "node:crypto";
+import { CodexAppServerServerRequestCancelledError, } from "./client.js";
+import { redactCodexNativeSensitiveText, redactCodexNativeValue } from "./redaction.js";
+const MAX_REQUEST_TEXT_LENGTH = 4_000;
+const MAX_USER_INPUT_ANSWER_LENGTH = 16_000;
+const MAX_USER_INPUT_QUESTIONS = 10;
+const MAX_USER_INPUT_OPTIONS = 20;
+const APPROVAL_DECISIONS = [
+    { id: "accept", label: "Approve once", description: "Allow this action once." },
+    { id: "acceptForSession", label: "Approve for session", description: "Allow matching actions for the rest of this native session." },
+    { id: "decline", label: "Decline", description: "Deny this action and let the turn continue." },
+    { id: "cancel", label: "Cancel turn", description: "Deny this action and interrupt the active turn." },
+];
+const APPROVAL_DECISION_IDS = new Set(APPROVAL_DECISIONS.map((decision) => decision.id));
+function deferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((resolvePromise, rejectPromise) => {
+        resolve = resolvePromise;
+        reject = rejectPromise;
+    });
+    return { promise, resolve, reject };
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function requiredRecord(value, label) {
+    if (!isRecord(value))
+        throw new Error(`Codex ${label} is invalid.`);
+    return value;
+}
+function requiredString(value, label) {
+    if (typeof value !== "string" || !value)
+        throw new Error(`Codex ${label} is invalid.`);
+    return value;
+}
+function requiredInteger(value, label) {
+    if (!Number.isSafeInteger(value))
+        throw new Error(`Codex ${label} is invalid.`);
+    return Number(value);
+}
+function boundedText(value, fallback = "") {
+    if (typeof value !== "string")
+        return fallback;
+    return redactCodexNativeSensitiveText(value).slice(0, MAX_REQUEST_TEXT_LENGTH);
+}
+function jsonValue(value) {
+    return redactCodexNativeValue(value);
+}
+function nativeRequestKey(requestId) {
+    return `${typeof requestId}:${String(requestId)}`;
+}
+function cloneApproval(request) {
+    return structuredClone(request);
+}
+function cloneUserInput(request) {
+    return structuredClone(request);
+}
+function validateScope(params, expectedThreadId, activeTurnId, label) {
+    const threadId = requiredString(params.threadId, `${label} thread id`);
+    const turnId = requiredString(params.turnId, `${label} turn id`);
+    const itemId = requiredString(params.itemId, `${label} item id`);
+    if (threadId !== expectedThreadId)
+        throw new Error(`Codex ${label} belongs to a different native thread.`);
+    if (!activeTurnId || turnId !== activeTurnId)
+        throw new Error(`Codex ${label} does not match the active native turn.`);
+    return { threadId, turnId, itemId };
+}
+function approvalRequest(requestId, requestType, params) {
+    if (requestType === "command_execution") {
+        const command = boundedText(params.command, "Codex command");
+        const reason = boundedText(params.reason);
+        const argumentsValue = {
+            command,
+            itemId: requiredString(params.itemId, "command approval item id"),
+        };
+        if (Array.isArray(params.commandActions))
+            argumentsValue.commandActions = jsonValue(params.commandActions);
+        if (params.networkApprovalContext !== undefined && params.networkApprovalContext !== null) {
+            argumentsValue.networkApprovalContext = jsonValue(params.networkApprovalContext);
+        }
+        if (params.proposedExecpolicyAmendment !== undefined && params.proposedExecpolicyAmendment !== null) {
+            argumentsValue.proposedExecpolicyAmendment = jsonValue(params.proposedExecpolicyAmendment);
+        }
+        if (params.proposedNetworkPolicyAmendments !== undefined && params.proposedNetworkPolicyAmendments !== null) {
+            argumentsValue.proposedNetworkPolicyAmendments = jsonValue(params.proposedNetworkPolicyAmendments);
+        }
+        return {
+            requestId,
+            requestType,
+            title: "Run Codex command",
+            ...(reason ? { detail: reason } : {}),
+            arguments: argumentsValue,
+            decisions: APPROVAL_DECISIONS.map((decision) => ({ ...decision })),
+        };
+    }
+    const reason = boundedText(params.reason);
+    const argumentsValue = {
+        itemId: requiredString(params.itemId, "file approval item id"),
+    };
+    if (typeof params.grantRoot === "string" && params.grantRoot) {
+        argumentsValue.grantRoot = boundedText(params.grantRoot);
+    }
+    return {
+        requestId,
+        requestType,
+        title: "Apply Codex file changes",
+        ...(reason ? { detail: reason } : {}),
+        arguments: argumentsValue,
+        decisions: APPROVAL_DECISIONS.map((decision) => ({ ...decision })),
+    };
+}
+function validateOptions(value, questionId) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (!Array.isArray(value) || value.length > MAX_USER_INPUT_OPTIONS) {
+        throw new Error(`Codex user-input options for question "${questionId}" are invalid.`);
+    }
+    return value.map((entry) => {
+        const option = requiredRecord(entry, "user-input option");
+        return {
+            label: boundedText(requiredString(option.label, "user-input option label")),
+            ...(typeof option.description === "string"
+                ? { description: boundedText(option.description) }
+                : {}),
+        };
+    });
+}
+function userInputQuestion(value) {
+    const question = requiredRecord(value, "user-input question");
+    const id = requiredString(question.id, "user-input question id");
+    return {
+        id,
+        header: boundedText(requiredString(question.header, "user-input question header")),
+        question: boundedText(requiredString(question.question, "user-input question text")),
+        options: validateOptions(question.options, id),
+        multiSelect: false,
+        allowFreeform: question.isOther === true,
+        secret: question.isSecret === true,
+    };
+}
+function normalizeAnswers(request, answers) {
+    const expected = new Set(request.questions.map((question) => question.id));
+    for (const key of Object.keys(answers)) {
+        if (!expected.has(key))
+            throw new Error(`Unknown answer id "${key}" for runtime user-input request.`);
+    }
+    const normalized = {};
+    for (const question of request.questions) {
+        const value = answers[question.id];
+        const values = typeof value === "string"
+            ? [value]
+            : Array.isArray(value) && value.every((entry) => typeof entry === "string")
+                ? value
+                : undefined;
+        if (!values || values.length === 0 || values.some((entry) => entry.length > MAX_USER_INPUT_ANSWER_LENGTH)) {
+            throw new Error(`Runtime user-input question "${question.id}" requires at least one bounded string answer.`);
+        }
+        if (question.multiSelect !== true && values.length > 1) {
+            throw new Error(`Runtime user-input question "${question.id}" accepts one answer.`);
+        }
+        if (question.options?.length && !question.allowFreeform) {
+            const allowed = new Set(question.options.map((option) => option.label));
+            if (values.some((entry) => !allowed.has(entry))) {
+                throw new Error(`Runtime user-input question "${question.id}" requires a listed option.`);
+            }
+        }
+        normalized[question.id] = { answers: [...values] };
+    }
+    return { answers: normalized };
+}
+export class CodexNativeRequestController {
+    client;
+    getThreadId;
+    getActiveTurnId;
+    structuredUserInputEnabled;
+    emit;
+    pendingByProductId = new Map();
+    productIdByNativeKey = new Map();
+    unsubscribeNotifications;
+    unsubscribeDiagnostics;
+    disposed = false;
+    constructor(client, getThreadId, getActiveTurnId, structuredUserInputEnabled, emit) {
+        this.client = client;
+        this.getThreadId = getThreadId;
+        this.getActiveTurnId = getActiveTurnId;
+        this.structuredUserInputEnabled = structuredUserInputEnabled;
+        this.emit = emit;
+        client.setServerRequestHandler((request) => this.handleServerRequest(request));
+        this.unsubscribeNotifications = client.subscribeNotifications((notification) => {
+            if (this.disposed)
+                return;
+            if (notification.method === "serverRequest/resolved")
+                this.handleResolvedNotification(notification.params);
+            else if (notification.method === "turn/completed")
+                this.handleTurnCompleted(notification.params);
+            else if (notification.method === "turn/started")
+                this.handleTurnStarted(notification.params);
+        });
+        this.unsubscribeDiagnostics = client.subscribeDiagnostics((diagnostic) => {
+            if (this.disposed || diagnostic.level !== "error")
+                return;
+            for (const pending of [...this.pendingByProductId.values()])
+                this.cancelPending(pending, "aborted");
+        });
+    }
+    get pendingApproval() {
+        return this.pendingApprovals[0];
+    }
+    get pendingUserInput() {
+        return this.pendingUserInputs[0];
+    }
+    get pendingApprovals() {
+        return [...this.pendingByProductId.values()]
+            .filter((pending) => pending.kind === "approval")
+            .map((pending) => cloneApproval(pending.request));
+    }
+    get pendingUserInputs() {
+        return [...this.pendingByProductId.values()]
+            .filter((pending) => pending.kind === "user_input")
+            .map((pending) => cloneUserInput(pending.request));
+    }
+    async respondToApproval(requestId, decision) {
+        const pending = this.pendingByProductId.get(requestId);
+        if (!pending || pending.kind !== "approval")
+            throw new Error("The runtime approval request is no longer pending.");
+        if (!APPROVAL_DECISION_IDS.has(decision) || !pending.request.decisions?.some((candidate) => candidate.id === decision)) {
+            throw new Error(`Unsupported runtime approval decision "${decision}".`);
+        }
+        this.removePending(pending, "responded");
+        pending.deferred.resolve({ decision: decision });
+    }
+    async respondToUserInput(requestId, answers) {
+        const pending = this.pendingByProductId.get(requestId);
+        if (!pending || pending.kind !== "user_input")
+            throw new Error("The runtime user-input request is no longer pending.");
+        const response = normalizeAnswers(pending.request, answers);
+        this.removePending(pending, "responded");
+        pending.deferred.resolve(response);
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.unsubscribeNotifications();
+        this.unsubscribeDiagnostics();
+        this.client.setServerRequestHandler(undefined);
+        for (const pending of [...this.pendingByProductId.values()])
+            this.cancelPending(pending, "aborted");
+    }
+    async handleServerRequest(request) {
+        if (this.disposed)
+            throw new CodexAppServerServerRequestCancelledError();
+        if (request.method === "item/commandExecution/requestApproval")
+            return await this.handleCommandApproval(request);
+        if (request.method === "item/fileChange/requestApproval")
+            return await this.handleFileApproval(request);
+        if (request.method === "item/tool/requestUserInput")
+            return await this.handleUserInput(request);
+        throw new Error(`Unsupported Codex server request method: ${request.method}`);
+    }
+    async handleCommandApproval(request) {
+        const params = requiredRecord(request.params, "command approval request");
+        const scope = validateScope(params, this.getThreadId(), this.getActiveTurnId(), "command approval request");
+        requiredInteger(params.startedAtMs, "command approval start timestamp");
+        const pending = this.createApproval(request.id, scope, approvalRequest(randomUUID(), "command_execution", params));
+        return await pending.deferred.promise;
+    }
+    async handleFileApproval(request) {
+        const params = requiredRecord(request.params, "file approval request");
+        const scope = validateScope(params, this.getThreadId(), this.getActiveTurnId(), "file approval request");
+        requiredInteger(params.startedAtMs, "file approval start timestamp");
+        const pending = this.createApproval(request.id, scope, approvalRequest(randomUUID(), "file_change", params));
+        return await pending.deferred.promise;
+    }
+    async handleUserInput(request) {
+        if (!this.structuredUserInputEnabled)
+            throw new Error("Codex structured user input is not enabled for this configured runtime instance.");
+        const params = requiredRecord(request.params, "user-input request");
+        const scope = validateScope(params, this.getThreadId(), this.getActiveTurnId(), "user-input request");
+        if (typeof params.isBlocking !== "boolean")
+            throw new Error("Codex user-input blocking state is invalid.");
+        if (!Array.isArray(params.questions) || params.questions.length === 0 || params.questions.length > MAX_USER_INPUT_QUESTIONS) {
+            throw new Error("Codex user-input questions are invalid.");
+        }
+        const questions = params.questions.map(userInputQuestion);
+        if (new Set(questions.map((question) => question.id)).size !== questions.length) {
+            throw new Error("Codex user-input question ids must be unique.");
+        }
+        const productRequestId = randomUUID();
+        const runtimeRequest = {
+            requestId: productRequestId,
+            questions,
+            blocking: params.isBlocking,
+        };
+        const pending = {
+            kind: "user_input",
+            productRequestId,
+            nativeRequestId: request.id,
+            nativeRequestKey: nativeRequestKey(request.id),
+            ...scope,
+            request: runtimeRequest,
+            deferred: deferred(),
+        };
+        this.addPending(pending);
+        this.emit({ type: "user_input_requested", request: cloneUserInput(runtimeRequest) });
+        return await pending.deferred.promise;
+    }
+    createApproval(nativeRequestId, scope, runtimeRequest) {
+        const pending = {
+            kind: "approval",
+            productRequestId: runtimeRequest.requestId,
+            nativeRequestId,
+            nativeRequestKey: nativeRequestKey(nativeRequestId),
+            ...scope,
+            request: runtimeRequest,
+            deferred: deferred(),
+        };
+        this.addPending(pending);
+        this.emit({ type: "approval_requested", request: cloneApproval(runtimeRequest) });
+        return pending;
+    }
+    addPending(pending) {
+        if (this.productIdByNativeKey.has(pending.nativeRequestKey))
+            throw new Error("Codex repeated a pending server request id.");
+        this.pendingByProductId.set(pending.productRequestId, pending);
+        this.productIdByNativeKey.set(pending.nativeRequestKey, pending.productRequestId);
+    }
+    removePending(pending, resolution) {
+        if (!this.pendingByProductId.delete(pending.productRequestId))
+            return;
+        this.productIdByNativeKey.delete(pending.nativeRequestKey);
+        this.emit(pending.kind === "approval"
+            ? { type: "approval_resolved", requestId: pending.productRequestId, resolution }
+            : { type: "user_input_resolved", requestId: pending.productRequestId, resolution });
+    }
+    cancelPending(pending, resolution) {
+        this.removePending(pending, resolution);
+        pending.deferred.reject(new CodexAppServerServerRequestCancelledError());
+    }
+    handleResolvedNotification(value) {
+        const params = requiredRecord(value, "server-request resolution notification");
+        if (requiredString(params.threadId, "server-request resolution thread id") !== this.getThreadId())
+            return;
+        const requestId = params.requestId;
+        if ((typeof requestId !== "string" && typeof requestId !== "number") || (typeof requestId === "number" && !Number.isSafeInteger(requestId))) {
+            throw new Error("Codex server-request resolution id is invalid.");
+        }
+        const productRequestId = this.productIdByNativeKey.get(nativeRequestKey(requestId));
+        if (!productRequestId)
+            return;
+        const pending = this.pendingByProductId.get(productRequestId);
+        if (pending)
+            this.cancelPending(pending, "cleared");
+    }
+    handleTurnCompleted(value) {
+        const params = requiredRecord(value, "turn completion notification");
+        if (requiredString(params.threadId, "turn completion thread id") !== this.getThreadId())
+            return;
+        const turn = requiredRecord(params.turn, "completed turn");
+        const turnId = requiredString(turn.id, "completed turn id");
+        for (const pending of [...this.pendingByProductId.values()]) {
+            if (pending.turnId === turnId)
+                this.cancelPending(pending, "cleared");
+        }
+    }
+    handleTurnStarted(value) {
+        const params = requiredRecord(value, "turn start notification");
+        if (requiredString(params.threadId, "turn start thread id") !== this.getThreadId())
+            return;
+        const turn = requiredRecord(params.turn, "started turn");
+        const turnId = requiredString(turn.id, "started turn id");
+        for (const pending of [...this.pendingByProductId.values()]) {
+            if (pending.turnId !== turnId)
+                this.cancelPending(pending, "expired");
+        }
+    }
+}