X Dm Auto Chat

import argparse
import sys

def main():
    sys.stdout.reconfigure(encoding='utf-8', newline='\n')
    parser = argparse.ArgumentParser(description='Check X DM composer state: confirm textarea available, return current value and current message count')
    args = parser.parse_args()

    js = """
    (() => {
      try {
        const passcode = document.querySelector('input[pattern="[0-9]*"][maxlength="1"]');
        if (passcode) return JSON.stringify({ error: true, message: 'passcode_required' });

        const panel = document.querySelector('[data-testid="dm-conversation-panel"]');
        if (!panel) return JSON.stringify({ error: true, message: 'no active conversation (open a conversation first)' });

        const textarea = document.querySelector('[data-testid="dm-composer-textarea"]');
        if (!textarea) return JSON.stringify({ error: true, message: 'dm-composer-textarea not found (composer may be disabled)' });

        const sendBtn = document.querySelector('[data-testid="dm-composer-send-button"]');
        const voiceBtn = document.querySelector('[data-testid="dm-composer-voice-button"]');

        const msgCount = document.querySelectorAll('[data-testid^="message-"]:not([data-testid^="message-text-"])').length;
        const lastMsgEl = document.querySelectorAll('[data-testid^="message-"]:not([data-testid^="message-text-"])');
        const lastId = lastMsgEl.length ? lastMsgEl[lastMsgEl.length - 1].getAttribute('data-testid').replace('message-', '') : null;

        const convIdMatch = location.pathname.match(/\\/i\\/chat\\/(\\d+)-(\\d+)/);
        let convId = null;
        if (convIdMatch) {
          const a = BigInt(convIdMatch[1]);
          const b = BigInt(convIdMatch[2]);
          convId = (a < b ? `${a}:${b}` : `${b}:${a}`);
        }

        return JSON.stringify({
          conversation_id: convId,
          url: location.href,
          composer_ready: true,
          current_value: textarea.value,
          has_send_button: !!sendBtn,
          has_voice_button: !!voiceBtn,
          message_count: msgCount,
          last_message_id: lastId
        });
      } catch(e) {
        return JSON.stringify({ error: true, message: e.message });
      }
    })()
    """
    print(js)

if __name__ == '__main__':
    main()

import argparse
import sys

def main():
    sys.stdout.reconfigure(encoding='utf-8', newline='\n')
    parser = argparse.ArgumentParser(description='Check X DM page state: URL, login status, passcode requirement, conversation panel availability')
    args = parser.parse_args()

    js = """
    (() => {
      try {
        return JSON.stringify({
          url: location.href,
          logged_in: !!document.querySelector('[aria-label="Account menu"]') || !!document.cookie.split('; ').find(c => c.startsWith('twid=')),
          need_passcode: !!document.querySelector('input[pattern="[0-9]*"][maxlength="1"]'),
          on_inbox: /\\/i\\/chat\\/?$/.test(location.pathname),
          on_conversation: /\\/i\\/chat\\/\\d+-\\d+/.test(location.pathname),
          has_panel: !!document.querySelector('[data-testid="dm-conversation-panel"]'),
          has_composer: !!document.querySelector('[data-testid="dm-composer-textarea"]'),
          inbox_count: document.querySelectorAll('[data-testid^="dm-conversation-item-"]').length
        });
      } catch(e) {
        return JSON.stringify({ error: true, message: e.message });
      }
    })()
    """
    print(js)

if __name__ == '__main__':
    main()

import argparse
import sys

