agent-messenger 1.14.0 → 2.0.0

package/dist/src/tui/app.js

@@ -0,0 +1,652 @@
+import blessed from 'blessed';
+import { SlackAdapter } from './adapters/slack-adapter.js';
+import { DiscordAdapter } from './adapters/discord-adapter.js';
+import { TeamsAdapter } from './adapters/teams-adapter.js';
+import { TelegramAdapter } from './adapters/telegram-adapter.js';
+import { WhatsAppAdapter } from './adapters/whatsapp-adapter.js';
+import { LineAdapter } from './adapters/line-adapter.js';
+import { InstagramAdapter } from './adapters/instagram-adapter.js';
+import { KakaoTalkAdapter } from './adapters/kakaotalk-adapter.js';
+import { ChannelTalkAdapter } from './adapters/channeltalk-adapter.js';
+import { ChannelPicker } from './views/channel-picker.js';
+import { WorkspacePicker } from './views/workspace-picker.js';
+import { formatTimestamp } from './utils.js';
+export async function createApp() {
+    let mode = 'selection';
+    let navLevel = 'platform';
+    let activePlatformIndex = -1;
+    let activeChannelId = null;
+    const platformStates = [
+        { adapter: new SlackAdapter(), label: 'Slack', enabled: false, channels: null, workspaces: null, listening: false, lastChannelId: null },
+        { adapter: new DiscordAdapter(), label: 'Discord', enabled: false, channels: null, workspaces: null, listening: false, lastChannelId: null },
+        { adapter: new TeamsAdapter(), label: 'Teams', enabled: false, channels: null, workspaces: null, listening: false, lastChannelId: null },
+        { adapter: new TelegramAdapter(), label: 'Telegram', enabled: false, channels: null, workspaces: null, listening: false, lastChannelId: null },
+        { adapter: new WhatsAppAdapter(), label: 'WhatsApp', enabled: false, channels: null, workspaces: null, listening: false, lastChannelId: null },
+        { adapter: new LineAdapter(), label: 'LINE', enabled: false, channels: null, workspaces: null, listening: false, lastChannelId: null },
+        { adapter: new InstagramAdapter(), label: 'Instagram', enabled: false, channels: null, workspaces: null, listening: false, lastChannelId: null },
+        { adapter: new KakaoTalkAdapter(), label: 'KakaoTalk', enabled: false, channels: null, workspaces: null, listening: false, lastChannelId: null },
+        { adapter: new ChannelTalkAdapter(), label: 'Channel Talk', enabled: false, channels: null, workspaces: null, listening: false, lastChannelId: null },
+    ];
+    const screen = blessed.screen({
+        smartCSR: true,
+        fullUnicode: true,
+        title: 'Agent Messenger',
+    });
+    const header = blessed.box({
+        parent: screen,
+        top: 0,
+        left: 0,
+        right: 0,
+        height: 1,
+        tags: true,
+        style: { fg: 'white', bg: 'black' },
+    });
+    const sidebar = blessed.list({
+        parent: screen,
+        left: 0,
+        top: 1,
+        width: 28,
+        height: '100%-4',
+        border: { type: 'line' },
+        style: {
+            border: { fg: '#444444' },
+            selected: { bg: 'blue', fg: 'white', bold: true },
+            item: { fg: 'white' },
+        },
+        keys: true,
+        mouse: true,
+        scrollable: true,
+        label: ' Platforms ',
+    });
+    const messageLog = blessed.log({
+        parent: screen,
+        left: 28,
+        top: 1,
+        right: 0,
+        height: '100%-4',
+        border: { type: 'line' },
+        style: {
+            border: { fg: '#444444' },
+            fg: 'white',
+        },
+        tags: true,
+        keys: true,
+        scrollable: true,
+        scrollbar: { style: { bg: 'blue' } },
+        mouse: true,
+        label: ' Messages ',
+    });
+    const inputBox = blessed.textarea({
+        parent: screen,
+        bottom: 0,
+        left: 0,
+        right: 0,
+        height: 3,
+        border: { type: 'line' },
+        style: {
+            border: { fg: '#444444' },
+            fg: 'white',
+        },
+        inputOnFocus: true,
+        label: ' Message ',
+    });
+    const statusBar = blessed.box({
+        parent: screen,
+        bottom: 0,
+        left: 0,
+        right: 0,
+        height: 1,
+        tags: true,
+        style: { fg: 'gray', bg: 'black' },
+    });
+    const channelPicker = new ChannelPicker(screen);
+    const workspacePicker = new WorkspacePicker(screen);
+    // --- Auth mode ---
+    let authResolve = null;
+    let authReject = null;
+    function createAuthIO() {
+        return {
+            print(message) {
+                messageLog.log(message);
+                screen.render();
+            },
+            prompt(label) {
+                messageLog.log(`{yellow-fg}${label}:{/}`);
+                inputBox.clearValue();
+                inputBox.setLabel(` ${label} `);
+                focusInput();
+                screen.render();
+                return new Promise((resolve, reject) => {
+                    authResolve = resolve;
+                    authReject = reject;
+                });
+            },
+        };
+    }
+    async function startAuth(platform, platformIndex) {
+        mode = 'auth';
+        messageLog.setLabel(` ${platform.label} `);
+        messageLog.setContent('');
+        messageLog.log(`{bold}Authenticating ${platform.label}...{/}`);
+        screen.render();
+        const io = createAuthIO();
+        try {
+            await platform.adapter.authenticate(io);
+            platform.enabled = true;
+            activePlatformIndex = platformIndex;
+            messageLog.setContent('');
+            messageLog.setLabel(' Messages ');
+            inputBox.setLabel(' Message ');
+            mode = 'selection';
+            renderHeader();
+            await showWorkspaceLevel();
+        }
+        catch (err) {
+            const detail = err instanceof Error ? err.message : String(err);
+            if (detail !== 'Authentication cancelled') {
+                messageLog.log(`{red-fg}Authentication failed: ${detail}{/}`);
+            }
+            mode = 'selection';
+            inputBox.setLabel(' Message ');
+            focusSidebar();
+            renderAll();
+        }
+    }
+    function enabledIndices() {
+        return platformStates.map((p, i) => (p.enabled ? i : -1)).filter((i) => i >= 0);
+    }
+    function activePlatform() {
+        return activePlatformIndex >= 0 ? platformStates[activePlatformIndex] : null;
+    }
+    // --- Rendering ---
+    function renderHeader() {
+        const p = activePlatform();
+        if (!p) {
+            header.setContent(' {bold}Agent Messenger{/}');
+            return;
+        }
+        const parts = [p.label];
+        const ws = p.adapter.getCurrentWorkspace?.();
+        if (ws)
+            parts.push(ws.name);
+        const channel = p.channels?.find((ch) => ch.id === activeChannelId);
+        if (channel)
+            parts.push(channel.name);
+        header.setContent(` {bold}${parts.join(' \u203A ')}{/}`);
+    }
+    function renderStatusBar() {
+        if (mode === 'selection') {
+            const hints = ['{gray-fg}\u2191\u2193{/}: Navigate'];
+            if (navLevel === 'platform') {
+                hints.push('{gray-fg}Enter{/}: Select');
+            }
+            else {
+                hints.push('{gray-fg}Enter/\u2192{/}: Select', '{gray-fg}\u2190/Esc{/}: Back');
+            }
+            if (activeChannelId) {
+                hints.push('{gray-fg}Esc{/}: Read');
+            }
+            hints.push('{gray-fg}Ctrl+C{/}: Quit');
+            statusBar.setContent(' ' + hints.join('  '));
+        }
+        else if (mode === 'auth') {
+            statusBar.setContent(' {gray-fg}Enter{/}: Submit  {gray-fg}Esc{/}: Cancel  {gray-fg}Ctrl+C{/}: Quit');
+        }
+        else if (mode === 'read') {
+            statusBar.setContent(' {gray-fg}Enter{/}: Write  {gray-fg}Esc{/}: Selection  {gray-fg}Ctrl+K{/}: Channel  {gray-fg}Ctrl+W{/}: Workspace  {gray-fg}Ctrl+C{/}: Quit');
+        }
+        else {
+            statusBar.setContent(' {gray-fg}Enter{/}: Send  {gray-fg}Esc{/}: Read  {gray-fg}Ctrl+K{/}: Channel  {gray-fg}Ctrl+W{/}: Workspace  {gray-fg}Ctrl+C{/}: Quit');
+        }
+    }
+    function renderAll() {
+        renderHeader();
+        renderStatusBar();
+        screen.render();
+    }
+    // --- Focus management ---
+    function applyFocusStyle(widget, focused) {
+        widget.style.border.fg = focused ? 'blue' : '#444444';
+    }
+    function focusSidebar() {
+        applyFocusStyle(sidebar, true);
+        applyFocusStyle(messageLog, false);
+        applyFocusStyle(inputBox, false);
+        sidebar.focus();
+    }
+    function focusMessages() {
+        applyFocusStyle(sidebar, false);
+        applyFocusStyle(messageLog, true);
+        applyFocusStyle(inputBox, false);
+        messageLog.focus();
+    }
+    function focusInput() {
+        applyFocusStyle(sidebar, false);
+        applyFocusStyle(messageLog, false);
+        applyFocusStyle(inputBox, true);
+        inputBox.focus();
+    }
+    // --- Sidebar population ---
+    async function showPlatformLevel() {
+        navLevel = 'platform';
+        sidebar.setLabel(' Platforms ');
+        const items = platformStates.map((p, i) => {
+            const marker = i === activePlatformIndex ? '\u25B6 ' : '  ';
+            return p.enabled ? `${marker}${p.label}` : `${marker}${p.label} (offline)`;
+        });
+        sidebar.setItems(items);
+        const activeInList = activePlatformIndex >= 0 ? activePlatformIndex : 0;
+        sidebar.select(activeInList);
+        renderAll();
+    }
+    async function showWorkspaceLevel() {
+        const p = activePlatform();
+        if (!p || !p.adapter.getWorkspaces) {
+            await showChannelLevel();
+            return;
+        }
+        if (!p.workspaces) {
+            sidebar.setLabel(` ${p.label} \u203A Workspaces `);
+            sidebar.setItems(['Loading...']);
+            screen.render();
+            try {
+                p.workspaces = await p.adapter.getWorkspaces();
+            }
+            catch {
+                p.workspaces = [];
+            }
+        }
+        if (p.workspaces.length <= 1) {
+            await showChannelLevel();
+            return;
+        }
+        navLevel = 'workspace';
+        sidebar.setLabel(` ${p.label} \u203A Workspaces `);
+        const currentWs = p.adapter.getCurrentWorkspace?.();
+        const items = p.workspaces.map((ws) => {
+            const marker = currentWs && ws.id === currentWs.id ? '\u25B6 ' : '  ';
+            return `${marker}${ws.name}`;
+        });
+        sidebar.setItems(items);
+        const currentIdx = currentWs ? p.workspaces.findIndex((ws) => ws.id === currentWs.id) : 0;
+        sidebar.select(Math.max(0, currentIdx));
+        renderAll();
+    }
+    async function showChannelLevel() {
+        const p = activePlatform();
+        if (!p)
+            return;
+        navLevel = 'channel';
+        const wsLabel = p.adapter.getCurrentWorkspace?.()?.name;
+        sidebar.setLabel(wsLabel ? ` ${p.label}:${wsLabel} \u203A Channels ` : ` ${p.label} \u203A Channels `);
+        if (!p.channels) {
+            sidebar.setItems(['Loading...']);
+            screen.render();
+            try {
+                p.channels = await p.adapter.getChannels();
+            }
+            catch {
+                p.channels = [];
+            }
+        }
+        const items = p.channels.map((ch) => {
+            const marker = ch.id === activeChannelId ? '\u25B6 ' : '  ';
+            return `${marker}${ch.name}`;
+        });
+        sidebar.setItems(items);
+        const currentIdx = activeChannelId ? p.channels.findIndex((ch) => ch.id === activeChannelId) : 0;
+        sidebar.select(Math.max(0, currentIdx));
+        renderAll();
+    }
+    // --- Mode transitions ---
+    function enterSelectionMode(level) {
+        mode = 'selection';
+        inputBox.cancel();
+        focusSidebar();
+        if (level) {
+            switch (level) {
+                case 'platform':
+                    showPlatformLevel();
+                    break;
+                case 'workspace':
+                    showWorkspaceLevel();
+                    break;
+                case 'channel':
+                    showChannelLevel();
+                    break;
+            }
+        }
+        else {
+            if (activePlatformIndex >= 0) {
+                showChannelLevel();
+            }
+            else {
+                showPlatformLevel();
+            }
+        }
+    }
+    function enterReadMode() {
+        if (!activeChannelId)
+            return;
+        mode = 'read';
+        const p = activePlatform();
+        const wsLabel = p?.adapter.getCurrentWorkspace?.()?.name;
+        sidebar.setLabel(wsLabel ? ` ${p?.label}:${wsLabel} ` : ` ${p?.label} `);
+        if (p?.channels) {
+            const items = p.channels.map((ch) => {
+                const marker = ch.id === activeChannelId ? '\u25B6 ' : '  ';
+                return `${marker}${ch.name}`;
+            });
+            sidebar.setItems(items);
+        }
+        focusMessages();
+        renderAll();
+    }
+    function enterWriteMode() {
+        if (!activeChannelId)
+            return;
+        mode = 'write';
+        focusInput();
+        renderAll();
+    }
+    // --- Messages ---
+    function appendMessage(msg) {
+        const time = formatTimestamp(msg.timestamp);
+        messageLog.log(`{gray-fg}${time}{/gray-fg} {bold}{cyan-fg}${msg.author}{/cyan-fg}{/bold} ${msg.content}`);
+        screen.render();
+    }
+    async function loadChannel(channelId) {
+        const p = activePlatform();
+        if (!p)
+            return;
+        activeChannelId = channelId;
+        p.lastChannelId = channelId;
+        messageLog.setContent('');
+        const channel = p.channels?.find((ch) => ch.id === channelId);
+        messageLog.setLabel(channel ? ` ${channel.name} ` : ' Messages ');
+        screen.render();
+        try {
+            const messages = await p.adapter.getMessages(channelId);
+            for (const msg of messages)
+                appendMessage(msg);
+        }
+        catch (err) {
+            messageLog.log(`{red-fg}Error: ${err}{/red-fg}`);
+        }
+        if (!p.listening && p.adapter.startListening) {
+            try {
+                await p.adapter.startListening((msg) => {
+                    if (msg.channelId === activeChannelId)
+                        appendMessage(msg);
+                });
+                p.listening = true;
+            }
+            catch { }
+        }
+        screen.render();
+    }
+    // --- Selection mode navigation ---
+    async function drillDown() {
+        const selectedIndex = sidebar.selected;
+        switch (navLevel) {
+            case 'platform': {
+                const selected = platformStates[selectedIndex];
+                if (!selected)
+                    return;
+                if (!selected.enabled) {
+                    startAuth(selected, selectedIndex);
+                    return;
+                }
+                activePlatformIndex = selectedIndex;
+                renderHeader();
+                await showWorkspaceLevel();
+                break;
+            }
+            case 'workspace': {
+                const p = activePlatform();
+                if (!p?.workspaces?.[selectedIndex])
+                    return;
+                const ws = p.workspaces[selectedIndex];
+                try {
+                    await p.adapter.switchWorkspace?.(ws.id);
+                    p.channels = null;
+                    renderHeader();
+                }
+                catch { }
+                await showChannelLevel();
+                break;
+            }
+            case 'channel': {
+                const p = activePlatform();
+                if (!p?.channels?.[selectedIndex])
+                    return;
+                const channel = p.channels[selectedIndex];
+                await loadChannel(channel.id);
+                enterReadMode();
+                break;
+            }
+        }
+    }
+    async function drillUp() {
+        switch (navLevel) {
+            case 'channel': {
+                const p = activePlatform();
+                const hasWorkspaces = p?.workspaces && p.workspaces.length > 1;
+                if (hasWorkspaces) {
+                    await showWorkspaceLevel();
+                }
+                else {
+                    await showPlatformLevel();
+                }
+                break;
+            }
+            case 'workspace':
+                await showPlatformLevel();
+                break;
+            case 'platform':
+                if (activeChannelId)
+                    enterReadMode();
+                break;
+        }
+    }
+    // --- Key bindings ---
+    sidebar.on('select', () => {
+        if (mode === 'selection')
+            drillDown();
+    });
+    sidebar.key(['right'], () => {
+        if (mode === 'selection')
+            drillDown();
+    });
+    sidebar.key(['left'], () => {
+        if (mode === 'selection')
+            drillUp();
+    });
+    screen.key(['tab'], () => {
+        if (mode === 'auth' || channelPicker.isActive() || workspacePicker.isActive())
+            return;
+        if (mode === 'read')
+            enterWriteMode();
+        else if (mode === 'write')
+            enterReadMode();
+    });
+    screen.key(['S-tab'], () => {
+        if (mode === 'auth' || channelPicker.isActive() || workspacePicker.isActive())
+            return;
+        if (mode === 'write')
+            enterReadMode();
+        else if (mode === 'read')
+            enterWriteMode();
+    });
+    screen.key(['escape'], () => {
+        if (mode === 'auth' || channelPicker.isActive() || workspacePicker.isActive())
+            return;
+        if (mode === 'read')
+            enterSelectionMode();
+        else if (mode === 'selection')
+            drillUp();
+    });
+    messageLog.key(['enter'], () => {
+        if (mode === 'read')
+            enterWriteMode();
+    });
+    screen.key(['C-k'], () => {
+        if (mode === 'auth' || channelPicker.isActive() || workspacePicker.isActive())
+            return;
+        const p = activePlatform();
+        if (!p?.channels?.length)
+            return;
+        channelPicker.open(p.channels, async (channel) => {
+            await loadChannel(channel.id);
+            enterReadMode();
+        });
+    });
+    screen.key(['C-w'], () => {
+        if (mode === 'selection' || mode === 'auth' || channelPicker.isActive() || workspacePicker.isActive())
+            return;
+        const p = activePlatform();
+        if (!p?.adapter.getWorkspaces)
+            return;
+        p.adapter.getWorkspaces().then((workspaces) => {
+            if (workspaces.length <= 1)
+                return;
+            workspacePicker.open(workspaces, (workspace) => {
+                if (!p.adapter.switchWorkspace)
+                    return;
+                p.adapter.switchWorkspace(workspace.id).then(() => {
+                    p.channels = null;
+                    p.workspaces = null;
+                    renderHeader();
+                    if (activeChannelId) {
+                        activeChannelId = null;
+                        messageLog.setContent('');
+                        messageLog.setLabel(' Messages ');
+                    }
+                    enterSelectionMode('channel');
+                }).catch(() => { });
+            });
+        }).catch(() => { });
+    });
+    inputBox.on('keypress', (_ch, key) => {
+        if (mode === 'auth') {
+            if (key.name === 'escape') {
+                inputBox.cancel();
+                inputBox.clearValue();
+                if (authReject) {
+                    const reject = authReject;
+                    authResolve = null;
+                    authReject = null;
+                    reject(new Error('Authentication cancelled'));
+                }
+                return;
+            }
+            if (key.name === 'enter' || key.name === 'return') {
+                const value = inputBox.getValue().trim();
+                inputBox.clearValue();
+                screen.render();
+                if (authResolve) {
+                    const resolve = authResolve;
+                    authResolve = null;
+                    authReject = null;
+                    resolve(value);
+                }
+                return;
+            }
+            return;
+        }
+        if (key.name === 'escape') {
+            inputBox.cancel();
+            enterReadMode();
+            return;
+        }
+        if (key.name === 'tab') {
+            inputBox.cancel();
+            enterReadMode();
+            return;
+        }
+        if (key.ctrl && key.name === 'k') {
+            inputBox.cancel();
+            const p = activePlatform();
+            if (!p?.channels?.length)
+                return;
+            channelPicker.open(p.channels, async (channel) => {
+                await loadChannel(channel.id);
+                enterReadMode();
+            });
+            return;
+        }
+        if (key.name === 'enter' || key.name === 'return') {
+            const text = inputBox.getValue().trim();
+            if (text && activeChannelId) {
+                const p = activePlatform();
+                inputBox.clearValue();
+                screen.render();
+                p?.adapter.sendMessage(activeChannelId, text).then(() => {
+                    if (!p?.listening) {
+                        appendMessage({
+                            id: Date.now().toString(),
+                            channelId: activeChannelId,
+                            author: 'you',
+                            content: text,
+                            timestamp: (Date.now() / 1000).toString(),
+                        });
+                    }
+                }).catch((err) => {
+                    const detail = err instanceof Error ? err.message : String(err);
+                    appendMessage({
+                        id: 'err',
+                        channelId: activeChannelId,
+                        author: 'system',
+                        content: `{red-fg}Send failed: ${detail}{/red-fg}`,
+                        timestamp: (Date.now() / 1000).toString(),
+                    });
+                });
+            }
+            return;
+        }
+    });
+    screen.key(['C-c'], () => {
+        for (const p of platformStates) {
+            p.adapter.stopListening?.();
+        }
+        screen.destroy();
+        process.exit(0);
+    });
+    // --- Startup ---
+    screen.render();
+    header.setContent(' {yellow-fg}Connecting...{/}');
+    screen.render();
+    const origStdoutWrite = process.stdout.write.bind(process.stdout);
+    const origStderrWrite = process.stderr.write.bind(process.stderr);
+    process.stdout.write = (...args) => {
+        const str = typeof args[0] === 'string' ? args[0] : '';
+        if (str.includes('\x1b['))
+            return origStdoutWrite(...args);
+        return true;
+    };
+    process.stderr.write = () => true;
+    const results = await Promise.allSettled(platformStates.map((p) => p.adapter.login()));
+    process.stdout.write = origStdoutWrite;
+    process.stderr.write = origStderrWrite;
+    screen.alloc();
+    screen.render();
+    for (let i = 0; i < results.length; i++) {
+        if (results[i].status === 'fulfilled') {
+            platformStates[i].enabled = true;
+        }
+    }
+    const enabled = enabledIndices();
+    if (enabled.length === 1) {
+        activePlatformIndex = enabled[0];
+        renderHeader();
+        await showChannelLevel();
+        focusSidebar();
+        renderAll();
+    }
+    else {
+        await showPlatformLevel();
+        focusSidebar();
+        renderAll();
+    }
+}
+//# sourceMappingURL=app.js.map