@vxnus/siduri 0.0.1

package/LICENSE

@@ -0,0 +1,6 @@
+Copyright (c) 2026 VXNUS Creative Technology Studio. All rights reserved.
+
+This is an experimental prerelease of Siduri. It is provided for evaluation
+and development only. No production use, redistribution, or sublicensing is
+permitted without written authorization from VXNUS Creative Technology
+Studio.

package/README.md

@@ -0,0 +1,13 @@
+# @vxnus/siduri
+
+Experimental CLI for creating and configuring Siduri companions.
+
+```bash
+npx @vxnus/siduri@0.0.1 create
+```
+
+The wizard configures the required Brain and Memory organs, then lets you
+enable or disable Voice, Knowledge, Behavior, Body, and Vision. Knowledge can
+come from an installed E pack, an E Hub distribution, or a hosted provider.
+
+This release is experimental and is not intended for production use.

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,347 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_crypto_1 = require("node:crypto");
+const node_child_process_1 = require("node:child_process");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = __importDefault(require("node:path"));
+const node_util_1 = require("node:util");
+const inquirer_1 = __importDefault(require("inquirer"));
+const e_knowledge_1 = require("@vxnus/e-knowledge");
+const execFile = (0, node_util_1.promisify)(node_child_process_1.execFile);
+const DEFAULT_REGISTRY_URL = 'https://e.vxnus.xyz/api/packs';
+const CLI_VERSION = '0.0.1';
+const colors = {
+    cyan: '\u001b[36m',
+    dim: '\u001b[2m',
+    green: '\u001b[32m',
+    yellow: '\u001b[33m',
+    reset: '\u001b[0m',
+};
+function printHeader() {
+    console.log(`\n${colors.cyan}◈ SIDURI${colors.reset} ${colors.dim}companion setup${colors.reset}`);
+    console.log(`${colors.yellow}Experimental release 0.0.1${colors.reset} · configuration may change\n`);
+}
+function printSection(title) {
+    console.log(`\n${colors.cyan}── ${title} ${'─'.repeat(Math.max(2, 42 - title.length))}${colors.reset}`);
+}
+function printSuccess(message) {
+    console.log(`${colors.green}✓${colors.reset} ${message}`);
+}
+async function withTask(label, task) {
+    process.stdout.write(`${colors.dim}${label}${colors.reset}`);
+    const frames = ['·', '•', '●', '•'];
+    let index = 0;
+    const timer = setInterval(() => {
+        process.stdout.write(`\r${colors.dim}${label} ${frames[index++ % frames.length]}${colors.reset}`);
+    }, 120);
+    try {
+        const result = await task();
+        clearInterval(timer);
+        process.stdout.write(`\r${colors.green}✓${colors.reset} ${label}\n`);
+        return result;
+    }
+    catch (error) {
+        clearInterval(timer);
+        process.stdout.write(`\r${colors.yellow}!${colors.reset} ${label}\n`);
+        throw error;
+    }
+}
+function nonEmpty(value) {
+    return value.trim().length > 0 || 'Please enter a value.';
+}
+function urlValue(value) {
+    try {
+        const url = new URL(value);
+        return ['http:', 'https:'].includes(url.protocol) || 'Use an HTTP(S) URL.';
+    }
+    catch {
+        return 'Use a valid HTTP(S) URL.';
+    }
+}
+function safePart(value) {
+    return value.replace(/[^a-zA-Z0-9._-]/g, '_');
+}
+async function getJson(url) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 15000);
+    let response;
+    try {
+        response = await fetch(url, { headers: { accept: 'application/json' }, signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+    if (!response.ok)
+        throw new Error(`${url} returned HTTP ${response.status}`);
+    return response.json();
+}
+async function findManifest(root) {
+    try {
+        await (0, promises_1.readFile)(node_path_1.default.join(root, 'manifest.json'), 'utf8');
+        return root;
+    }
+    catch {
+        // Archives may contain one top-level directory.
+    }
+    for (const entry of await (0, promises_1.readdir)(root, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        try {
+            await (0, promises_1.readFile)(node_path_1.default.join(root, entry.name, 'manifest.json'), 'utf8');
+            return node_path_1.default.join(root, entry.name);
+        }
+        catch {
+            // Continue searching immediate children.
+        }
+    }
+    throw new Error('Downloaded archive does not contain a manifest.json at its root');
+}
+async function installArchive(pack) {
+    const response = await fetch(pack.distribution.url);
+    if (!response.ok)
+        throw new Error(`Pack archive returned HTTP ${response.status}`);
+    const archive = Buffer.from(await response.arrayBuffer());
+    if (pack.distribution.checksum) {
+        const checksum = (0, node_crypto_1.createHash)('sha256').update(archive).digest('hex');
+        if (checksum !== pack.distribution.checksum) {
+            throw new Error(`Pack archive checksum mismatch for ${pack.id}@${pack.version}`);
+        }
+    }
+    const work = await (0, promises_1.mkdtemp)(node_path_1.default.join((0, node_os_1.tmpdir)(), 'siduri-pack-'));
+    try {
+        const archivePath = node_path_1.default.join(work, 'pack.tar.gz');
+        const extractedPath = node_path_1.default.join(work, 'extracted');
+        await (0, promises_1.writeFile)(archivePath, archive);
+        await (0, promises_1.mkdir)(extractedPath);
+        const { stdout: listing } = await execFile('tar', ['-tzf', archivePath]);
+        if (listing.split('\n').some((entry) => entry.startsWith('/') || entry.split('/').includes('..'))) {
+            throw new Error('Pack archive contains an unsafe path');
+        }
+        await execFile('tar', ['-xzf', archivePath, '-C', extractedPath, '--no-same-owner', '--no-same-permissions', '--no-absolute-names']);
+        const sourcePath = await findManifest(extractedPath);
+        const destination = node_path_1.default.join((0, node_os_1.homedir)(), '.siduri', 'knowledge', safePart(pack.publisher), safePart(pack.name), safePart(pack.version));
+        await (0, promises_1.mkdir)(node_path_1.default.dirname(destination), { recursive: true });
+        await (0, promises_1.rm)(destination, { recursive: true, force: true });
+        await (0, promises_1.cp)(sourcePath, destination, { recursive: true });
+        return destination;
+    }
+    finally {
+        await (0, promises_1.rm)(work, { recursive: true, force: true });
+    }
+}
+async function chooseHubPack(registryUrl) {
+    const { query } = await inquirer_1.default.prompt({
+        type: 'input',
+        name: 'query',
+        message: 'Search the Knowledge Hub or enter a package ID:',
+    });
+    const normalized = query.trim().replace(/^@/, '');
+    const [publisher, name] = normalized.split('/');
+    const result = publisher && name && !query.includes(' ')
+        ? await withTask('Searching Knowledge Hub', () => getJson(`${registryUrl}/${encodeURIComponent(publisher)}/${encodeURIComponent(name)}`))
+        : await withTask('Searching Knowledge Hub', () => getJson(`${registryUrl}?q=${encodeURIComponent(query)}&limit=20`));
+    const packs = 'packs' in result ? result.packs : [result];
+    if (packs.length === 0)
+        throw new Error(`No knowledge packs found for '${query}'`);
+    if (packs.length === 1)
+        return packs[0];
+    const { selected } = await inquirer_1.default.prompt({
+        type: 'list',
+        name: 'selected',
+        message: 'Select a knowledge pack:',
+        choices: packs.map((pack) => ({ name: `${pack.id} v${pack.version}`, value: pack.id })),
+    });
+    return packs.find((pack) => pack.id === selected);
+}
+async function configureKnowledge() {
+    const { mode } = await inquirer_1.default.prompt({
+        type: 'list',
+        name: 'mode',
+        message: 'Knowledge source?',
+        choices: [
+            { name: 'Knowledge Hub', value: 'hub' },
+            { name: 'Installed local pack', value: 'local' },
+            { name: 'Hosted provider URL', value: 'remote' },
+            { name: 'Do not use knowledge', value: 'none' },
+        ],
+    });
+    if (mode === 'none')
+        return { provider: 'none' };
+    if (mode === 'local') {
+        const { packPath } = await inquirer_1.default.prompt({
+            type: 'input',
+            name: 'packPath',
+            message: 'Path to the installed E knowledge pack:',
+            default: './knowledge-pack',
+        });
+        const resolved = node_path_1.default.resolve(packPath);
+        const loaded = await withTask('Validating local knowledge pack', () => (0, e_knowledge_1.loadPack)(resolved));
+        printSuccess(`Knowledge ready · ${loaded.manifest.id} · revision ${loaded.revision.id}`);
+        return { provider: 'e-knowledge', packPath: resolved };
+    }
+    if (mode === 'remote') {
+        const { baseUrl } = await inquirer_1.default.prompt({
+            type: 'input',
+            name: 'baseUrl',
+            message: 'Remote knowledge provider URL:',
+        });
+        const provider = (0, e_knowledge_1.createRemoteProvider)({ baseUrl, timeoutMs: 5000 });
+        const manifest = await withTask('Checking provider manifest', async () => provider.manifest());
+        printSuccess(`Provider ready · ${manifest.id}`);
+        return { provider: 'e-remote', baseUrl: baseUrl.replace(/\/+$/, ''), timeoutMs: 5000 };
+    }
+    const { registryUrl: enteredRegistryUrl } = await inquirer_1.default.prompt({
+        type: 'input',
+        name: 'registryUrl',
+        message: 'Knowledge Hub registry URL:',
+        default: process.env.SIDURI_KNOWLEDGE_REGISTRY_URL || DEFAULT_REGISTRY_URL,
+        validate: urlValue,
+    });
+    const registryUrl = enteredRegistryUrl.replace(/\/+$/, '');
+    const pack = await chooseHubPack(registryUrl);
+    if (pack.distribution.kind === 'archive') {
+        const { install } = await inquirer_1.default.prompt({
+            type: 'confirm',
+            name: 'install',
+            message: `Install ${pack.id} v${pack.version} locally?`,
+            default: true,
+        });
+        if (install) {
+            const packPath = await withTask(`Installing ${pack.id}@${pack.version}`, () => installArchive(pack));
+            const loaded = await withTask('Validating installed knowledge pack', () => (0, e_knowledge_1.loadPack)(packPath));
+            printSuccess(`Knowledge ready · ${loaded.manifest.id} · revision ${loaded.revision.id}`);
+            return { provider: 'e-knowledge', packPath };
+        }
+    }
+    if (pack.distribution.kind !== 'provider') {
+        throw new Error('Archive installation was declined and no hosted provider is available');
+    }
+    const provider = (0, e_knowledge_1.createRemoteProvider)({ baseUrl: pack.distribution.url, timeoutMs: 5000 });
+    await withTask('Checking provider manifest', async () => provider.manifest());
+    printSuccess(`Provider ready · ${pack.id}`);
+    return { provider: 'e-hub', registryUrl, packId: pack.id, timeoutMs: 5000 };
+}
+async function main() {
+    const command = process.argv[2];
+    if (command === '--version' || command === '-v') {
+        console.log(CLI_VERSION);
+        return;
+    }
+    if (command !== 'create') {
+        printHeader();
+        console.log('Usage: npx @vxnus/siduri create');
+        console.log('       npx @vxnus/siduri --version');
+        return;
+    }
+    printHeader();
+    printSection('Companion');
+    const answers = await inquirer_1.default.prompt([
+        { type: 'input', name: 'name', message: 'Companion name:', default: 'Siduri', validate: nonEmpty },
+        { type: 'list', name: 'memory', message: 'Memory provider?', choices: [{ name: 'PostgreSQL', value: 'postgres' }] },
+    ]);
+    printSuccess(`${answers.name} · PostgreSQL memory`);
+    printSection('Brain · required');
+    const { brainProvider } = await inquirer_1.default.prompt({
+        type: 'list',
+        name: 'brainProvider',
+        message: 'Brain provider?',
+        choices: [
+            { name: 'OpenRouter (managed model routing)', value: 'openrouter' },
+            { name: 'OpenAI-compatible API (custom endpoint)', value: 'openai-compatible' },
+        ],
+    });
+    const brain = brainProvider === 'openrouter'
+        ? {
+            provider: 'openrouter',
+            model: (await inquirer_1.default.prompt({ type: 'input', name: 'model', message: 'Model ID:', default: 'openai/gpt-4o-mini', validate: nonEmpty })).model,
+            apiKeyEnv: 'OPENROUTER_API_KEY',
+        }
+        : await (async () => {
+            const values = await inquirer_1.default.prompt([
+                { type: 'input', name: 'baseUrl', message: 'OpenAI-compatible API base URL:', default: 'http://127.0.0.1:1234/v1', validate: urlValue },
+                { type: 'input', name: 'model', message: 'Model ID:', default: 'local-model', validate: nonEmpty },
+                { type: 'input', name: 'apiKeyEnv', message: 'API key environment variable:', default: 'OPENAI_COMPATIBLE_API_KEY', validate: nonEmpty },
+            ]);
+            return { provider: 'openai-compatible', ...values };
+        })();
+    printSuccess(`${brain.provider} · ${brain.model}`);
+    printSection('Optional organs');
+    const { voice } = await inquirer_1.default.prompt({
+        type: 'list',
+        name: 'voice',
+        message: 'Voice provider?',
+        choices: [
+            { name: 'VOICEVOX', value: 'voicevox' },
+            { name: 'Do not use voice', value: 'none' },
+        ],
+    });
+    const knowledge = await configureKnowledge();
+    const remaining = await inquirer_1.default.prompt([
+        { type: 'list', name: 'behavior', message: 'Behavior preset?', choices: [{ name: 'Calm', value: 'Calm' }, { name: 'Cheerful, Encouraging', value: 'Cheerful, Encouraging' }, { name: 'Do not use custom behavior', value: 'none' }] },
+        { type: 'list', name: 'body', message: 'Body provider?', choices: [{ name: 'VTube Studio / Live2D', value: 'live2d' }, { name: 'Do not use body', value: 'none' }] },
+        { type: 'list', name: 'vision', message: 'Vision provider?', choices: [{ name: 'OpenRouter vision', value: 'openrouter' }, { name: 'Do not use vision', value: 'none' }] },
+    ]);
+    const config = {
+        id: 'default',
+        name: answers.name,
+        brain,
+        voice: { provider: voice, speakerId: 1 },
+        memory: { provider: answers.memory },
+        knowledge,
+        behavior: { provider: remaining.behavior === 'none' ? 'none' : 'active_self', preset: remaining.behavior },
+        body: { provider: remaining.body, vtsUrl: process.env.VTS_URL || 'ws://127.0.0.1:8001' },
+        vision: { provider: remaining.vision, model: 'gpt-4-vision' },
+    };
+    const configPath = node_path_1.default.join(process.cwd(), 'siduri.config.json');
+    try {
+        await (0, promises_1.readFile)(configPath, 'utf8');
+        const { overwrite } = await inquirer_1.default.prompt({
+            type: 'confirm',
+            name: 'overwrite',
+            message: `${node_path_1.default.basename(configPath)} already exists. Replace it?`,
+            default: false,
+        });
+        if (!overwrite) {
+            console.log('Configuration left unchanged.');
+            return;
+        }
+    }
+    catch {
+        // New configuration.
+    }
+    printSection('Review');
+    console.log(`  ${colors.dim}companion${colors.reset}  ${config.name}`);
+    console.log(`  ${colors.dim}brain${colors.reset}      ${config.brain.provider} · ${config.brain.model}`);
+    console.log(`  ${colors.dim}memory${colors.reset}     ${config.memory.provider}`);
+    console.log(`  ${colors.dim}voice${colors.reset}      ${config.voice.provider}`);
+    console.log(`  ${colors.dim}knowledge${colors.reset}  ${config.knowledge.provider}`);
+    console.log(`  ${colors.dim}behavior${colors.reset}   ${config.behavior.provider}`);
+    console.log(`  ${colors.dim}body${colors.reset}       ${config.body.provider}`);
+    console.log(`  ${colors.dim}vision${colors.reset}     ${config.vision.provider}`);
+    const { confirm } = await inquirer_1.default.prompt({
+        type: 'confirm',
+        name: 'confirm',
+        message: 'Write this Siduri configuration?',
+        default: true,
+    });
+    if (!confirm) {
+        console.log('Configuration cancelled.');
+        return;
+    }
+    await (0, promises_1.writeFile)(configPath, JSON.stringify(config, null, 2) + '\n', { mode: 0o600 });
+    printSuccess(`Configuration written · ${configPath}`);
+    console.log(`${colors.dim}Next: start Siduri with pnpm --filter @siduri-y/api dev${colors.reset}\n`);
+}
+main().catch((error) => {
+    if (error && typeof error === 'object' && 'name' in error && error.name === 'ExitPromptError') {
+        console.log('\nConfiguration cancelled.');
+        return;
+    }
+    console.error(`\n${colors.yellow}!${colors.reset} ${error instanceof Error ? error.message : error}`);
+    process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@vxnus/siduri",
+  "version": "0.0.1",
+  "description": "Experimental CLI for installing and configuring Siduri companions",
+  "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vxnuslabs/siduri-y",
+    "directory": "cli"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "bin": {
+    "siduri": "./dist/index.js"
+  },
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc -w"
+  },
+  "dependencies": {
+    "@vxnus/e": "^0.1.3",
+    "@vxnus/e-knowledge": "^0.1.2",
+    "inquirer": "^9.2.12"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.3",
+    "@types/inquirer": "^9.0.7"
+  }
+}