@vxnus/siduri 0.1.6 → 0.1.8

package/dist/doctor-db.test.js

@@ -1,141 +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 node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const doctor_1 = require("./doctor");
-const db_1 = require("./db");
-const generator_1 = require("./generator");
-const discovery_1 = require("./discovery");
-describe('Phase 4: Diagnostics and Database Provisioning Tests', () => {
-    const rootOrgansDir = node_path_1.default.resolve(__dirname, '../../packages/organs');
-    const registry = discovery_1.OrganRegistry.discover([rootOrgansDir]);
-    const brain = registry.get('brain');
-    const hands = registry.get('hands');
-    const memory = registry.get('memory');
-    const testTempRoot = node_path_1.default.resolve(__dirname, '../temp-phase4-test');
-    beforeAll(() => {
-        if (node_fs_1.default.existsSync(testTempRoot)) {
-            node_fs_1.default.rmSync(testTempRoot, { recursive: true, force: true });
-        }
-        node_fs_1.default.mkdirSync(testTempRoot, { recursive: true });
-    });
-    afterAll(() => {
-        if (node_fs_1.default.existsSync(testTempRoot)) {
-            node_fs_1.default.rmSync(testTempRoot, { recursive: true, force: true });
-        }
-    });
-    test('redactDatabaseUrl redacts password and sensitive credentials', () => {
-        const raw = 'postgresql://myuser:supersecretpassword@db.example.com:5432/siduri_db';
-        const redacted = (0, db_1.redactDatabaseUrl)(raw);
-        expect(redacted).not.toContain('supersecretpassword');
-        expect(redacted).toContain('***');
-        expect(redacted).toContain('myuser');
-        expect(redacted).toContain('db.example.com:5432/siduri_db');
-    });
-    test('Test Matrix A: Brain only instance doctor and db push', async () => {
-        const instanceDir = node_path_1.default.join(testTempRoot, 'brain-only');
-        node_fs_1.default.mkdirSync(node_path_1.default.join(instanceDir, 'src'), { recursive: true });
-        const files = (0, generator_1.generateInstanceFiles)({
-            name: 'BrainOnlyInstance',
-            selectedManifests: [brain],
-        });
-        for (const [name, content] of Object.entries(files)) {
-            if (typeof content === 'string') {
-                const fullPath = node_path_1.default.join(instanceDir, name);
-                node_fs_1.default.mkdirSync(node_path_1.default.dirname(fullPath), { recursive: true });
-                node_fs_1.default.writeFileSync(fullPath, content);
-            }
-        }
-        // 1. Doctor without OPENROUTER_API_KEY -> FAIL (Brain Health Probe fails)
-        const doctorFail = await (0, doctor_1.runDoctor)({ projectDir: instanceDir, env: { OPENROUTER_API_KEY: '' } });
-        expect(doctorFail.passed).toBe(false);
-        expect(doctorFail.results.some((r) => r.category === 'Health Probe' && r.status === 'FAIL')).toBe(true);
-        // Database check must be SKIPPED
-        expect(doctorFail.results.some((r) => r.category === 'Database' && r.status === 'SKIPPED')).toBe(true);
-        // 2. Doctor with OPENROUTER_API_KEY -> PASS
-        const doctorPass = await (0, doctor_1.runDoctor)({
-            projectDir: instanceDir,
-            env: { OPENROUTER_API_KEY: 'test-key-123' },
-        });
-        expect(doctorPass.passed).toBe(true);
-        // 3. db push -> NOOP ("No database migrations are required...")
-        const dbResult = await (0, db_1.runDbPush)({ projectDir: instanceDir });
-        expect(dbResult.status).toBe('NOOP');
-        expect(dbResult.message).toContain('No database migrations are required');
-    });
-    test('Test Matrix B: Brain + Hands instance doctor and db push', async () => {
-        const instanceDir = node_path_1.default.join(testTempRoot, 'brain-hands');
-        node_fs_1.default.mkdirSync(node_path_1.default.join(instanceDir, 'src'), { recursive: true });
-        const files = (0, generator_1.generateInstanceFiles)({
-            name: 'BrainHandsInstance',
-            selectedManifests: [brain, hands],
-        });
-        for (const [name, content] of Object.entries(files)) {
-            if (typeof content === 'string') {
-                const fullPath = node_path_1.default.join(instanceDir, name);
-                node_fs_1.default.mkdirSync(node_path_1.default.dirname(fullPath), { recursive: true });
-                node_fs_1.default.writeFileSync(fullPath, content);
-            }
-        }
-        // Doctor checks both keys
-        const doctorRes = await (0, doctor_1.runDoctor)({
-            projectDir: instanceDir,
-            env: {
-                OPENROUTER_API_KEY: 'test-openrouter-key',
-                ACTION_POLICY_SECRET: 'test-policy-secret',
-            },
-        });
-        expect(doctorRes.passed).toBe(true);
-        expect(doctorRes.results.some((r) => r.name === 'OPENROUTER_API_KEY' && r.status === 'PASS')).toBe(true);
-        expect(doctorRes.results.some((r) => r.name === 'ACTION_POLICY_SECRET' && r.status === 'PASS')).toBe(true);
-        // Database check must be SKIPPED
-        expect(doctorRes.results.some((r) => r.category === 'Database' && r.status === 'SKIPPED')).toBe(true);
-        // db push returns NOOP
-        const dbResult = await (0, db_1.runDbPush)({ projectDir: instanceDir });
-        expect(dbResult.status).toBe('NOOP');
-    });
-    test('Test Matrix C: Brain + Memory instance requires DATABASE_URL', async () => {
-        const instanceDir = node_path_1.default.join(testTempRoot, 'brain-memory');
-        node_fs_1.default.mkdirSync(node_path_1.default.join(instanceDir, 'src'), { recursive: true });
-        const files = (0, generator_1.generateInstanceFiles)({
-            name: 'BrainMemoryInstance',
-            selectedManifests: [brain, memory],
-        });
-        for (const [name, content] of Object.entries(files)) {
-            if (typeof content === 'string') {
-                const fullPath = node_path_1.default.join(instanceDir, name);
-                node_fs_1.default.mkdirSync(node_path_1.default.dirname(fullPath), { recursive: true });
-                node_fs_1.default.writeFileSync(fullPath, content);
-            }
-        }
-        // 1. Doctor fails without DATABASE_URL
-        const doctorMissingDb = await (0, doctor_1.runDoctor)({
-            projectDir: instanceDir,
-            env: { OPENROUTER_API_KEY: 'test-key' },
-        });
-        expect(doctorMissingDb.passed).toBe(false);
-        expect(doctorMissingDb.results.some((r) => r.name === 'DATABASE_URL' && r.status === 'FAIL')).toBe(true);
-        // 2. db push fails clearly without DATABASE_URL
-        await expect((0, db_1.runDbPush)({ projectDir: instanceDir, env: {} })).rejects.toThrow(/DATABASE_URL is required/);
-    });
-    test('Test Matrix D: Diagnostics and Error Handling for invalid or missing configs', async () => {
-        // 1. Missing siduri.config.json
-        const nonExistentDir = node_path_1.default.join(testTempRoot, 'non-existent-dir');
-        await expect((0, doctor_1.runDoctor)({ projectDir: nonExistentDir })).rejects.toThrow(/siduri.config.json not found/);
-        await expect((0, db_1.runDbPush)({ projectDir: nonExistentDir })).rejects.toThrow(/siduri.config.json not found/);
-        // 2. Unreachable PostgreSQL host reported gracefully by doctor
-        const instDir = node_path_1.default.join(testTempRoot, 'brain-memory');
-        const doctorUnreachable = await (0, doctor_1.runDoctor)({
-            projectDir: instDir,
-            env: {
-                OPENROUTER_API_KEY: 'test-key',
-                DATABASE_URL: 'postgresql://postgres:postgres@127.0.0.1:59999/non_existent_db',
-            },
-        });
-        expect(doctorUnreachable.passed).toBe(false);
-        expect(doctorUnreachable.results.some((r) => r.category === 'Database' && r.status === 'FAIL')).toBe(true);
-    });
-});

