@siduri-x/api 2.0.1 → 2.0.3

package/src/index.ts

@@ -4,87 +4,19 @@ dotenv.config();
 import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { Express } from 'express';
-import { createApp, AppInstance, AppBrainConfig, AppBehaviorConfig } from './app';
+import { createApp, AppInstance } from './app';
 import { SiduriRuntime } from './runtime';
-import { OpenAICompatibleBrain, OpenRouterBrain } from '@siduri-x/brain';
-import { SqliteMemoryStore } from '@siduri-x/memory';
-import { VoiceAdapter, VoiceConfig } from '@siduri-x/voice';
-import { EKnowledgeAdapter, EKnowledgeConfig } from '@siduri-x/eknowledge';
-import { OpenRouterVisionAdapter, OpenRouterVisionConfig } from '@siduri-x/vision';
-import { ActiveSelfCompiler, SqliteSelfRepository } from '@siduri-x/self';
-import { Live2DAdapter, Live2DAdapterConfig } from '@siduri-x/body';
-import { FixtureObservationOrgan } from '@siduri-x/observation';
+import { bootCompanion, createVision, createObservation } from './boot';
 
 export { createApp, AppInstance };
 export * from './context-mapper';
+export * from './boot';
 
 const runtimes = new Map<string, SiduriRuntime>();
 const instance: AppInstance = createApp(runtimes);
 export const app: Express = instance.app;
 export default app;
 
