@siduri-x/core 1.0.5 → 1.0.8

package/dist/session-history.test.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const session_history_1 = require("./session-history");
+describe('SessionHistoryManager', () => {
+    test('isolates history across distinct sessions', () => {
+        const manager = new session_history_1.SessionHistoryManager();
+        manager.append('session-alice', { role: 'user', content: 'Alice message' });
+        manager.append('session-bob', { role: 'user', content: 'Bob message' });
+        expect(manager.getHistory('session-alice')).toEqual([
+            { role: 'user', content: 'Alice message' },
+        ]);
+        expect(manager.getHistory('session-bob')).toEqual([
+            { role: 'user', content: 'Bob message' },
+        ]);
+    });
+    test('bounds messages per session to configured limit and strips null bytes', () => {
+        const manager = new session_history_1.SessionHistoryManager({ maxMessagesPerSession: 3 });
+        manager.append('sess-1', { role: 'user', content: 'm1\0' });
+        manager.append('sess-1', { role: 'assistant', content: 'm2' });
+        manager.append('sess-1', { role: 'user', content: 'm3' });
+        manager.append('sess-1', { role: 'assistant', content: 'm4' });
+        const history = manager.getHistory('sess-1');
+        expect(history).toHaveLength(3);
+        expect(history[0].content).toBe('m2');
+        expect(history[2].content).toBe('m4');
+    });
+    test('bounds maximum active sessions with LRU eviction', () => {
+        const manager = new session_history_1.SessionHistoryManager({ maxSessions: 2 });
+        manager.append('sess-1', { role: 'user', content: 'm1' });
+        manager.append('sess-2', { role: 'user', content: 'm2' });
+        expect(manager.sessionCount()).toBe(2);
+        manager.append('sess-3', { role: 'user', content: 'm3' });
+        expect(manager.sessionCount()).toBe(2);
+        expect(manager.getHistory('sess-1')).toEqual([]);
+        expect(manager.getHistory('sess-2')).toHaveLength(1);
+        expect(manager.getHistory('sess-3')).toHaveLength(1);
+    });
+});

package/dist/sqlite-action-store.d.ts

@@ -0,0 +1,20 @@
+import { ActionAuditEvent } from './action';
+import { ActionStore, PersistentExecutionRecord } from './capability';
+export interface SqliteActionStoreOptions {
+    dbPath?: string;
+}
+export declare class SqliteActionStore implements ActionStore {
+    private db;
+    private lastAuditHash;
+    constructor(options?: SqliteActionStoreOptions);
+    private initSchema;
+    private initLastAuditHash;
+    reserveExecution(record: PersistentExecutionRecord): Promise<boolean>;
+    updateExecution(record: PersistentExecutionRecord): Promise<void>;
+    getExecution(executionId: string): Promise<PersistentExecutionRecord | undefined>;
+    saveApproval(executionId: string, approverActorId: string, reason?: string): Promise<void>;
+    isActionApproved(executionId: string): Promise<boolean>;
+    appendAudit(event: ActionAuditEvent): Promise<void>;
+    getAuditLog(executionId?: string): Promise<ActionAuditEvent[]>;
+    close(): void;
+}

