This repository is a macOS iMessage/SMS automation tool called `imsg`. It provides a CLI and JSON-RPC interface for reading, watching, and sending messages. The architecture has three layers: a Swift CLI that parses commands and outputs NDJSON or plain text; a core library (`IMsgCore`) that reads the local Messages SQLite database and manages the bridge to Messages.app; and an injected Objective-C dylib (`IMsgHelper`) that hooks into private IMCore APIs for advanced features like typing indicators, polls, stickers, rich links, and message mutations. The tool can fall back to AppleScript automation for basic sends when the bridge is unavailable (e.g., SIP enabled). The RPC server runs over stdio, making it suitable for integration with AI agents and scripts. The codebase is well-tested with unit tests for all layers, including native Objective-C tests for the injected helper. It demonstrates deep reverse-engineering of Apple's private messaging protocols and careful handling of platform-specific quirks. The primary data flow is read-only from the local `chat.db` SQLite database for history and live updates, with write operations going through either AppleScript (via `osascript`) or the injected bridge (via UUID-keyed IPC queues). External dependencies include SQLite.swift, PhoneNumberKit, ffmpeg, afconvert, and private macOS frameworks (IMCore, CNContactStore). The build system uses SwiftPM with custom scripts for universal macOS binaries and Linux static archives. The project is actively maintained with CI, releases, and a documentation site.
Novu is a comprehensive notification infrastructure platform designed for multi-channel delivery (Email, SMS, Push, Chat, In-App) and workflow orchestration. It functions as both a SaaS product and a self-hosted solution, providing a unified API to manage subscribers, triggers, and notification templates. The system integrates deeply with AI agents, supporting Model Context Protocol (MCP) and managed runtimes (e.g., Anthropic) for conversational notifications. The architecture is a TypeScript monorepo managed by Nx and pnpm, featuring a NestJS backend (API, Worker, WebSocket), React/Next.js frontend (Dashboard, Playground), and MongoDB/Redis/ClickHouse data stores. It emphasizes extensibility through a provider factory pattern and a programmatic workflow DSL.
WePush is a Java application monorepo with two coexisting generations of a multi-channel bulk messaging system. The legacy `src/main` tree is a Swing desktop client that manages accounts, message templates, recipient lists, tasks, and run history, and sends via WeChat (official accounts, mini programs, WeCom), SMS vendors, email, HTTP, DingTalk/Feishu bots, and carrier SMS protocols (CMPP/SMGP/SGIP/SMPP). It persists to SQLite through MyBatis and generates UI with IntelliJ GUI Designer forms. The `next/` tree is a modular, distributed push orchestration platform: a Spring Boot control plane (REST + gRPC), remote agents connected via an mTLS gRPC stream, a provider SPI with built-in HTTP, Aliyun SMS, SMTP, WeChat, and bot providers, and pluggable signed PF4J plugins for carrier protocols. It adds multi-tenant workspaces, secret envelope encryption, artifact storage (local/S3), audience streaming import, run state machines with idempotency and retry, schedule management, a React/Vite web UI, an Electron desktop shell, and a Java SDK. Persistence is SQLite for standalone mode or PostgreSQL for server mode, with Flyway migrations and JDBC repositories. The Next codebase is well-architected with core-api/engine/provider-spi/service/domain/infrastructure separation, ADRs, architecture tests, integration tests, CI, and installers. However, the repository as a whole carries the legacy desktop codebase in parallel, duplicating several domain concepts and retaining generated UI code and older dependencies. This split and the aging legacy portions are the main sources of technical debt.
This is an Android application that turns a smartphone into an SMS/MMS gateway. It exposes a local REST API (Ktor-based HTTP server) for sending and receiving messages, supports cloud server integration via Firebase and Server-Sent Events, and provides webhook delivery, end-to-end encryption (RSA-OAEP + AES-GCM), and device key rotation. The architecture is modular: foreground services (SSE, ping, local server), WorkManager workers for background tasks (message sending, webhook queue processing, inbox upload, settings sync), a Room database for persistence, and Koin for dependency injection. The codebase is well-structured with event-driven communication via a custom EventBus, a validated state machine for message lifecycle, encrypted storage, and rich UI fragments. It supports SMS, MMS, and data SMS, with inbound message capture via broadcast receivers and content observers.
SmsForwarder is an Android application written in Kotlin that monitors SMS messages, incoming calls, and app notifications on a device and forwards them to multiple third-party channels such as DingTalk, WeChat Work, Feishu, Telegram, email, Bark, Webhook, and others. It also provides a local HTTP server for remote control (query/send SMS, call logs, contacts, battery status, location, and Wake-on-LAN) and an automation engine with configurable conditions (cron, battery, network, Bluetooth, location, screen state, etc.) and actions (forward, send SMS, trigger alarm, control frpc tunnels, etc.). The architecture follows a standard Android pattern with Room database, WorkManager for background tasks, XUI for UI components, and a fragment-based navigation system. The codebase is large and feature-rich, with over 15 sender channels and a flexible rule engine, but exhibits some technical debt such as deprecated API usage, hardcoded vendor-specific intents, and a few large monolithic fragments.
Notifme SDK is a Node.js library for sending transactional notifications across multiple channels (email, SMS, push, webpush, Slack, WhatsApp, voice). It provides a unified interface with a provider pattern, allowing users to configure one or more providers per channel with built-in multi-provider strategies (fallback, round-robin, no-fallback). The library handles authentication, request formatting, and error handling for each provider, and includes a development mode with a notification catcher for local testing. The architecture is centered around a Sender class that dispatches requests to channel-specific strategies, which in turn call provider instances. External dependencies include nodemailer, node-fetch, web-push, winston, and node-pushnotifications. The codebase uses Flow for type checking and Babel for transpilation, with comprehensive Jest tests achieving 100% coverage thresholds.
This repository is an Android application that bridges device events (SMS, MMS, missed calls, battery changes, app notifications) to a Telegram bot for monitoring and remote control. It uses the Telegram Bot API to forward events and long-polls for incoming commands to send SMS, USSD, list/read/delete SMS, fetch logcat, and more. The architecture is a monolith with multiple background services, broadcast receivers, and job scheduler jobs, all within a single Android app. It uses MMKV for key-value storage, OkHttp for HTTP, Gson for serialization, and libsodium for encryption. The codebase is well-structured with reusable utility classes (e.g., custom Mustache template engine, Telegram API wrapper, encryption helpers) and has unit tests for several components. It supports multi-language, QR code configuration import, and carbon-copy forwarding to external services via HAR format.