small-software 0.6.0__py3-none-any.whl

small_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.6.0"

small_cli/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

small_cli/access.py

@@ -0,0 +1,114 @@
+"""Доступ к приложению: ACCESS_TOKEN (ссылки-приглашения "имя:токен,…") и ACCESS_EMAILS (вход по почте).
+
+Тот же формат понимают magic_link.py, magic-link.js и шаблон streamlit: убрали чей-то токен — его ссылка
+и куки перестают работать, у остальных всё остаётся. Убрали адрес из ACCESS_EMAILS — вход по нему закрыт сразу.
+"""
+
+import re
+import secrets
+from urllib.parse import quote
+
+from .config import CONFIG_FILE, load_config
+from .i18n import tr
+from .railway import Railway, RailwayError, token_from_env
+from .scaffold import TEMPLATES_DIR
+
+NAME_RE = re.compile(r"[A-Za-z0-9_.@-]{1,40}\Z")
+EMAIL_RE = re.compile(r"[^@\s,;<>\"']+@[^@\s,;<>\"']+\.[^@\s,;<>\"']+\Z")
+DOMAIN_RE = re.compile(r"@[^@\s,;<>\"']+\.[^@\s,;<>\"']+\Z")
+MAIL_VARS = ("RESEND_API_KEY", "SMTP_URL", "LOGIN_LINKS_TO_LOG")
+
+
+def parse(value):
+    """"alice:tok1, tok2" -> [("alice", "tok1"), ("", "tok2")]."""
+    entries = []
+    for item in (value or "").split(","):
+        name, _, token = item.strip().rpartition(":")
+        if token.strip():
+            entries.append((name.strip(), token.strip()))
+    return entries
+
+
+def serialize(entries):
+    return ",".join("%s:%s" % (name, token) if name else token for name, token in entries)
+
+
+def new_token():
+    return secrets.token_urlsafe(32)
+
+
+def is_email(value):
+    """Адрес почты или целый домен "@company.com"."""
+    return bool(EMAIL_RE.match(value) or DOMAIN_RE.match(value))
+
+
+def parse_emails(value):
+    """"Ivan@Company.com, @team.com" -> ["ivan@company.com", "@team.com"]: без регистра, повторов и мусора."""
+    found = []
+    for item in (value or "").split(","):
+        item = item.strip().lower()
+        if is_email(item) and item not in found:
+            found.append(item)
+    return found
+
+
+def app_env(root, state, warn=None):
+    """(переменные приложения, откуда каждая): Railway, поверх — непустые значения из small.json."""
+    env, sources = {}, {}
+    linked = all(state.get(k) for k in ("projectId", "environmentId", "serviceId"))
+    if linked and token_from_env():
+        try:
+            env = dict(Railway(token_from_env()).service_variables(
+                state["projectId"], state["environmentId"], state["serviceId"]))
+            sources = dict.fromkeys(env, "Railway")
+        except RailwayError as e:
+            if warn:
+                warn(tr("Could not read the service variables from Railway: %s",
+                        "Не удалось прочитать переменные сервиса в Railway: %s") % e)
+    for name, value in load_config(root / CONFIG_FILE)["env"].items():
+        if value:
+            env[name], sources[name] = value, CONFIG_FILE
+    return env, sources
+
+
+def current(root, state, warn=None):
+    """(записи ACCESS_TOKEN, откуда): из small.json, иначе из переменных сервиса в Railway, иначе ([], None)."""
+    raw = load_config(root / CONFIG_FILE)["env"].get("ACCESS_TOKEN")
+    if raw:
+        return parse(raw), CONFIG_FILE
+    env, sources = app_env(root, state, warn)
+    if env.get("ACCESS_TOKEN"):
+        return parse(env["ACCESS_TOKEN"]), sources["ACCESS_TOKEN"]
+    return [], None
+
+
+def pick(entries, name=None):
+    """Токен человека name; без имени — первый (владельца). None, если такого нет."""
+    if name is None:
+        return entries[0][1] if entries else None
+    return next((token for who, token in entries if who == name), None)
+
+
+def invite_link(domain, token):
+    url = "https://%s/" % domain
+    return url + "?token=" + quote(token, safe="") if token else url
+
+
+def email_login_problem(root):
+    """None — код приложения умеет вход по почте; иначе — что мешает и как исправить."""
+    for name, template in (("magic_link.py", "python-http"), ("magic-link.js", "node-http")):
+        path = root / name
+        if path.is_file():
+            if "ACCESS_EMAILS" in path.read_text(encoding="utf-8", errors="replace"):
+                return None
+            return (tr("%s in the app is an old version and does not support sign-in by email. "
+                       "Replace it with the new one: %s",
+                       "%s в приложении старой версии и не знает входа по почте. Замените его новым: %s")
+                    % (name, TEMPLATES_DIR / template / name))
+    app = root / "app.py"
+    if app.is_file() and "streamlit" in app.read_text(encoding="utf-8", errors="replace"):
+        return tr("the streamlit template does not support sign-in by email yet — "
+                  "grant a personal link instead: small access add NAME",
+                  "в шаблоне streamlit вход по почте пока не поддерживается — "
+                  "выдайте личную ссылку: small access add ИМЯ")
+    return None

