small-software 0.6.0__py3-none-any.whl

small_cli/commands/notify.py

@@ -0,0 +1,147 @@
+"""small notify: уведомления о запросах доступа в Telegram.
+
+Кнопка «Запросить доступ» на экране 403 отправляет запрос в приложение; если у приложения заданы
+TELEGRAM_BOT_TOKEN и TELEGRAM_CHAT_ID, middleware пересылает его владельцу в Telegram. Эта команда
+проверяет токен бота, находит ID чата, шлёт пробное сообщение и записывает обе переменные.
+"""
+
+import argparse
+import getpass
+import json
+import os
+import sys
+import time
+import urllib.error
+import urllib.request
+
+from ..common import CliError, app_dir, say
+from ..config import CONFIG_FILE, STATE_FILE, load_config, load_state
+from ..i18n import tr
+from .env import add_no_deploy, change_env, report_env_change
+
+TELEGRAM_API = "https://api.telegram.org"
+CHAT_WAIT_SECONDS = 120
+
+
+def register(sub):
+    n = sub.add_parser("notify", help=tr("Telegram notifications about access requests",
+                                         "уведомления о запросах доступа в Telegram"),
+                       description=tr("Requests from the \"Request access\" button go to the owner in Telegram. "
+                                      "telegram: connect a bot (token from TELEGRAM_BOT_TOKEN or hidden input); "
+                                      "off: turn off; with no subcommand, shows the status.",
+                                      "Запросы с кнопки «Запросить доступ» приходят владельцу в Telegram. "
+                                      "telegram — подключить бота (токен из TELEGRAM_BOT_TOKEN или ввод без эха), "
+                                      "off — отключить, без подкоманды — статус."))
+    n.add_argument("-C", "--path", default=".", help=tr("app folder (default: current folder)",
+                                                        "папка приложения (по умолчанию текущая)"))
+    n.set_defaults(func=cmd_notify_status)
+    notify_sub = n.add_subparsers(dest="notify_command", metavar="<telegram|off>")
+    nt = notify_sub.add_parser("telegram", help=tr("connect a Telegram bot", "подключить Telegram-бота"))
+    nt.add_argument("--chat-id", help=tr("chat ID, if you know it (otherwise small finds it)",
+                                         "ID чата, если он известен (иначе small найдёт его сам)"))
+    nt.add_argument("--wait", type=int, default=CHAT_WAIT_SECONDS, help=argparse.SUPPRESS)
+    nt.set_defaults(func=cmd_notify_telegram)
+    no = notify_sub.add_parser("off", help=tr("turn off notifications", "отключить уведомления"))
+    no.set_defaults(func=cmd_notify_off)
+    for parser in (nt, no):
+        parser.add_argument("-C", "--path", default=argparse.SUPPRESS, help=tr("app folder", "папка приложения"))
+        add_no_deploy(parser)
+
+
+def telegram(token, method, params=None):
+    url = "%s/bot%s/%s" % (os.environ.get("TELEGRAM_API_URL", TELEGRAM_API).rstrip("/"), token, method)
+    req = urllib.request.Request(url, data=json.dumps(params or {}).encode("utf-8"),
+                                 headers={"Content-Type": "application/json"})
+    try:
+        with urllib.request.urlopen(req, timeout=30) as resp:
+            payload = json.loads(resp.read() or b"{}")
+    except urllib.error.HTTPError as e:
+        try:
+            payload = json.loads(e.read() or b"{}")
+        except ValueError:
+            payload = {"description": "HTTP %d" % e.code}
+    except OSError as e:
+        raise CliError(tr("cannot reach Telegram: %s", "нет связи с Telegram: %s") % getattr(e, "reason", e)) from None
+    if not payload.get("ok"):
+        raise CliError("Telegram: %s" % payload.get("description", tr("unknown error", "неизвестная ошибка")))
+    return payload["result"]
+
+
+def bot_token():
+    token = os.environ.get("TELEGRAM_BOT_TOKEN", "").strip()
+    if token:
+        return token
+    if not sys.stdin or not sys.stdin.isatty():
+        raise CliError(tr("set TELEGRAM_BOT_TOKEN (a token from @BotFather) or run the command in a terminal",
+                          "задайте TELEGRAM_BOT_TOKEN (токен от @BotFather) или запустите команду в терминале"))
+    say(tr("Bot token from @BotFather (to create a bot: /newbot). Input is hidden.",
+           "Токен бота от @BotFather (создать: /newbot). Ввод не отображается."))
+    token = getpass.getpass("TELEGRAM_BOT_TOKEN: ").strip()
+    if not token:
+        raise CliError(tr("no token entered", "токен не введён"))
+    return token
+
+
+def find_chat(token, username, wait):
+    """ID чата из последнего сообщения боту; если сообщений нет — просим написать и ждём."""
+    deadline, offset, asked = time.monotonic() + wait, None, False
+    while True:
+        updates = telegram(token, "getUpdates", {"timeout": 0, **({"offset": offset} if offset else {})})
+        chats = [u["message"]["chat"] for u in updates if u.get("message", {}).get("chat")]
+        if chats:
+            return chats[-1]
+        if updates:
+            offset = updates[-1]["update_id"] + 1
+        if not asked:
+            say(tr("Send any message to @%s in Telegram. Waiting up to %d s…",
+                   "Напишите боту @%s любое сообщение в Telegram — жду до %d с…") % (username, wait))
+            asked = True
+        if time.monotonic() > deadline:
+            raise CliError(tr("nobody messaged the bot within %d s. Message @%s and try again, or pass --chat-id",
+                              "боту никто не написал за %d с. Напишите @%s и повторите, или передайте --chat-id")
+                           % (wait, username))
+        time.sleep(2)
+
+
+def cmd_notify_telegram(args):
+    root = app_dir(args.path)
+    token = bot_token()
+    username = telegram(token, "getMe")["username"]
+    if args.chat_id:
+        chat_id, who = args.chat_id, args.chat_id
+    else:
+        chat = find_chat(token, username, args.wait)
+        chat_id = chat["id"]
+        who = chat.get("title") or " ".join(filter(None, (chat.get("first_name"), chat.get("last_name")))) or chat_id
+    app = load_config(root / CONFIG_FILE)["name"] or load_state(root / STATE_FILE).get("name") or root.name
+    text = tr("✅ small: access requests for %s from the \"Request access\" button will arrive here.",
+              "✅ small: сюда будут приходить запросы доступа к %s с кнопки «Запросить доступ».") % app
+    telegram(token, "sendMessage", {"chat_id": chat_id, "text": text})
+    linked = change_env(root, {"TELEGRAM_BOT_TOKEN": token, "TELEGRAM_CHAT_ID": str(chat_id)},
+                        deploy=not args.no_deploy)
+    report_env_change(linked, not args.no_deploy, tr("Notifications via @%s → %s turned on",
+                                                     "Уведомления через @%s → %s включены") % (username, who))
+    return 0
+
+
+def cmd_notify_off(args):
+    root = app_dir(args.path)
+    linked = change_env(root, unset=["TELEGRAM_BOT_TOKEN", "TELEGRAM_CHAT_ID"], deploy=not args.no_deploy)
+    report_env_change(linked, not args.no_deploy, tr("Telegram notifications turned off",
+                                                     "Уведомления в Telegram отключены"))
+    return 0
+
+
+def cmd_notify_status(args):
+    env = load_config(app_dir(args.path) / CONFIG_FILE)["env"]
+    if env.get("TELEGRAM_BOT_TOKEN") and env.get("TELEGRAM_CHAT_ID"):
+        say(tr("Access request notifications: Telegram, chat %s", "Уведомления о запросах доступа: Telegram, чат %s")
+            % env["TELEGRAM_CHAT_ID"])
+        print("telegram")
+    else:
+        say(tr("Notifications are off: access requests show up only in the log (small logs). "
+               "Turn on: small notify telegram",
+               "Уведомления выключены: запросы доступа видны только в логе (small logs). "
+               "Включить: small notify telegram"))
+        print("off")
+    return 0

