@coeiro-operator/core 1.0.0

package/dist/operator/index.d.ts

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+/**
+ * src/operator/index.ts: オペレータ管理システム（TypeScript実装）
+ * キャラクター:スタイル単位での管理とMCP情報提供に対応
+ */
+import { Character, Style } from './character-info-service.js';
+interface CharacterSession {
+    characterId: string;
+    styleId?: number;
+    styleName?: string;
+}
+interface AssignResult {
+    characterId: string;
+    characterName: string;
+    currentStyle: {
+        styleId: string;
+        styleName: string;
+        personality: string;
+        speakingStyle: string;
+    };
+    speakerConfig: {
+        speakerId: string;
+        styleId: number;
+    };
+    greeting?: string;
+    message?: string;
+}
+interface ReleaseResult {
+    characterId?: string;
+    characterName?: string;
+    farewell?: string;
+    wasAssigned: boolean;
+}
+interface StatusResult {
+    characterId?: string;
+    characterName?: string;
+    currentStyle?: {
+        styleId: string;
+        styleName: string;
+        personality: string;
+        speakingStyle: string;
+    };
+    message: string;
+}
+export declare class OperatorManager {
+    private sessionId;
+    private configDir;
+    private coeiroinkConfigFile;
+    private configManager;
+    private dataStore;
+    private characterInfoService;
+    constructor();
+    initialize(): Promise<void>;
+    /**
+     * 設定の事前構築（外部からの呼び出し用）
+     */
+    buildDynamicConfig(): Promise<void>;
+    /**
+     * キャラクター情報を取得
+     */
+    getCharacterInfo(characterId: string): Promise<Character | null>;
+    /**
+     * スタイルを選択
+     * @param character キャラクター情報
+     * @param specifiedStyle 指定されたスタイル名
+     */
+    selectStyle(character: Character, specifiedStyle?: string | null): Style;
+    /**
+     * 利用可能なオペレータを取得（仕事中のオペレータ情報も含む）
+     */
+    getAvailableOperators(): Promise<{
+        available: string[];
+        busy: string[];
+    }>;
+    /**
+     * オペレータを予約
+     */
+    reserveOperator(characterId: string, styleId?: number, styleName?: string): Promise<boolean>;
+    /**
+     * オペレータを返却
+     * オペレータが割り当てられていない場合も正常として扱う（時間切れ自動解放のケースがあるため）
+     */
+    releaseOperator(): Promise<ReleaseResult>;
+    /**
+     * 全ての利用状況をクリア
+     */
+    clearAllOperators(): Promise<boolean>;
+    /**
+     * 現在のセッションに割り当てられたオペレータIDを取得
+     */
+    getCurrentOperatorId(): Promise<string | null>;
+    /**
+     * 現在のセッション情報を取得
+     */
+    getCurrentOperatorSession(): Promise<CharacterSession | null>;
+    /**
+     * 現在のセッションのオペレータが有効かチェック
+     */
+    validateCurrentOperatorSession(): Promise<boolean>;
+    /**
+     * 指定されたキャラクターが利用中かチェック（全セッション対象）
+     */
+    isOperatorBusy(characterId: string): Promise<boolean>;
+    /**
+     * 現在のオペレータをサイレントで解放
+     */
+    silentReleaseCurrentOperator(): Promise<string | null>;
+    /**
+     * ランダムオペレータ選択と詳細情報付きアサイン
+     */
+    assignRandomOperator(style?: string | null): Promise<AssignResult>;
+    /**
+     * 指定されたオペレータを詳細情報付きでアサイン
+     */
+    assignSpecificOperator(specifiedCharacter: string, style?: string | null): Promise<AssignResult>;
+    /**
+     * 現在のオペレータ情報表示
+     * 仕様書準拠: getCurrentOperatorId()の自動時間切れ処理に依存し、統一された検証ロジックを実装
+     */
+    showCurrentOperator(): Promise<StatusResult>;
+    /**
+     * オペレータ予約のタイムアウトを延長
+     * Issue #58: sayコマンド実行時の動的タイムアウト延長
+     */
+    refreshOperatorReservation(): Promise<boolean>;
+}
+export default OperatorManager;
+//# sourceMappingURL=index.d.ts.map

package/dist/operator/index.js