small_cli/archive.py

@@ -0,0 +1,127 @@
+"""Сбор файлов проекта с учётом .gitignore/.railwayignore и упаковка в .tar.gz для Railway."""
+
+import io
+import os
+import re
+import tarfile
+
+# Никогда не загружаются, даже без .gitignore.
+ALWAYS_IGNORED = {".git", "node_modules", "__pycache__", ".venv", "venv"}
+IGNORE_FILES = (".gitignore", ".railwayignore")
+
+
+class IgnoreRules:
+    """Подмножество синтаксиса .gitignore: *, **, ?, [...], !отрицание, /якорь, хвостовой / для папок.
+
+    Читаются только файлы в корне проекта; вложенные .gitignore не учитываются.
+    """
+
+    def __init__(self, lines):
+        self.rules = []  # (regex, negate, dir_only)
+        for raw in lines:
+            line = raw.rstrip("\r\n").rstrip()
+            if not line or line.startswith("#"):
+                continue
+            negate = line.startswith("!")
+            if negate:
+                line = line[1:]
+            if line.startswith("\\"):
+                line = line[1:]
+            dir_only = line.endswith("/")
+            line = line.rstrip("/")
+            anchored = "/" in line
+            line = line.lstrip("/")
+            if not line:
+                continue
+            pattern = _translate(line)
+            if not anchored:
+                pattern = "(?:.*/)?" + pattern
+            try:
+                self.rules.append((re.compile(pattern), negate, dir_only))
+            except re.error:
+                continue
+
+    @classmethod
+    def load(cls, root):
+        lines = []
+        for name in IGNORE_FILES:
+            path = os.path.join(root, name)
+            if os.path.isfile(path):
+                with open(path, encoding="utf-8", errors="replace") as f:
+                    lines.extend(f)
+        return cls(lines)
+
+    def ignored(self, rel_path, is_dir):
+        result = False
+        for regex, negate, dir_only in self.rules:
+            if dir_only and not is_dir:
+                continue
+            if regex.fullmatch(rel_path):
+                result = not negate
+        return result
+
+
+def _translate(pattern):
+    out, i = [], 0
+    while i < len(pattern):
+        if pattern.startswith("**/", i):
+            out.append("(?:.*/)?")
+            i += 3
+        elif pattern.startswith("**", i):
+            out.append(".*")
+            i += 2
+        elif pattern[i] == "*":
+            out.append("[^/]*")
+            i += 1
+        elif pattern[i] == "?":
+            out.append("[^/]")
+            i += 1
+        elif pattern[i] == "[" and "]" in pattern[i + 2:]:
+            end = pattern.index("]", i + 2)
+            body = pattern[i + 1:end]
+            if body.startswith("!"):
+                body = "^" + body[1:]
+            out.append("[" + body + "]")
+            i = end + 1
+        else:
+            out.append(re.escape(pattern[i]))
+            i += 1
+    return "".join(out)
+
+
+def collect_files(root, skip_root_files=()):
+    """Относительные пути (через /) всех файлов, которые уйдут в Railway.
+
+    skip_root_files — имена файлов, которые не загружаются, только если лежат в корне (служебные файлы CLI).
+    """
+    rules = IgnoreRules.load(root)
+    files = []
+    for dirpath, dirnames, filenames in os.walk(root):
+        rel_dir = os.path.relpath(dirpath, root).replace(os.sep, "/")
+        prefix = "" if rel_dir == "." else rel_dir + "/"
+        dirnames[:] = sorted(
+            d for d in dirnames
+            if d not in ALWAYS_IGNORED and not rules.ignored(prefix + d, is_dir=True)
+        )
+        for name in sorted(filenames):
+            rel = prefix + name
+            if name in ALWAYS_IGNORED or (not prefix and name in skip_root_files):
+                continue
+            if not rules.ignored(rel, is_dir=False):
+                files.append(rel)
+    return files
+
+
+def make_tarball(root, files):
+    buf = io.BytesIO()
+    with tarfile.open(fileobj=buf, mode="w:gz", dereference=True) as tar:
+        for rel in files:
+            tar.add(os.path.join(root, *rel.split("/")), arcname="./" + rel,
+                    recursive=False, filter=_anonymize)
+    return buf.getvalue()
+
+
+def _anonymize(info):
+    info.uid = info.gid = 0
+    info.uname = info.gname = ""
+    return info