package/dist/sqlite-action-store.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteActionStore = void 0;
+const capability_1 = require("./capability");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const crypto = require('crypto');
+class SqliteActionStore {
+    db;
+    lastAuditHash = '0000000000000000000000000000000000000000000000000000000000000000';
+    constructor(options = {}) {
+        const dbPath = options.dbPath ?? ':memory:';
+        // Dynamically require node:sqlite (supported natively in Node.js >= 22)
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { DatabaseSync } = require('node:sqlite');
+        this.db = new DatabaseSync(dbPath);
+        this.initSchema();
+        this.initLastAuditHash();
+    }
+    initSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS action_executions (
+        execution_id TEXT PRIMARY KEY,
+        action_id TEXT NOT NULL,
+        tool_name TEXT NOT NULL,
+        provider_id TEXT NOT NULL,
+        parameters_hash TEXT NOT NULL,
+        lifecycle TEXT NOT NULL,
+        decision_json TEXT,
+        result_json TEXT,
+        error TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS action_approvals (
+        execution_id TEXT PRIMARY KEY,
+        approver_actor_id TEXT NOT NULL,
+        reason TEXT,
+        approved_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS action_audit_log (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        execution_id TEXT NOT NULL,
+        action_id TEXT NOT NULL,
+        tool_name TEXT NOT NULL,
+        provider_id TEXT,
+        companion_id TEXT NOT NULL,
+        actor_id TEXT,
+        session_id TEXT,
+        channel TEXT,
+        correlation_id TEXT,
+        risk_level TEXT NOT NULL,
+        lifecycle TEXT NOT NULL,
+        decision_json TEXT,
+        parameters_hash TEXT,
+        result_hash TEXT,
+        event_hash TEXT NOT NULL,
+        previous_event_hash TEXT NOT NULL,
+        duration_ms REAL,
+        error TEXT,
+        timestamp TEXT NOT NULL
+      );
+    `);
+    }
+    initLastAuditHash() {
+        const row = this.db.prepare('SELECT event_hash FROM action_audit_log ORDER BY id DESC LIMIT 1').get();
+        if (row && typeof row.event_hash === 'string') {
+            this.lastAuditHash = row.event_hash;
+        }
+    }
+    async reserveExecution(record) {
+        try {
+            const stmt = this.db.prepare(`
+        INSERT INTO action_executions (
+          execution_id, action_id, tool_name, provider_id, parameters_hash,
+          lifecycle, decision_json, result_json, error, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+            stmt.run(record.executionId, record.actionId, record.toolName, record.providerId, record.parametersHash, record.lifecycle, record.decision ? JSON.stringify(record.decision) : null, record.result !== undefined ? JSON.stringify(record.result) : null, record.error ?? null, record.createdAt, record.updatedAt);
+            return true;
+        }
+        catch (err) {
+            // Primary key constraint violation on execution_id
+            if (err.message && (err.message.includes('UNIQUE constraint failed') || err.message.includes('constraint failed'))) {
+                return false;
+            }
+            throw err;
+        }
+    }
+    async updateExecution(record) {
+        const stmt = this.db.prepare(`
+      INSERT INTO action_executions (
+        execution_id, action_id, tool_name, provider_id, parameters_hash,
+        lifecycle, decision_json, result_json, error, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(execution_id) DO UPDATE SET
+        action_id = excluded.action_id,
+        tool_name = excluded.tool_name,
+        provider_id = excluded.provider_id,
+        parameters_hash = excluded.parameters_hash,
+        lifecycle = excluded.lifecycle,
+        decision_json = excluded.decision_json,
+        result_json = excluded.result_json,
+        error = excluded.error,
+        updated_at = excluded.updated_at
+    `);
+        stmt.run(record.executionId, record.actionId, record.toolName, record.providerId, record.parametersHash, record.lifecycle, record.decision ? JSON.stringify(record.decision) : null, record.result !== undefined ? JSON.stringify(record.result) : null, record.error ?? null, record.createdAt, record.updatedAt);
+    }
+    async getExecution(executionId) {
+        const stmt = this.db.prepare('SELECT * FROM action_executions WHERE execution_id = ?');
+        const row = stmt.get(executionId);
+        if (!row) {
+            return undefined;
+        }
+        return {
+            executionId: row.execution_id,
+            actionId: row.action_id,
+            toolName: row.tool_name,
+            providerId: row.provider_id,
+            parametersHash: row.parameters_hash,
+            lifecycle: row.lifecycle,
+            decision: row.decision_json ? JSON.parse(row.decision_json) : undefined,
+            result: row.result_json ? JSON.parse(row.result_json) : undefined,
+            error: row.error ?? undefined,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+        };
+    }
+    async saveApproval(executionId, approverActorId, reason) {
+        const stmt = this.db.prepare(`
+      INSERT INTO action_approvals (execution_id, approver_actor_id, reason, approved_at)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(execution_id) DO UPDATE SET
+        approver_actor_id = excluded.approver_actor_id,
+        reason = excluded.reason,
+        approved_at = excluded.approved_at
+    `);
+        stmt.run(executionId, approverActorId, reason ?? null, new Date().toISOString());
+    }
+    async isActionApproved(executionId) {
+        const stmt = this.db.prepare('SELECT 1 FROM action_approvals WHERE execution_id = ?');
+        const row = stmt.get(executionId);
+        return !!row;
+    }
+    async appendAudit(event) {
+        const prevHash = this.lastAuditHash;
+        const eventPayload = {
+            executionId: event.executionId,
+            actionId: event.actionId,
+            toolName: event.toolName,
+            providerId: event.providerId || null,
+            companionId: event.companionId,
+            actorId: event.actorId || null,
+            sessionId: event.sessionId || null,
+            channel: event.channel || null,
+            correlationId: event.correlationId || null,
+            riskLevel: event.riskLevel,
+            lifecycle: event.lifecycle,
+            decision: event.decision ? {
+                allowed: event.decision.allowed,
+                reason: event.decision.reason,
+                riskLevel: event.decision.riskLevel,
+                decisionCode: event.decision.decisionCode,
+            } : null,
+            parametersHash: event.parametersHash || null,
+            error: event.error || null,
+            timestamp: event.timestamp,
+        };
+        const canonical = (0, capability_1.canonicalizeJson)(eventPayload);
+        const eventHash = crypto
+            .createHash('sha256')
+            .update(`${prevHash}:${canonical}`, 'utf8')
+            .digest('hex');
+        this.lastAuditHash = eventHash;
+        const resultHash = event.resultHash || eventHash;
+        const stmt = this.db.prepare(`
+      INSERT INTO action_audit_log (
+        execution_id, action_id, tool_name, provider_id, companion_id,
+        actor_id, session_id, channel, correlation_id, risk_level,
+        lifecycle, decision_json, parameters_hash, result_hash, event_hash,
+        previous_event_hash, duration_ms, error, timestamp
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        stmt.run(event.executionId, event.actionId, event.toolName, event.providerId ?? null, event.companionId, event.actorId ?? null, event.sessionId ?? null, event.channel ?? null, event.correlationId ?? null, event.riskLevel, event.lifecycle, event.decision ? JSON.stringify(event.decision) : null, event.parametersHash ?? null, resultHash, eventHash, prevHash, event.durationMs ?? null, event.error ?? null, event.timestamp);
+    }
+    async getAuditLog(executionId) {
+        let rows;
+        if (executionId) {
+            const stmt = this.db.prepare('SELECT * FROM action_audit_log WHERE execution_id = ? ORDER BY id ASC');
+            rows = stmt.all(executionId);
+        }
+        else {
+            const stmt = this.db.prepare('SELECT * FROM action_audit_log ORDER BY id ASC');
+            rows = stmt.all();
+        }
+        return rows.map((row) => ({
+            executionId: row.execution_id,
+            actionId: row.action_id,
+            toolName: row.tool_name,
+            providerId: row.provider_id ?? undefined,
+            companionId: row.companion_id,
+            actorId: row.actor_id ?? undefined,
+            sessionId: row.session_id ?? undefined,
+            channel: row.channel ?? undefined,
+            correlationId: row.correlation_id ?? undefined,
+            riskLevel: row.risk_level,
+            lifecycle: row.lifecycle,
+            decision: row.decision_json ? JSON.parse(row.decision_json) : undefined,
+            parametersHash: row.parameters_hash ?? undefined,
+            resultHash: row.result_hash ?? undefined,
+            eventHash: row.event_hash,
+            previousEventHash: row.previous_event_hash,
+            durationMs: row.duration_ms ?? undefined,
+            error: row.error ?? undefined,
+            timestamp: row.timestamp,
+        }));
+    }
+    close() {
+        if (this.db) {
+            this.db.close();
+        }
+    }
+}
+exports.SqliteActionStore = SqliteActionStore;

package/dist/sqlite-action-store.test.d.ts

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

package/dist/sqlite-action-store.test.js

@@ -0,0 +1,251 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const crypto = require('crypto');
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const sqlite_action_store_1 = require("./sqlite-action-store");
+const action_policy_1 = require("./action-policy");
+const capability_1 = require("./capability");
+describe('SqliteActionStore Implementation & Durability', () => {
+    let tmpDir;
+    let dbPath;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'siduri-sqlite-test-'));
+        dbPath = path.join(tmpDir, 'actions.db');
+    });
+    afterEach(() => {
+        try {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+        catch {
+            // ignore
+        }
+    });
+    it('reserves execution atomically and prevents duplicate executionId', async () => {
+        const store = new sqlite_action_store_1.SqliteActionStore({ dbPath });
+        const record = {
+            executionId: 'exec-100',
+            actionId: 'act-100',
+            toolName: 'test_tool',
+            providerId: 'builtin',
+            parametersHash: 'hash-100',
+            lifecycle: 'EXECUTING',
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+        };
+        const first = await store.reserveExecution(record);
+        expect(first).toBe(true);
+        // Second reservation with same executionId fails
+        const second = await store.reserveExecution({
+            ...record,
+            actionId: 'act-duplicate',
+        });
+        expect(second).toBe(false);
+        // Fetch and verify contents
+        const fetched = await store.getExecution('exec-100');
+        expect(fetched).toBeDefined();
+        expect(fetched?.executionId).toBe('exec-100');
+        expect(fetched?.toolName).toBe('test_tool');
+        // Update execution
+        await store.updateExecution({
+            ...record,
+            lifecycle: 'COMPLETED',
+            result: { success: true, count: 42 },
+        });
+        const updated = await store.getExecution('exec-100');
+        expect(updated?.lifecycle).toBe('COMPLETED');
+        expect(updated?.result).toEqual({ success: true, count: 42 });
+        store.close();
+    });
+    it('persists approvals and survives process restart with a fresh instance', async () => {
+        // Process 1: save approval in instance 1
+        const store1 = new sqlite_action_store_1.SqliteActionStore({ dbPath });
+        await store1.saveApproval('exec-restart-test', 'operator-alice', 'Routine maintenance');
+        expect(await store1.isActionApproved('exec-restart-test')).toBe(true);
+        expect(await store1.isActionApproved('non-existent')).toBe(false);
+        store1.close();
+        // Process 2: open new instance on the same file (simulating engine reboot)
+        const store2 = new sqlite_action_store_1.SqliteActionStore({ dbPath });
+        const isApprovedAfterReboot = await store2.isActionApproved('exec-restart-test');
+        expect(isApprovedAfterReboot).toBe(true);
+        expect(await store2.isActionApproved('non-existent')).toBe(false);
+        store2.close();
+    });
+    it('maintains tamper-evident SHA-256 hash chaining in SQLite audit log', async () => {
+        const store = new sqlite_action_store_1.SqliteActionStore({ dbPath });
+        const event1 = {
+            executionId: 'exec-audit-1',
+            actionId: 'act-audit-1',
+            toolName: 'system/disk_clean',
+            providerId: 'system',
+            companionId: 'comp-1',
+            actorId: 'user-1',
+            riskLevel: 'LOW',
+            lifecycle: 'POLICY_CHECKED',
+            timestamp: '2026-09-09T10:00:00.000Z',
+        };
+        const event2 = {
+            executionId: 'exec-audit-2',
+            actionId: 'act-audit-2',
+            toolName: 'system/disk_clean',
+            providerId: 'system',
+            companionId: 'comp-1',
+            actorId: 'user-1',
+            riskLevel: 'LOW',
+            lifecycle: 'COMPLETED',
+            timestamp: '2026-09-09T10:00:05.000Z',
+        };
+        await store.appendAudit(event1);
+        await store.appendAudit(event2);
+        const log = await store.getAuditLog();
+        expect(log).toHaveLength(2);
+        const initialPrevHash = '0000000000000000000000000000000000000000000000000000000000000000';
+        expect(log[0].previousEventHash).toBe(initialPrevHash);
+        expect(log[1].previousEventHash).toBe(log[0].eventHash);
+        // Verify hash computation on event 1
+        const canonical1 = (0, capability_1.canonicalizeJson)({
+            executionId: event1.executionId,
+            actionId: event1.actionId,
+            toolName: event1.toolName,
+            providerId: event1.providerId,
+            companionId: event1.companionId,
+            actorId: event1.actorId,
+            sessionId: null,
+            channel: null,
+            correlationId: null,
+            riskLevel: event1.riskLevel,
+            lifecycle: event1.lifecycle,
+            decision: null,
+            parametersHash: null,
+            error: null,
+            timestamp: event1.timestamp,
+        });
+        const expectedHash1 = crypto.createHash('sha256').update(`${initialPrevHash}:${canonical1}`, 'utf8').digest('hex');
+        expect(log[0].eventHash).toBe(expectedHash1);
+        store.close();
+        // Reopen in a new instance and verify audit chain resumes seamlessly
+        const storeReopened = new sqlite_action_store_1.SqliteActionStore({ dbPath });
+        const event3 = {
+            executionId: 'exec-audit-3',
+            actionId: 'act-audit-3',
+            toolName: 'system/disk_clean',
+            providerId: 'system',
+            companionId: 'comp-1',
+            actorId: 'user-1',
+            riskLevel: 'LOW',
+            lifecycle: 'COMPLETED',
+            timestamp: '2026-09-09T10:00:10.000Z',
+        };
+        await storeReopened.appendAudit(event3);
+        const logReopened = await storeReopened.getAuditLog();
+        expect(logReopened).toHaveLength(3);
+        expect(logReopened[2].previousEventHash).toBe(logReopened[1].eventHash);
+        // Query specific executionId
+        const filtered = await storeReopened.getAuditLog('exec-audit-2');
+        expect(filtered).toHaveLength(1);
+        expect(filtered[0].executionId).toBe('exec-audit-2');
+        storeReopened.close();
+    });
+    it('works seamlessly with ActionPolicyEngine across simulated restarts', async () => {
+        const secretKey = 'test_sqlite_policy_key';
+        const store1 = new sqlite_action_store_1.SqliteActionStore({ dbPath });
+        const engine1 = new action_policy_1.ActionPolicyEngine({
+            store: store1,
+            secretKey,
+            defaultRiskLevel: 'HIGH',
+            defaultRequireApprovalForHighRisk: true,
+        });
+        const dangerousTool = {
+            name: 'cleanup_disk',
+            providerId: 'system',
+            description: 'Clean up disk',
+            inputSchema: {},
+            riskLevel: 'HIGH',
+            requiresApproval: true,
+        };
+        engine1.registerToolDefinition(dangerousTool);
+        const context = {
+            companionId: 'comp-local',
+            actor: {
+                actorId: 'local-owner',
+                sessionId: 'sess-1',
+                authorizationRole: 'operator',
+                capabilities: ['system:manage'],
+                authenticated: true,
+            },
+            conversation: {
+                channel: 'direct',
+                correlationId: 'corr-1',
+            },
+        };
+        const action = {
+            actionId: 'act-danger-1',
+            executionId: 'exec-danger-1',
+            toolName: 'system/cleanup_disk',
+            parameters: { force: true },
+            context,
+        };
+        // 1. Initial attempt without approval -> rejected
+        const eval1 = await engine1.evaluateAction(action);
+        expect(eval1.decision.allowed).toBe(false);
+        expect(eval1.decision.decisionCode).toBe('REJECTED_HIGH_RISK_UNAPPROVED');
+        // 2. Owner approves
+        await engine1.approveAction({
+            executionId: 'exec-danger-1',
+            approverActorId: 'local-owner',
+            reason: 'Owner confirmed cleanup',
+        });
+        store1.close();
+        // 3. Process restart: engine2 with fresh SqliteActionStore connecting to same db
+        const store2 = new sqlite_action_store_1.SqliteActionStore({ dbPath });
+        const engine2 = new action_policy_1.ActionPolicyEngine({
+            store: store2,
+            secretKey,
+            defaultRiskLevel: 'HIGH',
+            defaultRequireApprovalForHighRisk: true,
+        });
+        engine2.registerToolDefinition(dangerousTool);
+        // 4. Evaluate after restart -> approval is retrieved from SQLite and capability granted
+        const eval2 = await engine2.evaluateAction(action);
+        expect(eval2.decision.allowed).toBe(true);
+        expect(eval2.decision.decisionCode).toBe('ALLOWED_POLICY');
+        expect(eval2.capability).toBeDefined();
+        expect((0, capability_1.verifyCapabilitySignature)(eval2.capability, secretKey)).toBe(true);
+        store2.close();
+    });
+});

package/dist/teaching.d.ts

@@ -0,0 +1,15 @@
+import { RequestContext, MemoryProposal, BehaviorProposal } from './index';
+export interface ExtractedTeaching {
+    claims: MemoryProposal[];
+    behaviorProposals: BehaviorProposal[];
+}
+/**
+ * Deterministically extracts teaching candidates from user messages according to single-owner model.
+ *
+ * Rules:
+ * - Scoped to the requesting actor context (subject: `actor:${actorId}`), NEVER `primary_user`.
+ * - Candidates are pending proposals only, never active/approved.
+ * - In a single-owner companion, preferences apply across the companion instance without audience partitioning.
+ * - Companion identity is isolated.
+ */
+export declare function extractDeterministicTeaching(message: string, context?: RequestContext, sourceEventId?: string): ExtractedTeaching;