@coeiro-operator/core 1.0.0

package/dist/operator/config-manager.d.ts

@@ -0,0 +1,145 @@
+/**
+ * src/operator/config-manager.ts: 設定管理システム
+ * 動的音声フォント取得、設定マージ、キャッシュ管理を担当
+ */
+import { BaseCharacterConfig, CharacterConfig } from './character-defaults.js';
+import { AudioConfig, FullConfig as BaseFullConfig } from '../types.js';
+export interface FullConfig extends Omit<BaseFullConfig, 'characters'> {
+    characters: Record<string, BaseCharacterConfig | CharacterConfig>;
+}
+export interface TerminalBackgroundConfig {
+    enabled: boolean;
+    backgroundImages?: {
+        [characterId: string]: string;
+    };
+    operatorImage?: {
+        display: 'api' | 'file' | 'none';
+        position: 'top-right' | 'bottom-right';
+        opacity: number;
+        filePath?: string;
+    };
+}
+interface Config {
+    connection: {
+        host: string;
+        port: string;
+    };
+    audio: AudioConfig;
+    operator: {
+        rate: number;
+        timeout: number;
+        assignmentStrategy: 'random';
+    };
+    terminal: {
+        background: TerminalBackgroundConfig;
+    };
+    characters: Record<string, Partial<BaseCharacterConfig> & {
+        speakerId?: string;
+        disabled?: boolean;
+    }>;
+}
+type UserConfig = Partial<Config>;
+declare const DEFAULT_CONFIG: {
+    readonly connection: {
+        readonly host: "localhost";
+        readonly port: "50032";
+    };
+    readonly operator: {
+        readonly rate: 200;
+        readonly timeout: 14400000;
+        readonly assignmentStrategy: "random";
+    };
+    readonly terminal: {
+        readonly background: {
+            readonly enabled: true;
+            readonly operatorImage: {
+                readonly display: "api";
+                readonly position: "bottom-right";
+                readonly opacity: 0.3;
+            };
+        };
+    };
+};
+interface MergedConfig {
+    characters: Record<string, CharacterConfig>;
+    operatorTimeout: number;
+    characterSettings: {
+        assignmentStrategy: 'random';
+    };
+}
+export declare class ConfigManager {
+    private configDir;
+    private configFile;
+    private mergedConfig;
+    private speakerProvider;
+    constructor(configDir: string);
+    /**
+     * JSONファイルを安全に読み込み
+     */
+    readJsonFile<T>(filePath: string, defaultValue: T): Promise<T>;
+    /**
+     * JSONファイルを安全に書き込み
+     */
+    writeJsonFile(filePath: string, data: unknown): Promise<void>;
+    /**
+     * 統一設定ファイルを読み込み
+     */
+    loadConfig(): Promise<UserConfig>;
+    /**
+     * 接続設定を更新して音声プロバイダを再設定
+     */
+    private updateVoiceProviderConnection;
+    /**
+     * 動的設定を構築してマージ
+     */
+    buildDynamicConfig(): Promise<void>;
+    /**
+     * マージ済み設定を取得
+     */
+    getMergedConfig(): MergedConfig | null;
+    /**
+     * キャラクター設定を取得
+     */
+    getCharacterConfig(characterId: string): Promise<CharacterConfig | null>;
+    /**
+     * 利用可能なキャラクターIDを取得
+     */
+    getAvailableCharacterIds(): Promise<string[]>;
+    /**
+     * オペレータのタイムアウト時間を取得
+     */
+    getOperatorTimeout(): Promise<number>;
+    /**
+     * 設定ディレクトリの存在確認と作成
+     */
+    ensureConfigDir(): Promise<void>;
+    /**
+     * 話速（rate）を取得
+     */
+    getRate(): Promise<number>;
+    /**
+     * ターミナル背景設定を取得
+     */
+    getTerminalBackgroundConfig(): Promise<TerminalBackgroundConfig>;
+    /**
+     * 接続設定を取得
+     */
+    getConnectionConfig(): Promise<{
+        host: string;
+        port: string;
+    }>;
+    /**
+     * 音声設定を取得
+     */
+    getAudioConfig(): Promise<AudioConfig>;
+    /**
+     * オペレータ設定を取得
+     */
+    getOperatorConfig(): Promise<typeof DEFAULT_CONFIG.operator>;
+    /**
+     * 完全なConfig型を取得（SayCoeiroink用）
+     */
+    getFullConfig(): Promise<FullConfig>;
+}
+export default ConfigManager;
+//# sourceMappingURL=config-manager.d.ts.map

