@siduri-x/api 1.0.1 → 1.0.2

package/dist/auth.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveIdentity = resolveIdentity;
-exports.requireRole = requireRole;
-exports.attachIdentity = attachIdentity;
-function resolveIdentity(req) {
-    const authHeader = req.headers.authorization;
-    const token = authHeader?.startsWith('Bearer ') ? authHeader.split(' ')[1] : undefined;
-    // 1. Explicit token matches
-    if (process.env.OWNER_TOKEN && token === process.env.OWNER_TOKEN) {
-        return { role: 'OWNER' };
-    }
-    if (process.env.OPERATOR_TOKEN && token === process.env.OPERATOR_TOKEN) {
-        return { role: 'OPERATOR' };
-    }
-    // 2. Development fallback
-    const isDev = process.env.NODE_ENV !== 'production';
-    if (isDev && process.env.DEV_LOCAL_AUTH_ROLE) {
-        const fallbackRole = process.env.DEV_LOCAL_AUTH_ROLE.toUpperCase();
-        if (['OWNER', 'OPERATOR', 'VIEWER'].includes(fallbackRole)) {
-            return { role: fallbackRole };
-        }
-    }
-    // Default
-    return { role: 'VIEWER' };
-}
-function requireRole(allowedRoles) {
-    return (req, res, next) => {
-        const identity = resolveIdentity(req);
-        req.identity = identity;
-        if (!allowedRoles.includes(identity.role)) {
-            return res.status(403).json({ error: `Forbidden: requires one of ${allowedRoles.join(', ')}` });
-        }
-        next();
-    };
-}
-function attachIdentity(req, res, next) {
-    req.identity = resolveIdentity(req);
-    next();
-}

package/dist/auth.test.d.ts

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

package/dist/auth.test.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const auth_1 = require("./auth");
-describe('Auth Identity Resolution', () => {
-    const originalEnv = process.env;
-    beforeEach(() => {
-        jest.resetModules();
-        process.env = { ...originalEnv };
-    });
-    afterAll(() => {
-        process.env = originalEnv;
-    });
-    const mockReq = (token) => ({
-        headers: {
-            authorization: token ? `Bearer ${token}` : undefined
-        }
-    });
-    test('resolves explicit owner token', () => {
-        process.env.OWNER_TOKEN = 'owner-secret';
-        process.env.OPERATOR_TOKEN = 'operator-secret';
-        process.env.NODE_ENV = 'production';
-        const ownerId = (0, auth_1.resolveIdentity)(mockReq('owner-secret'));
-        expect(ownerId.role).toBe('OWNER');
-    });
-    test('resolves explicit operator token', () => {
-        process.env.OWNER_TOKEN = 'owner-secret';
-        process.env.OPERATOR_TOKEN = 'operator-secret';
-        process.env.NODE_ENV = 'production';
-        const opId = (0, auth_1.resolveIdentity)(mockReq('operator-secret'));
-        expect(opId.role).toBe('OPERATOR');
-    });
-    test('defaults to viewer when no token is present in production', () => {
-        process.env.NODE_ENV = 'production';
-        const viewerId = (0, auth_1.resolveIdentity)(mockReq());
-        expect(viewerId.role).toBe('VIEWER');
-    });
-    test('defaults to viewer for invalid token in production', () => {
-        process.env.NODE_ENV = 'production';
-        const invalidId = (0, auth_1.resolveIdentity)(mockReq('invalid-token'));
-        expect(invalidId.role).toBe('VIEWER');
-    });
-    test('resolves development fallback role', () => {
-        process.env.NODE_ENV = 'development';
-        process.env.DEV_LOCAL_AUTH_ROLE = 'OWNER';
-        const devId = (0, auth_1.resolveIdentity)(mockReq());
-        expect(devId.role).toBe('OWNER');
-    });
-});

package/dist/b0-b6.test.d.ts

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

package/dist/b0-b6.test.js