small_cli/cli.py

@@ -0,0 +1,76 @@
+"""small — микро-приложения на Railway одной командой.
+
+Точка входа: разбор аргументов и обработка ошибок. Сами команды — в small_cli/commands/,
+общие помощники — в small_cli/common.py.
+"""
+
+import argparse
+import codecs
+import os
+import sys
+
+from . import __version__, commands
+from .common import CliError
+from .config import ConfigError
+from .i18n import tr
+from .railway import RailwayError
+
+
+def main(argv=None):
+    setup_streams()
+    args = build_parser().parse_args(argv)
+    try:
+        return args.func(args)
+    except (CliError, ConfigError, RailwayError) as e:
+        print(tr("Error: %s", "Ошибка: %s") % e, file=sys.stderr)
+        return 1
+    except KeyboardInterrupt:
+        print(tr("\nInterrupted. A build that has already started will keep running in Railway.",
+                 "\nПрервано. Уже запущенная сборка продолжится в Railway."), file=sys.stderr)
+        return 130
+
+
+def setup_streams():
+    """В терминал Python пишет Unicode сам. Вывод в канал или файл (`small logs | Select-String вход`) он кодирует
+    в ANSI (cp1251), а PowerShell читает его в кодировке консоли (866 или UTF-8): кириллица превращается в мусор,
+    и поиск по ней ничего не находит. Поэтому в канал пишем в кодировке, которой его прочитают."""
+    encoding = pipe_encoding()
+    for stream in (sys.stdout, sys.stderr):
+        if not hasattr(stream, "reconfigure"):
+            continue
+        if encoding and not stream.isatty():
+            stream.reconfigure(encoding=encoding, errors="replace")
+        else:
+            stream.reconfigure(errors="replace")
+
+
+def pipe_encoding():
+    """Кодировка для вывода в канал: PYTHONIOENCODING, если задана (small.cmd запускает `python -I`, и сам Python
+    её не читает), иначе на Windows — кодировка консоли. None — оставить как есть."""
+    explicit = os.environ.get("PYTHONIOENCODING", "").split(":")[0]
+    if explicit:
+        try:
+            return codecs.lookup(explicit).name
+        except LookupError:
+            return None
+    if sys.platform != "win32":
+        return None
+    codepage = _console_codepage()  # 0 — у процесса нет консоли
+    return "utf-8" if codepage == 65001 else "cp%d" % codepage if codepage else None
+
+
+def _console_codepage():
+    import ctypes
+
+    return ctypes.windll.kernel32.GetConsoleOutputCP()
+
+
+def build_parser():
+    parser = argparse.ArgumentParser(prog="small", description=tr("Micro-apps on Railway with one command.",
+                                                                  "Микро-приложения на Railway одной командой."))
+    parser.add_argument("--version", action="version", version="small " + __version__)
+    sub = parser.add_subparsers(dest="command", metavar=tr("<command>", "<команда>"))
+    sub.required = True
+    for module in commands.ALL:
+        module.register(sub)
+    return parser

small_cli/commands/__init__.py

@@ -0,0 +1,8 @@
+"""Команды small. Каждый модуль добавляет свои подкоманды функцией register(subparsers).
+
+Порядок здесь — порядок в `small --help`: от создания приложения к его удалению.
+"""
+
+from . import access, dashboard, db, deploy, destroy, domain, env, init, link, logs, mail, notify, sleep
+
+ALL = (init, deploy, link, access, mail, notify, env, db, domain, sleep, logs, dashboard, destroy)

