@siduri-x/api 1.0.0 → 1.0.2

package/dist/context-mapper.js

@@ -1,287 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mapRequestContext = mapRequestContext;
-const core_1 = require("@siduri-x/core");
-function mapRequestContext(input, options = {}) {
-    const diagnostics = [];
-    const endpointPolicy = options.endpointPolicy || 'public';
-    const defaultPublicAudience = options.defaultPublicAudience || 'audience-public';
-    if (!input || typeof input !== 'object') {
-        return {
-            accepted: false,
-            error: {
-                code: 'MISSING_CONTEXT',
-                fields: ['request'],
-            },
-        };
-    }
-    // Check for legacy MASTER_PRIVATE in any audience field or request
-    const rawAudience = input?.context?.conversation?.audienceId ??
-        input?.conversation?.audienceId ??
-        input?.audienceId ??
-        input?.audience;
-    if (rawAudience === 'MASTER_PRIVATE' || input?.scope === 'MASTER_PRIVATE') {
-        if (endpointPolicy === 'public' || input?.channel === 'public' || input?.context?.conversation?.channel === 'public') {
-            return {
-                accepted: false,
-                error: {
-                    code: 'LEGACY_PERSONAL_AUDIENCE',
-                    field: 'audienceId',
-                    correlationId: input?.context?.conversation?.correlationId || input?.correlationId,
-                },
-            };
-        }
-    }
-    // 1. If incoming input already has a full neutral context structure
-    if (input.context && typeof input.context === 'object') {
-        const rawCtx = input.context;
-        const companionId = input.companionId || rawCtx.companionId || input.id;
-        const correlationId = rawCtx.conversation?.correlationId || input.correlationId;
-        if (!companionId) {
-            return {
-                accepted: false,
-                error: {
-                    code: 'MISSING_CONTEXT',
-                    fields: ['companionId'],
-                    correlationId,
-                },
-            };
-        }
-        // Role cannot select audience or subject
-        const rawRole = input.role || rawCtx.actor?.authorizationRole;
-        if (input.role && !rawCtx.conversation?.channel && !rawCtx.conversation?.audienceId) {
-            return {
-                accepted: false,
-                error: {
-                    code: 'AMBIGUOUS_CONTEXT',
-                    conflicts: ['role_does_not_select_audience', 'role_does_not_select_subject'],
-                    correlationId,
-                },
-            };
-        }
-        const channel = rawCtx.conversation?.channel || endpointPolicy;
-        let audienceId = rawCtx.conversation?.audienceId;
-        if (!audienceId) {
-            if (channel === 'public' || endpointPolicy === 'public') {
-                audienceId = defaultPublicAudience;
-                diagnostics.push('audience_defaulted_by_public_policy');
-            }
-            else {
-                return {
-                    accepted: false,
-                    error: {
-                        code: 'MISSING_CONTEXT',
-                        fields: ['conversation.audienceId'],
-                        correlationId,
-                    },
-                };
-            }
-        }
-        if (!correlationId) {
-            return {
-                accepted: false,
-                error: {
-                    code: 'MISSING_CONTEXT',
-                    fields: ['conversation.correlationId'],
-                },
-            };
-        }
-        const actor = rawCtx.actor;
-        if (!actor || typeof actor !== 'object') {
-            return {
-                accepted: false,
-                error: {
-                    code: 'MISSING_CONTEXT',
-                    fields: ['actor'],
-                    correlationId,
-                },
-            };
-        }
-        // Check required capabilities for private/operator/direct channels
-        const capabilities = Array.isArray(actor.capabilities) ? actor.capabilities : [];
-        if (channel === 'private' && !capabilities.includes('chat:private')) {
-            return {
-                accepted: false,
-                error: {
-                    code: 'UNAUTHORIZED_CHANNEL_OR_CAPABILITY',
-                    message: 'Private channel requires explicit chat:private capability',
-                    fields: ['actor.capabilities'],
-                    correlationId,
-                },
-            };
-        }
-        if (channel === 'operator' && !capabilities.includes('memory:inspect') && !capabilities.includes('operator:access')) {
-            return {
-                accepted: false,
-                error: {
-                    code: 'UNAUTHORIZED_CHANNEL_OR_CAPABILITY',
-                    message: 'Operator channel requires explicit operator capability',
-                    fields: ['actor.capabilities'],
-                    correlationId,
-                },
-            };
-        }
-        // Check subject policy
-        let subject = rawCtx.subject;
-        if (subject) {
-            if (subject.subjectId === 'primary_user' || subject === 'primary_user') {
-                // Global primary_user is rejected or quarantined
-                return {
-                    accepted: false,
-                    error: {
-                        code: 'FORBIDDEN_CONTEXT',
-                        message: 'Global primary_user subject is forbidden',
-                        field: 'subject.subjectId',
-                        correlationId,
-                    },
-                };
-            }
-        }
-        const constructed = {
-            companionId,
-            actor: {
-                actorId: actor.actorId,
-                sessionId: actor.sessionId,
-                authorizationRole: actor.authorizationRole,
-                capabilities,
-                authenticated: Boolean(actor.authenticated),
-            },
-            conversation: {
-                channel,
-                audienceId,
-                isLive: rawCtx.conversation?.isLive,
-                correlationId,
-            },
-            subject,
-        };
-        const validated = (0, core_1.validateRequestContext)(constructed);
-        if (!validated.accepted) {
-            return validated;
-        }
-        return {
-            accepted: true,
-            context: validated.context,
-            diagnostics: diagnostics.length > 0 ? diagnostics : undefined,
-        };
-    }
-    // 2. Legacy compatibility envelope mapping
-    const companionId = input.companionId || input.id;
-    const correlationId = input.correlationId || input.conversation?.correlationId;
-    if (!companionId) {
-        return {
-            accepted: false,
-            error: {
-                code: 'MISSING_CONTEXT',
-                fields: ['companionId'],
-                correlationId,
-            },
-        };
-    }
-    if (companionId === 'default') {
-        diagnostics.push('companion_default_mapped_for_bootstrap');
-    }
-    // Map legacy role to authorizationRole
-    const legacyRole = input.role?.toString().toUpperCase();
-    let authRole = 'viewer';
-    if (legacyRole === 'OWNER') {
-        authRole = 'administrator';
-        diagnostics.push('legacy_role_mapped_to_authorization');
-    }
-    else if (legacyRole === 'OPERATOR') {
-        authRole = 'operator';
-        diagnostics.push('legacy_role_mapped_to_authorization');
-    }
-    else if (legacyRole === 'VIEWER') {
-        authRole = 'viewer';
-        diagnostics.push('legacy_role_mapped_to_authorization');
-    }
-    else if (input.role) {
-        return {
-            accepted: false,
-            error: {
-                code: 'INVALID_CONTEXT',
-                field: 'role',
-                correlationId,
-            },
-        };
-    }
-    // Check endpoint policy vs legacy request
-    if (endpointPolicy === 'private' || endpointPolicy === 'operator' || endpointPolicy === 'direct') {
-        // Missing explicit channel, audience, or capability on private/operator endpoint is an error
-        const fields = [];
-        if (!input.channel)
-            fields.push('conversation.channel');
-        if (!input.audienceId)
-            fields.push('conversation.audienceId');
-        if (!input.capabilities && !input.actor?.capabilities)
-            fields.push('actor.capabilities');
-        if (!correlationId)
-            fields.push('conversation.correlationId');
-        return {
-            accepted: false,
-            error: {
-                code: 'MISSING_CONTEXT',
-                fields: fields.length > 0 ? fields : ['conversation.audienceId', 'actor.capabilities'],
-                correlationId,
-            },
-        };
-    }
-    // Ambiguity check: if legacy input specifies role without correlationId or endpoint context for stateful op
-    if (input.subject === 'primary_user' || input.subjectId === 'primary_user') {
-        return {
-            accepted: false,
-            error: {
-                code: 'FORBIDDEN_CONTEXT',
-                message: 'Global primary_user subject is forbidden',
-                field: 'subject',
-                correlationId,
-            },
-        };
-    }
-    // Missing correlationId for stateful requests
-    const finalCorrelationId = correlationId || (input.generateCorrelationId ? `corr-${Date.now()}` : undefined);
-    if (!finalCorrelationId) {
-        return {
-            accepted: false,
-            error: {
-                code: 'MISSING_CONTEXT',
-                fields: ['conversation.correlationId'],
-            },
-        };
-    }
-    // Build anonymous public context
-    const actorId = input.actorId || input.actor?.actorId || 'anonymous-session-a';
-    const sessionId = input.sessionId || input.actor?.sessionId || 'session-a';
-    if (!input.actorId && !input.actor?.actorId) {
-        diagnostics.push('anonymous_session_generated');
-    }
-    const channel = 'public';
-    const audienceId = defaultPublicAudience;
-    diagnostics.push('audience_defaulted_by_public_policy');
-    const capabilities = authRole === 'administrator'
-        ? ['chat:public', 'admin:access']
-        : authRole === 'operator'
-            ? ['chat:public', 'operator:access']
-            : ['chat:public'];
-    const mappedContext = {
-        companionId,
-        actor: {
-            actorId,
-            sessionId,
-            authorizationRole: authRole,
-            capabilities,
-            authenticated: Boolean(input.authenticated),
-        },
-        conversation: {
-            channel,
-            audienceId,
-            correlationId: finalCorrelationId,
-        },
-        subject: undefined, // Anonymous public chat has no subject
-    };
-    return {
-        accepted: true,
-        context: mappedContext,
-        diagnostics: diagnostics.length > 0 ? diagnostics : undefined,
-    };
-}