def main():
    sys.stdout.reconfigure(encoding='utf-8', newline='\n')
    parser = argparse.ArgumentParser(description='Fetch X DM inbox via GraphQL API (metadata only, message bodies are E2E encrypted)')
    parser.add_argument('--cursor-id', default='', help='Pagination cursor_id from previous response inboxCursor; empty for first page')
    parser.add_argument('--graph-snapshot-id', default='', help='Pagination graph_snapshot_id from previous response; empty for first page')
    parser.add_argument('--limit', type=int, default=20, help='Conversations per page')
    args = parser.parse_args()

    js = f"""
    (async () => {{
      try {{
        const AUTH = 'Bearer AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA';
        const csrf = document.cookie.split('; ').find(c => c.startsWith('ct0='))?.split('=')[1];
        if (!csrf) return JSON.stringify({{ error: true, message: 'ct0 cookie missing - not logged in' }});
        const headers = {{
          'authorization': AUTH,
          'x-csrf-token': csrf,
          'accept': 'application/graphql-response+json, application/json',
          'apollo-require-preflight': 'true'
        }};
        const cursorId = {repr(args.cursor_id)};
        const graphSnap = {repr(args.graph_snapshot_id)};
        const limit = {args.limit};

        let url;
        if (cursorId && graphSnap) {{
          url = 'https://api.x.com/graphql/udvEZwRtFbZht-atludZcw/GetInboxPageRequestQuery?variables=' +
            encodeURIComponent(JSON.stringify({{
              continue_cursor: {{ cursor_id: cursorId, graph_snapshot_id: graphSnap }},
              query_settings: {{ conversation_event_limit: 200, inbox_conversation_event_limit: 5, inbox_conversation_limit: limit, user_event_limit: 500 }}
            }}));
        }} else {{
          url = 'https://api.x.com/graphql/eovtSNDuKOzRLKXV4yWcow/GetInitialXChatPageQuery?variables=' +
            encodeURIComponent(JSON.stringify({{
              max_local_sequence_id: null,
              query_settings: {{ conversation_event_limit: 200, inbox_conversation_event_limit: 5, inbox_conversation_limit: limit, user_event_limit: 500 }},
              message_pull_version: null
            }}));
        }}

        const r = await fetch(url, {{ credentials: 'include', headers }});
        if (!r.ok) return JSON.stringify({{ error: true, message: 'HTTP ' + r.status }});
        const j = await r.json();
        const page = j?.data?.get_initial_chat_page || j?.data?.get_inbox_page;
        if (!page) return JSON.stringify({{ error: true, message: 'unexpected response shape', sample: JSON.stringify(j).slice(0, 300) }});

        const myId = document.cookie.split('; ').find(c => c.startsWith('twid='))?.split('=')[1]?.replace(/^u%3D/, '').replace(/^u=/, '');
        const items = (page.items || []).map(it => {{
          const d = it.conversation_detail || {{}};
          const parts = (d.participants_results || []).map(p => {{
            const u = p.result || {{}};
            return {{
              user_id: u.rest_id,
              name: u.core?.name,
              screen_name: u.core?.screen_name,
              avatar_url: u.avatar?.image_url,
              is_blue_verified: u.verification?.is_blue_verified,
              is_verified_organization: u.verification?.is_verified_organization,
              can_dm: u.chat_permissions?.can_dm,
              can_dm_on_xchat: u.chat_permissions?.can_dm_on_xchat,
              can_dm_reason: u.chat_permissions?.can_dm_reason,
              is_trusted: u.chat_permissions?.is_trusted,
              protected: u.privacy?.protected,
              suspended: u.privacy?.suspended
            }};
          }});
          const peers = parts.filter(p => p.user_id !== myId);
          return {{
            conversation_id: d.conversation_id,
            is_muted: d.is_muted,
            is_deleted_by_viewer: it.is_deleted_by_viewer,
            has_more: it.has_more,
            participants: parts,
            peer_user_id: peers[0]?.user_id,
            peer_screen_name: peers[0]?.screen_name,
            peer_name: peers[0]?.name
          }};
        }});

        const cursor = page.inboxCursor || {{}};
        const isEnd = cursor.__typename === 'XChatGetInboxPageEndCursor';
        return JSON.stringify({{
          my_user_id: myId,
          count: items.length,
          items,
          next_cursor: isEnd ? null : {{ cursor_id: cursor.cursor_id, graph_snapshot_id: cursor.graph_snapshot_id }},
          message_requests_count: page.message_requests_count
        }});
      }} catch(e) {{
        return JSON.stringify({{ error: true, message: e.message }});
      }}
    }})()
    """
    print(js)

if __name__ == '__main__':
    main()

import argparse
import sys