small_cli/commands/access.py

@@ -0,0 +1,167 @@
+"""small access: кто может открыть приложение. По почте (ACCESS_EMAILS) — как доступ к Google Doc, или по личной
+ссылке-приглашению (ACCESS_TOKEN). add выдаёт доступ, revoke отзывает, list показывает, у кого он есть."""
+
+import argparse
+
+from .. import access as tokens
+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
+
+
+def register(sub):
+    a = sub.add_parser("access", help=tr("who can open the app: by email or by personal link",
+                                         "кто может открыть приложение: по почте или по личной ссылке"),
+                       description=tr("add ivan@company.com: sign-in by work email (an email with a sign-in link); "
+                                      "add @company.com: the whole domain; add bob: a personal invite link. "
+                                      "revoke takes access away from one person, everyone else keeps theirs. "
+                                      "Emails are stored in ACCESS_EMAILS, links in ACCESS_TOKEN (in %s and in "
+                                      "Railway).",
+                                      "add ivan@company.com — вход по рабочей почте (письмо со ссылкой для входа); "
+                                      "add @company.com — весь домен; add bob — личная ссылка-приглашение. "
+                                      "revoke отзывает доступ одного человека, у остальных всё остаётся. "
+                                      "Адреса хранятся в ACCESS_EMAILS, ссылки — в ACCESS_TOKEN (в %s и в Railway).")
+                       % CONFIG_FILE)
+    a.add_argument("-C", "--path", default=".", help=tr("app folder (default: current folder)",
+                                                        "папка приложения (по умолчанию текущая)"))
+    a.set_defaults(func=cmd_access_list)
+    access_sub = a.add_subparsers(dest="access_command", metavar="<list|add|revoke>")
+    al = access_sub.add_parser("list", help=tr("who has access", "у кого есть доступ"))
+    al.set_defaults(func=cmd_access_list)
+    aa = access_sub.add_parser("add", help=tr("grant access: small access add ivan@company.com | @company.com | bob",
+                                              "выдать доступ: small access add ivan@company.com | @company.com | bob"))
+    aa.add_argument("name", metavar=tr("EMAIL|NAME", "ПОЧТА|ИМЯ"))
+    aa.set_defaults(func=cmd_access_add)
+    ar = access_sub.add_parser("revoke", help=tr("revoke access: small access revoke ivan@company.com | bob",
+                                                 "отозвать доступ: small access revoke ivan@company.com | bob"))
+    ar.add_argument("name", metavar=tr("EMAIL|NAME", "ПОЧТА|ИМЯ"))
+    ar.set_defaults(func=cmd_access_revoke)
+    for parser in (al, aa, ar):
+        parser.add_argument("-C", "--path", default=argparse.SUPPRESS, help=tr("app folder", "папка приложения"))
+    for parser in (aa, ar):
+        add_no_deploy(parser)
+
+
+def cmd_access_list(args):
+    root = app_dir(args.path)
+    env, sources = tokens.app_env(root, load_state(root / STATE_FILE), warn=say)
+    entries, emails = tokens.parse(env.get("ACCESS_TOKEN")), tokens.parse_emails(env.get("ACCESS_EMAILS"))
+    if not entries and not emails:
+        say(tr("Nobody has access: the app is closed to everyone. "
+               "Grant access: small access add ivan@company.com (by email) or small access add NAME (by link)",
+               "Доступа нет ни у кого — приложение закрыто для всех. "
+               "Выдать: small access add ivan@company.com (по почте) или small access add ИМЯ (по ссылке)"))
+        return 0
+    if emails:
+        say(tr("Sign-in by email (ACCESS_EMAILS from %s):", "Вход по почте (ACCESS_EMAILS из %s):")
+            % sources["ACCESS_EMAILS"])
+        for email in emails:
+            print("  %s" % (email + tr("  (whole domain)", "  (весь домен)") if email.startswith("@") else email))
+        warn_mail(env)
+    if entries:
+        say(tr("Personal links (ACCESS_TOKEN from %s):", "Личные ссылки (ACCESS_TOKEN из %s):")
+            % sources["ACCESS_TOKEN"])
+        for name, token in entries:
+            print("  %-24s %s…" % (name or tr("(shared link)", "(общая ссылка)"), token[:4]))
+        say(tr("Link: small link --as NAME", "Ссылка: small link --as ИМЯ"))
+    say(tr("Revoke: small access revoke EMAIL|NAME", "Отозвать: small access revoke ПОЧТА|ИМЯ"))
+    return 0
+
+
+def cmd_access_add(args):
+    root = app_dir(args.path)
+    if tokens.is_email(args.name.strip().lower()):
+        return add_email(root, args.name.strip().lower(), args.no_deploy)
+    if not tokens.NAME_RE.match(args.name):
+        raise CliError(tr("specify an email address (ivan@company.com), a domain (@company.com) or a name: "
+                          "up to 40 characters, Latin letters, digits, _ . -",
+                          "укажите адрес почты (ivan@company.com), домен (@company.com) или имя — до 40 символов: "
+                          "латиница, цифры, _ . -"))
+    state = load_state(root / STATE_FILE)
+    entries, _ = tokens.current(root, state, warn=say)
+    if any(name == args.name for name, _ in entries):
+        raise CliError(tr("%s already has a link: small link --as %s", "у %s уже есть ссылка: small link --as %s")
+                       % (args.name, args.name))
+    token = tokens.new_token()
+    linked = change_env(root, {"ACCESS_TOKEN": tokens.serialize(entries + [(args.name, token)])},
+                        deploy=not args.no_deploy)
+    report_env_change(linked, not args.no_deploy, tr("Access granted to %s", "Доступ для %s добавлен") % args.name)
+    if state.get("domain"):
+        say(tr("Personal link for %s (it works like a password, send it to this person only):",
+               "Личная ссылка для %s (работает как пароль — пересылайте только ему):") % args.name)
+        print(tokens.invite_link(state["domain"], token), flush=True)
+    else:
+        say(tr("The link will be available after small deploy: small link --as %s",
+               "Ссылка появится после small deploy: small link --as %s") % args.name)
+    return 0
+
+
+def add_email(root, email, no_deploy):
+    problem = tokens.email_login_problem(root)
+    if problem:
+        raise CliError(problem)
+    state = load_state(root / STATE_FILE)
+    env, _ = tokens.app_env(root, state, warn=say)
+    emails = tokens.parse_emails(env.get("ACCESS_EMAILS"))
+    if email in emails:
+        raise CliError(tr("%s is already on the access list", "%s уже есть в списке доступа") % email)
+    changes = {"ACCESS_EMAILS": ", ".join(emails + [email])}
+    if not env.get("SESSION_SECRET"):
+        changes["SESSION_SECRET"] = tokens.new_token()  # ключ подписи ссылок для входа и сессий
+    # Настоящий адрес для ссылок в письмах: RAILWAY_PUBLIC_DOMAIN после переименования домена устаревает.
+    # Свой PUBLIC_URL в small.json (например, свой домен) не трогаем.
+    extra = {}
+    if state.get("domain") and not load_config(root / CONFIG_FILE)["env"].get("PUBLIC_URL"):
+        extra["PUBLIC_URL"] = "https://" + state["domain"]
+    linked = change_env(root, changes, deploy=not no_deploy, railway_only=extra)
+    who = tr("all %s addresses", "все адреса %s") % email if email.startswith("@") else email
+    report_env_change(linked, not no_deploy, tr("Email access granted: %s", "Доступ по почте: %s") % who)
+    url = ("https://%s/" % state["domain"] if state.get("domain")
+           else tr("the app URL (after small deploy)", "адрес приложения (после small deploy)"))
+    say(tr("How to sign in: open %s and enter a work email; an email with a sign-in link will arrive.",
+           "Как войти: открыть %s и ввести рабочую почту — придёт письмо со ссылкой для входа.") % url)
+    warn_mail(env)
+    return 0
+
+
+def warn_mail(env):
+    if not any(env.get(name) for name in tokens.MAIL_VARS):
+        say(tr("Warning: email is not set up, so sign-in emails are not sent. Set it up: small mail resend",
+               "Внимание: почта не настроена, письма для входа не уходят. Подключить: small mail resend"))
+
+
+def cmd_access_revoke(args):
+    root = app_dir(args.path)
+    state = load_state(root / STATE_FILE)
+    email = args.name.strip().lower()
+    if tokens.is_email(email):
+        env, _ = tokens.app_env(root, state, warn=say)
+        emails = tokens.parse_emails(env.get("ACCESS_EMAILS"))
+        if email not in emails:
+            raise CliError(tr("%s is not on the access list. On the list: %s", "%s нет в списке доступа. Есть: %s")
+                           % (email, ", ".join(emails) or "—"))
+        remaining = [e for e in emails if e != email]
+        linked = change_env(root, {"ACCESS_EMAILS": ", ".join(remaining)} if remaining else None,
+                            unset=() if remaining else ["ACCESS_EMAILS"], deploy=not args.no_deploy)
+        report_env_change(linked, not args.no_deploy,
+                          tr("Access revoked for %s: sign-in stops working right after the restart, "
+                             "even in a browser that is already open",
+                             "Доступ %s отозван — вход закроется сразу после перезапуска, даже в открытом браузере")
+                          % email)
+        return 0
+
+    entries, _ = tokens.current(root, state, warn=say)
+    remaining = [(name, token) for name, token in entries if name != args.name]
+    if len(remaining) == len(entries):
+        raise CliError(tr("%s has no personal link. Existing links: %s", "у %s нет личной ссылки. Есть: %s")
+                       % (args.name, ", ".join(n or tr("(shared)", "(общая)") for n, _ in entries) or "—"))
+    if not remaining:
+        say(tr("This is the last token: once it is revoked, nobody can sign in by link.",
+               "Это последний токен: после отзыва войти по ссылке не сможет никто."))
+    linked = change_env(root, {"ACCESS_TOKEN": tokens.serialize(remaining)} if remaining else None,
+                        unset=() if remaining else ["ACCESS_TOKEN"], deploy=not args.no_deploy)
+    report_env_change(linked, not args.no_deploy,
+                      tr("Access revoked for %s: their link and cookies stop working after the restart",
+                         "Доступ %s отозван — его ссылка и куки перестанут действовать после перезапуска") % args.name)
+    return 0

