Moderation hook endpoint in Node.js

// verify.js
import { Buffer } from 'node:buffer';
import { createHmac, timingSafeEqual } from 'node:crypto';

const SECRET = process.env.CKEDITOR_AI_HOOK_SECRET; // whsec_...
const TOLERANCE_SECONDS = 300;

export function verify( headers, rawBody ) {
	const id = headers[ 'webhook-id' ];
	const timestamp = headers[ 'webhook-timestamp' ];
	const header = headers[ 'webhook-signature' ];

	if ( !id || !timestamp || !header ) {
		return false;
	}

	if ( Math.abs( Date.now() / 1000 - Number( timestamp ) ) > TOLERANCE_SECONDS ) {
		return false;
	}

	const key = Buffer.from( SECRET.slice( 'whsec_'.length ), 'base64' );
	const expected = createHmac( 'sha256', key )
		.update( `${ id }.${ timestamp }.` )
		.update( rawBody, 'utf8' )
		.digest( 'base64' );

	return header.split( ' ' ).some( entry => equals( entry.split( ',' )[ 1 ] ?? '', expected ) );
}

function equals( a, b ) {
	return a.length === b.length && timingSafeEqual( Buffer.from( a ), Buffer.from( b ) );
}

// policy-service.js
export async function screen( { userId, matterId, text, requestId, conversationId } ) {
	return {
		allowed: true, // false refuses the turn
		message: '', // the text the user reads when allowed is false
		ruleId: '' // the rule that refused, stored in attributes.policyRule
	};
}

import express from 'express';
import { verify } from './verify.js'; // the signature check from Dependencies
import { screen } from './policy-service.js'; // your policy service, or the stand-in above

// Stand-in for your ethical walls. In production this is a lookup keyed on the user and the matter.
// The key is the user id from the token's `sub` claim. Replace it with the id your token endpoint issues.
const WALLS = {
	'user-789': [ 'M-2031' ]
};

// Stand-in for your policy rules, so every path is easy to hit from a test.
function localRules( { userId, matterId, text } ) {
	if ( matterId && WALLS[ userId ]?.includes( matterId ) ) {
		return `You are not on the team for matter ${ matterId }, so I cannot discuss it. Contact the matter partner if you need access.`;
	}

	if ( /counterparty|opposing counsel/i.test( text ) ) {
		return 'I cannot help with material about the opposing side. Ask the conflicts desk first.';
	}

	return null;
}

// Everything the user sent, prompt and attachments alike. All of it is unscreened.
function textToScreen( turn ) {
	const parts = [ turn.prompt ];

	for ( const part of turn.content ) {
		if ( part.type === 'file' || part.type === 'web-resource' ) {
			// Binary attachments arrive as `contentBase64`, and one that did not fit the budget as `omittedReason`.
			parts.push( part.content ?? part.name ?? part.url ?? '' );
		}
	}

	return parts.join( '\n' );
}

const app = express();

// Note the text parser: the signature covers the body exactly as it arrived.
app.post( '/ckeditor-ai/turn-start', express.text( { type: 'application/json', limit: '32mb' } ), async ( req, res ) => {
	if ( !verify( req.headers, req.body ) ) {
		res.sendStatus( 401 );
		return;
	}

	const { turn, userId, conversationId, requestId } = JSON.parse( req.body );
	const matterId = turn.content.find( part => part.type === 'delegation-context' )?.data?.matterId;
	const text = textToScreen( turn );

	// Path 1: our own rules. No round trip needed.
	const refusal = localRules( { userId, matterId, text } );

	if ( refusal ) {
		res.json( {
			directive: 'halt',
			reply: [ refusal ],
			attributes: { policyDecision: 'refused', policyRule: 'ethical-wall', matterId }
		} );
		return;
	}

	// Path 2: your policy service. Its verdict decides the turn.
	try {
		const verdict = await screen( { userId, matterId, text, requestId, conversationId } );

		if ( !verdict.allowed ) {
			res.json( {
				directive: 'halt',
				reply: [ verdict.message ],
				attributes: { policyDecision: 'refused', policyRule: verdict.ruleId, matterId }
			} );
			return;
		}
	} catch ( error ) {
		// Path 3: screening failed. Refuse on purpose, with something the user can act on.
		console.error( 'Screening failed', { requestId, error } );
		res.json( {
			directive: 'halt',
			reply: [ 'Message screening is unavailable, so I cannot answer right now. Try again shortly.' ],
			attributes: { policyDecision: 'unavailable' }
		} );
		return;
	}

	// Path 4: allowed. Hand the turn over as it is.
	res.json( {
		directive: 'continue',
		attributes: { policyDecision: 'allowed', matterId }
	} );
} );