def main():
    sys.stdout.reconfigure(encoding='utf-8', newline='\n')
    parser = argparse.ArgumentParser(description='Navigate to (or create) a 1-on-1 DM conversation with a given user by user_id')
    parser.add_argument('user_id', help='Target user rest_id (numeric string)')
    args = parser.parse_args()

    js = f"""
    (async () => {{
      try {{
        const myId = document.cookie.split('; ').find(c => c.startsWith('twid='))?.split('=')[1]?.replace(/^u%3D/, '').replace(/^u=/, '');
        if (!myId) return JSON.stringify({{ error: true, message: 'twid cookie missing - not logged in' }});
        const peerId = {repr(args.user_id)};

        const a = BigInt(myId);
        const b = BigInt(peerId);
        const urlPath = a < b ? `/i/chat/${{a}}-${{b}}` : `/i/chat/${{b}}-${{a}}`;

        return JSON.stringify({{
          my_user_id: myId,
          peer_user_id: peerId,
          conversation_url: urlPath,
          conversation_id: a < b ? `${{a}}:${{b}}` : `${{b}}:${{a}}`,
          next_step: 'navigate to conversation_url then verify composer_ready'
        }});
      }} catch(e) {{
        return JSON.stringify({{ error: true, message: e.message }});
      }}
    }})()
    """
    print(js)

if __name__ == '__main__':
    main()

import argparse
import sys

def main():
    sys.stdout.reconfigure(encoding='utf-8', newline='\n')
    parser = argparse.ArgumentParser(description='Read all currently-loaded messages from the active X DM conversation DOM')
    args = parser.parse_args()

    js = """
    (() => {
      try {
        const passcode = document.querySelector('input[pattern="[0-9]*"][maxlength="1"]');
        if (passcode) return JSON.stringify({ error: true, message: 'passcode_required' });

        const header = document.querySelector('[data-testid="dm-conversation-header"]');
        const peerName = header?.innerText?.trim();
        const panel = document.querySelector('[data-testid="dm-conversation-panel"]');
        if (!panel) return JSON.stringify({ error: true, message: 'no active conversation (dm-conversation-panel not found); navigate to /i/chat/{id1}-{id2} or click an inbox item' });

        const convIdMatch = location.pathname.match(/\\/i\\/chat\\/(\\d+)-(\\d+)/);
        let convId = null;
        if (convIdMatch) {
          const a = BigInt(convIdMatch[1]);
          const b = BigInt(convIdMatch[2]);
          convId = (a < b ? `${a}:${b}` : `${b}:${a}`);
        }

        const myId = document.cookie.split('; ').find(c => c.startsWith('twid='))?.split('=')[1]?.replace(/^u%3D/, '').replace(/^u=/, '');

        const msgEls = document.querySelectorAll('[data-testid^="message-"]:not([data-testid^="message-text-"])');
        const messages = [];
        msgEls.forEach(el => {
          const testid = el.getAttribute('data-testid');
          const msgId = testid.replace('message-', '');
          const textEl = document.querySelector(`[data-testid="message-text-${msgId}"]`);
          let text = textEl?.textContent || '';
          // Strip trailing timestamp duplicates like "6:25 PM6:25 PM" that get picked up
          // by textContent when the time element is a sibling inside message-text
          text = text.replace(/(\\d{1,2}:\\d{2}\\s?(?:AM|PM)?)+\\s*$/, '').trimEnd();

          const cls = el.className || '';
          const fromSelf = cls.includes('justify-end');
          const fromPeer = cls.includes('justify-start');
          const direction = fromSelf ? 'self' : (fromPeer ? 'peer' : 'unknown');

          // Time — X renders as HH:MM or similar; collect all text in element minus main text
          let timestamp = null;
          const allText = el.innerText || '';
          const timeMatch = allText.match(/\\b(\\d{1,2}:\\d{2}\\s?(?:AM|PM)?)\\b/);
          if (timeMatch) timestamp = timeMatch[1];

          // Extract attached URLs (rich links)
          const links = [...el.querySelectorAll('a[href^="http"]')].map(a => a.getAttribute('href')).filter((v, i, arr) => arr.indexOf(v) === i);

          // Attached images (avatars excluded)
          const images = [...el.querySelectorAll('img[src]')]
            .map(im => im.getAttribute('src'))
            .filter(s => !/profile_images/.test(s))
            .filter((v, i, arr) => arr.indexOf(v) === i);

          messages.push({
            message_id: msgId,
            direction,
            text,
            timestamp_text: timestamp,
            links,
            images
          });
        });

        return JSON.stringify({
          conversation_id: convId,
          url: location.href,
          peer_display_name: peerName,
          my_user_id: myId,
          message_count: messages.length,
          messages
        });
      } catch(e) {
        return JSON.stringify({ error: true, message: e.message });
      }
    })()
    """
    print(js)