small_cli/commands/dashboard.py

@@ -0,0 +1,49 @@
+"""small dashboard: локальная страница со списком приложений (сервер — в small_cli/dashboard.py)."""
+
+import webbrowser
+
+from .. import dashboard as server_module
+from ..common import app_dir, say
+from ..i18n import tr
+from ..railway import token_from_env
+
+
+def register(sub):
+    b = sub.add_parser("dashboard", help=tr("local page that lists your apps",
+                                            "локальная страница со списком приложений"),
+                       description=tr("Find apps in a folder (small.json / .small.json, up to %d levels deep) "
+                                      "and show them in the browser: name, status, links, path.",
+                                      "Найти в папке приложения (small.json / .small.json, до %d уровней вглубь) "
+                                      "и показать их в браузере: имя, статус, ссылки, путь.") % server_module.MAX_DEPTH)
+    b.add_argument("path", nargs="?", default=".", help=tr("where to look (default: current folder; e.g. ..)",
+                                                           "где искать (по умолчанию текущая папка; например, ..)"))
+    b.add_argument("--port", type=int, default=server_module.DEFAULT_PORT,
+                   help=tr("port (default %d; if it's busy, any free one)",
+                           "порт (по умолчанию %d; если занят — любой свободный)") % server_module.DEFAULT_PORT)
+    b.add_argument("--no-browser", action="store_true", help=tr("don't open the browser", "не открывать браузер"))
+    b.set_defaults(func=cmd_dashboard)
+
+
+def cmd_dashboard(args):
+    root = app_dir(args.path)
+    token = token_from_env()
+    server = server_module.start_server(root, args.port, token)
+    port = server.server_address[1]
+    if args.port and port != args.port:
+        say(tr("Port %d is busy, using %d", "Порт %d занят, использую %d") % (args.port, port))
+    found = len(server_module.scan_apps(root))
+    say(tr("small dashboard: %s, apps found: %d", "small dashboard: %s, приложений найдено: %d") % (root, found))
+    say(tr("Deploy statuses from Railway: %s", "Статусы деплоя из Railway: %s")
+        % (tr("on", "включены") if token else tr("off (no RAILWAY_API_TOKEN), offline mode",
+                                                 "выключены (нет RAILWAY_API_TOKEN), офлайн-режим")))
+    say(tr("Ctrl+C to stop", "Ctrl+C — остановить"))
+    print(server.url, flush=True)
+    if not args.no_browser:
+        webbrowser.open(server.url)
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        say(tr("Dashboard stopped", "Дашборд остановлен"))
+    finally:
+        server.server_close()
+    return 0