@xfey/tenso 0.1.130

package/dist/server-shell/http/host-tunnel.d.ts

@@ -0,0 +1,24 @@
+import type { FastifyInstance } from "fastify";
+import type { RelayHostTunnelRequestHandler, RelayHostTunnelStreamRequestHandler } from "@tutti/relay-client";
+import type { IntegrationApprovalDecisionDisposition, IntegrationClarificationResponse, TrustedClarificationCommand, IntegrationDeliveryDisposition, IntegrationManagedReferenceDisposition, TrustedApprovalDecisionCommand, TrustedConversationSourceIngestionCommand, TrustedManagedReferenceIngestionCommand, TrustedReferenceAttachmentIngestionCommand } from "@tutti/shared/schemas/internal";
+import type { ProjectSurface } from "@tutti/shared/domain";
+import { type TrustedRelaySessionMetadataStore } from "../session/relay-session-context.js";
+export type HostProjectApiTunnelDispatchOptions = {
+    app: FastifyInstance;
+    projectSurface?: ProjectSurface;
+    trustedMetadataStore: TrustedRelaySessionMetadataStore;
+    integrationClarification?: (command: TrustedClarificationCommand) => IntegrationClarificationResponse;
+    integrationDelivery?: (command: TrustedConversationSourceIngestionCommand) => IntegrationDeliveryDisposition;
+    integrationApprovalDecision?: (command: TrustedApprovalDecisionCommand) => IntegrationApprovalDecisionDisposition;
+    integrationReferenceAttachment?: (command: TrustedReferenceAttachmentIngestionCommand) => Promise<IntegrationDeliveryDisposition>;
+    integrationManagedReference?: (command: TrustedManagedReferenceIngestionCommand) => Promise<IntegrationManagedReferenceDisposition>;
+};
+export type HostProjectApiTunnelStreamDispatchOptions = {
+    baseUrl: string;
+    projectSurface?: ProjectSurface;
+    trustedMetadataStore: TrustedRelaySessionMetadataStore;
+    fetch?: typeof fetch;
+};
+export declare function createHostProjectApiTunnelRequestHandler(options: HostProjectApiTunnelDispatchOptions): RelayHostTunnelRequestHandler;
+export declare function createHostProjectApiTunnelStreamRequestHandler(options: HostProjectApiTunnelStreamDispatchOptions): RelayHostTunnelStreamRequestHandler;
+//# sourceMappingURL=host-tunnel.d.ts.map

package/dist/server-shell/http/host-tunnel.js

