sesigram 0.1.0__tar.gz

sesigram-0.1.0/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: sesigram
+Version: 0.1.0
+Summary: Universal Telegram CLI Wrapper for AI Assistants and Terminals
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests
+
+# Sesigram
+
+**Sesigram** es un wrapper universal de terminal que te permite interactuar con cualquier asistente de IA de línea de comandos (como Claude Code, Aider, Antigravity, etc.) o cualquier programa interactivo desde Telegram.
+
+Con Sesigram, puedes alejarte de tu computadora y seguir respondiendo o leyendo las salidas de la terminal en tiempo real desde tu celular.
+
+## Instalación
+
+Puedes instalar Sesigram globalmente usando `pipx` (recomendado) o `pip`:
+
+```bash
+pip install sesigram
+```
+
+*(O puedes instalarlo localmente desde el código fuente con `pip install -e .`)*
+
+## Configuración
+
+Una vez instalado, ejecuta el comando de configuración inicial:
+
+```bash
+sesigram setup
+```
+
+Sigue las instrucciones en pantalla para vincular tu bot de Telegram y tu chat ID.
+
+## Uso
+
+Para usar Sesigram, simplemente **envuelve** el comando que quieres ejecutar con `sesigram run`:
+
+```bash
+# Ejemplo con bash interactivo
+sesigram run bash
+
+# Ejemplo con Aider
+sesigram run aider
+
+# Ejemplo con Claude Code
+sesigram run claude
+```
+
+A partir de ese momento, la terminal arrancará normalmente pero todo el texto que imprima te llegará a Telegram. Si respondes a tu bot de Telegram, el mensaje se inyectará como si lo hubieras escrito en la consola.
+
+Para cerrar la sesión de forma remota, envía `/stop_sesigram` en Telegram.
+
+## Características
+
+- **Agnóstico**: No requiere plugins ni modificaciones en el programa subyacente. Utiliza Pseudo-Terminales (PTY) nativas de Python.
+- **Sin Demonios**: No se queda corriendo en segundo plano. El puente hacia Telegram solo existe mientras dura el comando envuelto.
+- **Smart Buffering**: Acumula las salidas rápidas para no hacer spam ni exceder el límite de mensajes de la API de Telegram.

sesigram-0.1.0/README.md

@@ -0,0 +1,50 @@
+# Sesigram
+
+**Sesigram** es un wrapper universal de terminal que te permite interactuar con cualquier asistente de IA de línea de comandos (como Claude Code, Aider, Antigravity, etc.) o cualquier programa interactivo desde Telegram.
+
+Con Sesigram, puedes alejarte de tu computadora y seguir respondiendo o leyendo las salidas de la terminal en tiempo real desde tu celular.
+
+## Instalación
+
+Puedes instalar Sesigram globalmente usando `pipx` (recomendado) o `pip`:
+
+```bash
+pip install sesigram
+```
+
+*(O puedes instalarlo localmente desde el código fuente con `pip install -e .`)*
+
+## Configuración
+
+Una vez instalado, ejecuta el comando de configuración inicial:
+
+```bash
+sesigram setup
+```
+
+Sigue las instrucciones en pantalla para vincular tu bot de Telegram y tu chat ID.
+
+## Uso
+
+Para usar Sesigram, simplemente **envuelve** el comando que quieres ejecutar con `sesigram run`:
+
+```bash
+# Ejemplo con bash interactivo
+sesigram run bash
+
+# Ejemplo con Aider
+sesigram run aider
+
+# Ejemplo con Claude Code
+sesigram run claude
+```
+
+A partir de ese momento, la terminal arrancará normalmente pero todo el texto que imprima te llegará a Telegram. Si respondes a tu bot de Telegram, el mensaje se inyectará como si lo hubieras escrito en la consola.
+
+Para cerrar la sesión de forma remota, envía `/stop_sesigram` en Telegram.
+
+## Características
+
+- **Agnóstico**: No requiere plugins ni modificaciones en el programa subyacente. Utiliza Pseudo-Terminales (PTY) nativas de Python.
+- **Sin Demonios**: No se queda corriendo en segundo plano. El puente hacia Telegram solo existe mientras dura el comando envuelto.
+- **Smart Buffering**: Acumula las salidas rápidas para no hacer spam ni exceder el límite de mensajes de la API de Telegram.

sesigram-0.1.0/pyproject.toml

@@ -0,0 +1,16 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sesigram"
+version = "0.1.0"
+description = "Universal Telegram CLI Wrapper for AI Assistants and Terminals"
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = [
+    "requests",
+]
+
+[project.scripts]
+sesigram = "sesigram.cli:main"