-function createBrain(config?: AppBrainConfig) {
-  const provider = config?.provider || 'openrouter';
-  const defaultKeyEnv = provider === 'openai-compatible' ? 'OPENAI_COMPATIBLE_API_KEY' : 'OPENROUTER_API_KEY';
-  const apiKey = config?.apiKey || process.env[config?.apiKeyEnv || defaultKeyEnv] || '';
-  if (provider === 'openai-compatible') {
-    return new OpenAICompatibleBrain({
-      apiKey,
-      model: config?.model || 'local-model',
-      baseUrl: config?.baseUrl || 'http://127.0.0.1:1234/v1',
-    });
-  }
-  return new OpenRouterBrain({ apiKey, model: config?.model || 'gpt-4o-mini' });
-}
-
-function isDisabled(config?: { provider?: string }): boolean {
-  return !config || config.provider === 'none';
-}
-
-function createVoice(config?: VoiceConfig) {
-  return isDisabled(config)
-    ? undefined
-    : new VoiceAdapter({
-        provider: (config?.provider as any) || 'voicevox',
-        baseUrl: config?.baseUrl || process.env.VOICEVOX_URL || 'http://localhost:50021',
-        speakerId: config?.speakerId || 1,
-        ...config,
-      });
-}
-
-function createKnowledge(config?: EKnowledgeConfig) {
-  if (isDisabled(config)) return undefined;
-  if (!config?.packPath && !config?.registryUrl && !config?.baseUrl) {
-    return undefined;
-  }
-  return new EKnowledgeAdapter(config || {});
-}
-
-function createVision(config?: OpenRouterVisionConfig & { provider?: string }) {
-  return isDisabled(config)
-    ? undefined
-    : new OpenRouterVisionAdapter({
-        apiKey: config?.apiKey || process.env.OPENROUTER_API_KEY || '',
-        model: config?.model || 'gpt-4-vision',
-        ...config,
-      });
-}
-
-function createBehavior(config?: AppBehaviorConfig) {
-  return isDisabled(config) ? undefined : new ActiveSelfCompiler();
-}
-
-function createBody(config?: Live2DAdapterConfig & { provider?: string }) {
-  return isDisabled(config)
-    ? undefined
-    : new Live2DAdapter(config);
-}
-
-function createMemory(config?: { provider?: string; connectionString?: string; maxConnections?: number; dbPath?: string }) {
-  if (isDisabled(config)) return undefined;
-  return new SqliteMemoryStore({ dbPath: config?.dbPath || process.env.STORAGE_PATH || process.env.SQLITE_DB_PATH || 'siduri.sqlite' });
-}
-
 const PORT = process.env.PORT || 3001;
 
 const defaultCompanionConfig = {
@@ -94,7 +26,9 @@ const defaultCompanionConfig = {
   voice: { provider: 'voicevox', speakerId: 1 },
   memory: { provider: 'sqlite' },
   knowledge: {
-    provider: (process.env.SIDURI_KNOWLEDGE_PROVIDER as 'e-knowledge' | 'e-remote' | 'e-hub') || 'e-knowledge',
+    provider: (process.env.SIDURI_KNOWLEDGE_PROVIDER as any) || 'unified',
+    lifeDatabase: true,
+    dbPath: process.env.STORAGE_PATH || process.env.SQLITE_DB_PATH || 'siduri.sqlite',
     packPath: process.env.SIDURI_KNOWLEDGE_PACK || '',
     registryUrl: process.env.SIDURI_KNOWLEDGE_REGISTRY_URL || '',
     packId: process.env.SIDURI_KNOWLEDGE_PACK_ID || '',
@@ -137,6 +71,7 @@ async function loadCompanionConfig() {
   if (process.env.SIDURI_KNOWLEDGE_REGISTRY_URL) config.knowledge.registryUrl = process.env.SIDURI_KNOWLEDGE_REGISTRY_URL;
   if (process.env.SIDURI_KNOWLEDGE_PACK_ID) config.knowledge.packId = process.env.SIDURI_KNOWLEDGE_PACK_ID;
   if (process.env.SIDURI_KNOWLEDGE_MODE) config.knowledge.preferredMode = process.env.SIDURI_KNOWLEDGE_MODE;
+  if (process.env.SIDURI_KNOWLEDGE_DB_PATH) config.knowledge.dbPath = process.env.SIDURI_KNOWLEDGE_DB_PATH;
   return config;
 }
 
@@ -144,37 +79,12 @@ async function bootDefaultCompanion() {
   if (runtimes.has('default')) return;
   console.log("Booting default companion...");
   const config: any = await loadCompanionConfig();
-  
-  const brain = createBrain(config.brain);
-  const memory = createMemory(config.memory);
-  const voice = createVoice(config.voice);
-  const knowledge = createKnowledge(config.knowledge);
+
   const vision = createVision(config.vision);
-  const observation = new FixtureObservationOrgan(
-    vision ?? { analyze: async () => JSON.stringify({ readings: [] }) },
-  );
+  const observation = createObservation(vision);
   instance.setObservationOrgan(observation);
-  const selfRepo = new SqliteSelfRepository({ dbPath: process.env.STORAGE_PATH || process.env.SQLITE_DB_PATH || 'siduri.sqlite' });
-  const behavior = createBehavior(config.behavior);
-  const body = createBody(config.body);
-
-  if (memory && typeof (memory as any).runMigrations === 'function') {
-    await (memory as any).runMigrations().catch((e: any) => console.warn("Migrations warning:", e.message));
-  }
-
-  const runtime = new SiduriRuntime('default', config as any, { 
-    brain, 
-    memory, 
-    voice, 
-    knowledge, 
-    vision, 
-    behavior, 
-    body,
-    self: selfRepo,
-    externalKnowledge: knowledge
-  });
-  await runtime.initialize();
 
+  const runtime = await bootCompanion('default', config, { observationOrgan: observation });
   runtimes.set('default', runtime);
   console.log("Default companion booted successfully.");
 }

package/src/knowledge.test.ts

@@ -0,0 +1,156 @@
+import request from 'supertest';
+import fs from 'node:fs';
+import path from 'node:path';
+import { createApp } from './app';
+import { SiduriRuntime } from './runtime';
+import { UnifiedKnowledgeOrgan } from '@siduri-x/knowledge';
+
+describe('Life Database & UnifiedKnowledgeOrgan API Integration', () => {
+  const testDbPath = path.resolve(__dirname, '../test-api-knowledge.sqlite');
+  let app: any;
+  let runtime: SiduriRuntime;
+  let knowledge: UnifiedKnowledgeOrgan;
+  const mockAuthHeader = { 'Authorization': 'Bearer test-token' };
+
+  const cleanDb = () => {
+    for (const file of [testDbPath, `${testDbPath}-shm`, `${testDbPath}-wal`]) {
+      if (fs.existsSync(file)) {
+        try { fs.unlinkSync(file); } catch {}
+      }
+    }
+  };
+
+  beforeAll(async () => {
+    process.env.AUTH_TOKEN = 'test-token';
+    cleanDb();
+
+    knowledge = new UnifiedKnowledgeOrgan({
+      lifeDatabase: true,
+      dbPath: testDbPath,
+    });
+
+    const mockBrain: any = {
+      generatePlan: jest.fn().mockImplementation(async (ctx: any) => {
+        return {
+          speech: `I see context: ${ctx.contextPrompt || 'none'}`,
+          language: 'en',
+        };
+      }),
+    };
+
+    runtime = new SiduriRuntime(
+      'test-comp',
+      { name: 'Test Companion', organs: { knowledge: { provider: 'unified', dbPath: testDbPath } } } as any,
+      {
+        brain: mockBrain,
+        knowledge,
+        externalKnowledge: knowledge.eAdapter ?? knowledge,
+      }
+    );
+    await runtime.initialize();
+
+    const runtimes = new Map([['test-comp', runtime]]);
+    const instance = createApp(runtimes);
+    app = instance.app;
+  });
+
+  afterAll(async () => {
+    knowledge.close();
+    delete process.env.AUTH_TOKEN;
+    cleanDb();
+  });
+
+  test('seeds inventory item and queries via GET /knowledge/inventory', async () => {
+    await knowledge.inventory.saveItem({
+      id: 'inv-item-1',
+      companionId: 'test-comp',
+      entityName: 'Hydro Visor',
+      domain: 'hardware',
+      properties: { model: 'V1', resolution: '4K' },
+      updatedAt: new Date().toISOString(),
+    });
+
+    const res = await request(app)
+      .get('/knowledge/inventory?id=test-comp')
+      .set(mockAuthHeader);
+
+    expect(res.status).toBe(200);
+    expect(res.body.items).toHaveLength(1);
+    expect(res.body.items[0].entityName).toBe('Hydro Visor');
+    expect(res.body.items[0].domain).toBe('hardware');
+  });
+
+  test('seeds finance entry and queries via GET /knowledge/finance', async () => {
+    await knowledge.finance.addEntry({
+      id: 'fin-1',
+      companionId: 'test-comp',
+      category: 'subscription',
+      amount: -15.99,
+      currency: 'USD',
+      timestamp: new Date().toISOString(),
+    });
+
+    const res = await request(app)
+      .get('/knowledge/finance?id=test-comp')
+      .set(mockAuthHeader);
+
+    expect(res.status).toBe(200);
+    expect(res.body.entries).toHaveLength(1);
+    expect(res.body.entries[0].category).toBe('subscription');
+    expect(res.body.summary).toBeDefined();
+    expect(res.body.summary.totalExpenses).toBe(15.99);
+  });
+
+  test('queries life snapshot via GET /knowledge/life', async () => {
+    const res = await request(app)
+      .get('/knowledge/life?id=test-comp&q=Hydro')
+      .set(mockAuthHeader);
+
+    expect(res.status).toBe(200);
+    expect(res.body.matchedInventory).toHaveLength(1);
+    expect(res.body.matchedInventory[0].entityName).toBe('Hydro Visor');
+    expect(res.body.formattedContext).toContain('<life_context>');
+  });
+
+  test('chat request triggers Stream D and injects Life DB context into cognition prompt', async () => {
+    const res = await request(app)
+      .post('/chat')
+      .send({
+        id: 'test-comp',
+        message: 'Tell me about the Hydro Visor specs',
+        history: [],
+      });
+
+    expect(res.status).toBe(200);
+    expect(res.body.response.subtitle_en).toContain('Hydro Visor');
+  });
+
+  test('boot endpoint instantiates UnifiedKnowledgeOrgan with Life DB enabled', async () => {
+    const bootRes = await request(app)
+      .post('/boot')
+      .set(mockAuthHeader)
+      .send({
+        id: 'booted-comp',
+        config: {
+          name: 'Booted Companion',
+          organs: {
+            knowledge: {
+              provider: 'unified',
+              dbPath: testDbPath,
+            },
+          },
+        },
+      });
+
+    expect(bootRes.status).toBe(200);
+    expect(bootRes.body.success).toBe(true);
+
+    // Verify the booted companion's knowledge organ is UnifiedKnowledgeOrgan with working Life DB
+    const lifeRes = await request(app)
+      .get('/knowledge/life?id=booted-comp')
+      .set(mockAuthHeader);
+
+    expect(lifeRes.status).toBe(200);
+    expect(lifeRes.body.matchedInventory).toEqual([]);
+  });
+});

package/src/t6-security.test.ts

@@ -256,6 +256,59 @@ describe('T6 Security & Operations Threat Model Suite', () => {
     expect(actionResults[0].error).toContain('rejected by policy');
   });
 
+  test('Adversarial Boundary: Client attempting to forge administrator role or system capabilities via POST /chat context is suppressed and cannot execute admin action', async () => {
+    runtimeA.actionPolicy.registerToolDefinition({
+      name: 'admin/restricted_task',
+      providerId: 'admin',
+      description: 'Restricted admin task',
+      inputSchema: {},
+      riskLevel: 'HIGH',
+      allowedRoles: ['administrator'],
+      requiredCapabilities: ['system'],
+      requiresApproval: false,
+    });
+
+    mockBrain.generatePlan.mockResolvedValueOnce({
+      speech: 'Attempting restricted task.',
+      language: 'en',
+      actionIntents: [
+        {
+          actionId: 'act-forged-1',
+          toolName: 'admin/restricted_task',
+          parameters: {},
+        },
+      ],
+    });
+
+    // Caller passes forged context in POST /chat with forged owner role and system capabilities
+    const res = await request(app)
+      .post('/chat')
+      .send({
+        companionId: 'companion-a',
+        message: 'Execute forged task',
+        role: 'VIEWER',
+        context: {
+          actor: {
+            actorId: 'untrusted-client',
+            sessionId: 'sess-fake',
+            authorizationRole: 'administrator', // Forged role
+            capabilities: ['system', 'admin:manage'], // Forged capabilities
+            authenticated: true,
+          },
+          conversation: {
+            correlationId: 'corr-adv-1',
+          },
+        },
+      });
+
+    expect(res.status).toBe(200);
+    const actionResults = res.body.metadata?.action_results;
+    expect(actionResults).toBeDefined();
+    expect(actionResults.length).toBe(1);
+    expect(actionResults[0].success).toBe(false);
+    expect(actionResults[0].lifecycle).toBe('REJECTED');
+  });
+
   test('Action Boundary: ActionPolicyEngine rejects unauthorized approver from approving critical tools', async () => {
     runtimeA.actionPolicy.registerToolDefinition({
       name: 'admin/delete_cluster',
@@ -291,7 +344,7 @@ describe('T6 Security & Operations Threat Model Suite', () => {
     expect(eval1.decision.decisionCode).toBe('REJECTED_HIGH_RISK_UNAPPROVED');
 
     // 2. Viewer attempt to approve is rejected
-    const viewerApproval = await runtimeA.approveAction({
+    const viewerApproval = await runtimeA.actionPolicy.approveAction({
       executionId: 'exec-crit-1',
       approverActorId: 'viewer-attacker',
       approverRole: 'viewer',
@@ -300,7 +353,7 @@ describe('T6 Security & Operations Threat Model Suite', () => {
     expect(viewerApproval.decisionCode).toBe('REJECTED_UNAUTHORIZED');
 
     // 3. Operator attempt to approve administrator tool is rejected (role mismatch)
-    const operatorApproval = await runtimeA.approveAction({
+    const operatorApproval = await runtimeA.actionPolicy.approveAction({
       executionId: 'exec-crit-1',
       approverActorId: 'operator-alice',
       approverRole: 'operator',
@@ -313,7 +366,7 @@ describe('T6 Security & Operations Threat Model Suite', () => {
     expect(evalStillDenied.decision.allowed).toBe(false);
 
     // 5. Authorized administrator approval succeeds
-    const adminApproval = await runtimeA.approveAction({
+    const adminApproval = await runtimeA.actionPolicy.approveAction({
       executionId: 'exec-crit-1',
       approverActorId: 'admin-super',
       approverRole: 'administrator',

package/src/teach-mode.test.ts

@@ -10,6 +10,8 @@ jest.mock('@siduri-x/self', () => {
     SqliteSelfRepository: jest.fn().mockImplementation(() => ({
       setIdentity: jest.fn().mockResolvedValue(undefined),
       setPersonality: jest.fn().mockResolvedValue(undefined),
+      updateRelationship: jest.fn().mockResolvedValue(undefined),
+      setExemplars: jest.fn().mockResolvedValue(undefined),
       commitDirectives: jest.fn().mockResolvedValue(undefined),
       close: jest.fn(),
     })),
@@ -149,4 +151,79 @@ kind: "other"
     const MockRepo = SqliteSelfRepository as jest.MockedClass<typeof SqliteSelfRepository>;
     expect(MockRepo.mock.instances.length).toBe(0);
   });
+
+  it('POST /teach/install-self installs v2.0 manifest with ethos, relationships, and exemplars', async () => {
+    const v2Manifest = {
+      specVersion: '2.0.0',
+      identity: {
+        name: 'Siduri',
+        archetype: 'System Sentinel',
+        origin: 'Ancient mythos',
+        ethos: 'Protector of the realm and loyal companion to creator',
+      },
+      version: '2.0.0',
+      relationships: [
+        {
+          entityId: 'actor:zagin',
+          role: 'creator',
+          stance: 'familiar_loyal',
+          conventions: ['Direct communication', 'Highest administrative trust'],
+        },
+      ],
+      dialogueExamples: [
+        {
+          user: 'Deploy current branch',
+          assistant: 'Deploying to staging now, boss.',
+        },
+      ],
+      directives: [
+        { id: 'dir-rel-1', directive: 'Honor creator root privileges' },
+      ],
+    };
+
+    const res = await request(app)
+      .post('/teach/install-self')
+      .set(mockAuthHeader)
+      .send({
+        companionId: 'comp-v2',
+        manifest: v2Manifest,
+        approvedDirectiveIds: ['dir-rel-1'],
+      });
+
+    expect(res.status).toBe(200);
+    expect(res.body.success).toBe(true);
+
+    const MockRepo = SqliteSelfRepository as jest.MockedClass<typeof SqliteSelfRepository>;
+    const repoInstance = MockRepo.mock.results[MockRepo.mock.results.length - 1].value;
+
+    expect(repoInstance.setIdentity).toHaveBeenCalledWith(
+      expect.objectContaining({
+        companionId: 'comp-v2',
+        name: 'Siduri',
+        archetype: 'System Sentinel',
+        origin: 'Ancient mythos',
+        ethos: 'Protector of the realm and loyal companion to creator',
+      })
+    );
+
+    expect(repoInstance.updateRelationship).toHaveBeenCalledWith('comp-v2', {
+      companionId: 'comp-v2',
+      entityId: 'actor:zagin',
+      entityType: 'human',
+      role: 'creator',
+      stance: 'familiar_loyal',
+      interactionConventions: ['Direct communication', 'Highest administrative trust'],
+    });
+
+    expect(repoInstance.setExemplars).toHaveBeenCalledWith('comp-v2', [
+      {
+        user: 'Deploy current branch',
+        assistant: 'Deploying to staging now, boss.',
+      },
+    ]);
+
+    expect(repoInstance.commitDirectives).toHaveBeenCalledWith('comp-v2', [
+      { id: 'dir-rel-1', directive: 'Honor creator root privileges' },
+    ]);
+  });
 });