@@ -1,121 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const supertest_1 = __importDefault(require("supertest"));
-const app_1 = require("./app");
-const runtime_1 = require("./runtime");
-describe('T0 B0 & B6 Runtime Proof Suite', () => {
-    let mockBrain;
-    let mockMemory;
-    let mockKnowledge;
-    let mockBehavior;
-    let runtime;
-    let app;
-    beforeEach(async () => {
-        mockBrain = {
-            generatePlan: jest.fn().mockImplementation(async (ctx) => {
-                return {
-                    speech: 'Hello. I am a neutral companion.',
-                    language: 'en',
-                };
-            }),
-        };
-        mockMemory = {
-            initialize: jest.fn().mockResolvedValue(undefined),
-            searchClaims: jest.fn().mockResolvedValue([]),
-            getClaims: jest.fn().mockResolvedValue([]),
-            getDirectives: jest.fn().mockResolvedValue([]),
-            getPendingClaims: jest.fn().mockResolvedValue([]),
-            proposeClaim: jest.fn().mockResolvedValue({}),
-            approveClaim: jest.fn().mockResolvedValue(undefined),
-            rejectClaim: jest.fn().mockResolvedValue(undefined),
-        };
-        mockKnowledge = {
-            search: jest.fn().mockResolvedValue([]),
-        };
-        mockBehavior = {
-            compile: jest.fn().mockResolvedValue(''),
-        };
-        const config = {
-            name: 'NeutralCompanion',
-            brain: { provider: 'openrouter' },
-            memory: { provider: 'postgres' },
-            knowledge: { provider: 'e-knowledge' },
-            behavior: { provider: 'active-self' },
-            voice: { provider: 'none' },
-            vision: { provider: 'none' },
-            body: { provider: 'none' },
-        };
-        runtime = new runtime_1.SiduriRuntime('companion-a', config, {
-            brain: mockBrain,
-            memory: mockMemory,
-            knowledge: mockKnowledge,
-            behavior: mockBehavior,
-        });
-        await runtime.initialize();
-        const runtimes = new Map([['companion-a', runtime]]);
-        const created = (0, app_1.createApp)(runtimes);
-        app = created.app;
-    });
-    // B0: Fresh companion is empty (no prior claims, no user relationship, no knowledge search on greeting)
-    describe('B0 — Fresh companion is empty', () => {
-        test('initial state has empty memory and empty directives', async () => {
-            const claims = await runtime.memory?.getClaims();
-            const directives = await runtime.memory?.getDirectives();
-            expect(claims).toEqual([]);
-            expect(directives).toEqual([]);
-        });
-        test('greeting does not query knowledge or inject prior personal knowledge', async () => {
-            const res = await (0, supertest_1.default)(app)
-                .post('/chat')
-                .send({
-                companionId: 'companion-a',
-                message: 'Hello.',
-                history: [],
-            });
-            expect(res.status).toBe(200);
-            expect(mockKnowledge.search).not.toHaveBeenCalled();
-            expect(mockBrain.generatePlan).toHaveBeenCalledWith(expect.objectContaining({
-                contextPrompt: '',
-                recipient: 'OWNER',
-            }));
-        });
-    });
-    // B6: Identity and relationship are learned, not inferred (self identity questions do not query external knowledge)
-    describe('B6 — Identity and relationship are learned, not inferred', () => {
-        test('asking "Who are you?" suppresses knowledge query and asserts self identity without external search', async () => {
-            mockBrain.generatePlan.mockResolvedValueOnce({
-                speech: 'I am NeutralCompanion.',
-                language: 'en',
-            });
-            const res = await (0, supertest_1.default)(app)
-                .post('/chat')
-                .send({
-                companionId: 'companion-a',
-                message: 'Who are you?',
-                history: [],
-            });
-            expect(res.status).toBe(200);
-            // B6 oracle: self identity chat does not query external knowledge
-            expect(mockKnowledge.search).not.toHaveBeenCalled();
-            expect(mockMemory.searchClaims).toHaveBeenCalled();
-            expect(mockBrain.generatePlan).toHaveBeenCalledWith(expect.objectContaining({
-                contextPrompt: '',
-            }));
-            expect(res.body.response.subtitle_en).toBe('I am NeutralCompanion.');
-        });
-        test('asking "Tell me about yourself" suppresses knowledge query', async () => {
-            const res = await (0, supertest_1.default)(app)
-                .post('/chat')
-                .send({
-                companionId: 'companion-a',
-                message: 'Tell me about yourself',
-                history: [],
-            });
-            expect(res.status).toBe(200);
-            expect(mockKnowledge.search).not.toHaveBeenCalled();
-        });
-    });
-});

package/dist/context-mapper.d.ts

@@ -1,15 +0,0 @@
-import { RequestContext, DiagnosticCode, ContextError } from '@siduri-x/core';
-export interface ContextMapperOptions {
-    endpointPolicy?: 'public' | 'private' | 'operator' | 'direct';
-    defaultPublicAudience?: string;
-    defaultPrivateAudience?: string;
-    defaultOperatorAudience?: string;
-    allowAnonymousPublicChat?: boolean;
-}
-export interface MapRequestContextResult {
-    accepted: boolean;
-    context?: RequestContext;
-    diagnostics?: DiagnosticCode[];
-    error?: ContextError;
-}
-export declare function mapRequestContext(input: any, options?: ContextMapperOptions): MapRequestContextResult;

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 {};