if __name__ == '__main__':
    main()

import argparse
import sys

def main():
    sys.stdout.reconfigure(encoding='utf-8', newline='\n')
    parser = argparse.ArgumentParser(description='Combined X DM inbox scan: merge API (metadata, screen_name) + DOM (preview, unread, timestamp)')
    args = parser.parse_args()

    js = """
    (async () => {
      try {
        const passcode = document.querySelector('input[pattern="[0-9]*"][maxlength="1"]');
        if (passcode) return JSON.stringify({ error: true, message: 'passcode_required', hint: 'Page is on DM passcode screen; unlock first' });

        const myId = document.cookie.split('; ').find(c => c.startsWith('twid='))?.split('=')[1]?.replace(/^u%3D/, '').replace(/^u=/, '');
        if (!myId) return JSON.stringify({ error: true, message: 'twid cookie missing - not logged in' });

        const AUTH = 'Bearer AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA';
        const csrf = document.cookie.split('; ').find(c => c.startsWith('ct0='))?.split('=')[1];
        const headers = {
          'authorization': AUTH,
          'x-csrf-token': csrf,
          'accept': 'application/graphql-response+json, application/json',
          'apollo-require-preflight': 'true'
        };

        const apiUrl = 'https://api.x.com/graphql/eovtSNDuKOzRLKXV4yWcow/GetInitialXChatPageQuery?variables=' +
          encodeURIComponent(JSON.stringify({
            max_local_sequence_id: null,
            query_settings: { conversation_event_limit: 200, inbox_conversation_event_limit: 5, inbox_conversation_limit: 20, user_event_limit: 500 },
            message_pull_version: null
          }));
        const r = await fetch(apiUrl, { credentials: 'include', headers });
        if (!r.ok) return JSON.stringify({ error: true, message: 'inbox API HTTP ' + r.status });
        const j = await r.json();
        const page = j?.data?.get_initial_chat_page;
        if (!page) return JSON.stringify({ error: true, message: 'unexpected API response shape' });

        const apiByConvId = {};
        (page.items || []).forEach(it => {
          const d = it.conversation_detail || {};
          const parts = (d.participants_results || []).map(p => {
            const u = p.result || {};
            return {
              user_id: u.rest_id,
              name: u.core?.name,
              screen_name: u.core?.screen_name,
              avatar_url: u.avatar?.image_url,
              is_blue_verified: u.verification?.is_blue_verified,
              is_verified_organization: u.verification?.is_verified_organization,
              can_dm: u.chat_permissions?.can_dm,
              can_dm_reason: u.chat_permissions?.can_dm_reason
            };
          });
          const peers = parts.filter(p => p.user_id !== myId);
          apiByConvId[d.conversation_id] = {
            is_muted: d.is_muted,
            is_deleted_by_viewer: it.is_deleted_by_viewer,
            peer: peers[0] || null,
            participants: parts
          };
        });

        const items = document.querySelectorAll('[data-testid^="dm-conversation-item-"]');
        const merged = [];
        items.forEach(el => {
          const testid = el.getAttribute('data-testid');
          const convId = testid.replace('dm-conversation-item-', '');
          const apiData = apiByConvId[convId] || {};

          const anchor = el.querySelector('a[href*="/chat/"]');
          const href = anchor?.getAttribute('href');

          const texts = [];
          const walker = document.createTreeWalker(el, NodeFilter.SHOW_TEXT);
          let n;
          while (n = walker.nextNode()) {
            const t = n.textContent.trim();
            if (t) texts.push(t);
          }
          const peerName = texts[0];
          const timestamp = texts[1];
          let youPrefix = false;
          let preview = texts[2] || '';
          if (preview === 'You:' && texts.length >= 4) {
            youPrefix = true;
            preview = texts[3];
          }

          const unread = !!el.querySelector('svg[data-icon="icon-circle-fill"].text-primary');

          merged.push({
            conversation_id: convId,
            conversation_url: href,
            peer_user_id: apiData.peer?.user_id,
            peer_screen_name: apiData.peer?.screen_name,
            peer_display_name: apiData.peer?.name || peerName,
            peer_avatar_url: apiData.peer?.avatar_url,
            peer_is_blue_verified: apiData.peer?.is_blue_verified,
            peer_can_dm: apiData.peer?.can_dm,
            peer_can_dm_reason: apiData.peer?.can_dm_reason,
            is_muted: apiData.is_muted,
            is_deleted_by_viewer: apiData.is_deleted_by_viewer,
            latest_message_timestamp: timestamp,
            latest_message_preview: preview,
            latest_message_from_self: youPrefix,
            unread
          });
        });

        const cursor = page.inboxCursor || {};
        const isEnd = cursor.__typename === 'XChatGetInboxPageEndCursor';

        return JSON.stringify({
          my_user_id: myId,
          count: merged.length,
          unread_count: merged.filter(m => m.unread).length,
          items: merged,
          next_cursor: isEnd ? null : { cursor_id: cursor.cursor_id, graph_snapshot_id: cursor.graph_snapshot_id },
          message_requests_count: page.message_requests_count
        });
      } catch(e) {
        return JSON.stringify({ error: true, message: e.message, stack: (e.stack||'').slice(0, 300) });
      }
    })()
    """
    print(js)