package/dist/doctor.d.ts

@@ -1,19 +0,0 @@
-export interface DoctorCheckResult {
-    category: 'Environment' | 'Services' | 'Database' | 'Health Probe';
-    name: string;
-    status: 'PASS' | 'FAIL' | 'OPTIONAL_MISSING' | 'SKIPPED';
-    organName?: string;
-    message?: string;
-    remediation?: string;
-}
-export interface DoctorReport {
-    instanceName: string;
-    configuredOrgans: string[];
-    results: DoctorCheckResult[];
-    passed: boolean;
-}
-export interface DoctorOptions {
-    projectDir?: string;
-    env?: Record<string, string | undefined>;
-}
-export declare function runDoctor(options?: DoctorOptions): Promise<DoctorReport>;

package/dist/doctor.js

@@ -1,225 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runDoctor = runDoctor;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const discovery_1 = require("./discovery");
-const pg_1 = require("pg");
-async function runDoctor(options = {}) {
-    const projectDir = options.projectDir ? node_path_1.default.resolve(options.projectDir) : process.cwd();
-    const configPath = node_path_1.default.join(projectDir, 'siduri.config.json');
-    if (!node_fs_1.default.existsSync(configPath)) {
-        throw new Error(`siduri.config.json not found at ${projectDir}. Make sure you are in a Siduri instance directory.`);
-    }
-    // Load .env if present in projectDir
-    const envFile = node_path_1.default.join(projectDir, '.env');
-    const fileEnv = {};
-    if (node_fs_1.default.existsSync(envFile)) {
-        const lines = node_fs_1.default.readFileSync(envFile, 'utf8').split('\n');
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (!trimmed || trimmed.startsWith('#'))
-                continue;
-            const eqIdx = trimmed.indexOf('=');
-            if (eqIdx !== -1) {
-                const key = trimmed.slice(0, eqIdx).trim();
-                const val = trimmed.slice(eqIdx + 1).trim();
-                fileEnv[key] = val;
-            }
-        }
-    }
-    const effectiveEnv = {
-        ...process.env,
-        ...fileEnv,
-        ...(options.env || {}),
-    };
-    const config = JSON.parse(node_fs_1.default.readFileSync(configPath, 'utf8'));
-    const configuredOrgansMap = config.organs || {};
-    const organKeys = Object.keys(configuredOrgansMap);
-    const registry = discovery_1.OrganRegistry.discover([
-        node_path_1.default.join(projectDir, 'node_modules/@siduri-x'),
-        node_path_1.default.resolve(__dirname, '../../packages/organs'),
-        node_path_1.default.resolve(process.cwd(), 'packages/organs'),
-    ]);
-    const selectedManifests = [];
-    const results = [];
-    // 1. Resolve manifests for selected organs
-    for (const organKey of organKeys) {
-        const m = registry.get(organKey) || registry.getAll().find((item) => item.configKey === organKey || item.organType === organKey);
-        if (!m) {
-            results.push({
-                category: 'Environment',
-                name: `Manifest resolution: ${organKey}`,
-                status: 'FAIL',
-                message: `Could not resolve package manifest for configured organ '${organKey}'.`,
-                remediation: `Ensure @siduri-x/${organKey} is installed in package.json and npm install has been run.`,
-            });
-        }
-        else {
-            selectedManifests.push(m);
-        }
-    }
-    // 2. Check Environment Variables (deduplicated)
-    const checkedEnvVars = new Set();
-    for (const m of selectedManifests) {
-        for (const envVar of m.environment || []) {
-            if (checkedEnvVars.has(envVar.name))
-                continue;
-            checkedEnvVars.add(envVar.name);
-            const val = effectiveEnv[envVar.name];
-            const isMissing = !val || val.trim() === '';
-            if (isMissing) {
-                if (envVar.required) {
-                    results.push({
-                        category: 'Environment',
-                        name: envVar.name,
-                        status: 'FAIL',
-                        organName: m.name,
-                        message: `Missing required environment variable '${envVar.name}'.`,
-                        remediation: `Set ${envVar.name} in .env or your shell environment. ${envVar.description || ''}`,
-                    });
-                }
-                else {
-                    results.push({
-                        category: 'Environment',
-                        name: envVar.name,
-                        status: 'OPTIONAL_MISSING',
-                        organName: m.name,
-                        message: `Optional variable '${envVar.name}' not set.`,
-                    });
-                }
-            }
-            else {
-                results.push({
-                    category: 'Environment',
-                    name: envVar.name,
-                    status: 'PASS',
-                    organName: m.name,
-                    message: 'Configured',
-                });
-            }
-        }
-    }
-    // 3. Check External Services
-    for (const m of selectedManifests) {
-        for (const service of m.services || []) {
-            results.push({
-                category: 'Services',
-                name: `${service.name} (${m.organType})`,
-                status: 'PASS',
-                organName: m.name,
-                message: 'Service requirement declared',
-            });
-        }
-    }
-    // 4. Database Check (only if an organ declares database requirement)
-    const dbOrgan = selectedManifests.find((m) => m.database !== null && m.database !== undefined);
-    if (dbOrgan) {
-        const dbUrl = effectiveEnv.DATABASE_URL;
-        if (!dbUrl) {
-            results.push({
-                category: 'Database',
-                name: 'PostgreSQL Connection',
-                status: 'FAIL',
-                organName: dbOrgan.name,
-                message: 'DATABASE_URL is not configured.',
-                remediation: 'Provide DATABASE_URL in .env (e.g. postgresql://postgres:postgres@localhost:5432/siduri)',
-            });
-        }
-        else {
-            const pool = new pg_1.Pool({ connectionString: dbUrl, connectionTimeoutMillis: 3000 });
-            try {
-                const client = await pool.connect();
-                await client.query('SELECT 1');
-                client.release();
-                await pool.end();
-                results.push({
-                    category: 'Database',
-                    name: 'PostgreSQL Connection',
-                    status: 'PASS',
-                    organName: dbOrgan.name,
-                    message: 'Connection successful',
-                });
-            }
-            catch (err) {
-                await pool.end().catch(() => { });
-                results.push({
-                    category: 'Database',
-                    name: 'PostgreSQL Connection',
-                    status: 'FAIL',
-                    organName: dbOrgan.name,
-                    message: `Connection failed: ${err.message}`,
-                    remediation: 'Check database host availability, port, credentials, and network accessibility.',
-                });
-            }
-        }
-    }
-    else {
-        results.push({
-            category: 'Database',
-            name: 'PostgreSQL Database',
-            status: 'SKIPPED',
-            message: 'Not required by current composition',
-        });
-    }
-    // 5. Organ Health Probes
-    for (const m of selectedManifests) {
-        if (m.healthCheck) {
-            try {
-                // Resolve package entrypoint
-                const candidateEntrypoints = [
-                    node_path_1.default.resolve(projectDir, 'node_modules', m.name, m.entrypoint),
-                    node_path_1.default.resolve(__dirname, '../../packages/organs', m.organType, m.entrypoint),
-                    node_path_1.default.resolve(process.cwd(), 'packages/organs', m.organType, m.entrypoint),
-                ];
-                const entryPath = candidateEntrypoints.find((p) => node_fs_1.default.existsSync(p));
-                if (entryPath) {
-                    const mod = require(entryPath);
-                    const probeFn = mod[m.healthCheck];
-                    if (typeof probeFn === 'function') {
-                        const organConf = configuredOrgansMap[m.configKey] || configuredOrgansMap[m.organType];
-                        const probeRes = await probeFn({ config: organConf, env: effectiveEnv });
-                        if (probeRes && probeRes.ok === false) {
-                            results.push({
-                                category: 'Health Probe',
-                                name: `${m.displayName} Probe`,
-                                status: 'FAIL',
-                                organName: m.name,
-                                message: probeRes.message || 'Health probe check failed',
-                                remediation: `Check ${m.displayName} configuration in siduri.config.json.`,
-                            });
-                        }
-                        else {
-                            results.push({
-                                category: 'Health Probe',
-                                name: `${m.displayName} Probe`,
-                                status: 'PASS',
-                                organName: m.name,
-                                message: probeRes?.message || 'Operational',
-                            });
-                        }
-                    }
-                }
-            }
-            catch (err) {
-                results.push({
-                    category: 'Health Probe',
-                    name: `${m.displayName} Probe`,
-                    status: 'FAIL',
-                    organName: m.name,
-                    message: `Probe invocation failed: ${err.message}`,
-                });
-            }
-        }
-    }
-    const passed = results.every((r) => r.status !== 'FAIL');
-    return {
-        instanceName: config.name || 'Siduri Instance',
-        configuredOrgans: organKeys,
-        results,
-        passed,
-    };
-}

package/dist/generator.d.ts

@@ -1,21 +0,0 @@
-import { OrganManifest } from './manifest';
-export interface GeneratedInstanceFiles {
-    'package.json': string;
-    'siduri.config.json': string;
-    'siduri.schema.json': string;
-    '.env.example': string;
-    'README.md': string;
-    'src/index.js': string;
-    'public/index.html': string;
-    'docker-compose.yml'?: string;
-    createAssetsBodyDir?: boolean;
-    createAssetsDirs?: string[];
-}
-export interface InstanceGeneratorOptions {
-    name: string;
-    id?: string;
-    selectedManifests: OrganManifest[];
-    organConfigs?: Record<string, any>;
-    coreVersion?: string;
-}
-export declare function generateInstanceFiles(options: InstanceGeneratorOptions): GeneratedInstanceFiles;