@su-record/vibe 2.7.11 → 2.7.12

package/dist/daemon/InterfaceManager.js

@@ -1,785 +0,0 @@
-/**
- * InterfaceManager - Auto-start enabled interfaces on daemon boot
- *
- * Reads ~/.vibe/interfaces.json and starts enabled interfaces (slack, telegram, etc.)
- * Environment variables provide credentials; interfaces.json controls enabled state.
- */
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as os from 'node:os';
-const VIBE_DIR = path.join(os.homedir(), '.vibe');
-const INTERFACE_CONFIG = path.join(VIBE_DIR, 'interfaces.json');
-const TELEGRAM_CONFIG = path.join(VIBE_DIR, 'telegram.json');
-const SLACK_CONFIG = path.join(VIBE_DIR, 'slack.json');
-/** Time-aware greeting message */
-function getGreeting() {
-    const hour = new Date().getHours();
-    if (hour < 6)
-        return '늦은 밤이에요, 무엇을 도와드릴까요?';
-    if (hour < 12)
-        return '좋은 아침이에요! 무엇을 도와드릴까요?';
-    if (hour < 18)
-        return '안녕하세요! 무엇을 도와드릴까요?';
-    return '좋은 저녁이에요! 무엇을 도와드릴까요?';
-}
-/** Global config dir for Google Apps token check */
-function getGlobalConfigDir() {
-    return process.platform === 'win32'
-        ? path.join(process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming'), 'vibe')
-        : path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'), 'vibe');
-}
-export class InterfaceManager {
-    interfaces = new Map();
-    logger;
-    sessionPool;
-    /** Pending OAuth auth managers keyed by chatId */
-    pendingOAuth = new Map();
-    constructor(logger) {
-        this.logger = logger;
-    }
-    /** Attach session pool for message routing */
-    setSessionPool(pool) {
-        this.sessionPool = pool;
-    }
-    async startEnabledInterfaces() {
-        const state = this.loadState();
-        const enabledNames = Object.entries(state)
-            .filter(([, v]) => v.enabled)
-            .map(([k]) => k);
-        if (enabledNames.length === 0) {
-            this.logger('info', 'No interfaces enabled, skipping interface startup');
-            return;
-        }
-        this.logger('info', `Starting enabled interfaces: ${enabledNames.join(', ')}`);
-        for (const name of enabledNames) {
-            try {
-                await this.startInterface(name);
-            }
-            catch (err) {
-                this.logger('error', `Failed to start interface "${name}"`, {
-                    error: err instanceof Error ? err.message : String(err),
-                });
-            }
-        }
-        // Send startup notification to all connected interfaces
-        await this.sendStartupNotification();
-    }
-    async stopAll() {
-        // Stop browser service
-        try {
-            const { shutdownBrowserService } = await import('../tools/browser/index.js');
-            await shutdownBrowserService();
-            this.logger('info', 'Browser service stopped');
-        }
-        catch {
-            // Browser service may not be initialized — ignore
-        }
-        // Stop Google service
-        try {
-            const { shutdownGoogleService } = await import('../tools/google/index.js');
-            shutdownGoogleService();
-            this.logger('info', 'Google service stopped');
-        }
-        catch {
-            // Google service may not be initialized — ignore
-        }
-        // Stop Voice service
-        try {
-            const { shutdownVoiceService } = await import('../tools/voice/index.js');
-            shutdownVoiceService();
-            this.logger('info', 'Voice service stopped');
-        }
-        catch {
-            // Voice service may not be initialized — ignore
-        }
-        // Stop Vision service
-        try {
-            const { shutdownVisionService } = await import('../tools/vision/index.js');
-            shutdownVisionService();
-            this.logger('info', 'Vision service stopped');
-        }
-        catch {
-            // Vision service may not be initialized — ignore
-        }
-        // Stop Sandbox service
-        try {
-            const { shutdownSandboxService } = await import('../tools/sandbox/index.js');
-            await shutdownSandboxService();
-            this.logger('info', 'Sandbox service stopped');
-        }
-        catch {
-            // Sandbox service may not be initialized — ignore
-        }
-        // Stop Integration service
-        try {
-            const { shutdownIntegrationService } = await import('../tools/integration/index.js');
-            await shutdownIntegrationService();
-            this.logger('info', 'Integration service stopped');
-        }
-        catch {
-            // Integration service may not be initialized — ignore
-        }
-        for (const [name, iface] of this.interfaces) {
-            try {
-                await iface.stop();
-                this.logger('info', `Interface "${name}" stopped`);
-            }
-            catch (err) {
-                this.logger('warn', `Error stopping interface "${name}"`, {
-                    error: err instanceof Error ? err.message : String(err),
-                });
-            }
-        }
-        this.interfaces.clear();
-    }
-    getActiveInterfaces() {
-        return Array.from(this.interfaces.entries()).map(([name, iface]) => ({
-            name,
-            status: iface.getStatus(),
-        }));
-    }
-    async startInterface(name) {
-        const ifaceLogger = (level, msg, data) => {
-            this.logger(level, `[${name}] ${msg}`, data);
-        };
-        switch (name) {
-            case 'slack':
-                await this.startSlack(ifaceLogger);
-                break;
-            case 'telegram':
-                await this.startTelegram(ifaceLogger);
-                break;
-            case 'web':
-                await this.startWeb(ifaceLogger);
-                break;
-            default:
-                this.logger('warn', `Interface "${name}" auto-start not supported`);
-        }
-    }
-    /**
-     * Phase 6: Quick Pre-Check — 동기적 O(1) 사전 필터링
-     * - 'skip': 빈 메시지 (텍스트+파일+위치 모두 없음)
-     * - 'busy': 세션 처리 중 → pendingInstructions로 전달
-     * - 'process': 정상 처리 진행
-     */
-    quickPreCheck(message) {
-        const hasContent = (message.content?.trim().length ?? 0) > 0;
-        const hasFiles = Boolean(message.files?.length);
-        const hasLocation = Boolean(message.location);
-        if (!hasContent && !hasFiles && !hasLocation) {
-            return 'skip';
-        }
-        if (this.sessionPool) {
-            const session = this.sessionPool.findSessionByProject(process.cwd());
-            if (session?.status === 'busy') {
-                this.sessionPool.addPendingInstruction(session.id, message.content);
-                return 'busy';
-            }
-        }
-        return 'process';
-    }
-    registerMessageHandler(name, iface) {
-        iface.onMessage(async (message) => {
-            this.logger('info', `[${name}] Message received from ${message.userId}: ${message.content.slice(0, 100)}`);
-            // Log to HUD activity
-            try {
-                const { logHudActivity } = await import('../cli/hud.js');
-                logHudActivity('message_in', message.content, name);
-            }
-            catch { /* ignore if hud unavailable */ }
-            // Intercept OAuth code paste from mobile users
-            if (await this.tryHandleOAuthCode(name, iface, message))
-                return;
-            if (!this.sessionPool) {
-                this.logger('warn', `[${name}] No session pool attached, cannot process message`);
-                await iface.sendResponse({
-                    messageId: message.id,
-                    channel: message.channel,
-                    chatId: message.chatId,
-                    content: 'Vibe 데몬이 메시지를 수신했으나, 세션 풀이 아직 준비되지 않았습니다.',
-                    format: 'text',
-                });
-                return;
-            }
-            // Phase 6: Quick Pre-Check
-            const preCheck = this.quickPreCheck(message);
-            if (preCheck === 'skip') {
-                this.logger('debug', `[${name}] Empty message skipped`);
-                return;
-            }
-            if (preCheck === 'busy') {
-                this.logger('info', `[${name}] Session busy, message queued as pending instruction`);
-                await iface.sendResponse({
-                    messageId: message.id,
-                    channel: message.channel,
-                    chatId: message.chatId,
-                    content: '현재 요청을 처리 중입니다. 메시지가 대기열에 추가되었습니다.',
-                    format: 'text',
-                });
-                return;
-            }
-            // Typing indicator — let user know we're processing
-            await this.sendTypingIndicator(name, iface, message.chatId);
-            // Voice message → STT 전처리
-            let content = message.content;
-            if (message.type === 'voice') {
-                const transcribed = await this.transcribeVoice(name, iface, message);
-                if (!transcribed)
-                    return; // 에러 메시지는 transcribeVoice에서 전송
-                content = transcribed;
-            }
-            try {
-                const session = this.sessionPool.getOrCreateSession(process.cwd());
-                // Keep typing indicator alive during long processing
-                const typingInterval = setInterval(() => {
-                    this.sendTypingIndicator(name, iface, message.chatId);
-                }, 5_000);
-                const result = await this.sessionPool.sendRequest(session.id, content);
-                clearInterval(typingInterval);
-                // Log response to HUD
-                try {
-                    const { logHudActivity } = await import('../cli/hud.js');
-                    logHudActivity('message_out', result.slice(0, 120), name);
-                }
-                catch { /* ignore */ }
-                await iface.sendResponse({
-                    messageId: message.id,
-                    channel: message.channel,
-                    chatId: message.chatId,
-                    content: result,
-                    format: 'markdown',
-                });
-            }
-            catch (err) {
-                this.logger('error', `[${name}] Failed to process message`, {
-                    error: err instanceof Error ? err.message : String(err),
-                });
-                // Log error to HUD
-                try {
-                    const { logHudActivity } = await import('../cli/hud.js');
-                    logHudActivity('error', err instanceof Error ? err.message : String(err), name);
-                }
-                catch { /* ignore */ }
-                await iface.sendResponse({
-                    messageId: message.id,
-                    channel: message.channel,
-                    chatId: message.chatId,
-                    content: '처리 중 오류가 발생했습니다. 잠시 후 다시 시도해주세요.',
-                    format: 'text',
-                });
-            }
-        });
-    }
-    /**
-     * 음성 메시지 → Gemini STT 변환
-     * Telegram file download → 임시 파일 → transcribeAudio → 정리
-     */
-    async transcribeVoice(name, iface, message) {
-        const fileId = message.metadata?.telegramFileId;
-        if (!fileId) {
-            await iface.sendResponse({
-                messageId: message.id,
-                channel: message.channel,
-                chatId: message.chatId,
-                content: '음성 파일 정보가 없습니다.',
-                format: 'text',
-            });
-            return null;
-        }
-        try {
-            // 1. Telegram에서 파일 다운로드
-            const { TelegramBot } = await import('../interface/telegram/TelegramBot.js');
-            if (!(iface instanceof TelegramBot)) {
-                return null;
-            }
-            const audioBuffer = await iface.downloadFile(fileId);
-            const mimeType = message.metadata?.voiceMimeType || 'audio/ogg';
-            const ext = mimeType.includes('ogg') ? '.ogg' : '.mp3';
-            // 2. 임시 파일 저장
-            const tmpDir = path.join(os.tmpdir(), 'vibe-stt');
-            if (!fs.existsSync(tmpDir)) {
-                fs.mkdirSync(tmpDir, { recursive: true });
-            }
-            const tmpFile = path.join(tmpDir, `voice-${Date.now()}${ext}`);
-            fs.writeFileSync(tmpFile, audioBuffer);
-            // 3. Gemini STT 변환
-            const { transcribeAudio } = await import('../infra/lib/gemini/capabilities.js');
-            const result = await transcribeAudio(tmpFile, { language: 'Korean' });
-            // 4. 임시 파일 정리
-            try {
-                fs.unlinkSync(tmpFile);
-            }
-            catch { /* ignore */ }
-            const text = result.transcription?.trim();
-            if (!text) {
-                await iface.sendResponse({
-                    messageId: message.id,
-                    channel: message.channel,
-                    chatId: message.chatId,
-                    content: '음성을 인식하지 못했습니다. 다시 시도해주세요.',
-                    format: 'text',
-                });
-                return null;
-            }
-            // 5. 인식 결과 확인 메시지
-            this.logger('info', `[${name}] Voice transcribed: ${text.slice(0, 100)}`);
-            return text;
-        }
-        catch (err) {
-            this.logger('error', `[${name}] Voice transcription failed`, {
-                error: err instanceof Error ? err.message : String(err),
-            });
-            await iface.sendResponse({
-                messageId: message.id,
-                channel: message.channel,
-                chatId: message.chatId,
-                content: '음성 인식에 실패했습니다. 텍스트로 입력해주세요.',
-                format: 'text',
-            });
-            return null;
-        }
-    }
-    /**
-     * Check if message contains an OAuth authorization code (mobile paste flow)
-     * Returns true if handled (message was an OAuth code)
-     */
-    async tryHandleOAuthCode(name, iface, message) {
-        const content = message.content.trim();
-        // Check if this looks like an OAuth callback URL or code
-        let code = null;
-        // Case 1: Full URL pasted from browser address bar
-        const urlMatch = content.match(/[?&]code=([^&\s]+)/);
-        if (urlMatch) {
-            code = decodeURIComponent(urlMatch[1]);
-        }
-        // Case 2: Raw authorization code (starts with 4/ for Google)
-        if (!code && /^4\/[A-Za-z0-9_-]{20,}/.test(content)) {
-            code = content.split(/\s/)[0];
-        }
-        if (!code)
-            return false;
-        // Check if we have a pending OAuth for this chat
-        const pending = this.pendingOAuth.get(message.chatId);
-        if (!pending) {
-            // No pending auth - might be stale code paste, ignore
-            return false;
-        }
-        this.logger('info', `[${name}] OAuth code received from mobile paste`);
-        clearTimeout(pending.timeout);
-        this.pendingOAuth.delete(message.chatId);
-        try {
-            const { GoogleAuthManager } = await import('../router/services/GoogleAuthManager.js');
-            const manager = pending.manager;
-            await manager.exchangeCode(code);
-            await iface.sendResponse({
-                messageId: `google-auth-done-${Date.now()}`,
-                channel: message.channel,
-                chatId: message.chatId,
-                content: 'Google Apps 연결 완료! (Gmail, Drive, Sheets, Calendar, YouTube)',
-                format: 'text',
-            });
-            try {
-                const { logHudActivity } = await import('../cli/hud.js');
-                logHudActivity('info', 'Google OAuth completed via mobile code paste', name);
-            }
-            catch { /* ignore */ }
-        }
-        catch (err) {
-            await iface.sendResponse({
-                messageId: `google-auth-fail-${Date.now()}`,
-                channel: message.channel,
-                chatId: message.chatId,
-                content: `Google Apps 인증 실패: ${err instanceof Error ? err.message : String(err)}`,
-                format: 'text',
-            });
-        }
-        return true;
-    }
-    /** Send typing indicator to the appropriate interface */
-    async sendTypingIndicator(name, iface, chatId) {
-        try {
-            if (name === 'telegram') {
-                const { TelegramBot } = await import('../interface/telegram/TelegramBot.js');
-                if (iface instanceof TelegramBot) {
-                    await iface.sendChatAction(chatId, 'typing');
-                }
-            }
-            // Slack typing indicator is handled by the Slack API automatically
-        }
-        catch { /* ignore — non-critical */ }
-    }
-    async startSlack(logger) {
-        // Read from env vars first, then config file (vibe slack setup)
-        let botToken = process.env.SLACK_BOT_TOKEN;
-        let appToken = process.env.SLACK_APP_TOKEN;
-        let allowedChannels = (process.env.SLACK_ALLOWED_CHANNELS || '').split(',').filter(Boolean);
-        if (!botToken || !appToken) {
-            try {
-                if (fs.existsSync(SLACK_CONFIG)) {
-                    const config = JSON.parse(fs.readFileSync(SLACK_CONFIG, 'utf-8'));
-                    if (config?.botToken && config?.appToken) {
-                        botToken = config.botToken;
-                        appToken = config.appToken;
-                        if (Array.isArray(config.allowedChannelIds) && config.allowedChannelIds.length > 0) {
-                            allowedChannels = config.allowedChannelIds;
-                        }
-                    }
-                }
-            }
-            catch {
-                // ignore parse errors
-            }
-        }
-        if (!botToken || !appToken) {
-            this.logger('warn', 'Slack: missing tokens (env or ~/.vibe/slack.json), skipping');
-            return;
-        }
-        const { SlackBot } = await import('../interface/slack/SlackBot.js');
-        const slack = new SlackBot({ botToken, appToken, allowedChannelIds: allowedChannels }, logger);
-        await slack.start();
-        this.registerMessageHandler('slack', slack);
-        this.interfaces.set('slack', slack);
-        this.logger('info', 'Slack interface started');
-    }
-    async startTelegram(logger) {
-        // Read from config file first (vibe telegram setup), then env var
-        let botToken = process.env.TELEGRAM_BOT_TOKEN;
-        let allowedChatIds = (process.env.TELEGRAM_ALLOWED_CHAT_IDS || '').split(',').filter(Boolean);
-        if (!botToken) {
-            try {
-                if (fs.existsSync(TELEGRAM_CONFIG)) {
-                    const config = JSON.parse(fs.readFileSync(TELEGRAM_CONFIG, 'utf-8'));
-                    if (config?.botToken) {
-                        botToken = config.botToken;
-                        if (Array.isArray(config.allowedChatIds) && config.allowedChatIds.length > 0) {
-                            allowedChatIds = config.allowedChatIds;
-                        }
-                    }
-                }
-            }
-            catch {
-                // ignore parse errors
-            }
-        }
-        if (!botToken) {
-            this.logger('warn', 'Telegram: missing bot token (env or ~/.vibe/telegram.json), skipping');
-            return;
-        }
-        const { TelegramBot } = await import('../interface/telegram/TelegramBot.js');
-        const telegram = new TelegramBot({ botToken, allowedChatIds }, logger);
-        await telegram.start();
-        this.registerMessageHandler('telegram', telegram);
-        this.interfaces.set('telegram', telegram);
-        this.logger('info', 'Telegram interface started');
-    }
-    async startWeb(logger) {
-        const port = parseInt(process.env.VIBE_WEB_PORT ?? '7860', 10);
-        const host = process.env.VIBE_WEB_HOST ?? '127.0.0.1';
-        // Google OAuth client ID/secret
-        let googleClientId;
-        let googleClientSecret;
-        try {
-            const { getSyncClientId, getSyncClientSecret } = await import('../infra/lib/sync/constants.js');
-            googleClientId = getSyncClientId();
-            googleClientSecret = getSyncClientSecret();
-        }
-        catch {
-            googleClientId = process.env.VIBE_GOOGLE_CLIENT_ID;
-            googleClientSecret = process.env.VIBE_GOOGLE_CLIENT_SECRET;
-        }
-        const authMode = googleClientId ? 'google' : 'local';
-        const { WebServer } = await import('../interface/web/WebServer.js');
-        const web = new WebServer({
-            port,
-            host,
-            authMode,
-            googleClientId,
-            googleClientSecret,
-            corsOrigins: ['http://localhost:*', 'http://127.0.0.1:*'],
-        }, logger);
-        await web.start();
-        this.registerMessageHandler('web', web);
-        this.interfaces.set('web', web);
-        const loginUrl = authMode === 'google'
-            ? ` → Login: http://${host}:${port}/auth/google/login`
-            : ` → Token: ${web.getAuthToken().slice(0, 8)}...`;
-        this.logger('info', `Web interface started on ${host}:${port} (${authMode} auth)${loginUrl}`);
-    }
-    /**
-     * 데몬 시작 시 연결된 인터페이스에 인사말 전송
-     * Google Apps 미인증 시 인라인 버튼으로 인증 요청
-     */
-    async sendStartupNotification() {
-        if (this.interfaces.size === 0) {
-            this.logger('info', 'No interfaces connected, skipping startup notification');
-            return;
-        }
-        const googleAppsOk = fs.existsSync(path.join(getGlobalConfigDir(), 'google-tokens.json'));
-        let googleOAuthReady = false;
-        try {
-            const { isGoogleOAuthConfigured } = await import('../infra/lib/sync/constants.js');
-            googleOAuthReady = isGoogleOAuthConfigured();
-        }
-        catch (err) {
-            this.logger('warn', `Failed to check Google OAuth config: ${err instanceof Error ? err.message : String(err)}`);
-        }
-        this.logger('info', `Startup notification: googleAppsOk=${googleAppsOk}, googleOAuthReady=${googleOAuthReady}`);
-        const telegram = this.interfaces.get('telegram');
-        if (telegram) {
-            try {
-                await this.sendTelegramStartup(telegram, googleAppsOk, googleOAuthReady);
-                this.logger('info', 'Telegram startup notification sent');
-            }
-            catch (err) {
-                this.logger('error', `Telegram startup notification failed: ${err instanceof Error ? err.message : String(err)}`);
-            }
-        }
-        const slack = this.interfaces.get('slack');
-        if (slack) {
-            await this.sendSlackStartup(slack, googleAppsOk, googleOAuthReady);
-        }
-    }
-    async sendTelegramStartup(telegram, googleAppsOk, googleOAuthReady) {
-        const { TelegramBot } = await import('../interface/telegram/TelegramBot.js');
-        if (!(telegram instanceof TelegramBot))
-            return;
-        const chatIds = this.loadTelegramChatIds();
-        const greeting = getGreeting();
-        // Google Apps 연결 완료 또는 OAuth 환경변수 미설정 → 인사말만
-        if (googleAppsOk || !googleOAuthReady) {
-            for (const chatId of chatIds) {
-                try {
-                    await telegram.sendResponse({
-                        messageId: `startup-${Date.now()}`,
-                        channel: 'telegram',
-                        chatId,
-                        content: greeting,
-                        format: 'text',
-                    });
-                }
-                catch { /* ignore */ }
-            }
-            return;
-        }
-        // OAuth 환경변수 있고, 토큰 없음 → 인사말 + 인라인 버튼으로 인증 유도
-        for (const chatId of chatIds) {
-            try {
-                await telegram.sendInlineKeyboard(chatId, `${greeting}\n\nGoogle Apps가 연결되지 않았어요.`, [[{ text: 'Google Apps 연결', callback_data: 'google_apps_auth' }]]);
-            }
-            catch (err) {
-                this.logger('warn', `[telegram] Startup notification failed for ${chatId}`, {
-                    error: err instanceof Error ? err.message : String(err),
-                });
-            }
-        }
-        // Register callback handler for the button
-        telegram.onCallbackQuery(async (chatId, data, callbackQueryId) => {
-            if (data !== 'google_apps_auth')
-                return;
-            await telegram.answerCallbackQuery(callbackQueryId, 'Starting Google Apps OAuth...');
-            try {
-                const { GoogleAuthManager } = await import('../router/services/GoogleAuthManager.js');
-                const logger = (level, msg) => {
-                    if (level === 'error')
-                        this.logger('warn', `[google-auth] ${msg}`);
-                };
-                const authManager = new GoogleAuthManager(logger);
-                const authUrl = authManager.getAuthUrl();
-                await telegram.sendResponse({
-                    messageId: `google-auth-${Date.now()}`,
-                    channel: 'telegram',
-                    chatId,
-                    content: [
-                        '아래 링크를 열어 Google Apps를 인증해주세요:',
-                        authUrl,
-                        '',
-                        '--- 모바일 사용자 ---',
-                        '인증 후 "localhost" 오류가 나면,',
-                        '주소창의 URL 전체를 복사해서 이 채팅에 붙여넣기 해주세요.',
-                    ].join('\n'),
-                    format: 'text',
-                });
-                // Register pending OAuth for mobile code paste (5 min timeout)
-                const existingPending = this.pendingOAuth.get(chatId);
-                if (existingPending)
-                    clearTimeout(existingPending.timeout);
-                const oauthTimeout = setTimeout(() => {
-                    this.pendingOAuth.delete(chatId);
-                }, 5 * 60 * 1000);
-                this.pendingOAuth.set(chatId, { manager: authManager, timeout: oauthTimeout });
-                // Also start local server for desktop users
-                try {
-                    const code = await authManager.startAuthFlow();
-                    // Desktop flow succeeded - clear pending
-                    clearTimeout(oauthTimeout);
-                    this.pendingOAuth.delete(chatId);
-                    await authManager.exchangeCode(code);
-                    await telegram.sendResponse({
-                        messageId: `google-auth-done-${Date.now()}`,
-                        channel: 'telegram',
-                        chatId,
-                        content: 'Google Apps 연결 완료! (Gmail, Drive, Sheets, Calendar, YouTube)',
-                        format: 'text',
-                    });
-                }
-                catch {
-                    // Local server timed out or failed — mobile paste flow still active
-                    this.logger('info', '[google-auth] Local server flow ended, mobile paste still available');
-                }
-            }
-            catch (err) {
-                await telegram.sendResponse({
-                    messageId: `google-auth-fail-${Date.now()}`,
-                    channel: 'telegram',
-                    chatId,
-                    content: `Google Apps 인증 실패: ${err instanceof Error ? err.message : String(err)}`,
-                    format: 'text',
-                });
-            }
-        });
-    }
-    async sendSlackStartup(slack, googleAppsOk, googleOAuthReady) {
-        const { SlackBot } = await import('../interface/slack/SlackBot.js');
-        if (!(slack instanceof SlackBot))
-            return;
-        const channelIds = this.loadSlackChannelIds();
-        const greeting = getGreeting();
-        // Google Apps 연결 완료 또는 OAuth 환경변수 미설정 → 인사말만
-        if (googleAppsOk || !googleOAuthReady) {
-            for (const channelId of channelIds) {
-                try {
-                    await slack.sendResponse({
-                        messageId: `startup-${Date.now()}`,
-                        channel: 'slack',
-                        chatId: channelId,
-                        content: greeting,
-                        format: 'text',
-                    });
-                }
-                catch { /* ignore */ }
-            }
-            return;
-        }
-        // OAuth 환경변수 있고 토큰 없음 → Block Kit 버튼
-        for (const channelId of channelIds) {
-            try {
-                await slack.sendBlockMessage(channelId, greeting, [
-                    {
-                        type: 'section',
-                        text: {
-                            type: 'mrkdwn',
-                            text: `${greeting}\n\n:warning: Google Apps가 연결되지 않았어요.`,
-                        },
-                    },
-                    {
-                        type: 'actions',
-                        elements: [
-                            {
-                                type: 'button',
-                                text: { type: 'plain_text', text: 'Google Apps 연결' },
-                                action_id: 'google_apps_auth',
-                                style: 'primary',
-                            },
-                        ],
-                    },
-                ]);
-            }
-            catch (err) {
-                this.logger('warn', `[slack] Startup notification failed for ${channelId}`, {
-                    error: err instanceof Error ? err.message : String(err),
-                });
-            }
-        }
-        // Block action 핸들러 등록
-        slack.onBlockAction(async (channelId, actionId) => {
-            if (actionId !== 'google_apps_auth')
-                return;
-            try {
-                const { GoogleAuthManager } = await import('../router/services/GoogleAuthManager.js');
-                const logger = (level, msg) => {
-                    if (level === 'error')
-                        this.logger('warn', `[google-auth] ${msg}`);
-                };
-                const authManager = new GoogleAuthManager(logger);
-                const authUrl = authManager.getAuthUrl();
-                await slack.sendBlockMessage(channelId, 'Google Apps 인증', [
-                    {
-                        type: 'section',
-                        text: {
-                            type: 'mrkdwn',
-                            text: ':link: 이 링크를 열어 Google Apps를 인증해주세요:',
-                        },
-                    },
-                    {
-                        type: 'actions',
-                        elements: [
-                            {
-                                type: 'button',
-                                text: { type: 'plain_text', text: 'Google 계정 인증' },
-                                action_id: 'google_apps_open_link',
-                                url: authUrl,
-                            },
-                        ],
-                    },
-                ]);
-                const code = await authManager.startAuthFlow();
-                await authManager.exchangeCode(code);
-                await slack.sendResponse({
-                    messageId: `google-auth-done-${Date.now()}`,
-                    channel: 'slack',
-                    chatId: channelId,
-                    content: 'Google Apps 연결 완료! (Gmail, Drive, Sheets, Calendar, YouTube)',
-                    format: 'text',
-                });
-            }
-            catch (err) {
-                await slack.sendResponse({
-                    messageId: `google-auth-fail-${Date.now()}`,
-                    channel: 'slack',
-                    chatId: channelId,
-                    content: `Google Apps 인증 실패: ${err instanceof Error ? err.message : String(err)}`,
-                    format: 'text',
-                });
-            }
-        });
-    }
-    loadTelegramChatIds() {
-        try {
-            const ids = (process.env.TELEGRAM_ALLOWED_CHAT_IDS || '').split(',').filter(Boolean);
-            if (ids.length > 0)
-                return ids;
-            if (fs.existsSync(TELEGRAM_CONFIG)) {
-                const config = JSON.parse(fs.readFileSync(TELEGRAM_CONFIG, 'utf-8'));
-                if (Array.isArray(config?.allowedChatIds))
-                    return config.allowedChatIds;
-            }
-        }
-        catch { /* ignore */ }
-        return [];
-    }
-    loadSlackChannelIds() {
-        try {
-            const ids = (process.env.SLACK_ALLOWED_CHANNELS || '').split(',').filter(Boolean);
-            if (ids.length > 0)
-                return ids;
-            if (fs.existsSync(SLACK_CONFIG)) {
-                const config = JSON.parse(fs.readFileSync(SLACK_CONFIG, 'utf-8'));
-                if (Array.isArray(config?.allowedChannelIds))
-                    return config.allowedChannelIds;
-            }
-        }
-        catch { /* ignore */ }
-        return [];
-    }
-    loadState() {
-        try {
-            if (!fs.existsSync(INTERFACE_CONFIG))
-                return {};
-            return JSON.parse(fs.readFileSync(INTERFACE_CONFIG, 'utf-8'));
-        }
-        catch {
-            return {};
-        }
-    }
-}
-//# sourceMappingURL=InterfaceManager.js.map