@su-record/vibe 2.7.2 → 2.7.5

package/dist/daemon/InterfaceManager.js

@@ -0,0 +1,785 @@
+/**
+ * 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