app.listen( 3010 );

app.post( '/ckeditor-ai/turn-start', express.text( { type: 'application/json', limit: '32mb' } ), async ( req, res ) => {
	if ( !verify( req.headers, req.body ) ) {
		res.sendStatus( 401 );
		return;
	}

	res.type( 'application/x-ndjson' );

	const write = line => res.write( JSON.stringify( line ) + '\n' );

	write( { type: 'progress', text: 'Checking the matter walls…' } );

	// ... screen as in the endpoint above, writing a progress line per stage ...

	write( { directive: 'continue', attributes: { policyDecision: 'allowed' } } );
	res.end();
} );

const HOST = process.env.CKEDITOR_AI_HOST;	// your on-premises CKEditor AI
const TOKEN = process.env.CKEDITOR_AI_TOKEN;  // the response body of <your-development-token-url>

async function post( path, body ) {
	const response = await fetch( `${ HOST }${ path }`, {
		method: 'POST',
		headers: { 'Authorization': `Bearer ${ TOKEN }`, 'Content-Type': 'application/json' },
		body: JSON.stringify( body )
	} );

	if ( !response.ok ) {
		throw new Error( `${ response.status } ${ await response.text() }` );
	}

	return response.json();
}

async function stream( path, body ) {
	const response = await fetch( `${ HOST }${ path }`, {
		method: 'POST',
		headers: { 'Authorization': `Bearer ${ TOKEN }`, 'Content-Type': 'application/json', 'Accept': 'text/event-stream' },
		body: JSON.stringify( body )
	} );

	if ( !response.ok ) {
		throw new Error( `${ response.status } ${ await response.text() }` );
	}

	const decoder = new TextDecoder();
	let buffer = '';

	for await ( const chunk of response.body ) {
		buffer += decoder.decode( chunk, { stream: true } );

		let end;
		while ( ( end = buffer.indexOf( '\n\n' ) ) >= 0 ) {
			const lines = buffer.slice( 0, end ).split( '\n' );
			buffer = buffer.slice( end + 2 );

			const event = lines.find( line => line.startsWith( 'event: ' ) )?.slice( 7 );
			const data = lines.find( line => line.startsWith( 'data: ' ) )?.slice( 6 );

			console.log( `event: ${ event }\ndata: ${ data }\n` );
		}
	}
}

await post( '/v1/conversations', { id: 'matter-2044-memo' } );

const { id: documentId } = await post( '/v1/conversations/matter-2044-memo/documents', {
	content: '<h1>Matter 2044: transaction memo</h1><h2>1. Background</h2><p>The client asks whether the proposed share transfer requires regulatory clearance.</p><h2>2. Analysis</h2><p>To be completed.</p>'
} );

await stream( '/v1/conversations/matter-2044-memo/messages', {
	prompt: 'Summarise where matter M-2031 stands.',
	model: 'agent-1',
	content: [
		{ type: 'document', id: documentId },
		{ type: 'delegation-context', id: 'who', data: { matterId: 'M-2031' } }
	]
} );

await stream( '/v1/conversations/matter-2044-memo/messages', {
	prompt: 'Draft section 2 from the background above.',
	model: 'agent-1',
	content: [
		{ type: 'document', id: documentId },
		{ type: 'delegation-context', id: 'who', data: { matterId: '2044' } }
	]
} );