@@ -0,0 +1,353 @@
+#!/usr/bin/env node
+/**
+ * src/operator/index.ts: オペレータ管理システム（TypeScript実装）
+ * キャラクター:スタイル単位での管理とMCP情報提供に対応
+ */
+import { join } from 'path';
+import ConfigManager from './config-manager.js';
+import FileOperationManager from './file-operation-manager.js';
+import { hostname } from 'os';
+import CharacterInfoService from './character-info-service.js';
+import { getConfigDir } from '../common/config-paths.js';
+/**
+ * セッションIDを取得
+ */
+function getSessionId() {
+    if (process.env.ITERM_SESSION_ID) {
+        return process.env.ITERM_SESSION_ID.replace(/[:-]/g, '_');
+    }
+    else if (process.env.TERM_SESSION_ID) {
+        return process.env.TERM_SESSION_ID.replace(/[:-]/g, '_');
+    }
+    else {
+        return process.ppid.toString();
+    }
+}
+export class OperatorManager {
+    sessionId;
+    configDir = null;
+    coeiroinkConfigFile = null;
+    configManager = null;
+    dataStore;
+    characterInfoService;
+    constructor() {
+        this.sessionId = getSessionId();
+        // ファイルパス生成（tmpディレクトリ）
+        const hostnameClean = hostname().replace(/[^a-zA-Z0-9]/g, '_');
+        const filePath = `/tmp/coeiroink-operators-${hostnameClean}.json`;
+        // デフォルト4時間のタイムアウトでFileOperationManagerを初期化
+        this.dataStore = new FileOperationManager(filePath, this.sessionId);
+        this.characterInfoService = new CharacterInfoService();
+    }
+    async initialize() {
+        this.configDir = await getConfigDir();
+        this.coeiroinkConfigFile = join(this.configDir, 'coeiroink-config.json');
+        // 設定管理システムを初期化
+        this.configManager = new ConfigManager(this.configDir);
+        // ConfigManagerの動的設定を事前にビルドして初期化を完了
+        try {
+            await this.configManager.buildDynamicConfig();
+        }
+        catch (error) {
+            console.warn(`OperatorManager dynamic config build failed:`, error.message);
+        }
+        // dataStoreを初期化（設定からタイムアウト取得）
+        try {
+            const timeoutMs = await this.configManager.getOperatorTimeout();
+            const hostnameClean = hostname().replace(/[^a-zA-Z0-9]/g, '_');
+            const filePath = `/tmp/coeiroink-operators-${hostnameClean}.json`;
+            this.dataStore = new FileOperationManager(filePath, this.sessionId, timeoutMs);
+        }
+        catch (error) {
+            console.warn('OperatorManager initialization warning:', error.message);
+            // 初期化に失敗してもデフォルト設定で続行
+        }
+        // CharacterInfoServiceを初期化
+        this.characterInfoService.initialize(this.configManager, this.coeiroinkConfigFile);
+    }
+    /**
+     * 設定の事前構築（外部からの呼び出し用）
+     */
+    async buildDynamicConfig() {
+        if (!this.configManager) {
+            throw new Error('ConfigManager is not initialized');
+        }
+        try {
+            await this.configManager.buildDynamicConfig();
+        }
+        catch (error) {
+            console.error(`OperatorManager buildDynamicConfig failed:`, error.message);
+            throw error;
+        }
+    }
+    /**
+     * キャラクター情報を取得
+     */
+    async getCharacterInfo(characterId) {
+        return await this.characterInfoService.getCharacterInfo(characterId);
+    }
+    /**
+     * スタイルを選択
+     * @param character キャラクター情報
+     * @param specifiedStyle 指定されたスタイル名
+     */
+    selectStyle(character, specifiedStyle = null) {
+        return this.characterInfoService.selectStyle(character, specifiedStyle);
+    }
+    /**
+     * 利用可能なオペレータを取得（仕事中のオペレータ情報も含む）
+     */
+    async getAvailableOperators() {
+        if (!this.configManager) {
+            throw new Error('State manager is not initialized');
+        }
+        const allOperators = await this.configManager.getAvailableCharacterIds();
+        const otherAssignments = await this.dataStore.getOtherEntries();
+        const busyCharacters = otherAssignments
+            ? Object.values(otherAssignments).map(session => session.characterId)
+            : [];
+        const availableCharacters = allOperators.filter(op => !busyCharacters.includes(op));
+        return {
+            available: availableCharacters,
+            busy: busyCharacters,
+        };
+    }
+    /**
+     * オペレータを予約
+     */
+    async reserveOperator(characterId, styleId, styleName) {
+        try {
+            await this.dataStore.store({ characterId, styleId, styleName });
+            return true;
+        }
+        catch (error) {
+            throw new Error(`オペレータ ${characterId} の予約に失敗しました: ${error.message}`);
+        }
+    }
+    /**
+     * オペレータを返却
+     * オペレータが割り当てられていない場合も正常として扱う（時間切れ自動解放のケースがあるため）
+     */
+    async releaseOperator() {
+        const operatorSession = await this.getCurrentOperatorSession();
+        if (!operatorSession) {
+            // オペレータが割り当てられていない場合も正常として扱う
+            return {
+                wasAssigned: false,
+            };
+        }
+        const characterId = operatorSession.characterId;
+        await this.dataStore.remove();
+        // お別れの挨拶情報を取得
+        let character = null;
+        try {
+            character = await this.characterInfoService.getCharacterInfo(characterId);
+            if (!character) {
+                character = null;
+            }
+        }
+        catch {
+            character = null;
+        }
+        return {
+            characterId,
+            characterName: character?.speaker?.speakerName || characterId,
+            farewell: character?.farewell || '',
+            wasAssigned: true,
+        };
+    }
+    /**
+     * 全ての利用状況をクリア
+     */
+    async clearAllOperators() {
+        await this.dataStore.clear();
+        return true;
+    }
+    /**
+     * 現在のセッションに割り当てられたオペレータIDを取得
+     */
+    async getCurrentOperatorId() {
+        const session = await this.dataStore.restore();
+        return session ? session.characterId : null;
+    }
+    /**
+     * 現在のセッション情報を取得
+     */
+    async getCurrentOperatorSession() {
+        return this.dataStore.restore();
+    }
+    /**
+     * 現在のセッションのオペレータが有効かチェック
+     */
+    async validateCurrentOperatorSession() {
+        const currentOperatorId = await this.getCurrentOperatorId();
+        return currentOperatorId !== null;
+    }
+    /**
+     * 指定されたキャラクターが利用中かチェック（全セッション対象）
+     */
+    async isOperatorBusy(characterId) {
+        const result = await this.getAvailableOperators();
+        return !result.available.includes(characterId);
+    }
+    /**
+     * 現在のオペレータをサイレントで解放
+     */
+    async silentReleaseCurrentOperator() {
+        try {
+            const currentSession = await this.getCurrentOperatorSession();
+            if (!currentSession) {
+                return null;
+            }
+            await this.dataStore.remove();
+            return currentSession.characterId;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * ランダムオペレータ選択と詳細情報付きアサイン
+     */
+    async assignRandomOperator(style = null) {
+        const result = await this.getAvailableOperators();
+        if (result.available.length === 0) {
+            throw new Error('利用可能なオペレータがありません');
+        }
+        // ランダム選択
+        const selectedCharacter = result.available[Math.floor(Math.random() * result.available.length)];
+        return await this.assignSpecificOperator(selectedCharacter, style);
+    }
+    /**
+     * 指定されたオペレータを詳細情報付きでアサイン
+     */
+    async assignSpecificOperator(specifiedCharacter, style = null) {
+        if (!specifiedCharacter) {
+            throw new Error('キャラクターIDを指定してください');
+        }
+        if (!this.configManager) {
+            throw new Error('Manager is not initialized');
+        }
+        // キャラクター情報を取得
+        const character = await this.characterInfoService.getOperatorCharacterInfo(specifiedCharacter);
+        if (!character) {
+            throw new Error(`オペレータ '${specifiedCharacter}' は存在しないか無効です`);
+        }
+        // 既存のオペレータがいる場合は自動的にリリース（交代処理）
+        const currentCharacterId = await this.getCurrentOperatorId();
+        if (currentCharacterId) {
+            // 同じキャラクターが指定された場合は何もしない
+            if (currentCharacterId === specifiedCharacter) {
+                const selectedStyle = this.characterInfoService.selectStyle(character, style);
+                return {
+                    characterId: specifiedCharacter,
+                    characterName: character.speaker?.speakerName || character.characterId,
+                    currentStyle: {
+                        styleId: selectedStyle.styleId.toString(),
+                        styleName: selectedStyle.styleName,
+                        personality: character.personality,
+                        speakingStyle: character.speakingStyle,
+                    },
+                    speakerConfig: {
+                        speakerId: character.speaker?.speakerId || '',
+                        styleId: selectedStyle.styleId,
+                    },
+                    message: `現在のオペレータ: ${character.speaker?.speakerName || character.characterId} (${specifiedCharacter})`,
+                };
+            }
+            // 現在のオペレータをサイレントリリース
+            await this.silentReleaseCurrentOperator();
+        }
+        // 仕様書準拠: 統一された時間切れクリーンアップ付きで他セッション利用状況をチェック
+        if (await this.isOperatorBusy(specifiedCharacter)) {
+            throw new Error(`オペレータ '${specifiedCharacter}' は既に他のセッションで利用中です`);
+        }
+        // スタイルを選択
+        const selectedStyle = this.characterInfoService.selectStyle(character, style);
+        // キャラクターを予約（スタイル情報も含めて）
+        await this.reserveOperator(specifiedCharacter, selectedStyle.styleId, selectedStyle.styleName);
+        return {
+            characterId: specifiedCharacter,
+            characterName: character.speaker?.speakerName || character.characterId,
+            currentStyle: {
+                styleId: selectedStyle.styleId.toString(),
+                styleName: selectedStyle.styleName,
+                personality: character.personality,
+                speakingStyle: character.speakingStyle,
+            },
+            speakerConfig: {
+                speakerId: character.speaker?.speakerId || '',
+                styleId: selectedStyle.styleId,
+            },
+            greeting: character.greeting || '',
+        };
+    }
+    /**
+     * 現在のオペレータ情報表示
+     * 仕様書準拠: getCurrentOperatorId()の自動時間切れ処理に依存し、統一された検証ロジックを実装
+     */
+    async showCurrentOperator() {
+        if (!this.configManager) {
+            throw new Error('Manager is not initialized');
+        }
+        // 仕様書準拠: getCurrentOperatorSession()が時間切れチェックと自動解放を実行
+        const operatorSession = await this.getCurrentOperatorSession();
+        if (!operatorSession) {
+            return {
+                message: 'オペレータは割り当てられていません',
+            };
+        }
+        const { characterId, styleId, styleName } = operatorSession;
+        let character;
+        try {
+            character = await this.characterInfoService.getCharacterInfo(characterId);
+            if (!character) {
+                return {
+                    characterId,
+                    message: `現在のオペレータ: ${characterId} (キャラクター情報なし)`,
+                };
+            }
+        }
+        catch {
+            return {
+                characterId,
+                message: `現在のオペレータ: ${characterId} (キャラクター情報なし)`,
+            };
+        }
+        // 保存されたスタイル情報を使用するか、デフォルトを選択
+        let selectedStyle;
+        if (styleId !== undefined && styleName) {
+            // 保存されたスタイルを検索
+            const styles = character.speaker?.styles || [];
+            selectedStyle =
+                styles.find(s => s.styleId === styleId) || this.characterInfoService.selectStyle(character);
+        }
+        else {
+            selectedStyle = this.characterInfoService.selectStyle(character);
+        }
+        return {
+            characterId,
+            characterName: character.speaker?.speakerName || character.characterId,
+            currentStyle: {
+                styleId: selectedStyle.styleId.toString(),
+                styleName: selectedStyle.styleName,
+                personality: character.personality,
+                speakingStyle: character.speakingStyle,
+            },
+            message: `現在のオペレータ: ${character.speaker?.speakerName || character.characterId} (${characterId}) - ${selectedStyle.styleName}`,
+        };
+    }
+    /**
+     * オペレータ予約のタイムアウトを延長
+     * Issue #58: sayコマンド実行時の動的タイムアウト延長
+     */
+    async refreshOperatorReservation() {
+        const operatorSession = await this.getCurrentOperatorSession();
+        if (!operatorSession) {
+            return false; // オペレータが割り当てられていない
+        }
+        return this.dataStore.refresh();
+    }
+}
+export default OperatorManager;
+//# sourceMappingURL=index.js.map

package/dist/terminal/terminal-background.d.ts

@@ -0,0 +1,37 @@
+import { ConfigManager } from '../operator/config-manager.js';
+export declare class TerminalBackground {
+    private currentCharacterId;
+    private configManager;
+    private termBg;
+    private sessionId;
+    constructor(configManager: ConfigManager, sessionId?: string);
+    /**
+     * セッションIDを取得（OperatorManagerと同じロジック）
+     */
+    private getSessionId;
+    /**
+     * 背景画像が有効かチェック
+     */
+    isEnabled(): Promise<boolean>;
+    /**
+     * キャラクター切り替え時の背景更新
+     */
+    switchCharacter(characterId: string): Promise<void>;
+    /**
+     * 背景画像を設定
+     */
+    private setBackgroundImage;
+    /**
+     * APIからオペレータ画像を取得
+     */
+    private fetchOperatorImageFromAPI;
+    /**
+     * 背景をクリア
+     */
+    clearBackground(): Promise<void>;
+    /**
+     * 現在のキャラクターID取得
+     */
+    getCurrentCharacter(): string | null;
+}
+//# sourceMappingURL=terminal-background.d.ts.map