if __name__ == '__main__':
    main()

import argparse
import sys

def main():
    sys.stdout.reconfigure(encoding='utf-8', newline='\n')
    parser = argparse.ArgumentParser(description='Scroll message list to top to trigger loading older messages; returns whether new messages were loaded')
    args = parser.parse_args()

    js = """
    (async () => {
      try {
        const list = document.querySelector('[data-testid="dm-message-list-container"]') || document.querySelector('[data-testid="dm-message-list"]');
        if (!list) return JSON.stringify({ error: true, message: 'message list container not found' });

        const beforeCount = document.querySelectorAll('[data-testid^="message-"]:not([data-testid^="message-text-"])').length;
        list.scrollTop = 0;

        // Wait up to 5s for new messages to load
        let afterCount = beforeCount;
        for (let i = 0; i < 50; i++) {
          await new Promise(r => setTimeout(r, 100));
          afterCount = document.querySelectorAll('[data-testid^="message-"]:not([data-testid^="message-text-"])').length;
          if (afterCount > beforeCount) break;
        }

        return JSON.stringify({
          before_count: beforeCount,
          after_count: afterCount,
          loaded_more: afterCount > beforeCount,
          reached_top: afterCount === beforeCount  // No new messages loaded → likely at top
        });
      } catch(e) {
        return JSON.stringify({ error: true, message: e.message });
      }
    })()
    """
    print(js)

if __name__ == '__main__':
    main()

import argparse
import sys

def main():
    sys.stdout.reconfigure(encoding='utf-8', newline='\n')
    parser = argparse.ArgumentParser(description='Search X users via GraphQL TypeaheadXChatQuery; returns candidate users with DM permission info')
    parser.add_argument('query', help='Search query (name, screen_name or partial)')
    args = parser.parse_args()

    js = f"""
    (async () => {{
      try {{
        const passcode = document.querySelector('input[pattern="[0-9]*"][maxlength="1"]');
        if (passcode) return JSON.stringify({{ error: true, message: 'passcode_required' }});

        const AUTH = 'Bearer AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA';
        const csrf = document.cookie.split('; ').find(c => c.startsWith('ct0='))?.split('=')[1];
        if (!csrf) return JSON.stringify({{ error: true, message: 'ct0 cookie missing - not logged in' }});

        const url = 'https://api.x.com/graphql/mYbJ7Qq9UAtG-68VAiBpYA/TypeaheadXChatQuery?variables=' +
          encodeURIComponent(JSON.stringify({{
            query: {repr(args.query)},
            include_group_check: true,
            conv_id: null,
            surface: 'NewDm'
          }}));

        const r = await fetch(url, {{
          credentials: 'include',
          headers: {{
            'authorization': AUTH,
            'x-csrf-token': csrf,
            'accept': 'application/graphql-response+json, application/json',
            'apollo-require-preflight': 'true'
          }}
        }});
        if (!r.ok) return JSON.stringify({{ error: true, message: 'HTTP ' + r.status }});
        const j = await r.json();
        const hits = j?.data?.search_by_raw_query?.x_chat_users_typeahead || [];

        const users = hits.map(h => {{
          const u = h.typeahead_user?.user_results?.result || {{}};
          return {{
            user_id: u.rest_id,
            name: u.core?.name,
            screen_name: u.core?.screen_name,
            avatar_url: u.avatar?.image_url,
            is_blue_verified: u.verification?.is_blue_verified,
            is_verified_organization: u.verification?.is_verified_organization,
            verified_type: u.verification?.verified_type,
            can_dm: u.chat_permissions?.can_dm,
            can_dm_on_xchat: u.chat_permissions?.can_dm_on_xchat,
            can_dm_reason: u.chat_permissions?.can_dm_reason,
            protected: u.privacy?.protected,
            suspended: u.privacy?.suspended
          }};
        }});

        return JSON.stringify({{
          query: {repr(args.query)},
          count: users.length,
          users
        }});
      }} catch(e) {{
        return JSON.stringify({{ error: true, message: e.message }});
      }}
    }})()
    """
    print(js)