@@ -0,0 +1,437 @@
+import { dispatchIntegrationClarification } from "./integration-clarification-dispatch.js";
+import { INTEGRATION_APPROVAL_DECISION_TUNNEL_PATH, INTEGRATION_CLARIFICATION_TUNNEL_PATH, INTEGRATION_MANAGED_REFERENCE_TUNNEL_PATH, INTEGRATION_REFERENCE_ATTACHMENT_TUNNEL_PATH, isTrustedApprovalDecisionCommand, isTrustedConversationSourceIngestionCommand, isTrustedManagedReferenceIngestionCommand, isTrustedReferenceAttachmentIngestionCommand, } from "@tutti/shared/schemas/internal";
+import { TRUSTED_INTEGRATION_INGESTION_PATH, TRUSTED_INTEGRATION_REFERENCE_ATTACHMENT_PATH, } from "../../collaboration-ingestion/index.js";
+import { TRUSTED_RELAY_METADATA_REQUEST_HEADER, } from "../session/relay-session-context.js";
+function browserMetadataMatchesSurface(projectSurface, request) {
+    return projectSurface === "standalone"
+        ? "relay_session_context" in request.metadata
+        : "feishu_platform_session_context" in request.metadata;
+}
+function forbiddenBrowserResponse(requestId) {
+    return {
+        request_id: requestId,
+        status_code: 403,
+        headers: { "content-type": "application/json; charset=utf-8" },
+        body_base64: Buffer.from(JSON.stringify({
+            error: {
+                code: "forbidden",
+                message: "Project surface does not allow this session",
+                retryable: false,
+            },
+        }), "utf8").toString("base64"),
+    };
+}
+function decodeRequestBody(bodyBase64) {
+    if (bodyBase64 === undefined) {
+        return undefined;
+    }
+    return Buffer.from(bodyBase64, "base64");
+}
+function integrationResponse(requestId, disposition) {
+    const body = {
+        protocol_version: 1,
+        disposition,
+    };
+    return {
+        request_id: requestId,
+        status_code: 200,
+        headers: { "content-type": "application/json; charset=utf-8" },
+        body_base64: Buffer.from(JSON.stringify(body), "utf8").toString("base64"),
+    };
+}
+function integrationApprovalResponse(requestId, disposition) {
+    const body = {
+        protocol_version: 1,
+        disposition,
+    };
+    return {
+        request_id: requestId,
+        status_code: 200,
+        headers: { "content-type": "application/json; charset=utf-8" },
+        body_base64: Buffer.from(JSON.stringify(body), "utf8").toString("base64"),
+    };
+}
+function integrationManagedReferenceResponse(requestId, disposition) {
+    const body = {
+        protocol_version: 1,
+        disposition,
+    };
+    return {
+        request_id: requestId,
+        status_code: 200,
+        headers: { "content-type": "application/json; charset=utf-8" },
+        body_base64: Buffer.from(JSON.stringify(body), "utf8").toString("base64"),
+    };
+}
+function sameInstallation(left, right) {
+    return left.platform === right.platform && left.installation_ref === right.installation_ref;
+}
+function dispatchIntegrationDelivery(options, request) {
+    if ((options.projectSurface ?? "standalone") !== "feishu") {
+        return Promise.resolve(integrationResponse(request.request_id, {
+            kind: "unsupported",
+            reason_code: "project_surface_mismatch",
+        }));
+    }
+    if (!("integration_delivery" in request.metadata)) {
+        throw new TypeError("Integration delivery metadata is required");
+    }
+    if (request.path === INTEGRATION_APPROVAL_DECISION_TUNNEL_PATH) {
+        return dispatchIntegrationApprovalDecision(options, request);
+    }
+    if (request.path === INTEGRATION_CLARIFICATION_TUNNEL_PATH)
+        return Promise.resolve(dispatchIntegrationClarification(options, request));
+    if (request.path === INTEGRATION_REFERENCE_ATTACHMENT_TUNNEL_PATH) {
+        return dispatchIntegrationReferenceAttachment(options, request);
+    }
+    if (request.path === INTEGRATION_MANAGED_REFERENCE_TUNNEL_PATH) {
+        return dispatchIntegrationManagedReference(options, request);
+    }
+    if (request.method.toUpperCase() !== "POST" ||
+        request.path !== TRUSTED_INTEGRATION_INGESTION_PATH) {
+        return Promise.resolve(integrationResponse(request.request_id, {
+            kind: "invalid",
+            reason_code: "internal_route_invalid",
+        }));
+    }
+    const payload = decodeRequestBody(request.body_base64);
+    let command;
+    try {
+        command = payload === undefined ? undefined : JSON.parse(payload.toString("utf8"));
+    }
+    catch {
+        command = undefined;
+    }
+    if (!isTrustedConversationSourceIngestionCommand(command)) {
+        return Promise.resolve(integrationResponse(request.request_id, {
+            kind: "invalid",
+            reason_code: "trusted_command_invalid",
+        }));
+    }
+    const metadata = request.metadata.integration_delivery;
+    if (!("receipt_key" in metadata) ||
+        command.relay_project_ref !== metadata.relay_project_ref ||
+        command.binding_ref !== metadata.binding_ref ||
+        command.receipt.receipt_key !== metadata.receipt_key ||
+        command.actor.verified_at !== metadata.verified_at ||
+        !sameInstallation(command.receipt.installation, metadata.installation)) {
+        return Promise.resolve(integrationResponse(request.request_id, {
+            kind: "invalid",
+            reason_code: "trusted_metadata_mismatch",
+        }));
+    }
+    if (options.integrationDelivery === undefined) {
+        return Promise.resolve(integrationResponse(request.request_id, {
+            kind: "host_incompatible",
+            retryable: true,
+            reason_code: "integration_source_ingestion_unsupported",
+        }));
+    }
+    return Promise.resolve(integrationResponse(request.request_id, options.integrationDelivery(command)));
+}
+async function dispatchIntegrationReferenceAttachment(options, request) {
+    if (!("integration_delivery" in request.metadata)) {
+        throw new TypeError("Integration delivery metadata is required");
+    }
+    if (request.method.toUpperCase() !== "POST" ||
+        request.path !== TRUSTED_INTEGRATION_REFERENCE_ATTACHMENT_PATH) {
+        return integrationResponse(request.request_id, {
+            kind: "invalid",
+            reason_code: "internal_route_invalid",
+        });
+    }
+    const payload = decodeRequestBody(request.body_base64);
+    let command;
+    try {
+        command = payload === undefined ? undefined : JSON.parse(payload.toString("utf8"));
+    }
+    catch {
+        command = undefined;
+    }
+    if (!isTrustedReferenceAttachmentIngestionCommand(command)) {
+        return integrationResponse(request.request_id, {
+            kind: "invalid",
+            reason_code: "trusted_attachment_command_invalid",
+        });
+    }
+    const metadata = request.metadata.integration_delivery;
+    if (!("receipt_key" in metadata) ||
+        command.relay_project_ref !== metadata.relay_project_ref ||
+        command.binding_ref !== metadata.binding_ref ||
+        command.receipt.receipt_key !== metadata.receipt_key ||
+        command.actor.verified_at !== metadata.verified_at ||
+        !sameInstallation(command.receipt.installation, metadata.installation)) {
+        return integrationResponse(request.request_id, {
+            kind: "invalid",
+            reason_code: "trusted_metadata_mismatch",
+        });
+    }
+    if (options.integrationReferenceAttachment === undefined) {
+        return integrationResponse(request.request_id, {
+            kind: "host_incompatible",
+            retryable: true,
+            reason_code: "integration_attachment_ingestion_unsupported",
+        });
+    }
+    return integrationResponse(request.request_id, await options.integrationReferenceAttachment(command));
+}
+async function dispatchIntegrationManagedReference(options, request) {
+    if (!("integration_delivery" in request.metadata)) {
+        throw new TypeError("Integration delivery metadata is required");
+    }
+    if (request.method.toUpperCase() !== "POST" ||
+        request.path !== INTEGRATION_MANAGED_REFERENCE_TUNNEL_PATH) {
+        return integrationManagedReferenceResponse(request.request_id, {
+            kind: "invalid",
+            reason_code: "internal_route_invalid",
+        });
+    }
+    const payload = decodeRequestBody(request.body_base64);
+    let command;
+    try {
+        command = payload === undefined ? undefined : JSON.parse(payload.toString("utf8"));
+    }
+    catch {
+        command = undefined;
+    }
+    if (!isTrustedManagedReferenceIngestionCommand(command)) {
+        return integrationManagedReferenceResponse(request.request_id, {
+            kind: "invalid",
+            reason_code: "trusted_managed_reference_command_invalid",
+        });
+    }
+    const metadata = request.metadata.integration_delivery;
+    if (!("operation_ref" in metadata) ||
+        command.relay_project_ref !== metadata.relay_project_ref ||
+        command.binding_ref !== metadata.binding_ref ||
+        command.operation_ref !== metadata.operation_ref ||
+        command.actor.verified_at !== metadata.verified_at ||
+        !sameInstallation(command.source.installation, metadata.installation)) {
+        return integrationManagedReferenceResponse(request.request_id, {
+            kind: "invalid",
+            reason_code: "trusted_metadata_mismatch",
+        });
+    }
+    if (options.integrationManagedReference === undefined) {
+        return integrationManagedReferenceResponse(request.request_id, {
+            kind: "host_incompatible",
+            retryable: true,
+            reason_code: "integration_managed_reference_ingestion_unsupported",
+        });
+    }
+    return integrationManagedReferenceResponse(request.request_id, await options.integrationManagedReference(command));
+}
+function dispatchIntegrationApprovalDecision(options, request) {
+    if (!("integration_delivery" in request.metadata)) {
+        throw new TypeError("Integration delivery metadata is required");
+    }
+    if (request.method.toUpperCase() !== "POST") {
+        return Promise.resolve(integrationApprovalResponse(request.request_id, {
+            kind: "invalid",
+            reason_code: "internal_route_invalid",
+        }));
+    }
+    const payload = decodeRequestBody(request.body_base64);
+    let command;
+    try {
+        command = payload === undefined ? undefined : JSON.parse(payload.toString("utf8"));
+    }
+    catch {
+        command = undefined;
+    }
+    if (!isTrustedApprovalDecisionCommand(command)) {
+        return Promise.resolve(integrationApprovalResponse(request.request_id, {
+            kind: "invalid",
+            reason_code: "trusted_command_invalid",
+        }));
+    }
+    const metadata = request.metadata.integration_delivery;
+    if (!("receipt_key" in metadata) ||
+        command.relay_project_ref !== metadata.relay_project_ref ||
+        command.binding_ref !== metadata.binding_ref ||
+        command.receipt.receipt_key !== metadata.receipt_key ||
+        command.actor.verified_at !== metadata.verified_at ||
+        !sameInstallation(command.receipt.installation, metadata.installation)) {
+        return Promise.resolve(integrationApprovalResponse(request.request_id, {
+            kind: "invalid",
+            reason_code: "trusted_metadata_mismatch",
+        }));
+    }
+    if (options.integrationApprovalDecision === undefined) {
+        return Promise.resolve(integrationApprovalResponse(request.request_id, {
+            kind: "host_incompatible",
+            retryable: true,
+            reason_code: "integration_approval_decision_unsupported",
+        }));
+    }
+    return Promise.resolve(integrationApprovalResponse(request.request_id, options.integrationApprovalDecision(command)));
+}
+function injectHeaders(request) {
+    const headers = {};
+    for (const [name, value] of Object.entries(request.headers)) {
+        if (name.toLowerCase() === TRUSTED_RELAY_METADATA_REQUEST_HEADER) {
+            continue;
+        }
+        headers[name] = typeof value === "string" ? value : Array.from(value);
+    }
+    return headers;
+}
+function responseHeaders(headers) {
+    const relayHeaders = {};
+    for (const [name, value] of Object.entries(headers)) {
+        if (value === undefined) {
+            continue;
+        }
+        relayHeaders[name] = typeof value === "number" ? String(value) : value;
+    }
+    return relayHeaders;
+}
+function responseBodyBuffer(response) {
+    const rawPayload = response.rawPayload;
+    if (Buffer.isBuffer(rawPayload)) {
+        return rawPayload;
+    }
+    if (rawPayload instanceof Uint8Array) {
+        return Buffer.from(rawPayload);
+    }
+    if (rawPayload instanceof ArrayBuffer) {
+        return Buffer.from(rawPayload);
+    }
+    return Buffer.from(response.body, "utf8");
+}
+function fetchResponseHeaders(headers) {
+    const relayHeaders = {};
+    headers.forEach((value, name) => {
+        relayHeaders[name] = value;
+    });
+    return relayHeaders;
+}
+function fetchRequestHeaders(headers) {
+    const fetchHeaders = {};
+    for (const [name, value] of Object.entries(headers)) {
+        fetchHeaders[name] = typeof value === "string" ? value : value.join(", ");
+    }
+    return fetchHeaders;
+}
+function toInjectMethod(method) {
+    const normalized = method.toUpperCase();
+    switch (normalized) {
+        case "DELETE":
+        case "GET":
+        case "HEAD":
+        case "PATCH":
+        case "POST":
+        case "PUT":
+        case "OPTIONS":
+            return normalized;
+        default:
+            return "TRACE";
+    }
+}
+export function createHostProjectApiTunnelRequestHandler(options) {
+    return async (request) => {
+        if ("integration_delivery" in request.metadata) {
+            return dispatchIntegrationDelivery(options, request);
+        }
+        if (!browserMetadataMatchesSurface(options.projectSurface ?? "standalone", request)) {
+            return forbiddenBrowserResponse(request.request_id);
+        }
+        const headers = injectHeaders(request);
+        headers[TRUSTED_RELAY_METADATA_REQUEST_HEADER] = options.trustedMetadataStore.stage(request.metadata);
+        const payload = decodeRequestBody(request.body_base64);
+        const injectOptions = {
+            method: toInjectMethod(request.method),
+            url: request.path,
+            headers,
+        };
+        if (payload !== undefined) {
+            injectOptions.payload = payload;
+        }
+        const response = await options.app.inject(injectOptions);
+        const responsePayload = responseBodyBuffer(response);
+        const tunnelResponse = {
+            request_id: request.request_id,
+            status_code: response.statusCode,
+            headers: responseHeaders(response.headers),
+        };
+        if (responsePayload.length === 0) {
+            return tunnelResponse;
+        }
+        return {
+            ...tunnelResponse,
+            body_base64: responsePayload.toString("base64"),
+        };
+    };
+}
+async function writeFetchBodyToStreamSink(response, sink) {
+    if (response.body === null) {
+        sink.end();
+        return;
+    }
+    const reader = response.body.getReader();
+    try {
+        while (!sink.signal.aborted) {
+            const chunk = await reader.read();
+            if (chunk.done) {
+                break;
+            }
+            const value = chunk.value;
+            if (value instanceof Uint8Array) {
+                sink.write(value);
+            }
+            else if (typeof value === "string") {
+                sink.write(value);
+            }
+            else if (value instanceof ArrayBuffer) {
+                sink.write(new Uint8Array(value));
+            }
+            else {
+                throw new Error("Unsupported fetch stream chunk type");
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    if (!sink.signal.aborted) {
+        sink.end();
+    }
+}
+export function createHostProjectApiTunnelStreamRequestHandler(options) {
+    return async (request, sink) => {
+        if ("integration_delivery" in request.metadata) {
+            sink.error();
+            return;
+        }
+        if (!browserMetadataMatchesSurface(options.projectSurface ?? "standalone", request)) {
+            const response = forbiddenBrowserResponse(request.request_id);
+            sink.start({
+                status_code: response.status_code,
+                ...(response.headers === undefined ? {} : { headers: response.headers }),
+            });
+            if (response.body_base64 !== undefined) {
+                sink.write(Buffer.from(response.body_base64, "base64"));
+            }
+            sink.end();
+            return;
+        }
+        const headers = injectHeaders(request);
+        headers[TRUSTED_RELAY_METADATA_REQUEST_HEADER] = options.trustedMetadataStore.stage(request.metadata);
+        const payload = decodeRequestBody(request.body_base64);
+        const init = {
+            method: toInjectMethod(request.method),
+            headers: fetchRequestHeaders(headers),
+            signal: sink.signal,
+        };
+        if (payload !== undefined) {
+            init.body = payload;
+        }
+        const response = await (options.fetch ?? fetch)(new URL(request.path, options.baseUrl), init);
+        sink.start({
+            status_code: response.status,
+            headers: fetchResponseHeaders(response.headers),
+        });
+        await writeFetchBodyToStreamSink(response, sink);
+    };
+}
+//# sourceMappingURL=host-tunnel.js.map

package/dist/server-shell/http/integration-clarification-dispatch.d.ts

@@ -0,0 +1,6 @@
+import type { RelayHostTunnelRequest, RelayHostTunnelResponse } from "@tutti/relay-client";
+import { type IntegrationClarificationResponse, type TrustedClarificationCommand } from "@tutti/shared/schemas/internal";
+export declare function dispatchIntegrationClarification(options: {
+    integrationClarification?: (command: TrustedClarificationCommand) => IntegrationClarificationResponse;
+}, request: RelayHostTunnelRequest): RelayHostTunnelResponse;
+//# sourceMappingURL=integration-clarification-dispatch.d.ts.map

package/dist/server-shell/http/integration-clarification-dispatch.js

@@ -0,0 +1,43 @@
+import { INTEGRATION_CLARIFICATION_TUNNEL_PATH, isTrustedClarificationCommand, } from "@tutti/shared/schemas/internal";
+export function dispatchIntegrationClarification(options, request) {
+    const finish = (body) => ({
+        request_id: request.request_id,
+        status_code: 200,
+        headers: { "content-type": "application/json; charset=utf-8" },
+        body_base64: Buffer.from(JSON.stringify(body), "utf8").toString("base64"),
+    });
+    const invalid = (reason_code) => finish({ protocol_version: 1, disposition: { kind: "invalid", reason_code } });
+    if (request.method !== "POST" ||
+        request.path !== INTEGRATION_CLARIFICATION_TUNNEL_PATH ||
+        !("integration_delivery" in request.metadata))
+        return invalid("internal_route_invalid");
+    let command;
+    try {
+        command = JSON.parse(Buffer.from(request.body_base64 ?? "", "base64").toString("utf8"));
+    }
+    catch {
+        return invalid("trusted_command_invalid");
+    }
+    if (!isTrustedClarificationCommand(command))
+        return invalid("trusted_command_invalid");
+    const metadata = request.metadata.integration_delivery;
+    if (!("operation_ref" in metadata) ||
+        command.operation_ref !== metadata.operation_ref ||
+        command.binding_ref !== metadata.binding_ref ||
+        command.relay_project_ref !== metadata.relay_project_ref ||
+        command.actor.verified_at !== metadata.verified_at ||
+        command.conversation.installation.platform !== metadata.installation.platform ||
+        command.conversation.installation.installation_ref !== metadata.installation.installation_ref)
+        return invalid("trusted_metadata_mismatch");
+    if (options.integrationClarification === undefined)
+        return finish({
+            protocol_version: 1,
+            disposition: {
+                kind: "unavailable",
+                retryable: true,
+                reason_code: "integration_clarification_unsupported",
+            },
+        });
+    return finish(options.integrationClarification(command));
+}
+//# sourceMappingURL=integration-clarification-dispatch.js.map

package/dist/server-shell/http/logger.d.ts

@@ -0,0 +1,9 @@
+import { serializeRuntimeRequestLog, serializeRuntimeResponseLog, type RuntimeSerializedErrorLog } from "@tutti/shared/utils";
+import type { FastifyError, FastifyServerOptions } from "fastify";
+export declare const serializeRequestLog: typeof serializeRuntimeRequestLog;
+export declare const serializeResponseLog: typeof serializeRuntimeResponseLog;
+export declare function serializeErrorLog(error: FastifyError): RuntimeSerializedErrorLog;
+export declare function createRedactedLoggerOptions(service: string, options?: {
+    file?: string;
+}): Exclude<FastifyServerOptions["logger"], undefined>;
+//# sourceMappingURL=logger.d.ts.map

package/dist/server-shell/http/logger.js

@@ -0,0 +1,20 @@
+import { serializeRuntimeErrorLog, serializeRuntimeRequestLog, serializeRuntimeResponseLog, } from "@tutti/shared/utils";
+export const serializeRequestLog = serializeRuntimeRequestLog;
+export const serializeResponseLog = serializeRuntimeResponseLog;
+export function serializeErrorLog(error) {
+    return serializeRuntimeErrorLog(error);
+}
+export function createRedactedLoggerOptions(service, options = {}) {
+    return {
+        level: "info",
+        messageKey: "message",
+        base: { service, component: "http" },
+        ...(options.file === undefined ? {} : { file: options.file }),
+        serializers: {
+            req: serializeRequestLog,
+            res: serializeResponseLog,
+            err: serializeErrorLog,
+        },
+    };
+}
+//# sourceMappingURL=logger.js.map

package/dist/server-shell/http/routes/agent-context-auth.d.ts

@@ -0,0 +1,42 @@
+import type { FastifyRequest } from "fastify";
+import type { ActivityRef, ProjectId } from "@tutti/shared/ids";
+import type { CodexAppServerContextApiScope, CodexAppServerSkillSelectionName } from "../../../providers/openai/app-server/skills.js";
+export declare const DEFAULT_AGENT_CONTEXT_TOKEN_TTL_MS: number;
+export type AgentContextTokenRecord = {
+    reference_invocation_ref: string;
+    token: string;
+    project_id: ProjectId;
+    activity_ref?: ActivityRef;
+    selection: CodexAppServerSkillSelectionName;
+    scopes: CodexAppServerContextApiScope[];
+    expires_at: string;
+};
+export declare class AgentContextTokenRegistry {
+    private readonly options;
+    private readonly records;
+    constructor(options?: {
+        now?: () => Date;
+        ttlMs?: number;
+        tokenFactory?: () => string;
+    });
+    issueToken(input: {
+        projectId: ProjectId;
+        activityRef?: ActivityRef;
+        selection: CodexAppServerSkillSelectionName;
+        scopes: CodexAppServerContextApiScope[];
+        ttlMs?: number;
+    }): AgentContextTokenRecord;
+    validate(options: {
+        token: string;
+        projectId: ProjectId;
+        requiredScope: CodexAppServerContextApiScope;
+    }): AgentContextTokenRecord;
+    private now;
+}
+export declare function authorizeAgentContextRequest(request: FastifyRequest, options: {
+    project: {
+        project_id: ProjectId;
+    };
+    tokenRegistry: AgentContextTokenRegistry;
+}, requiredScope: CodexAppServerContextApiScope): AgentContextTokenRecord;
+//# sourceMappingURL=agent-context-auth.d.ts.map

package/dist/server-shell/http/routes/agent-context-auth.js

@@ -0,0 +1,75 @@
+import { randomBytes } from "node:crypto";
+import { createEventRef } from "@tutti/shared/ids";
+export const DEFAULT_AGENT_CONTEXT_TOKEN_TTL_MS = 30 * 60 * 1000;
+export class AgentContextTokenRegistry {
+    options;
+    records = new Map();
+    constructor(options = {}) {
+        this.options = options;
+    }
+    issueToken(input) {
+        const now = this.now();
+        const ttlMs = input.ttlMs ?? this.options.ttlMs ?? DEFAULT_AGENT_CONTEXT_TOKEN_TTL_MS;
+        const token = this.options.tokenFactory?.() ?? `agctx_${randomBytes(32).toString("base64url")}`;
+        const record = {
+            reference_invocation_ref: createEventRef(),
+            token,
+            project_id: input.projectId,
+            ...(input.activityRef === undefined ? {} : { activity_ref: input.activityRef }),
+            selection: input.selection,
+            scopes: [...new Set(input.scopes)],
+            expires_at: new Date(now.getTime() + ttlMs).toISOString(),
+        };
+        this.records.set(token, record);
+        return record;
+    }
+    validate(options) {
+        const record = this.records.get(options.token);
+        if (record === undefined) {
+            throw new AgentContextAuthError(401, "unauthorized", "Agent context token is invalid");
+        }
+        if (Date.parse(record.expires_at) <= this.now().getTime()) {
+            this.records.delete(options.token);
+            throw new AgentContextAuthError(401, "unauthorized", "Agent context token is expired");
+        }
+        if (record.project_id !== options.projectId) {
+            throw new AgentContextAuthError(403, "forbidden", "Agent context token is not valid here");
+        }
+        if (!record.scopes.includes(options.requiredScope)) {
+            throw new AgentContextAuthError(403, "forbidden", "Agent context scope is not allowed");
+        }
+        return record;
+    }
+    now() {
+        return (this.options.now ?? (() => new Date()))();
+    }
+}
+class AgentContextAuthError extends Error {
+    statusCode;
+    code;
+    constructor(statusCode, code, message) {
+        super(message);
+        this.name = "AgentContextAuthError";
+        this.statusCode = statusCode;
+        this.code = code;
+    }
+}
+function bearerToken(request) {
+    const authorization = request.headers.authorization;
+    if (authorization === undefined) {
+        throw new AgentContextAuthError(401, "unauthorized", "Agent context token is required");
+    }
+    const match = /^Bearer\s+(.+)$/iu.exec(authorization);
+    if (match?.[1] === undefined || match[1].trim() === "") {
+        throw new AgentContextAuthError(401, "unauthorized", "Agent context token is invalid");
+    }
+    return match[1].trim();
+}
+export function authorizeAgentContextRequest(request, options, requiredScope) {
+    return options.tokenRegistry.validate({
+        token: bearerToken(request),
+        projectId: options.project.project_id,
+        requiredScope,
+    });
+}
+//# sourceMappingURL=agent-context-auth.js.map

package/dist/server-shell/http/routes/agent-context-errors.d.ts

@@ -0,0 +1,6 @@
+export declare class AgentContextBadRequestError extends Error {
+    readonly statusCode = 400;
+    readonly code = "bad_request";
+    constructor(message: string);
+}
+//# sourceMappingURL=agent-context-errors.d.ts.map

package/dist/server-shell/http/routes/agent-context-errors.js

@@ -0,0 +1,9 @@
+export class AgentContextBadRequestError extends Error {
+    statusCode = 400;
+    code = "bad_request";
+    constructor(message) {
+        super(message);
+        this.name = "AgentContextBadRequestError";
+    }
+}
+//# sourceMappingURL=agent-context-errors.js.map