sesigram-0.1.0/sesigram/__init__.py

@@ -0,0 +1,4 @@
+"""
+Sesigram - Universal Telegram CLI Wrapper
+"""
+__version__ = "0.1.0"

sesigram-0.1.0/sesigram/cli.py

@@ -0,0 +1,108 @@
+import sys
+import time
+from .telegram_api import get_updates, send_message, load_config, save_config
+from .wrapper import TelegramWrapper
+
+def print_step(text):
+    print(f"\n\033[1m> {text}\033[0m")
+
+def print_ok(text):
+    print(f"  \033[32m✓\033[0m {text}")
+
+def print_err(text):
+    print(f"  \033[31m✗\033[0m {text}")
+
+def setup():
+    print("\n\033[1m🤖 Sesigram - Setup\033[0m")
+    print("=" * 45)
+    
+    print("\nPaso 1: Crear tu bot de Telegram")
+    print("1. Abre Telegram y busca @BotFather")
+    print("2. Escribe /newbot")
+    print("3. Ponle un nombre y un username")
+    print("4. Copia el Token que te da al final")
+    
+    token = input("\nPega aquí tu token: ").strip()
+    if not token:
+        print_err("Token inválido.")
+        sys.exit(1)
+        
+    print_step("Paso 2: Conectar tu cuenta de Telegram")
+    print("1. Abre Telegram en tu móvil o escritorio")
+    print("2. Busca el bot que acabas de crear")
+    print("3. Pulsa START o escribe /start")
+    print("4. Espera (detección automática en curso...)")
+    
+    chat_id = None
+    sys.stdout.write("\n  Esperando que escribas a tu bot...")
+    sys.stdout.flush()
+    
+    # Poll for messages to find chat_id
+    for _ in range(30): # 30 seconds wait
+        updates = get_updates(token, timeout=1)
+        if updates:
+            for update in updates:
+                if "message" in update:
+                    msg = update["message"]
+                    if msg.get("text") == "/start":
+                        chat_id = msg["chat"]["id"]
+                        first_name = msg["from"].get("first_name", "Usuario")
+                        print(f"\n  ✓ Conectado con {first_name} (ID: {chat_id})")
+                        break
+            if chat_id:
+                break
+        sys.stdout.write(".")
+        sys.stdout.flush()
+        time.sleep(1)
+        
+    if not chat_id:
+        print("\n\n  ⚠ Timeout. Introduce tu chat_id manualmente.")
+        try:
+            chat_id = int(input("  Chat ID: ").strip())
+        except ValueError:
+            print_err("ID inválido. Abortando.")
+            sys.exit(1)
+            
+    save_config(token, chat_id)
+    print_ok("Config guardada")
+    
+    send_message(token, chat_id, "🎉 Sesigram vinculado correctamente en esta máquina.")
+    print_ok("Mensaje de prueba enviado a Telegram")
+    
+    print("\n🎉 Setup completo!")
+    print("\nPara usar Sesigram, simplemente envuelve cualquier comando:")
+    print("  sesigram run bash")
+    print("  sesigram run claude")
+    print("  sesigram run python\n")
+
+def main():
+    if len(sys.argv) < 2 or sys.argv[1] in ["--help", "-h", "help"]:
+        print("Uso: sesigram <comando>")
+        print("  sesigram setup          -> Configura tu Bot de Telegram")
+        print("  sesigram run <comando>  -> Ejecuta un comando envolviéndolo con Telegram")
+        sys.exit(1 if len(sys.argv) < 2 else 0)
+        
+    command = sys.argv[1]
+    
+    if command == "setup":
+        setup()
+    elif command == "run":
+        if len(sys.argv) < 3:
+            print("Error: falta el comando a ejecutar.")
+            print("Uso: sesigram run <comando>")
+            sys.exit(1)
+            
+        config = load_config()
+        if not config:
+            print("Error: Sesigram no está configurado. Ejecuta 'sesigram setup' primero.")
+            sys.exit(1)
+            
+        argv = sys.argv[2:]
+        wrapper = TelegramWrapper(config)
+        wrapper.run(argv)
+    else:
+        print(f"Comando desconocido: {command}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

sesigram-0.1.0/sesigram/telegram_api.py

@@ -0,0 +1,78 @@
+import json
+import socket
+import requests
+from pathlib import Path
+
+CONFIG_FILE = Path.home() / ".sesigram-config"
+
+def load_config():
+    try:
+        if CONFIG_FILE.exists():
+            with open(CONFIG_FILE, 'r') as f:
+                return json.load(f)
+    except Exception:
+        pass
+    return None
+
+def save_config(token, chat_id, machine_name=None):
+    if not machine_name:
+        machine_name = socket.gethostname()
+    config = {
+        "bot_token": token,
+        "chat_id": chat_id,
+        "machine_name": machine_name
+    }
+    with open(CONFIG_FILE, 'w') as f:
+        json.dump(config, f, indent=2)
+
+def escape_md(text):
+    """Escape MarkdownV2 special characters."""
+    special = r"_*[]()~`>#+-=|{}.!"
+    for c in special:
+        text = text.replace(c, f"\\{c}")
+    return text
+
+def send_message(token, chat_id, text, machine_name=None, disable_notification=True):
+    if not text.strip():
+        return
+        
+    if len(text) > 3800:
+        text = text[:3800] + "\n\n[... mensaje truncado ...]"
+    
+    header = ""
+    if machine_name:
+        header = f"🖥️ *{escape_md(machine_name)}*\n\n"
+        
+    full_msg = header + escape_md(text)
+    
+    try:
+        requests.post(
+            f"https://api.telegram.org/bot{token}/sendMessage",
+            json={
+                "chat_id": chat_id,
+                "text": full_msg,
+                "parse_mode": "MarkdownV2",
+                "disable_notification": disable_notification
+            },
+            timeout=10
+        )
+    except Exception:
+        pass
+
+def get_updates(token, offset=None, timeout=30):
+    """Long polling for new messages."""
+    params = {"timeout": timeout}
+    if offset:
+        params["offset"] = offset
+        
+    try:
+        response = requests.get(
+            f"https://api.telegram.org/bot{token}/getUpdates",
+            params=params,
+            timeout=timeout + 5
+        )
+        if response.status_code == 200:
+            return response.json().get("result", [])
+    except Exception:
+        pass
+    return []

sesigram-0.1.0/sesigram/wrapper.py

@@ -0,0 +1,122 @@
+import os
+import pty
+import sys
+import threading
+import time
+import re
+from .telegram_api import get_updates, send_message
+
+ANSI_ESCAPE_RE = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
+
+class TelegramWrapper:
+    def __init__(self, config):
+        self.config = config
+        self.master_fd = None
+        self.output_buffer = ""
+        self.last_send_time = time.time()
+        self.buffer_lock = threading.Lock()
+        self.is_running = True
+
+    def _strip_ansi(self, text):
+        return ANSI_ESCAPE_RE.sub('', text)
+
+    def master_read(self, fd):
+        """Called by pty.spawn when there is output from the child process."""
+        data = os.read(fd, 1024)
+        text = data.decode('utf-8', errors='replace')
+        
+        with self.buffer_lock:
+            self.output_buffer += text
+            
+        return data
+
+    def telegram_sender_loop(self):
+        """Periodically sends buffered output to Telegram."""
+        while self.is_running:
+            time.sleep(1.0) # Check every second
+            with self.buffer_lock:
+                if not self.output_buffer:
+                    continue
+                
+                # Only send if there's a pause in output or buffer is large
+                current_time = time.time()
+                if current_time - self.last_send_time > 1.5 or len(self.output_buffer) > 2000:
+                    text_to_send = self._strip_ansi(self.output_buffer).strip()
+                    if text_to_send:
+                        send_message(
+                            self.config["bot_token"], 
+                            self.config["chat_id"], 
+                            text_to_send,
+                            self.config["machine_name"],
+                            disable_notification=True
+                        )
+                    self.output_buffer = ""
+                    self.last_send_time = current_time
+
+    def telegram_polling_loop(self):
+        """Polls Telegram for new messages and injects them into the PTY."""
+        offset = None
+        while self.is_running:
+            updates = get_updates(self.config["bot_token"], offset=offset, timeout=10)
+            for update in updates:
+                offset = update["update_id"] + 1
+                if "message" in update and "text" in update["message"]:
+                    # Only accept messages from the authorized chat_id
+                    if str(update["message"]["chat"]["id"]) == str(self.config["chat_id"]):
+                        text = update["message"]["text"]
+                        
+                        # System command check
+                        if text.strip().lower() == "/stop_sesigram":
+                            send_message(
+                                self.config["bot_token"], 
+                                self.config["chat_id"], 
+                                "🛑 Cerrando sesión remota.",
+                                self.config["machine_name"]
+                            )
+                            # Escribir Ctrl+C y Exit para intentar matar el child
+                            if self.master_fd:
+                                os.write(self.master_fd, b'\x03exit\n')
+                            continue
+
+                        # Inject into PTY
+                        if self.master_fd:
+                            # Escribir el texto seguido de un salto de línea
+                            payload = (text + "\n").encode('utf-8')
+                            os.write(self.master_fd, payload)
+            
+            time.sleep(0.5)
+
+    def run(self, argv):
+        # Setup threads
+        sender_thread = threading.Thread(target=self.telegram_sender_loop, daemon=True)
+        polling_thread = threading.Thread(target=self.telegram_polling_loop, daemon=True)
+        
+        sender_thread.start()
+        polling_thread.start()
+
+        def _spawn_read(fd):
+            if self.master_fd is None:
+                self.master_fd = fd
+            return self.master_read(fd)
+
+        print(f"🚀 Iniciando Sesigram en modo remoto para: {' '.join(argv)}")
+        send_message(
+            self.config["bot_token"], 
+            self.config["chat_id"], 
+            f"🚀 Sesión iniciada: `{' '.join(argv)}`",
+            self.config["machine_name"]
+        )
+
+        try:
+            # pty.spawn bloquea hasta que el subproceso termine
+            pty.spawn(argv, master_read=_spawn_read)
+        except Exception as e:
+            print(f"Error en pty.spawn: {e}")
+        finally:
+            self.is_running = False
+            send_message(
+                self.config["bot_token"], 
+                self.config["chat_id"], 
+                f"🛑 Sesión terminada: `{' '.join(argv)}`",
+                self.config["machine_name"]
+            )

sesigram-0.1.0/sesigram.egg-info/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: sesigram
+Version: 0.1.0
+Summary: Universal Telegram CLI Wrapper for AI Assistants and Terminals
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests
+
+# Sesigram
+
+**Sesigram** es un wrapper universal de terminal que te permite interactuar con cualquier asistente de IA de línea de comandos (como Claude Code, Aider, Antigravity, etc.) o cualquier programa interactivo desde Telegram.
+
+Con Sesigram, puedes alejarte de tu computadora y seguir respondiendo o leyendo las salidas de la terminal en tiempo real desde tu celular.
+
+## Instalación
+
+Puedes instalar Sesigram globalmente usando `pipx` (recomendado) o `pip`:
+
+```bash
+pip install sesigram
+```
+
+*(O puedes instalarlo localmente desde el código fuente con `pip install -e .`)*
+
+## Configuración
+
+Una vez instalado, ejecuta el comando de configuración inicial:
+
+```bash
+sesigram setup
+```
+
+Sigue las instrucciones en pantalla para vincular tu bot de Telegram y tu chat ID.
+
+## Uso
+
+Para usar Sesigram, simplemente **envuelve** el comando que quieres ejecutar con `sesigram run`:
+
+```bash
+# Ejemplo con bash interactivo
+sesigram run bash
+
+# Ejemplo con Aider
+sesigram run aider
+
+# Ejemplo con Claude Code
+sesigram run claude
+```
+
+A partir de ese momento, la terminal arrancará normalmente pero todo el texto que imprima te llegará a Telegram. Si respondes a tu bot de Telegram, el mensaje se inyectará como si lo hubieras escrito en la consola.
+
+Para cerrar la sesión de forma remota, envía `/stop_sesigram` en Telegram.
+
+## Características
+
+- **Agnóstico**: No requiere plugins ni modificaciones en el programa subyacente. Utiliza Pseudo-Terminales (PTY) nativas de Python.
+- **Sin Demonios**: No se queda corriendo en segundo plano. El puente hacia Telegram solo existe mientras dura el comando envuelto.
+- **Smart Buffering**: Acumula las salidas rápidas para no hacer spam ni exceder el límite de mensajes de la API de Telegram.

sesigram-0.1.0/sesigram.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+sesigram/__init__.py
+sesigram/cli.py
+sesigram/telegram_api.py
+sesigram/wrapper.py
+sesigram.egg-info/PKG-INFO
+sesigram.egg-info/SOURCES.txt
+sesigram.egg-info/dependency_links.txt
+sesigram.egg-info/entry_points.txt
+sesigram.egg-info/requires.txt
+sesigram.egg-info/top_level.txt

sesigram-0.1.0/sesigram.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sesigram-0.1.0/sesigram.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sesigram = sesigram.cli:main

sesigram-0.1.0/sesigram.egg-info/requires.txt

@@ -0,0 +1 @@
+requests

sesigram-0.1.0/sesigram.egg-info/top_level.txt

@@ -0,0 +1 @@
+sesigram

sesigram-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+