package/dist/operator/config-manager.js

@@ -0,0 +1,232 @@
+/**
+ * src/operator/config-manager.ts: 設定管理システム
+ * 動的音声フォント取得、設定マージ、キャッシュ管理を担当
+ */
+import { readFile, writeFile, mkdir, access } from 'fs/promises';
+import { constants } from 'fs';
+import { join } from 'path';
+import { BUILTIN_CHARACTER_CONFIGS, } from './character-defaults.js';
+import { getSpeakerProvider } from '../environment/speaker-provider.js';
+import { deepMerge } from '@coeiro-operator/common';
+// デフォルト設定の定義（必須フィールドのみ）
+const DEFAULT_CONFIG = {
+    connection: {
+        host: 'localhost',
+        port: '50032',
+    },
+    operator: {
+        rate: 200,
+        timeout: 14400000, // 4時間
+        assignmentStrategy: 'random',
+    },
+    terminal: {
+        background: {
+            enabled: true,
+            operatorImage: {
+                display: 'api',
+                position: 'bottom-right',
+                opacity: 0.3,
+            },
+        },
+    },
+    // audio と characters はオプショナルなので、実装で必要に応じて設定
+};
+export class ConfigManager {
+    configDir;
+    configFile;
+    mergedConfig = null;
+    speakerProvider = getSpeakerProvider();
+    constructor(configDir) {
+        this.configDir = configDir;
+        this.configFile = join(configDir, 'config.json');
+    }
+    /**
+     * JSONファイルを安全に読み込み
+     */
+    async readJsonFile(filePath, defaultValue) {
+        try {
+            await access(filePath, constants.F_OK);
+            const content = await readFile(filePath, 'utf8');
+            return JSON.parse(content);
+        }
+        catch {
+            return defaultValue;
+        }
+    }
+    /**
+     * JSONファイルを安全に書き込み
+     */
+    async writeJsonFile(filePath, data) {
+        const tempFile = `${filePath}.tmp`;
+        await writeFile(tempFile, JSON.stringify(data, null, 2), 'utf8');
+        try {
+            const fs = await import('fs');
+            await fs.promises.rename(tempFile, filePath);
+        }
+        catch (error) {
+            console.error(`設定ファイル書き込みエラー: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * 統一設定ファイルを読み込み
+     */
+    async loadConfig() {
+        return await this.readJsonFile(this.configFile, {});
+    }
+    /**
+     * 接続設定を更新して音声プロバイダを再設定
+     */
+    async updateVoiceProviderConnection() {
+        try {
+            const connectionConfig = await this.getConnectionConfig();
+            this.speakerProvider.updateConnection(connectionConfig);
+        }
+        catch (error) {
+            console.error(`接続設定更新エラー: ${error.message}`);
+        }
+    }
+    /**
+     * 動的設定を構築してマージ
+     */
+    async buildDynamicConfig() {
+        await this.updateVoiceProviderConnection();
+        const config = await this.loadConfig();
+        try {
+            const speakers = await this.speakerProvider.getSpeakers();
+            const dynamicCharacters = {};
+            // speakersがundefinedまたは配列でない場合は空の配列として扱う
+            const availableSpeakers = Array.isArray(speakers) ? speakers : [];
+            for (const [characterId, builtinConfig] of Object.entries(BUILTIN_CHARACTER_CONFIGS)) {
+                // speakerIdでCOEIROINKのSpeakerとマッチング
+                const speaker = availableSpeakers.find(s => s.speakerUuid === builtinConfig.speakerId);
+                if (!speaker)
+                    continue; // 利用可能なspeakerがない場合はスキップ
+                // ユーザー設定はcharacterIdで管理
+                const userCharacterConfig = config.characters?.[characterId] || {};
+                if (userCharacterConfig.disabled)
+                    continue;
+                // 利用可能なスタイル一覧を追加
+                const availableStyles = speaker.styles?.map(s => s.styleName) || [];
+                dynamicCharacters[characterId] = {
+                    ...builtinConfig,
+                    availableStyles,
+                    ...userCharacterConfig,
+                };
+            }
+            const operatorConfig = await this.getOperatorConfig();
+            this.mergedConfig = {
+                characters: dynamicCharacters,
+                operatorTimeout: operatorConfig.timeout,
+                characterSettings: {
+                    assignmentStrategy: operatorConfig.assignmentStrategy,
+                },
+            };
+        }
+        catch (error) {
+            console.error(`動的設定構築エラー:`, error);
+            // サーバーから取得できなかった場合は空の設定を使用
+            const staticCharacters = {};
+            this.mergedConfig = {
+                characters: staticCharacters,
+                operatorTimeout: config.operator?.timeout || 14400000,
+                characterSettings: {
+                    assignmentStrategy: config.operator?.assignmentStrategy || 'random',
+                },
+            };
+        }
+    }
+    /**
+     * マージ済み設定を取得
+     */
+    getMergedConfig() {
+        return this.mergedConfig;
+    }
+    /**
+     * キャラクター設定を取得
+     */
+    async getCharacterConfig(characterId) {
+        if (!this.mergedConfig) {
+            await this.buildDynamicConfig();
+        }
+        return this.mergedConfig?.characters[characterId] || null;
+    }
+    /**
+     * 利用可能なキャラクターIDを取得
+     */
+    async getAvailableCharacterIds() {
+        if (!this.mergedConfig) {
+            await this.buildDynamicConfig();
+        }
+        return Object.keys(this.mergedConfig?.characters || {});
+    }
+    /**
+     * オペレータのタイムアウト時間を取得
+     */
+    async getOperatorTimeout() {
+        const operatorConfig = await this.getOperatorConfig();
+        return operatorConfig.timeout;
+    }
+    /**
+     * 設定ディレクトリの存在確認と作成
+     */
+    async ensureConfigDir() {
+        try {
+            await mkdir(this.configDir, { recursive: true });
+        }
+        catch (error) {
+            console.error(`設定ディレクトリ作成エラー: ${error.message}`);
+        }
+    }
+    /**
+     * 話速（rate）を取得
+     */
+    async getRate() {
+        const operatorConfig = await this.getOperatorConfig();
+        return operatorConfig.rate;
+    }
+    /**
+     * ターミナル背景設定を取得
+     */
+    async getTerminalBackgroundConfig() {
+        const config = await this.loadConfig();
+        return deepMerge(DEFAULT_CONFIG.terminal.background, config.terminal?.background);
+    }
+    /**
+     * 接続設定を取得
+     */
+    async getConnectionConfig() {
+        const config = await this.loadConfig();
+        return deepMerge(DEFAULT_CONFIG.connection, config.connection);
+    }
+    /**
+     * 音声設定を取得
+     */
+    async getAudioConfig() {
+        const config = await this.loadConfig();
+        return config.audio || {};
+    }
+    /**
+     * オペレータ設定を取得
+     */
+    async getOperatorConfig() {
+        const config = await this.loadConfig();
+        return deepMerge(DEFAULT_CONFIG.operator, config.operator);
+    }
+    /**
+     * 完全なConfig型を取得（SayCoeiroink用）
+     */
+    async getFullConfig() {
+        if (!this.mergedConfig) {
+            await this.buildDynamicConfig();
+        }
+        return {
+            connection: await this.getConnectionConfig(),
+            audio: await this.getAudioConfig(),
+            operator: await this.getOperatorConfig(),
+            characters: this.mergedConfig?.characters || {},
+        };
+    }
+}
+export default ConfigManager;
+//# sourceMappingURL=config-manager.js.map

package/dist/operator/file-operation-manager.d.ts

@@ -0,0 +1,82 @@
+/**
+ * src/operator/file-operation-manager.ts: 汎用期限付きキーバリューストア
+ * 任意のデータTを期限付きで管理する汎用ファイル操作システム
+ */
+interface StorageEntry<T> {
+    data: T;
+    updated_at: string;
+}
+export interface TimedStorage<T> {
+    storage: Record<string, StorageEntry<T>>;
+}
+export declare class FileOperationManager<T> {
+    private filePath;
+    private key;
+    private timeoutMs;
+    private readonly maxLockRetries;
+    private readonly lockRetryDelay;
+    private readonly lockTimeout;
+    constructor(filePath: string, key: string, timeoutMs?: number);
+    /**
+     * JSONファイルを安全に読み込み
+     */
+    readJsonFile<U>(filePath: string, defaultValue?: U): Promise<U>;
+    /**
+     * JSONファイルを安全に書き込み（アトミック操作）
+     */
+    writeJsonFile<U = unknown>(filePath: string, data: U): Promise<void>;
+    /**
+     * ファイルの存在確認
+     */
+    fileExists(filePath: string): Promise<boolean>;
+    /**
+     * ファイルを削除（存在しない場合はエラーを無視）
+     */
+    deleteFile(filePath: string): Promise<void>;
+    /**
+     * ファイルロックを取得してコールバック実行
+     */
+    withFileLock<R>(callback: () => Promise<R>): Promise<R>;
+    /**
+     * ストレージの読み取り
+     */
+    private read;
+    /**
+     * ストレージの書き込み
+     */
+    private write;
+    /**
+     * 期限切れエントリのクリーンアップ
+     */
+    private cleanupExpired;
+    /**
+     * ロック付きで操作を実行
+     */
+    private withLock;
+    /**
+     * データの保存（期限付き）
+     */
+    store(data: T): Promise<void>;
+    /**
+     * データの復元
+     */
+    restore(): Promise<T | null>;
+    /**
+     * 期限の更新（現在時刻に延長）
+     */
+    refresh(): Promise<boolean>;
+    /**
+     * 自分以外の全データを取得
+     */
+    getOtherEntries(): Promise<Record<string, T>>;
+    /**
+     * 現在のキーのエントリを削除
+     */
+    remove(): Promise<boolean>;
+    /**
+     * 全データをクリア
+     */
+    clear(): Promise<void>;
+}
+export default FileOperationManager;
+//# sourceMappingURL=file-operation-manager.d.ts.map

package/dist/operator/file-operation-manager.js

@@ -0,0 +1,230 @@
+/**
+ * src/operator/file-operation-manager.ts: 汎用期限付きキーバリューストア
+ * 任意のデータTを期限付きで管理する汎用ファイル操作システム
+ */
+import { readFile, writeFile, stat, unlink, rename, access } from 'fs/promises';
+import { constants } from 'fs';
+export class FileOperationManager {
+    filePath;
+    key;
+    timeoutMs;
+    // ファイルロック設定
+    maxLockRetries = 50;
+    lockRetryDelay = 20; // ms
+    lockTimeout = 2000; // ms
+    constructor(filePath, key, timeoutMs = 4 * 60 * 60 * 1000 // デフォルト4時間
+    ) {
+        this.filePath = filePath;
+        this.key = key;
+        this.timeoutMs = timeoutMs;
+    }
+    /**
+     * JSONファイルを安全に読み込み
+     */
+    async readJsonFile(filePath, defaultValue = {}) {
+        try {
+            await access(filePath, constants.F_OK);
+            const content = await readFile(filePath, 'utf8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            console.error(`ファイル読み込みエラー: ${filePath}, ${error.message}`);
+            return defaultValue;
+        }
+    }
+    /**
+     * JSONファイルを安全に書き込み（アトミック操作）
+     */
+    async writeJsonFile(filePath, data) {
+        const tempFile = `${filePath}.tmp`;
+        await writeFile(tempFile, JSON.stringify(data, null, 2), 'utf8');
+        // ファイルが存在する場合のみ削除を試行
+        try {
+            await access(filePath, constants.F_OK);
+            await unlink(filePath);
+        }
+        catch {
+            // ファイルが存在しない場合は何もしない
+        }
+        await rename(tempFile, filePath);
+    }
+    /**
+     * ファイルの存在確認
+     */
+    async fileExists(filePath) {
+        try {
+            await access(filePath, constants.F_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * ファイルを削除（存在しない場合はエラーを無視）
+     */
+    async deleteFile(filePath) {
+        try {
+            await unlink(filePath);
+        }
+        catch {
+            // ファイルが存在しない場合は無視
+        }
+    }
+    /**
+     * ファイルロックを取得してコールバック実行
+     */
+    async withFileLock(callback) {
+        const lockFile = `${this.filePath}.lock`;
+        for (let i = 0; i < this.maxLockRetries; i++) {
+            try {
+                // 古いロックファイルのクリーンアップ（タイムアウト処理）
+                try {
+                    const stats = await stat(lockFile);
+                    const lockAge = Date.now() - stats.mtime.getTime();
+                    if (lockAge > this.lockTimeout) {
+                        console.warn(`Removing stale lock file: ${lockFile} (age: ${lockAge}ms)`);
+                        await this.deleteFile(lockFile);
+                    }
+                }
+                catch {
+                    // ロックファイルが存在しない場合は正常
+                }
+                // ロックファイル作成（排他的）
+                await writeFile(lockFile, process.pid.toString(), { flag: 'wx' });
+                try {
+                    // コールバック実行
+                    const result = await callback();
+                    return result;
+                }
+                finally {
+                    // ロック解除
+                    await this.deleteFile(lockFile);
+                }
+            }
+            catch (error) {
+                if (error.code === 'EEXIST') {
+                    // ロック競合 - 指数バックオフでリトライ
+                    const backoffDelay = this.lockRetryDelay * Math.min(Math.pow(1.5, i), 10);
+                    await new Promise(resolve => setTimeout(resolve, backoffDelay + Math.random() * 10));
+                    continue;
+                }
+                throw error;
+            }
+        }
+        throw new Error(`Failed to acquire file lock after ${this.maxLockRetries} retries: ${this.filePath}`);
+    }
+    /**
+     * ストレージの読み取り
+     */
+    async read(defaultValue) {
+        return this.readJsonFile(this.filePath, defaultValue);
+    }
+    /**
+     * ストレージの書き込み
+     */
+    async write(data) {
+        await this.writeJsonFile(this.filePath, data);
+    }
+    /**
+     * 期限切れエントリのクリーンアップ
+     */
+    cleanupExpired(state) {
+        const now = Date.now();
+        const validStorage = {};
+        for (const [k, entry] of Object.entries(state.storage)) {
+            const age = now - new Date(entry.updated_at).getTime();
+            if (age <= this.timeoutMs) {
+                validStorage[k] = entry;
+            }
+        }
+        return { storage: validStorage };
+    }
+    /**
+     * ロック付きで操作を実行
+     */
+    async withLock(callback) {
+        return this.withFileLock(async () => {
+            const state = await this.read({ storage: {} });
+            return callback(state);
+        });
+    }
+    /**
+     * データの保存（期限付き）
+     */
+    async store(data) {
+        await this.withLock(async (state) => {
+            const cleaned = this.cleanupExpired(state);
+            cleaned.storage[this.key] = {
+                data,
+                updated_at: new Date().toISOString(),
+            };
+            await this.write(cleaned);
+        });
+    }
+    /**
+     * データの復元
+     */
+    async restore() {
+        return this.withLock(async (state) => {
+            const cleaned = this.cleanupExpired(state);
+            await this.write(cleaned);
+            const entry = cleaned.storage[this.key];
+            return entry ? entry.data : null;
+        });
+    }
+    /**
+     * 期限の更新（現在時刻に延長）
+     */
+    async refresh() {
+        return this.withLock(async (state) => {
+            const cleaned = this.cleanupExpired(state);
+            const entry = cleaned.storage[this.key];
+            if (entry) {
+                entry.updated_at = new Date().toISOString();
+                await this.write(cleaned);
+                return true;
+            }
+            await this.write(cleaned);
+            return false;
+        });
+    }
+    /**
+     * 自分以外の全データを取得
+     */
+    async getOtherEntries() {
+        return this.withLock(async (state) => {
+            const cleaned = this.cleanupExpired(state);
+            await this.write(cleaned);
+            const result = {};
+            for (const [k, entry] of Object.entries(cleaned.storage)) {
+                if (k !== this.key) {
+                    result[k] = entry.data;
+                }
+            }
+            return result;
+        });
+    }
+    /**
+     * 現在のキーのエントリを削除
+     */
+    async remove() {
+        return this.withLock(async (state) => {
+            const cleaned = this.cleanupExpired(state);
+            const existed = !!cleaned.storage[this.key];
+            delete cleaned.storage[this.key];
+            await this.write(cleaned);
+            return existed;
+        });
+    }
+    /**
+     * 全データをクリア
+     */
+    async clear() {
+        await this.withLock(async () => {
+            await this.write({ storage: {} });
+        });
+    }
+}
+export default FileOperationManager;
+//# sourceMappingURL=file-operation-manager.js.map