small_cli/commands/sleep.py

@@ -0,0 +1,61 @@
+"""small sleep: режим serverless Railway — без запросов приложение засыпает и не тратит ресурсы,
+первый запрос его будит (несколько секунд задержки)."""
+
+import argparse
+
+from ..common import app_dir, linked_state, require_token, say
+from ..i18n import tr
+from ..railway import Railway
+
+
+def register(sub):
+    s = sub.add_parser("sleep", help=tr("sleep when idle to save cost: on / off / status",
+                                        "засыпать без запросов (экономия): on / off / статус"),
+                       description=tr("Railway sleep mode (serverless): with no incoming requests the app sleeps "
+                                      "and uses no CPU or memory; the first request wakes it up in a few seconds. "
+                                      "Handy for apps that are opened a couple of times a day.",
+                                      "Режим сна Railway (serverless): без входящих запросов приложение засыпает и "
+                                      "не расходует CPU и память; первый запрос будит его за несколько секунд. "
+                                      "Удобно для приложений, которые открывают пару раз в день."))
+    s.add_argument("mode", nargs="?", choices=("on", "off"),
+                   help=tr("turn on or off; with no argument, shows the status",
+                           "включить или выключить; без аргумента — статус"))
+    s.add_argument("-C", "--path", default=".", help=tr("app folder (default: current folder)",
+                                                        "папка приложения (по умолчанию текущая)"))
+    s.add_argument("--no-deploy", action="store_true",
+                   help=tr("don't restart the app (the setting takes effect on the next deploy)",
+                           "не перезапускать приложение (настройка вступит в силу при следующем деплое)"))
+    s.set_defaults(func=cmd_sleep)
+
+
+def cmd_sleep(args):
+    root = app_dir(args.path)
+    state = linked_state(root)
+    api = Railway(require_token())
+    sid, eid = state["serviceId"], state["environmentId"]
+    current = api.instance_status(sid, eid)
+    if args.mode is None:
+        deployment = current["deployment"]
+        say(tr("Sleep mode: %s%s", "Режим сна: %s%s") % (
+            tr("on, the app sleeps when there are no requests", "включён — без запросов приложение засыпает")
+            if current["sleep"] else
+            tr("off, the app is always running", "выключен — приложение работает всегда"),
+            tr("; now: %s", "; сейчас: %s") % deployment["status"] if deployment else ""))
+        print("on" if current["sleep"] else "off")
+        return 0
+    wanted = args.mode == "on"
+    if current["sleep"] == wanted:
+        say(tr("Sleep mode is already %s.", "Режим сна уже %s.")
+            % (tr("on", "включён") if wanted else tr("off", "выключен")))
+        return 0
+    api.update_instance(sid, eid, sleepApplication=wanted)
+    if not args.no_deploy:
+        api.redeploy(sid, eid)
+    say(tr("Sleep mode turned %s%s.", "Режим сна %s%s.") % (
+        tr("on", "включён") if wanted else tr("off", "выключен"),
+        tr(", Railway is restarting the app", ", Railway перезапускает приложение") if not args.no_deploy else
+        tr("; takes effect on the next deploy", "; вступит в силу при следующем деплое")))
+    if wanted:
+        say(tr("The first request after idle time takes a few seconds longer while the app wakes up.",
+               "Первый запрос после простоя будет на несколько секунд дольше: приложение просыпается."))
+    return 0