if __name__ == '__main__':
    main()

import argparse
import sys

def main():
    sys.stdout.reconfigure(encoding='utf-8', newline='\n')
    parser = argparse.ArgumentParser(description='Verify a message was sent by checking if a new self-direction message matching the given text appeared after the given previous last_message_id')
    parser.add_argument('expected_text', help='The message text that was supposed to be sent (exact match)')
    parser.add_argument('--prev-last-id', default='', help='The last_message_id before sending, used to detect the newly appeared message')
    args = parser.parse_args()

    # Escape backticks and ${ for JS template literals
    expected = args.expected_text.replace('\\', '\\\\').replace('`', '\\`').replace('${', '\\${')

    js = f"""
    (() => {{
      try {{
        const expected = `{expected}`;
        const prevLastId = {repr(args.prev_last_id)};
        const msgEls = document.querySelectorAll('[data-testid^="message-"]:not([data-testid^="message-text-"])');
        if (msgEls.length === 0) return JSON.stringify({{ sent: false, reason: 'no messages in conversation' }});

        let foundAfterPrev = false;
        let sawPrev = prevLastId === '';
        for (const el of msgEls) {{
          const id = el.getAttribute('data-testid').replace('message-', '');
          const cls = el.className || '';
          const isSelf = cls.includes('justify-end');
          const textEl = document.querySelector('[data-testid="message-text-' + id + '"]');
          let text = textEl?.textContent || '';
          text = text.replace(/(\\d{{1,2}}:\\d{{2}}\\s?(?:AM|PM)?)+\\s*$/, '').trimEnd();

          if (!sawPrev) {{
            if (id === prevLastId) sawPrev = true;
            continue;
          }}
          if (isSelf && text.includes(expected.trim())) {{
            foundAfterPrev = true;
            break;
          }}
        }}

        // Check for delivery failure: X renders a separate LI with "Failed, Try Again"
        // in dm-message-list when delivery fails (sibling of the message LI, no data-testid)
        const msgList = document.querySelector('[data-testid="dm-message-list"]');
        const hasDeliveryFailed = msgList
          ? [...msgList.querySelectorAll('li')].some(li => li.innerText?.trim() === 'Failed, Try Again')
          : false;

        if (foundAfterPrev && hasDeliveryFailed) {{
          return JSON.stringify({{ sent: false, reason: 'delivery_failed', composer_cleared: document.querySelector('[data-testid="dm-composer-textarea"]')?.value === '', current_message_count: msgEls.length }});
        }}

        const textarea = document.querySelector('[data-testid="dm-composer-textarea"]');
        const composerEmpty = textarea?.value === '';

        return JSON.stringify({{
          sent: foundAfterPrev,
          composer_cleared: composerEmpty,
          current_message_count: msgEls.length
        }});
      }} catch(e) {{
        return JSON.stringify({{ error: true, message: e.message }});
      }}
    }})()
    """
    print(js)

if __name__ == '__main__':
    main()