package/dist/context-mapper.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/context-mapper.test.js

@@ -1,233 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const context_mapper_1 = require("./context-mapper");
-describe('API Request Context Mapper (P2 & T1-01 to T1-10)', () => {
-    // T1-01: Anonymous public chat, no audience
-    test('T1-01: Anonymous public chat with no audience resolves to configured public audience and no subject', () => {
-        const input = {
-            companionId: 'companion-a',
-            context: {
-                actor: {
-                    actorId: 'anonymous-session-a',
-                    sessionId: 'session-a',
-                    authorizationRole: 'viewer',
-                    capabilities: ['chat:public'],
-                    authenticated: false,
-                },
-                conversation: {
-                    channel: 'public',
-                    correlationId: 'corr-public-a',
-                },
-            },
-            message: 'Hello.',
-            history: [],
-        };
-        const result = (0, context_mapper_1.mapRequestContext)(input, {
-            endpointPolicy: 'public',
-            defaultPublicAudience: 'audience-public',
-        });
-        expect(result.accepted).toBe(true);
-        expect(result.context?.companionId).toBe('companion-a');
-        expect(result.context?.conversation.channel).toBe('public');
-        expect(result.context?.conversation.audienceId).toBe('audience-public');
-        expect(result.context?.subject).toBeUndefined();
-        expect(result.diagnostics).toContain('audience_defaulted_by_public_policy');
-    });
-    // T1-02: OWNER public chat
-    test('T1-02: OWNER public chat maps authorization metadata only with no relationship or private routing', () => {
-        const input = {
-            id: 'companion-a',
-            role: 'OWNER',
-            correlationId: 'corr-owner-public',
-            message: 'Public broadcast message',
-        };
-        const result = (0, context_mapper_1.mapRequestContext)(input, { endpointPolicy: 'public' });
-        expect(result.accepted).toBe(true);
-        expect(result.context?.actor.authorizationRole).toBe('administrator');
-        expect(result.context?.conversation.channel).toBe('public');
-        expect(result.context?.conversation.audienceId).toBe('audience-public');
-        expect(result.context?.subject).toBeUndefined();
-        expect(result.diagnostics).toContain('legacy_role_mapped_to_authorization');
-    });
-    // T1-03: Private chat without capability
-    test('T1-03: Private chat without capability is rejected before organ invocation', () => {
-        const input = {
-            companionId: 'companion-a',
-            context: {
-                actor: {
-                    actorId: 'actor-a',
-                    sessionId: 'session-a',
-                    authorizationRole: 'viewer',
-                    capabilities: ['chat:public'], // Missing 'chat:private'
-                    authenticated: true,
-                },
-                conversation: {
-                    channel: 'private',
-                    audienceId: 'audience-private-a',
-                    correlationId: 'corr-private-a',
-                },
-            },
-            message: 'Show private data',
-        };
-        const result = (0, context_mapper_1.mapRequestContext)(input, { endpointPolicy: 'private' });
-        expect(result.accepted).toBe(false);
-        expect(result.error?.code).toBe('UNAUTHORIZED_CHANNEL_OR_CAPABILITY');
-        expect(result.error?.fields).toContain('actor.capabilities');
-    });
-    // T1-04: Operator request without operator context
-    test('T1-04: Operator request without operator context is rejected with diagnostic', () => {
-        const input = {
-            id: 'companion-a',
-            role: 'OPERATOR',
-            correlationId: 'corr-op-missing',
-        };
-        const result = (0, context_mapper_1.mapRequestContext)(input, { endpointPolicy: 'operator' });
-        expect(result.accepted).toBe(false);
-        expect(result.error?.code).toBe('MISSING_CONTEXT');
-        expect(result.error?.fields).toEqual(expect.arrayContaining(['conversation.channel', 'conversation.audienceId', 'actor.capabilities']));
-    });
-    // T1-05: Global primary_user input
-    test('T1-05: Global primary_user input is rejected/quarantined at mapper', () => {
-        const input = {
-            companionId: 'companion-a',
-            context: {
-                actor: {
-                    actorId: 'actor-a',
-                    sessionId: 'session-a',
-                    authorizationRole: 'viewer',
-                    capabilities: ['chat:public'],
-                    authenticated: true,
-                },
-                conversation: {
-                    channel: 'public',
-                    audienceId: 'audience-public',
-                    correlationId: 'corr-primary-user',
-                },
-                subject: {
-                    subjectId: 'primary_user',
-                    kind: 'actor',
-                },
-            },
-        };
-        const result = (0, context_mapper_1.mapRequestContext)(input);
-        expect(result.accepted).toBe(false);
-        expect(result.error?.code).toBe('FORBIDDEN_CONTEXT');
-        expect(result.error?.field).toBe('subject.subjectId');
-    });
-    // T1-06: MASTER_PRIVATE in public mode
-    test('T1-06: MASTER_PRIVATE in public mode is rejected with no fallback', () => {
-        const input = {
-            companionId: 'companion-a',
-            context: {
-                actor: {
-                    actorId: 'actor-a',
-                    sessionId: 'session-a',
-                    authorizationRole: 'viewer',
-                    capabilities: ['chat:public'],
-                    authenticated: false,
-                },
-                conversation: {
-                    channel: 'public',
-                    audienceId: 'MASTER_PRIVATE',
-                    correlationId: 'corr-master-private',
-                },
-            },
-        };
-        const result = (0, context_mapper_1.mapRequestContext)(input, { endpointPolicy: 'public' });
-        expect(result.accepted).toBe(false);
-        expect(result.error?.code).toBe('LEGACY_PERSONAL_AUDIENCE');
-        expect(result.error?.field).toBe('audienceId');
-    });
-    // T1-07: Missing actor on explicit teaching
-    test('T1-07: Missing actor on explicit teaching produces no durable profile and pending/anonymous context only', () => {
-        const input = {
-            companionId: 'companion-a',
-            context: {
-                actor: {
-                    actorId: '',
-                    sessionId: 'session-a',
-                    authorizationRole: 'viewer',
-                    capabilities: ['chat:public'],
-                    authenticated: false,
-                },
-                conversation: {
-                    channel: 'public',
-                    audienceId: 'audience-public',
-                    correlationId: 'corr-teach-no-actor',
-                },
-            },
-        };
-        const result = (0, context_mapper_1.mapRequestContext)(input);
-        expect(result.accepted).toBe(false);
-        expect(result.error?.code).toBe('MISSING_CONTEXT');
-        expect(result.error?.fields).toContain('actor.actorId');
-    });
-    // T1-08: Two companion IDs, same actor remain isolated
-    test('T1-08: Two companion IDs with same actor remain isolated under context mapper', () => {
-        const actor = {
-            actorId: 'actor-a',
-            sessionId: 'session-a',
-            authorizationRole: 'viewer',
-            capabilities: ['chat:public'],
-            authenticated: true,
-        };
-        const conv = {
-            channel: 'public',
-            audienceId: 'audience-public',
-            correlationId: 'corr-iso-1',
-        };
-        const reqA = { companionId: 'companion-a', context: { actor, conversation: conv } };
-        const reqB = { companionId: 'companion-b', context: { actor, conversation: conv } };
-        const resA = (0, context_mapper_1.mapRequestContext)(reqA);
-        const resB = (0, context_mapper_1.mapRequestContext)(reqB);
-        expect(resA.accepted).toBe(true);
-        expect(resB.accepted).toBe(true);
-        expect(resA.context?.companionId).toBe('companion-a');
-        expect(resB.context?.companionId).toBe('companion-b');
-    });
-    // T1-09: Missing correlation ID
-    test('T1-09: Missing correlation ID is rejected before stateful operation', () => {
-        const input = {
-            companionId: 'companion-a',
-            context: {
-                actor: {
-                    actorId: 'actor-a',
-                    sessionId: 'session-a',
-                    authorizationRole: 'viewer',
-                    capabilities: ['chat:public'],
-                    authenticated: true,
-                },
-                conversation: {
-                    channel: 'public',
-                    audienceId: 'audience-public',
-                    correlationId: '',
-                },
-            },
-        };
-        const result = (0, context_mapper_1.mapRequestContext)(input);
-        expect(result.accepted).toBe(false);
-        expect(result.error?.code).toBe('MISSING_CONTEXT');
-        expect(result.error?.fields).toContain('conversation.correlationId');
-    });
-    // T1-10: Ambiguous legacy request
-    test('T1-10: Ambiguous legacy request emits structured diagnostic and rejects ambiguous mapping', () => {
-        const input = {
-            companionId: 'companion-a',
-            role: 'VIEWER',
-            context: {
-                actor: {
-                    actorId: 'actor-a',
-                    sessionId: 'session-a',
-                    authorizationRole: 'viewer',
-                    capabilities: ['chat:public'],
-                    authenticated: true,
-                },
-                // Role supplied at top level without channel or audience
-            },
-        };
-        const result = (0, context_mapper_1.mapRequestContext)(input);
-        expect(result.accepted).toBe(false);
-        expect(result.error?.code).toBe('AMBIGUOUS_CONTEXT');
-        expect(result.error?.conflicts).toEqual(expect.arrayContaining(['role_does_not_select_audience', 'role_does_not_select_subject']));
-    });
-});

package/dist/index.d.ts

@@ -1,6 +0,0 @@
-import { Express } from 'express';
-import { createApp, AppInstance } from './app';
-export { createApp, AppInstance };
-export * from './context-mapper';
-export declare const app: Express;
-export default app;