small_cli/common.py

@@ -0,0 +1,92 @@
+"""Общее для всех команд: ошибки, вывод, вопросы пользователю, папка приложения и токен Railway."""
+
+import re
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+from .config import STATE_FILE, load_state
+from .i18n import tr
+from .railway import token_from_env
+
+
+class CliError(Exception):
+    pass
+
+
+def say(message):
+    """Прогресс и пояснения — в stderr; в stdout только результат (URL, ссылка, таблица)."""
+    print(message, file=sys.stderr, flush=True)
+
+
+def ask(prompt):
+    """Ответ пользователя или None, если терминала нет (скрипт, CI) или ввод закрыт."""
+    if not sys.stdin or not sys.stdin.isatty():
+        return None
+    sys.stderr.write(prompt)
+    sys.stderr.flush()
+    try:
+        return input().strip()
+    except EOFError:
+        sys.stderr.write("\n")
+        return None
+
+
+def confirm(prompt):
+    answer = ask(prompt)
+    return answer is not None and answer.lower() in ("y", "yes", "д", "да")
+
+
+def app_dir(path):
+    root = Path(path).resolve()
+    if not root.is_dir():
+        raise CliError(tr("folder not found: %s", "папка не найдена: %s") % root)
+    return root
+
+
+def is_linked(state):
+    return all(state.get(k) for k in ("projectId", "environmentId", "serviceId"))
+
+
+def linked_state(root):
+    state = load_state(root / STATE_FILE)
+    if not is_linked(state):
+        raise CliError(tr("%s has not been deployed yet (no %s). Run `small deploy` first",
+                          "%s ещё не задеплоено (нет %s). Сначала: small deploy") % (root, STATE_FILE))
+    return state
+
+
+def require_token():
+    token = token_from_env()
+    if not token:
+        raise CliError(tr("Railway token is not set. Create one in Railway → Account Settings → Tokens "
+                          "and put it in the RAILWAY_API_TOKEN environment variable.",
+                          "не задан токен Railway. Создайте его в Railway → Account Settings → Tokens "
+                          "и положите в переменную окружения RAILWAY_API_TOKEN."))
+    return token
+
+
+def slugify(name):
+    slug = re.sub(r"[^a-z0-9]+", "-", name.lower()).strip("-")
+    return slug[:40].strip("-") or "app"
+
+
+def human_size(size):
+    units = (tr("B", "Б"), tr("KB", "КБ"), tr("MB", "МБ"))
+    for unit in units:
+        if size < 1024 or unit == units[-1]:
+            return ("%d %s" if unit == units[0] else "%.1f %s") % (size, unit)
+        size /= 1024.0
+
+
+def format_elapsed(seconds):
+    return "%02d:%02d" % divmod(int(seconds), 60)
+
+
+def log_time(timestamp):
+    """ISO-время Railway (UTC, с наносекундами) -> локальное ЧЧ:ММ:СС."""
+    try:
+        moment = datetime.strptime(timestamp[:19], "%Y-%m-%dT%H:%M:%S").replace(tzinfo=timezone.utc)
+        return moment.astimezone().strftime("%H:%M:%S")
+    except (TypeError, ValueError):
+        return str(timestamp)

