From 2418f317ac69a7a9c7abee056cbac03ce45eb321 Mon Sep 17 00:00:00 2001 From: autonomic-bot Date: Tue, 4 Aug 2026 05:18:18 +0000 Subject: [PATCH] chore: upgrade synapse to v1.157.2, mautrix-telegram to v0.2607.0 --- .env.sample | 2 +- compose.discord.yml | 2 +- compose.signal.yml | 4 +- compose.telegram.yml | 2 +- compose.yml | 4 +- telegram_bridge.yaml.tmpl | 1099 +++++++++++++++++-------------------- 6 files changed, 516 insertions(+), 597 deletions(-) diff --git a/.env.sample b/.env.sample index b82a423..8b9c329 100644 --- a/.env.sample +++ b/.env.sample @@ -217,7 +217,7 @@ RETENTION_MAX_LIFETIME=4w #VERIFY_SSL=false #ENABLE_ENCRYPTION=true #TELEGRAM_APP_ID= -#TELEGRAM_BRIDGE_PERMISSIONS="{ \"*\": \"relay\", \"@foo:matrix.example.com\": \"admin\" }" +#TELEGRAM_BRIDGE_PERMISSIONS="{ \"*\": \"relaybot\", \"@foo:matrix.example.com\": \"admin\" }" #TELEGRAM_SYNC_CHANNEL_MEMBERS=true #SECRET_TELEGRAM_DB_PASSWORD_VERSION=v1 #SECRET_TELEGRAM_API_HASH_VERSION=v1 diff --git a/compose.discord.yml b/compose.discord.yml index 2ae3b20..84bc62d 100644 --- a/compose.discord.yml +++ b/compose.discord.yml @@ -30,7 +30,7 @@ services: - internal discorddb: - image: postgres:14-alpine + image: postgres:13-alpine secrets: - discord_db_password environment: diff --git a/compose.signal.yml b/compose.signal.yml index f51c3ea..7ebb972 100644 --- a/compose.signal.yml +++ b/compose.signal.yml @@ -10,7 +10,7 @@ services: - signal-data:/signal-data signalbridge: - image: dock.mau.dev/mautrix/signal:v0.2607.0 + image: dock.mau.dev/mautrix/signal:v26.02.2 depends_on: - signaldb configs: @@ -35,7 +35,7 @@ services: - internal signaldb: - image: postgres:14-alpine + image: postgres:13-alpine secrets: - signal_db_password environment: diff --git a/compose.telegram.yml b/compose.telegram.yml index de11b82..2869fe8 100644 --- a/compose.telegram.yml +++ b/compose.telegram.yml @@ -40,7 +40,7 @@ services: - internal telegramdb: - image: postgres:14-alpine + image: postgres:13-alpine secrets: - telegram_db_password environment: diff --git a/compose.yml b/compose.yml index 1260c7f..ef7c030 100644 --- a/compose.yml +++ b/compose.yml @@ -43,7 +43,7 @@ services: start_period: 2m app: - image: "matrixdotorg/synapse:v1.157.1" + image: "matrixdotorg/synapse:v1.157.2" volumes: - "data:/data" secrets: @@ -114,7 +114,7 @@ services: restart_policy: condition: on-failure labels: - - "coop-cloud.${STACK_NAME}.version=7.3.0+v1.155.0" + - "coop-cloud.${STACK_NAME}.version=7.3.1+v1.157.1" - "coop-cloud.${STACK_NAME}.timeout=${TIMEOUT}" healthcheck: test: ["CMD", "curl", "-f", "http://localhost:8008/health"] diff --git a/telegram_bridge.yaml.tmpl b/telegram_bridge.yaml.tmpl index f25f581..11b10d0 100644 --- a/telegram_bridge.yaml.tmpl +++ b/telegram_bridge.yaml.tmpl @@ -1,625 +1,544 @@ -# Network-specific config options -network: - # Get your own API keys at https://my.telegram.org/apps - api_id: {{ env "TELEGRAM_APP_ID" }} - api_hash: {{ secret "telegram_api_hash" }} +# Homeserver details +homeserver: + # The address that this appservice can use to connect to the homeserver. + address: {{ env "HOMESERVER_URL" }} + # The domain of the homeserver (for MXIDs, etc). + domain: {{ env "HOMESERVER_DOMAIN" }} + # Whether or not to verify the SSL certificate of the homeserver. + # Only applies if address starts with https:// + verify_ssl: {{ env "VERIFY_SSL" }} + asmux: false + # Number of retries for all HTTP requests if the homeserver isn't reachable. + http_retry_count: 4 + # The URL to push real-time bridge status to. + # If set, the bridge will make POST requests to this URL whenever a user's Telegram connection state changes. + # The bridge will use the appservice as_token to authorize requests. + status_endpoint: null + # Endpoint for reporting per-message status. + message_send_checkpoint_endpoint: null + # Whether asynchronous uploads via MSC2246 should be enabled for media. + # Requires a media repo that supports MSC2246. + async_media: false - # Device info shown in the Telegram device list. - device_info: - device_model: mautrix-telegram - system_version: - app_version: auto - lang_code: en - system_lang_code: en +# Application service host/registration related details +# Changing these values requires regeneration of the registration. +appservice: + # The address that the homeserver can use to connect to this appservice. + address: http://telegrambridge:29317 + # When using https:// the TLS certificate and key files for the address. + tls_cert: false + tls_key: false + # The hostname and port where this appservice should listen. + hostname: 0.0.0.0 + port: 29317 + # The maximum body size of appservice API requests (from the homeserver) in mebibytes + # Usually 1 is enough, but on high-traffic bridges you might need to increase this to avoid 413s + max_body_size: 1 + + # The full URI to the database. SQLite and Postgres are supported. + # Format examples: + # SQLite: sqlite:///filename.db + # Postgres: postgres://username:password@hostname/dbname + database: postgres://telegrambridge:{{ secret "telegram_db_password" }}@telegramdb/telegrambridge + # Additional arguments for asyncpg.create_pool() or sqlite3.connect() + # https://magicstack.github.io/asyncpg/current/api/index.html#asyncpg.pool.create_pool + # https://docs.python.org/3/library/sqlite3.html#sqlite3.connect + # For sqlite, min_size is used as the connection thread pool size and max_size is ignored. + database_opts: + min_size: 1 + max_size: 10 + + # Public part of web server for out-of-Matrix interaction with the bridge. + # Used for things like login if the user wants to make sure the 2FA password isn't stored in + # the HS database. + public: + # Whether or not the public-facing endpoints should be enabled. + enabled: false + # The prefix to use in the public-facing endpoints. + prefix: /public + # The base URL where the public-facing endpoints are available. The prefix is not added + # implicitly. + external: https://example.com/public + + # Provisioning API part of the web server for automated portal creation and fetching information. + # Used by things like mautrix-manager (https://github.com/tulir/mautrix-manager). + provisioning: + # Whether or not the provisioning API should be enabled. + enabled: false + # The prefix to use in the provisioning API endpoints. + prefix: /_matrix/provision + # The shared secret to authorize users of the API. + # Set to "generate" to generate and save a new token. + shared_secret: generate + + # The unique ID of this appservice. + id: {{ env "APP_SERVICE_ID" }} + # Username of the appservice bot. + bot_username: {{ env "APP_SERVICE_BOT_USERNAME" }} + # Display name and avatar for bot. Set to "remove" to remove display name/avatar, leave empty + # to leave display name/avatar as-is. + bot_displayname: {{ env "APP_SERVICE_DISPLAY_NAME" }} + bot_avatar: mxc://maunium.net/tJCRmUyJDsgRNgqhOgoiHWbX + + # Whether or not to receive ephemeral events via appservice transactions. + # Requires MSC2409 support (i.e. Synapse 1.22+). + # You should disable bridge -> sync_with_custom_puppets when this is enabled. + ephemeral_events: false + + # Authentication tokens for AS <-> HS communication. Autogenerated; do not modify. + as_token: "{{ secret "telegram_as_token" }}" + hs_token: "{{ secret "telegram_hs_token" }}" + +# Prometheus telemetry config. Requires prometheus-client to be installed. +metrics: + enabled: false + listen_port: 8000 + +# Manhole config. +manhole: + # Whether or not opening the manhole is allowed. + enabled: false + # The path for the unix socket. + path: /var/tmp/mautrix-telegram.manhole + # The list of UIDs who can be added to the whitelist. + # If empty, any UIDs can be specified in the open-manhole command. + whitelist: + - 0 + +# Bridge config +bridge: + # Localpart template of MXIDs for Telegram users. + # {userid} is replaced with the user ID of the Telegram user. + username_template: "telegram_{userid}" + # Localpart template of room aliases for Telegram portal rooms. + # {groupname} is replaced with the name part of the public channel/group invite link ( https://t.me/{} ) + alias_template: "telegram_{groupname}" + # Displayname template for Telegram users. + # {displayname} is replaced with the display name of the Telegram user. + displayname_template: "{displayname} (Telegram)" + + # Set the preferred order of user identifiers which to use in the Matrix puppet display name. + # In the (hopefully unlikely) scenario that none of the given keys are found, the numeric user + # ID is used. + # + # If the bridge is working properly, a phone number or an username should always be known, but + # the other one can very well be empty. + # + # Valid keys: + # "full name" (First and/or last name) + # "full name reversed" (Last and/or first name) + # "first name" + # "last name" + # "username" + # "phone number" + displayname_preference: + - full name + - username + - phone number + # Maximum length of displayname + displayname_max_length: 100 + # Remove avatars from Telegram ghost users when removed on Telegram. This is disabled by default + # as there's no way to determine whether an avatar is removed or just hidden from some users. If + # you're on a single-user instance, this should be safe to enable. + allow_avatar_remove: false + + # Maximum number of members to sync per portal when starting up. Other members will be + # synced when they send messages. The maximum is 10000, after which the Telegram server + # will not send any more members. + # -1 means no limit (which means it's limited to 10000 by the server) + max_initial_member_sync: 100 + # Whether or not to sync the member list in channels. + # If no channel admins have logged into the bridge, the bridge won't be able to sync the member + # list regardless of this setting. + sync_channel_members: {{ env "TELEGRAM_SYNC_CHANNEL_MEMBERS" }} + # Whether or not to skip deleted members when syncing members. + skip_deleted_members: true + # Whether or not to automatically synchronize contacts and chats of Matrix users logged into + # their Telegram account at startup. + startup_sync: true + # Number of most recently active dialogs to check when syncing chats. + # Set to 0 to remove limit. + sync_update_limit: 0 + # Number of most recently active dialogs to create portals for when syncing chats. + # Set to 0 to remove limit. + sync_create_limit: 30 + # Whether or not to sync and create portals for direct chats at startup. + sync_direct_chats: false + # The maximum number of simultaneous Telegram deletions to handle. + # A large number of simultaneous redactions could put strain on your homeserver. + max_telegram_delete: 10 + # Whether or not to automatically sync the Matrix room state (mostly unpuppeted displaynames) + # at startup and when creating a bridge. + sync_matrix_state: true + # Allow logging in within Matrix. If false, users can only log in using login-qr or the + # out-of-Matrix login website (see appservice.public config section) + allow_matrix_login: true + # Whether or not to bridge plaintext highlights. + # Only enable this if your displayname_template has some static part that the bridge can use to + # reliably identify what is a plaintext highlight. + plaintext_highlights: false + # Whether or not to make portals of publicly joinable channels/supergroups publicly joinable on Matrix. + public_portals: true + # Whether or not to use /sync to get presence, read receipts and typing notifications + # when double puppeting is enabled + sync_with_custom_puppets: true + # Whether or not to update the m.direct account data event when double puppeting is enabled. + # Note that updating the m.direct event is not atomic (except with mautrix-asmux) + # and is therefore prone to race conditions. + sync_direct_chat_list: false + # Servers to always allow double puppeting from + double_puppet_server_map: + {{ env "HOMESERVER_DOMAIN" }}: {{ env "HOMESERVER_URL" }} + # Allow using double puppeting from any server with a valid client .well-known file. + double_puppet_allow_discovery: false + # Shared secrets for https://github.com/devture/matrix-synapse-shared-secret-auth + # + # If set, custom puppets will be enabled automatically for local users + # instead of users having to find an access token and run `login-matrix` + # manually. + # If using this for other servers than the bridge's server, + # you must also set the URL in the double_puppet_server_map. + login_shared_secret_map: + {{ env "HOMESERVER_DOMAIN" }}: {{ secret "shared_secret_auth" }} + # Set to false to disable link previews in messages sent to Telegram. + telegram_link_preview: true + # Whether or not the !tg join command should do a HTTP request + # to resolve redirects in invite links. + invite_link_resolve: false + # Use inline images instead of a separate message for the caption. + # N.B. Inline images are not supported on all clients (e.g. Element iOS/Android). + inline_images: false + # Maximum size of image in megabytes before sending to Telegram as a document. + image_as_file_size: 10 + # Maximum number of pixels in an image before sending to Telegram as a document. Defaults to 1280x1280 = 1638400. + image_as_file_pixels: 1638400 + # Enable experimental parallel file transfer, which makes uploads/downloads much faster by + # streaming from/to Matrix and using many connections for Telegram. + # Note that generating HQ thumbnails for videos is not possible with streamed transfers. + # This option uses internal Telethon implementation details and may break with minor updates. + parallel_file_transfer: false + # Whether or not created rooms should have federation enabled. + # If false, created portal rooms will never be federated. + federate_rooms: true # Settings for converting animated stickers. animated_sticker: # Format to which animated stickers should be converted. - # - # disable - no conversion, send as-is (gzipped lottie) - # png - converts to non-animated png (fastest), - # gif - converts to animated gif - # webm - converts to webm video, requires ffmpeg executable with vp9 codec - # and webm container support - # webp - converts to animated webp, requires ffmpeg executable with webp - # codec/container support + # disable - No conversion, send as-is (gzipped lottie) + # png - converts to non-animated png (fastest), + # gif - converts to animated gif + # webm - converts to webm video, requires ffmpeg executable with vp9 codec and webm container support target: gif - # Should video stickers be converted to the specified format as well? - convert_from_webm: false # Arguments for converter. All converters take width and height. args: width: 256 height: 256 - fps: 25 # only for webm, webp and gif (2, 5, 10, 20 or 25 recommended) - - # Settings for syncing the member list for portals. - member_list: - # Maximum number of members to sync per portal when starting up. Other - # members will be synced when they send messages. The maximum is 10000, - # after which the Telegram server will not send any more members. - # - # -1 means no limit (which means it's limited to 10000 by the server) - max_initial_sync: 100 - # Whether or not to sync the member list in broadcast channels. If - # disabled, members will still be synced when they send messages. - # - # If no channel admins have logged into the bridge, the bridge won't be - # able to sync the member list regardless of this setting. - sync_broadcast_channels: {{ env "TELEGRAM_SYNC_CHANNEL_MEMBERS" }} - # Whether or not to skip deleted members when syncing members. - skip_deleted: true - - # Settings for pings to the Telegram server. - ping: - # The interval (in seconds) between pings. - interval_seconds: 30 - # The timeout (in seconds) for a single ping. - timeout_seconds: 10 - - # Proxy settings - proxy: - # Allowed types: disabled, socks5, mtproxy - type: disabled - # Proxy IP address/domain name and port. - address: "127.0.0.1:1080" - # Proxy authentication (optional). Put MTProxy secret in password field. - username: - password: - - sync: - # Number of most recently active dialogs to check when syncing chats. - # Set to -1 to remove limit. - update_limit: 100 - # Number of most recently active dialogs to create portals for when syncing chats. - # Set to -1 to remove limit. - create_limit: 15 - # Number of chats to sync immediately on login before the data export is accepted. - # The create_limit above still applies. This is ignored if takeout.dialog_sync is false. - login_sync_limit: 15 - # Whether or not to sync and create portals for direct chats at startup. - direct_chats: true - - takeout: - # Should the bridge use the data export mode for syncing the full chat list? - # If true, login_sync_limit of chats is synced immediately on login, - # then the rest are synced after the takeout is accepted. - dialog_sync: false - # Should the bridge use the data export mode for forward backfilling messages? - # This should be set to true if the forward backfill limits are set to high values, - # but is probably not necessary otherwise. - forward_backfill: false - # Should the bridge use the data export mode for backward backfilling messages? - # This only affects the backfill queue, which is only available on Beeper. - backward_backfill: false - - # Maximum number of participants in chats to bridge. Only applies when the - # portal is being created. If there are more members when trying to create - # a room, the room creation will be cancelled. + fps: 25 # only for webm and gif (2, 5, 10, 20 or 25 recommended) + # End-to-bridge encryption support options. # - # -1 means no limit (which means all chats can be bridged) - max_member_count: -1 - # Should personal avatars (that are only visible to specific users) be allowed? - contact_avatars: false - # Should contact names be updated from any source even if a name is already set? - # Note that contact names will still be used if there's no other name available. - contact_names: false - # Should the bridge send all unicode reactions as custom emoji reactions to - # Telegram? By default, the bridge only uses custom emojis for unicode emojis - # that aren't allowed in reactions. - always_custom_emoji_reaction: false - # The avatar to use for the Telegram Saved Messages chat - saved_message_avatar: mxc://maunium.net/XhhfHoPejeneOngMyBbtyWDk - # Create a new room and tombstone the old one when upgrading rooms - always_tombstone_on_supergroup_migration: false - # Maximum number of pixels in an image before sending to Telegram as a - # document. Defaults to 4096x4096 = 16777216. - image_as_file_pixels: 16777216 - # Should view-once messages be disabled entirely? - disable_view_once: false - # Should video URL previews be bridged as m.video messages to Matrix? - # By default, video URL previews will not be bridged. - video_url_preview_as_file: false - # Displayname template for Telegram users. - # {{ "{{ .FullName }}" }} - the full name of the Telegram user - # {{ "{{ .FirstName }}" }} - the first name of the Telegram user - # {{ "{{ .LastName }}" }} - the last name of the Telegram user - # {{ "{{ .Username }}" }} - the primary username of the Telegram user, if the user has one - # {{ "{{ .UserID }}" }} - the internal user ID of the Telegram user - # {{ "{{ .Deleted }}" }} - true if the user has been deleted, false otherwise - displayname_template: '{{ "{{ if .Deleted }}Deleted account {{ .UserID }}{{ else }}{{ .FullName }}{{ end }}" }}' - - -# Config options that affect the central bridge module. -bridge: - # The prefix for commands. Only required in non-management rooms. - command_prefix: '!tg' - # Should the bridge create a space for each login containing the rooms that account is in? - personal_filtering_spaces: true - # Whether the bridge should set names and avatars explicitly for DM portals. - # This is only necessary when using clients that don't support MSC4171. - private_chat_portal_meta: true - # Should events be handled asynchronously within portal rooms? - # If true, events may end up being out of order, but slow events won't block other ones. - # This is not yet safe to use. - async_events: false - # Should every user have their own portals rather than sharing them? - # By default, users who are in the same group on the remote network will be - # in the same Matrix room bridged to that group. If this is set to true, - # every user will get their own Matrix room instead. - # SETTING THIS IS IRREVERSIBLE AND POTENTIALLY DESTRUCTIVE IF PORTALS ALREADY EXIST. - split_portals: false - # Should the bridge resend `m.bridge` events to all portals on startup? + # See https://docs.mau.fi/bridges/general/end-to-bridge-encryption.html for more info. + encryption: + # Allow encryption, work in group chat rooms with e2ee enabled + allow: {{ env "ENABLE_ENCRYPTION" }} + # Default to encryption, force-enable encryption in all portals the bridge creates + # This will cause the bridge bot to be in private chats for the encryption to work properly. + default: false + # Database for the encryption data. If set to `default`, will use the appservice database. + database: default + # Options for automatic key sharing. + key_sharing: + # Enable key sharing? If enabled, key requests for rooms where users are in will be fulfilled. + # You must use a client that supports requesting keys from other users to use this feature. + allow: false + # Require the requesting device to have a valid cross-signing signature? + # This doesn't require that the bridge has verified the device, only that the user has verified it. + # Not yet implemented. + require_cross_signing: false + # Require devices to be verified by the bridge? + # Verification by the bridge is not yet implemented. + require_verification: false + # Whether or not to explicitly set the avatar and room name for private + # chat portal rooms. This will be implicitly enabled if encryption.default is true. + private_chat_portal_meta: false + # Whether or not the bridge should send a read receipt from the bridge bot when a message has + # been sent to Telegram. + delivery_receipts: false + # Whether or not delivery errors should be reported as messages in the Matrix room. + delivery_error_reports: false + # Set this to true to tell the bridge to re-send m.bridge events to all rooms on the next run. + # This field will automatically be changed back to false after it, + # except if the config file is not writable. resend_bridge_info: false - # Should `m.bridge` events be sent without a state key? - # By default, the bridge uses a unique key that won't conflict with other bridges. - no_bridge_info_state_key: false - # Should bridge connection status be sent to the management room as `m.notice` events? - # These contain the same data that can be posted to an external HTTP server using homeserver -> status_endpoint. - # Allowed values: none, errors, all - bridge_status_notices: errors - # How long after an unknown error should the bridge attempt a full reconnect? - # Must be at least 1 minute. The bridge will add an extra ±20% jitter to this value. - unknown_error_auto_reconnect: null - # Maximum number of times to do the auto-reconnect above. - # The counter is per login, but is never reset except on logout and restart. - unknown_error_max_auto_reconnects: 10 - - # Should leaving Matrix rooms be bridged as leaving groups on the remote network? - bridge_matrix_leave: false - # Should `m.notice` messages be bridged? - bridge_notices: false - # Should room tags only be synced when creating the portal? Tags mean things like favorite/pin and archive/low priority. - # Tags currently can't be synced back to the remote network, so a continuous sync means tagging from Matrix will be undone. + # When using double puppeting, should muted chats be muted in Matrix? + mute_bridging: false + # When using double puppeting, should pinned chats be moved to a specific tag in Matrix? + # The favorites tag is `m.favourite`. + pinned_tag: null + # Same as above for archived chats, the low priority tag is `m.lowpriority`. + archive_tag: null + # Whether or not mute status and tags should only be bridged when the portal room is created. tag_only_on_create: true - # List of tags to allow bridging. If empty, no tags will be bridged. - only_bridge_tags: [m.favourite, m.lowpriority] - # Should room mute status only be synced when creating the portal? - # Like tags, mutes can't currently be synced back to the remote network. - mute_only_on_create: true - # Should the bridge check the db to ensure that incoming events haven't been handled before - deduplicate_matrix_messages: false - # Should cross-room reply metadata be bridged? - # Most Matrix clients don't support this and servers may reject such messages too. - cross_room_replies: false - # If a state event fails to bridge, should the bridge revert any state changes made by that event? - revert_failed_state_changes: false - # In portals with no relay set, should Matrix users be kicked if they're - # not logged into an account that's in the remote chat? - kick_matrix_users: true - # Should the bridge listen to com.beeper.state_request events? - # This is not necessary for anything outside of Beeper. - enable_send_state_requests: false - # Should the com.beeper.bridge.identifiers list in global ghost profiles include phone numbers? - phone_numbers_in_profile: false + # Should leaving the room on Matrix make the user leave on Telegram? + bridge_matrix_leave: true + # Should the user be kicked out of all portals when logging out of the bridge? + kick_on_logout: true + # Should the "* user joined Telegram" notice always be marked as read automatically? + always_read_joined_telegram_notice: true + # Settings for backfilling messages from Telegram. + backfill: + # Whether or not the Telegram ghosts of logged in Matrix users should be + # invited to private chats when backfilling history from Telegram. This is + # usually needed to prevent rate limits and to allow timestamp massaging. + invite_own_puppet: true + # Maximum number of messages to backfill without using a takeout. + # The first time a takeout is used, the user has to manually approve it from a different + # device. If initial_limit or missed_limit are higher than this value, the bridge will ask + # the user to accept the takeout after logging in before syncing any chats. + takeout_limit: 100 + # Maximum number of messages to backfill initially. + # Set to 0 to disable backfilling when creating portal, or -1 to disable the limit. + # + # N.B. Initial backfill will only start after member sync. Make sure your + # max_initial_member_sync is set to a low enough value so it doesn't take forever. + initial_limit: 0 + # Maximum number of messages to backfill if messages were missed while the bridge was + # disconnected. Note that this only works for logged in users and only if the chat isn't + # older than sync_update_limit + # Set to 0 to disable backfilling missed messages. + missed_limit: 50 + # If using double puppeting, should notifications be disabled + # while the initial backfill is in progress? + disable_notifications: false + # Whether or not to enable backfilling in normal groups. + # Normal groups have numerous technical problems in Telegram, and backfilling normal groups + # will likely cause problems if there are multiple Matrix users in the group. + normal_groups: false - # What should be done to portal rooms when a user logs out or is logged out? - # Permitted values: - # nothing - Do nothing, let the user stay in the portals - # kick - Remove the user from the portal rooms, but don't delete them - # unbridge - Remove all ghosts in the room and disassociate it from the remote chat - # delete - Remove all ghosts and users from the room (i.e. delete it) - cleanup_on_logout: - # Should cleanup on logout be enabled at all? - enabled: false - # Settings for manual logouts (explicitly initiated by the Matrix user) - manual: - # Action for private portals which will never be shared with other Matrix users. - private: nothing - # Action for portals with a relay user configured. - relayed: nothing - # Action for portals which may be shared, but don't currently have any other Matrix users. - shared_no_users: nothing - # Action for portals which have other logged-in Matrix users. - shared_has_users: nothing - # Settings for credentials being invalidated (initiated by the remote network, possibly through user action). - # Keys have the same meanings as in the manual section. - bad_credentials: - private: nothing - relayed: nothing - shared_no_users: nothing - shared_has_users: nothing + # Overrides for base power levels. + initial_power_level_overrides: + user: {} + group: {} - # Settings for relay mode - relay: - # Whether relay mode should be allowed. If allowed, the set-relay command can be used to turn any - # authenticated user into a relaybot for that chat. - enabled: true - # Should only admins be allowed to set themselves as relay users? - # If true, non-admins can only set users listed in default_relays as relays in a room. - admin_only: true - # Should default relays be preferred when an explicit login ID isn't specified even if the user is logged in? - # This applies to the set-relay and bridge commands sent by any user, including admins. - prefer_default: true - # Should non-admins be allowed to use the bridge and sync-chat commands via default relays specified below? - allow_bridge: true - # List of user login IDs which anyone can set as a relay, as long as the relay user is in the room. - default_relays: [] - # The formats to use when sending messages via the relaybot. - # Available variables: - # .Sender.UserID - The Matrix user ID of the sender. - # .Sender.Displayname - The display name of the sender (if set). - # .Sender.RequiresDisambiguation - Whether the sender's name may be confused with the name of another user in the room. - # .Sender.DisambiguatedName - The disambiguated name of the sender. This will be the displayname if set, - # plus the user ID in parentheses if the displayname is not unique. - # If the displayname is not set, this is just the user ID. - # .Message - The `formatted_body` field of the message. - # .Caption - The `formatted_body` field of the message, if it's a caption. Otherwise an empty string. - # .FileName - The name of the file being sent. - message_formats: - m.text: "{{`{{ .Sender.DisambiguatedName }}: {{ .Message }}`}}" - m.notice: "{{`{{ .Sender.DisambiguatedName }}: {{ .Message }}`}}" - m.emote: "{{`* {{ .Sender.DisambiguatedName }} {{ .Message }}`}}" - m.file: "{{`{{ .Sender.DisambiguatedName }} sent a file{{ if .Caption }}: {{ .Caption }}{{ end }}`}}" - m.image: "{{`{{ .Sender.DisambiguatedName }} sent an image{{ if .Caption }}: {{ .Caption }}{{ end }}`}}" - m.audio: "{{`{{ .Sender.DisambiguatedName }} sent an audio file{{ if .Caption }}: {{ .Caption }}{{ end }}`}}" - m.video: "{{`{{ .Sender.DisambiguatedName }} sent a video{{ if .Caption }}: {{ .Caption }}{{ end }}`}}" - m.location: "{{`{{ .Sender.DisambiguatedName }} sent a location{{ if .Caption }}: {{ .Caption }}{{ end }}`}}" - # For networks that support per-message displaynames (i.e. Slack and Discord), the template for those names. - # This has all the Sender variables available under message_formats (but without the .Sender prefix). - # Note that you need to manually remove the displayname from message_formats above. - displayname_format: "{{`{{ .DisambiguatedName }}`}}" + # Whether to bridge Telegram bot messages as m.notices or m.texts. + bot_messages_as_notices: true + bridge_notices: + # Whether or not Matrix bot messages (type m.notice) should be bridged. + default: false + # List of user IDs for whom the previous flag is flipped. + # e.g. if bridge_notices.default is false, notices from other users will not be bridged, but + # notices from users listed here will be bridged. + exceptions: [] - # Filter for automatically creating portals. - portal_create_filter: - # The mode for filtering, either `deny` or `allow` - mode: deny - # The list of portal IDs to deny or allow depending on the mode config. - # Items here can either be the plain portal ID as a string, or an object with `id` and `receiver` fields. - # The receiver field is necessary if you want to target a specific DM portal for example. + # An array of possible values for the $distinguisher variable in message formats. + # Each user gets one of the values here, based on a hash of their user ID. + # If the array is empty, the $distinguisher variable will also be empty. + relay_user_distinguishers: ["🟦", "🟣", "🟩", "⭕️", "🔶", "⬛️", "🔵", "🟢"] + # The formats to use when sending messages to Telegram via the relay bot. + # Text msgtypes (m.text, m.notice and m.emote) support HTML, media msgtypes don't. + # + # Available variables: + # $sender_displayname - The display name of the sender (e.g. Example User) + # $sender_username - The username (Matrix ID localpart) of the sender (e.g. exampleuser) + # $sender_mxid - The Matrix ID of the sender (e.g. @exampleuser:example.com) + # $distinguisher - A random string from the options in the relay_user_distinguishers array. + # $message - The message content + message_formats: + m.text: "$distinguisher $sender_displayname: $message" + m.notice: "$distinguisher $sender_displayname: $message" + m.emote: "* $distinguisher $sender_displayname $message" + m.file: "$distinguisher $sender_displayname sent a file: $message" + m.image: "$distinguisher $sender_displayname sent an image: $message" + m.audio: "$distinguisher $sender_displayname sent an audio file: $message" + m.video: "$distinguisher $sender_displayname sent a video: $message" + m.location: "$distinguisher $sender_displayname sent a location: $message" + # Telegram doesn't have built-in emotes, this field specifies how m.emote's from authenticated + # users are sent to telegram. All fields in message_formats are supported. Additionally, the + # Telegram user info is available in the following variables: + # $displayname - Telegram displayname + # $username - Telegram username (may not exist) + # $mention - Telegram @username or displayname mention (depending on which exists) + emote_format: "* $mention $formatted_body" + + # The formats to use when sending state events to Telegram via the relay bot. + # + # Variables from `message_formats` that have the `sender_` prefix are available without the prefix. + # In name_change events, `$prev_displayname` is the previous displayname. + # + # Set format to an empty string to disable the messages for that event. + state_event_formats: + join: "$distinguisher $displayname joined the room." + leave: "$distinguisher $displayname left the room." + name_change: "$distinguisher $prev_displayname changed their name to $distinguisher $displayname" + + # Filter rooms that can/can't be bridged. Can also be managed using the `filter` and + # `filter-mode` management commands. + # + # Filters do not affect direct chats. + # An empty blacklist will essentially disable the filter. + filter: + # Filter mode to use. Either "blacklist" or "whitelist". + # If the mode is "blacklist", the listed chats will never be bridged. + # If the mode is "whitelist", only the listed chats can be bridged. + mode: blacklist + # The list of group/channel IDs to filter. list: [] - # A list of user login IDs from which to always deny creating portals. - # This is meant to be used with default relays, such that the relay bot - # being added to a group wouldn't automatically trigger portal creation. - always_deny_from_login: [] + + # The prefix for commands. Only required in non-management rooms. + command_prefix: "!tg" + + # Messages sent upon joining a management room. + # Markdown is supported. The defaults are listed below. + management_room_text: + # Sent when joining a room. + welcome: "Hello, I'm a Telegram bridge bot." + # Sent when joining a management room and the user is already logged in. + welcome_connected: "Use `help` for help." + # Sent when joining a management room and the user is not logged in. + welcome_unconnected: "Use `help` for help or `login` to log in." + # Optional extra text sent when joining a management room. + additional_help: "" + + # Send each message separately (for readability in some clients) + management_room_multiple_messages: false # Permissions for using the bridge. # Permitted values: - # relay - Talk through the relaybot (if enabled), no access otherwise - # commands - Access to use commands in the bridge, but not login. - # user - Access to use the bridge with puppeting. - # admin - Full access, user level with some additional administration tools. + # relaybot - Only use the bridge via the relaybot, no access to commands. + # user - Relaybot level + access to commands to create bridges. + # puppeting - User level + logging in with a Telegram account. + # full - Full access to use the bridge, i.e. previous levels + Matrix login. + # admin - Full access to use the bridge and some extra administration commands. # Permitted keys: # * - All Matrix users # domain - All users on that homeserver # mxid - Specific user permissions: {{ env "TELEGRAM_BRIDGE_PERMISSIONS" }} -# Config for the bridge's database. -database: - # The database type. "sqlite3-fk-wal" and "postgres" are supported. - type: postgres - # The database URI. - # SQLite: A raw file path is supported, but `file:?_txlock=immediate` is recommended. - # https://github.com/mattn/go-sqlite3#connection-string - # Postgres: Connection string. For example, postgres://user:password@host/database?sslmode=disable - # To connect via Unix socket, use something like postgres:///dbname?host=/var/run/postgresql - uri: postgres://telegrambridge:{{ secret "telegram_db_password" }}@telegramdb/telegrambridge?sslmode=disable - # Maximum number of connections. - max_open_conns: 5 - max_idle_conns: 1 - # Maximum connection idle time and lifetime before they're closed. Disabled if null. - # Parsed with https://pkg.go.dev/time#ParseDuration - max_conn_idle_time: null - max_conn_lifetime: null + # Options related to the message relay Telegram bot. + relaybot: + private_chat: + # List of users to invite to the portal when someone starts a private chat with the bot. + # If empty, private chats with the bot won't create a portal. + invite: [] + # Whether or not to bridge state change messages in relaybot private chats. + state_changes: true + # When private_chat_invite is empty, this message is sent to users /starting the + # relaybot. Telegram's "markdown" is supported. + message: This is a Matrix bridge relaybot and does not support direct chats + # List of users to invite to all group chat portals created by the bridge. + group_chat_invite: [] + # Whether or not the relaybot should not bridge events in unbridged group chats. + # If false, portals will be created when the relaybot receives messages, just like normal + # users. This behavior is usually not desirable, as it interferes with manually bridging + # the chat to another room. + ignore_unbridged_group_chat: true + # Whether or not to allow creating portals from Telegram. + authless_portals: true + # Whether or not to allow Telegram group admins to use the bot commands. + whitelist_group_admins: true + # Whether or not to ignore incoming events sent by the relay bot. + ignore_own_incoming_events: true + # List of usernames/user IDs who are also allowed to use the bot commands. + whitelist: + - myusername + - 12345678 -# Homeserver details. -homeserver: - # The address that this appservice can use to connect to the homeserver. - # Local addresses without HTTPS are generally recommended when the bridge is running on the same machine, - # but https also works if they run on different machines. - address: {{ env "HOMESERVER_URL" }} - # The domain of the homeserver (also known as server_name, used for MXIDs, etc). - domain: {{ env "HOMESERVER_DOMAIN" }} +# Telegram config +telegram: + # Get your own API keys at https://my.telegram.org/apps + api_id: {{ env "TELEGRAM_APP_ID" }} + api_hash: {{ secret "telegram_api_hash" }} + # (Optional) Create your own bot at https://t.me/BotFather + bot_token: {{ secret "telegram_bot_token" }} - # What software is the homeserver running? - # Standard Matrix homeservers like Synapse, Dendrite and Conduit should just use "standard" here. - software: standard - # The URL to push real-time bridge status to. - # If set, the bridge will make POST requests to this URL whenever a user's remote network connection state changes. - # The bridge will use the appservice as_token to authorize requests. - status_endpoint: - # Endpoint for reporting per-message status. - # If set, the bridge will make POST requests to this URL when processing a message from Matrix. - # It will make one request when receiving the message (step BRIDGE), one after decrypting if applicable - # (step DECRYPTED) and one after sending to the remote network (step REMOTE). Errors will also be reported. - # The bridge will use the appservice as_token to authorize requests. - message_send_checkpoint_endpoint: - # Does the homeserver support https://github.com/matrix-org/matrix-spec-proposals/pull/2246? - async_media: false + # Telethon connection options. + connection: + # The timeout in seconds to be used when connecting. + timeout: 120 + # How many times the reconnection should retry, either on the initial connection or when + # Telegram disconnects us. May be set to a negative or null value for infinite retries, but + # this is not recommended, since the program can get stuck in an infinite loop. + retries: 5 + # The delay in seconds to sleep between automatic reconnections. + retry_delay: 1 + # The threshold below which the library should automatically sleep on flood wait errors + # (inclusive). For instance, if a FloodWaitError for 17s occurs and flood_sleep_threshold + # is 20s, the library will sleep automatically. If the error was for 21s, it would raise + # the error instead. Values larger than a day (86400) will be changed to a day. + flood_sleep_threshold: 60 + # How many times a request should be retried. Request are retried when Telegram is having + # internal issues, when there is a FloodWaitError less than flood_sleep_threshold, or when + # there's a migrate error. May take a negative or null value for infinite retries, but this + # is not recommended, since some requests can always trigger a call fail (such as searching + # for messages). + request_retries: 5 - # Should the bridge use a websocket for connecting to the homeserver? - # The server side is currently not documented anywhere and is only implemented by mautrix-wsproxy, - # mautrix-asmux (deprecated), and hungryserv (proprietary). - websocket: false - # How often should the websocket be pinged? Pinging will be disabled if this is zero. - ping_interval_seconds: 0 - # When requests to the homeserver fail with a 502/503/504/429 status or a network error, - # how many times should the bridge retry the request before giving up? - retry_limit: 4 + # Device info sent to Telegram. + device_info: + # "auto" = OS name+version. + device_model: auto + # "auto" = Telethon version. + system_version: auto + # "auto" = mautrix-telegram version. + app_version: auto + lang_code: en + system_lang_code: en -# Application service host/registration related details. -# Changing these values requires regeneration of the registration (except when noted otherwise) -appservice: - # The address that the homeserver can use to connect to this appservice. - # Like the homeserver address, a local non-https address is recommended when the bridge is on the same machine. - # If the bridge is elsewhere, you must secure the connection yourself (e.g. with https or wireguard) - # If you want to use https, you need to use a reverse proxy. The bridge does not have TLS support built in. - address: http://telegrambridge:29317 - # A public address that external services can use to reach this appservice. - # This is only needed for things like public media. A reverse proxy is generally necessary when using this field. - # This value doesn't affect the registration file. - public_address: https://bridge.example.com - - # The hostname and port where this appservice should listen. - # For Docker, you generally have to change the hostname to 0.0.0.0. - hostname: 0.0.0.0 - port: 29317 - - # The unique ID of this appservice. - id: {{ env "APP_SERVICE_ID" }} - # Appservice bot details. - bot: - # Username of the appservice bot. - username: {{ env "APP_SERVICE_BOT_USERNAME" }} - # Display name and avatar for bot. Set to "remove" to remove display name/avatar, leave empty - # to leave display name/avatar as-is. - displayname: {{ env "APP_SERVICE_DISPLAY_NAME" }} - avatar: mxc://maunium.net/tJCRmUyJDsgRNgqhOgoiHWbX - - # Whether to receive ephemeral events via appservice transactions. - ephemeral_events: true - # Should incoming events be handled asynchronously? - # This may be necessary for large public instances with lots of messages going through. - # However, messages will not be guaranteed to be bridged in the same order they were sent in. - # This value doesn't affect the registration file. - async_transactions: false - - # Authentication tokens for AS <-> HS communication. Autogenerated; do not modify. - as_token: "{{ secret "telegram_as_token" }}" - hs_token: "{{ secret "telegram_hs_token" }}" - - # Localpart template of MXIDs for remote users. - # {{ "{{.}}" }} is replaced with the internal ID of the user. - username_template: telegram_{{ "{{.}}" }} - -# Config options that affect the Matrix connector of the bridge. -matrix: - # Whether the bridge should send the message status as a custom com.beeper.message_send_status event. - message_status_events: false - # Whether the bridge should send a read receipt after successfully bridging a message. - delivery_receipts: false - # Whether the bridge should send error notices via m.notice events when a message fails to bridge. - message_error_notices: true - # Whether the bridge should update the m.direct account data event when double puppeting is enabled. - sync_direct_chat_list: true - # Whether created rooms should have federation enabled. If false, created portal rooms - # will never be federated. Changing this option requires recreating rooms. - federate_rooms: true - # The threshold as bytes after which the bridge should roundtrip uploads via the disk - # rather than keeping the whole file in memory. - upload_file_threshold: 5242880 - # Should the bridge set additional custom profile info for ghosts? - # This can make a lot of requests, as there's no batch profile update endpoint. - ghost_extra_profile_info: false - -# Segment-compatible analytics endpoint for tracking some events, like provisioning API login and encryption errors. -analytics: - # API key to send with tracking requests. Tracking is disabled if this is null. - token: null - # Address to send tracking requests to. - url: https://api.segment.io/v1/track - # Optional user ID for tracking events. If null, defaults to using Matrix user ID. - user_id: null - -# Settings for provisioning API -provisioning: - # Shared secret for authentication. If set to "generate" or null, a random secret will be generated, - # or if set to "disable", the provisioning API will be disabled. Must be at least 16 characters. - shared_secret: generate - # Whether to allow provisioning API requests to be authed using Matrix access tokens. - # This follows the same rules as double puppeting to determine which server to contact to check the token, - # which means that by default, it only works for users on the same server as the bridge. - allow_matrix_auth: true - # Enable debug API at /debug with provisioning authentication. - debug_endpoints: false - # Enable session transfers between bridges. Note that this only validates Matrix or shared secret - # auth before passing live network client credentials down in the response. - enable_session_transfers: false - -# Some networks require publicly accessible media download links (e.g. for user avatars when using Discord webhooks). -# These settings control whether the bridge will provide such public media access. -public_media: - # Should public media be enabled at all? - # The public_address field under the appservice section MUST be set when enabling public media. - enabled: false - # A key for signing public media URLs. - # If set to "generate", a random key will be generated. - signing_key: generate - # Number of seconds that public media URLs are valid for. - # If set to 0, URLs will never expire. - expiry: 0 - # Length of hash to use for public media URLs. Must be between 0 and 32. - hash_length: 32 - # The path prefix for generated URLs. Note that this will NOT change the path where media is actually served. - # If you change this, you must configure your reverse proxy to rewrite the path accordingly. - path_prefix: /_mautrix/publicmedia - # Should the bridge store media metadata in the database in order to support encrypted media and generate shorter URLs? - # If false, the generated URLs will just have the MXC URI and a HMAC signature. - # The hash_length field will be used to decide the length of the generated URL. - # This also allows invalidating URLs by deleting the database entry. - use_database: false - -# Settings for converting remote media to custom mxc:// URIs instead of reuploading. -# More details can be found at https://docs.mau.fi/bridges/go/discord/direct-media.html -direct_media: - # Should custom mxc:// URIs be used instead of reuploading media? - enabled: false - # The server name to use for the custom mxc:// URIs. - # This server name will effectively be a real Matrix server, it just won't implement anything other than media. - # You must either set up .well-known delegation from this domain to the bridge, or proxy the domain directly to the bridge. - server_name: discord-media.example.com - # Optionally a custom .well-known response. This defaults to `server_name:443` - well_known_response: - # Optionally specify a custom prefix for the media ID part of the MXC URI. - media_id_prefix: - # If the remote network supports media downloads over HTTP, then the bridge will use MSC3860/MSC3916 - # media download redirects if the requester supports it. Optionally, you can force redirects - # and not allow proxying at all by setting this to false. - # This option does nothing if the remote network does not support media downloads over HTTP. - allow_proxy: true - # Matrix server signing key to make the federation tester pass, same format as synapse's .signing.key file. - # This key is also used to sign the mxc:// URIs to ensure only the bridge can generate them. - server_key: generate - -# Settings for backfilling messages. -# Note that the exact way settings are applied depends on the network connector. -# See https://docs.mau.fi/bridges/general/backfill.html for more details. -backfill: - # Whether to do backfilling at all. - enabled: false - # Maximum number of messages to backfill in empty rooms. - # If this is zero or negative, backfill will be disabled in new rooms. - max_initial_messages: 50 - # Maximum number of missed messages to backfill after bridge restarts. - max_catchup_messages: 500 - # If a backfilled chat is older than this number of hours, - # mark it as read even if it's unread on the remote network. - unread_hours_threshold: 720 - # Settings for backfilling threads within other backfills. - threads: - # Maximum number of messages to backfill in a new thread. - max_initial_messages: 50 - # Settings for the backwards backfill queue. This only applies when connecting to - # Beeper as standard Matrix servers don't support inserting messages into history. - queue: - # Should the backfill queue be enabled? + # Custom server to connect to. + server: + # Set to true to use these server settings. If false, will automatically + # use production server assigned by Telegram. Set to false in production. enabled: false - # Should manual calls to backfill queue tasks be allowed? - manual: false - # Number of messages to backfill in one batch. - batch_size: 100 - # Delay between batches in seconds. - batch_delay: 20 - # Maximum number of batches to backfill per portal. - # If set to -1, all available messages will be backfilled. - max_batches: -1 - # Optional network-specific overrides for max batches. - # Interpretation of this field depends on the network connector. - max_batches_override: {} + # The DC ID to connect to. + dc: 2 + # The IP to connect to. + ip: 149.154.167.40 + # The port to connect to. 443 may not work, 80 is better and both are equally secure. + port: 80 -# Settings for enabling double puppeting -double_puppet: - # Servers to always allow double puppeting from. - # This is only for other servers and should NOT contain the server the bridge is on. - servers: - {{ env "HOMESERVER_DOMAIN" }}: {{ env "HOMESERVER_URL" }} - # Whether to allow client API URL discovery for other servers. When using this option, - # users on other servers can use double puppeting even if their server URLs aren't - # explicitly added to the servers map above. - allow_discovery: false - # Shared secrets for automatic double puppeting. - # See https://docs.mau.fi/bridges/general/double-puppeting.html for instructions. - secrets: - {{ env "HOMESERVER_DOMAIN" }}: {{ secret "shared_secret_auth" }} + # Telethon proxy configuration. + # You must install PySocks from pip for proxies to work. + proxy: + # Allowed types: disabled, socks4, socks5, http, mtproxy + type: disabled + # Proxy IP address and port. + address: 127.0.0.1 + port: 1080 + # Whether or not to perform DNS resolving remotely. Only for socks/http proxies. + rdns: true + # Proxy authentication (optional). Put MTProxy secret in password field. + username: "" + password: "" -# End-to-bridge encryption support options. +# Python logging configuration. # -# See https://docs.mau.fi/bridges/general/end-to-bridge-encryption.html for more info. -encryption: - # Whether to enable encryption at all. If false, the bridge will not function in encrypted rooms. - allow: {{ env "ENABLE_ENCRYPTION" }} - # Whether to force-enable encryption in all bridged rooms. - default: false - # Whether to require all messages to be encrypted and drop any unencrypted messages. - require: false - # Whether to use MSC3202/MSC4203 instead of /sync long polling for receiving encryption-related data. - # This is an experimental option, see the docs for more info. - # Changing this option requires updating the appservice registration file. - appservice: false - # Whether to use MSC4190 instead of appservice login to create the bridge bot device. - # Requires the homeserver to support MSC4190 and the device masquerading parts of MSC3202. - # Only relevant when using end-to-bridge encryption, required when using encryption with next-gen auth (MSC3861). - msc4190: false - # Whether to encrypt reactions and reply metadata as per MSC4392. - # This is not supported by most clients. - msc4392: false - # Should the bridge bot generate a recovery key and cross-signing keys and verify itself? - # Note that without the latest version of MSC4190, this will fail if you reset the bridge database. - # The generated recovery key will be saved in the kv_store table under `recovery_key`. - self_sign: false - # Enable key sharing? If enabled, key requests for rooms where users are in will be fulfilled. - # You must use a client that supports requesting keys from other users to use this feature. - allow_key_sharing: true - # Should m.mentions be sent in the unencrypted content? This is non-standard and should not be enabled. - plaintext_mentions: false - # Pickle key for encrypting encryption keys in the bridge database. - # If set to generate, a random key will be generated. - pickle_key: generate - # Options for deleting megolm sessions from the bridge. - delete_keys: - # Beeper-specific: delete outbound sessions when hungryserv confirms - # that the user has uploaded the key to key backup. - delete_outbound_on_ack: false - # Don't store outbound sessions in the inbound table. - dont_store_outbound: false - # Ratchet megolm sessions forward after decrypting messages. - ratchet_on_decrypt: false - # Delete fully used keys (index >= max_messages) after decrypting messages. - delete_fully_used_on_decrypt: false - # Delete previous megolm sessions from same device when receiving a new one. - delete_prev_on_new_session: false - # Delete megolm sessions received from a device when the device is deleted. - delete_on_device_delete: false - # Periodically delete megolm sessions when 2x max_age has passed since receiving the session. - periodically_delete_expired: false - # Delete inbound megolm sessions that don't have the received_at field used for - # automatic ratcheting and expired session deletion. This is meant as a migration - # to delete old keys prior to the bridge update. - delete_outdated_inbound: false - # What level of device verification should be required from users? - # - # Valid levels: - # unverified - Send keys to all device in the room. - # cross-signed-untrusted - Require valid cross-signing, but trust all cross-signing keys. - # cross-signed-tofu - Require valid cross-signing, trust cross-signing keys on first use (and reject changes). - # cross-signed-verified - Require valid cross-signing, plus a valid user signature from the bridge bot. - # Note that creating user signatures from the bridge bot is not currently possible. - # verified - Require manual per-device verification - # (currently only possible by modifying the `trust` column in the `crypto_device` database table). - verification_levels: - # Minimum level for which the bridge should send keys to when bridging messages from the remote network to Matrix. - receive: unverified - # Minimum level that the bridge should accept for incoming Matrix messages. - send: unverified - # Minimum level that the bridge should require for accepting key requests. - share: cross-signed-tofu - # Options for Megolm room key rotation. These options allow you to configure the m.room.encryption event content. - # See https://spec.matrix.org/v1.10/client-server-api/#mroomencryption for more information about that event. - rotation: - # Enable custom Megolm room key rotation settings. Note that these - # settings will only apply to rooms created after this option is set. - enable_custom: false - # The maximum number of milliseconds a session should be used - # before changing it. The Matrix spec recommends 604800000 (a week) - # as the default. - milliseconds: 604800000 - # The maximum number of messages that should be sent with a given a - # session before changing it. The Matrix spec recommends 100 as the - # default. - messages: 100 - # Disable rotating keys when a user's devices change? - # You should not enable this option unless you understand all the implications. - disable_device_change_key_rotation: false - -# Logging config. See https://github.com/tulir/zeroconfig for details. +# See section 16.7.2 of the Python documentation for more info: +# https://docs.python.org/3.6/library/logging.config.html#configuration-dictionary-schema logging: - min_level: debug - writers: - - type: stdout - format: pretty-colored - - type: file - format: json - filename: ./logs/bridge.log - max_size: 100 - max_backups: 10 - compress: false + version: 1 + formatters: + colored: + (): mautrix_telegram.util.ColorFormatter + format: "[%(asctime)s] [%(levelname)s@%(name)s] %(message)s" + normal: + format: "[%(asctime)s] [%(levelname)s@%(name)s] %(message)s" + handlers: + file: + class: logging.handlers.RotatingFileHandler + formatter: normal + filename: /data/mautrix-telegram.log + maxBytes: 10485760 + backupCount: 10 + console: + class: logging.StreamHandler + formatter: colored + loggers: + mau: + level: ERROR + telethon: + level: ERROR + aiohttp: + level: ERROR + root: + level: ERROR + handlers: [file, console]