small_cli/config.py

@@ -0,0 +1,82 @@
+"""Файлы приложения: small.json (настройки пользователя) и .small.json (привязка к Railway).
+
+Используются `small deploy` и `small dashboard`, поэтому проверки одинаковы для обоих.
+"""
+
+import json
+import re
+
+from .i18n import tr
+
+CONFIG_FILE = "small.json"   # настройки пользователя: имя и переменные окружения
+STATE_FILE = ".small.json"   # куда CLI запоминает ID проекта, сервиса и домен
+CONFIG_KEYS = ("name", "env")
+ENV_NAME_RE = re.compile(r"[A-Za-z_][A-Za-z0-9_]*\Z")
+
+
+class ConfigError(Exception):
+    pass
+
+
+def load_config(path):
+    """Читает small.json: {"name": "...", "env": {"KEY": "value"}}. Оба поля необязательны."""
+    config = {"name": None, "env": {}}
+    if not path.is_file():
+        return config
+    try:
+        data = json.loads(path.read_text(encoding="utf-8-sig"))  # -sig: Блокнот сохраняет с BOM
+    except ValueError as e:
+        raise ConfigError(tr("%s: invalid JSON (%s)", "%s: некорректный JSON (%s)") % (CONFIG_FILE, e)) from None
+    if not isinstance(data, dict):
+        raise ConfigError(tr("%s: expected an object like {\"name\": ..., \"env\": {...}}",
+                             "%s: ожидается объект вида {\"name\": ..., \"env\": {...}}") % CONFIG_FILE)
+    unknown = sorted(set(data) - set(CONFIG_KEYS))
+    if unknown:
+        raise ConfigError(tr("%s: unknown fields %s (allowed: %s)", "%s: неизвестные поля %s (допустимы: %s)")
+                          % (CONFIG_FILE, ", ".join(unknown), ", ".join(CONFIG_KEYS)))
+
+    name = data.get("name")
+    if name is not None:
+        if not isinstance(name, str) or not name.strip():
+            raise ConfigError(tr("%s: name must be a non-empty string",
+                                 "%s: name должен быть непустой строкой") % CONFIG_FILE)
+        config["name"] = name.strip()
+
+    env = data.get("env")
+    if env is None:
+        return config
+    if not isinstance(env, dict):
+        raise ConfigError(tr("%s: env must be an object {\"NAME\": \"value\"}",
+                             "%s: env должен быть объектом {\"ИМЯ\": \"значение\"}") % CONFIG_FILE)
+    for key, value in env.items():
+        if not ENV_NAME_RE.match(key):
+            raise ConfigError(tr("%s: invalid variable name %r (Latin letters, digits, _; must not start with a digit)",
+                                 "%s: недопустимое имя переменной %r (латиница, цифры, _; не с цифры)")
+                              % (CONFIG_FILE, key))
+        if isinstance(value, bool):
+            value = "true" if value else "false"
+        elif isinstance(value, (int, float)):
+            value = str(value)
+        elif not isinstance(value, str):
+            raise ConfigError(tr("%s: value of %s must be a string, a number or true/false",
+                                 "%s: значение %s должно быть строкой, числом или true/false") % (CONFIG_FILE, key))
+        config["env"][key] = value
+    return config
+
+
+def load_state(path):
+    if not path.is_file():
+        return {}
+    try:
+        state = json.loads(path.read_text(encoding="utf-8"))
+    except ValueError as e:
+        raise ConfigError(tr("%s is corrupted (%s); delete it or run with --new",
+                             "%s повреждён (%s); удалите его или запустите с --new") % (path, e)) from None
+    if not isinstance(state, dict):
+        raise ConfigError(tr("%s is corrupted (expected an object); delete it or run with --new",
+                             "%s повреждён (ожидается объект); удалите его или запустите с --new") % path)
+    return state
+
+
+def save_state(path, state):
+    path.write_text(json.dumps(state, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")