从零部署 Emby 媒体服与用户管理

1
服务器 IP：176.123.6.17
2
可用端口：48111-48119

1
48111  Emby 反代线路
2
48112  EmbyPulse 管理后台
3
48113  EmbyPulse 用户中心
4
48114  Emby 直连播放线路
5
48119  SSH，若服务商已经分配给 SSH 就不要占用

1
服务器 IP：147.224.40.215
2
SSH 端口：22700

1
80/tcp      caddy
2
443/tcp     caddy
3
22700/tcp   sshd
4
8001/tcp    sing-box
5
50501/tcp   sing-box
6
50503/udp   sing-box
7
50504/udp   sing-box
8
40823/udp   sing-box
9
5353/udp    avahi-daemon / openclaw-gateway

1
8096/tcp    Emby 直连播放线路
2
18080/tcp   可选 Web API，仅监听 127.0.0.1
3
18081/tcp   可选 Web 前端，仅监听 127.0.0.1
4
18082/tcp   本地 Telegram Bot API，仅监听 127.0.0.1

1
https://emby.example.com     Cloudflare 橙云线路，用于网页管理
2
https://play.example.com     DNS only 灰云线路，用于直连播放
3
http://147.224.40.215:8096   IP 直连线路，用于调试或客户端播放

1
googleapi: Error 403: Quota exceeded
2
RATE_LIMIT_EXCEEDED

1
1. 创建项目，例如 rclone-emby-upload
2
2. APIs & Services -> Library
3
3. 启用 Google Drive API
4
4. Google Auth Platform / OAuth consent screen
5
5. Data Access 添加 scope:
6
   https://www.googleapis.com/auth/drive
7
6. Audience 添加自己的 Google 账号为测试用户，或发布到 In production
8
7. Clients -> Create OAuth client
9
8. Application type 选择 Desktop app
10
9. 复制 Client ID 和 Client Secret

1
n) New remote
2
name> gdrive
3
Storage> drive
4
client_id> 你的 Client ID
5
client_secret> 你的 Client Secret
6
scope> drive
7
root_folder_id> 直接回车
8
service_account_file> 直接回车
9
Edit advanced config? n
10
Use web browser to automatically authenticate rclone with remote? n

1
emby/embyserver:latest

1
emby/embyserver_arm64v8:latest

1
image: emby/embyserver_arm64v8:latest
2
platform: linux/arm64/v8

1
A  emby  服务器IP  Proxied / 橙云
2
A  play  服务器IP  DNS only / 灰云

1
Cloudflare 代理线路：
2
https://emby.example.com
3

4
直连 HTTPS 线路：
5
https://play.example.com
6

7
IP 直连线路：
8
http://服务器IP:8096

1
48111 -> Emby 反代线路
2
48114 -> Emby 直连播放线路

1
{
2
  auto_https off
3
}
4

5
:48111 {
6
  encode gzip
7
  reverse_proxy 127.0.0.1:8096
8
}

1
外部 48114 -> 内部 8096

1
http://服务器IP:48111  Emby 反代线路
2
http://服务器IP:48114  Emby 直连播放线路

1
媒体/
2
  电影/
3
    流浪地球 (2019)/
4
      流浪地球 (2019).mkv
5

6
    Avatar (2009)/
7
      Avatar (2009).mkv

1
媒体/
2
  电视剧/
3
    庆余年 (2019)/
4
      Season 01/
5
        庆余年 S01E01.mkv
6
        庆余年 S01E02.mkv
7
      Season 02/
8
        庆余年 S02E01.mkv

1
媒体/
2
  动漫/
3
    葬送的芙莉莲 (2023)/
4
      Season 01/
5
        葬送的芙莉莲 S01E01.mkv
6
        葬送的芙莉莲 S01E02.mkv
7
      Specials/
8
        葬送的芙莉莲 S00E01.mkv

1
电视剧/
2
  第01集.mkv
3
  第02集.mkv
4
  01.mp4

1
BOT_TOKEN
2
TELEGRAM_API_ID
3
TELEGRAM_API_HASH
4
你的 Telegram 数字 ID

1
ALLOWED_USER_IDS=123456789

1
cat > /opt/tg-bot-uploader/tg_uploader.py <<'PY'
2
#!/usr/bin/env python3
3
import os
4
import re
5
import time
6
import json
7
import shutil
8
import select
9
import threading
10
import subprocess
11
from pathlib import Path
12
from collections import deque
13
from urllib.parse import quote
14
from urllib.request import urlopen, Request
15

16
BOT_TOKEN = os.environ["BOT_TOKEN"]
17
BOT_API_URL = os.environ.get("BOT_API_URL", "http://127.0.0.1:18082").rstrip("/")
18
FILE_API_URL = os.environ.get("FILE_API_URL", "http://127.0.0.1:18082/file").rstrip("/")
19
DEFAULT_DEST_REMOTE = os.environ.get("DEST_REMOTE", "gdrive:TelegramUploads/待整理").rstrip("/")
20
STATE_FILE = Path(os.environ.get("STATE_FILE", "/opt/tg-bot-uploader/state.json"))
21
DOWNLOAD_DIR = Path(os.environ.get("DOWNLOAD_DIR", "/opt/tg-bot-uploader/downloads"))
22
PROGRESS_INTERVAL = int(os.environ.get("PROGRESS_INTERVAL", "10"))
23
SKIP_OLD = os.environ.get("SKIP_OLD_UPDATES_ON_START", "true").lower() in ["1", "true", "yes", "y"]
24

25
ALLOWED_DEST_PREFIXES = [x.strip() for x in os.environ.get("ALLOWED_DEST_PREFIXES", "gdrive:").split(",") if x.strip()]
26
ALLOWED_USER_IDS = {int(x.strip()) for x in os.environ.get("ALLOWED_USER_IDS", "").split(",") if x.strip()}
27

28
LOCAL_PREFIX = os.environ.get("LOCAL_BOT_API_PATH_PREFIX", "")
29
HOST_PREFIX = os.environ.get("HOST_BOT_API_PATH_PREFIX", "")
30

31
DOWNLOAD_DIR.mkdir(parents=True, exist_ok=True)
32
STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
33

34
state_lock = threading.Lock()
35
queue_cond = threading.Condition()
36
job_queue = deque()
37
current_job = None
38
job_seq = 0
39

40
class Cancelled(Exception):
41
    pass
42

43
def load_state_unlocked():
44
    if not STATE_FILE.exists():
45
        return {"users": {}, "last_update_id": None}
46
    try:
47
        data = json.loads(STATE_FILE.read_text("utf-8"))
48
    except Exception:
49
        return {"users": {}, "last_update_id": None}
50
    data.setdefault("users", {})
51
    data.setdefault("last_update_id", None)
52
    return data
53

54
def save_state_unlocked(data):
55
    tmp = STATE_FILE.with_suffix(".tmp")
56
    tmp.write_text(json.dumps(data, ensure_ascii=False, indent=2), "utf-8")
57
    tmp.replace(STATE_FILE)
58

59
def get_user_dest(user_id):
60
    with state_lock:
61
        state = load_state_unlocked()
62
        return state["users"].get(str(user_id), {}).get("dest", DEFAULT_DEST_REMOTE)
63

64
def set_user_dest(user_id, dest):
65
    dest = dest.strip().rstrip("/")
66
    if not dest:
67
        raise ValueError("目录不能为空")
68
    if not any(dest.startswith(prefix) for prefix in ALLOWED_DEST_PREFIXES):
69
        raise ValueError(f"不允许的目录。允许前缀：{', '.join(ALLOWED_DEST_PREFIXES)}")
70
    with state_lock:
71
        state = load_state_unlocked()
72
        state["users"].setdefault(str(user_id), {})
73
        state["users"][str(user_id)]["dest"] = dest
74
        save_state_unlocked(state)
75

76
def get_last_update_id():
77
    with state_lock:
78
        return load_state_unlocked().get("last_update_id")
79

80
def set_last_update_id(update_id):
81
    with state_lock:
82
        state = load_state_unlocked()
83
        state["last_update_id"] = update_id
84
        save_state_unlocked(state)
85

86
def api(method, data=None, timeout=300):
87
    url = f"{BOT_API_URL}/bot{BOT_TOKEN}/{method}"
88
    if data is None:
89
        req = Request(url)
90
    else:
91
        req = Request(url, data=json.dumps(data).encode("utf-8"), headers={"Content-Type": "application/json"})
92
    with urlopen(req, timeout=timeout) as r:
93
        return json.loads(r.read().decode("utf-8"))
94

95
def send(chat_id, text):
96
    try:
97
        res = api("sendMessage", {"chat_id": chat_id, "text": text})
98
        if res.get("ok"):
99
            return res["result"]["message_id"]
100
    except Exception as e:
101
        print("sendMessage error:", repr(e), flush=True)
102
    return None
103

104
def edit(chat_id, message_id, text):
105
    if not message_id:
106
        return
107
    try:
108
        api("editMessageText", {"chat_id": chat_id, "message_id": message_id, "text": text})
109
    except Exception as e:
110
        print("editMessageText error:", repr(e), flush=True)
111

112
def human_size(num):
113
    try:
114
        num = float(num)
115
    except Exception:
116
        return "未知"
117
    units = ["B", "KB", "MB", "GB", "TB"]
118
    for unit in units:
119
        if abs(num) < 1024:
120
            return f"{num:.2f} {unit}"
121
        num /= 1024
122
    return f"{num:.2f} PB"
123

124
def safe_name(name):
125
    return name.replace("/", "_").replace("\\", "_").strip() or f"telegram_file_{int(time.time())}"
126

127
def rclone_join(remote_dir, file_name):
128
    remote_dir = remote_dir.strip().rstrip("/")
129
    return remote_dir + file_name if remote_dir.endswith(":") else remote_dir + "/" + file_name
130

131
def ensure_remote_dir(remote_dir):
132
    subprocess.run(["rclone", "mkdir", remote_dir], check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
133

134
def get_media(message):
135
    for key in ["document", "video", "audio"]:
136
        if key in message:
137
            obj = message[key]
138
            file_id = obj["file_id"]
139
            file_name = obj.get("file_name") or f"{key}_{message['message_id']}" + (".mp4" if key == "video" else "")
140
            size = obj.get("file_size", 0)
141
            return file_id, safe_name(file_name), size
142
    if "photo" in message:
143
        obj = message["photo"][-1]
144
        return obj["file_id"], f"photo_{message['message_id']}.jpg", obj.get("file_size", 0)
145
    return None, None, None
146

147
def get_file_path(file_id):
148
    info = api("getFile", {"file_id": file_id})
149
    if not info.get("ok"):
150
        raise RuntimeError(info)
151
    return info["result"]["file_path"]
152

153
def resolve_local_path(file_path):
154
    paths = []
155
    if file_path.startswith("/"):
156
        paths.append(file_path)
157
        if LOCAL_PREFIX and HOST_PREFIX and file_path.startswith(LOCAL_PREFIX):
158
            paths.append(file_path.replace(LOCAL_PREFIX, HOST_PREFIX, 1))
159
    for p in paths:
160
        if os.path.exists(p):
161
            return Path(p)
162
    return None
163

164
def download_via_http(file_path, file_name, job):
165
    url = f"{FILE_API_URL}/bot{BOT_TOKEN}/{quote(file_path)}"
166
    local_path = DOWNLOAD_DIR / file_name
167
    with urlopen(url, timeout=3600) as r, open(local_path, "wb") as f:
168
        total = r.headers.get("Content-Length")
169
        total = int(total) if total and total.isdigit() else 0
170
        done = 0
171
        last_update = 0
172
        while True:
173
            if job["cancel_event"].is_set():
174
                raise Cancelled("已中止当前任务")
175
            chunk = r.read(8 * 1024 * 1024)
176
            if not chunk:
177
                break
178
            f.write(chunk)
179
            done += len(chunk)
180
            now = time.time()
181
            if now - last_update >= PROGRESS_INTERVAL:
182
                if total:
183
                    percent = done / total * 100
184
                    text = f"正在从 Telegram 下载到服务器：\n{file_name}\n\n进度：{percent:.2f}%\n已下载：{human_size(done)} / {human_size(total)}\n\n可发送 /cancel 中止当前任务"
185
                else:
186
                    text = f"正在从 Telegram 下载到服务器：\n{file_name}\n\n已下载：{human_size(done)}\n\n可发送 /cancel 中止当前任务"
187
                edit(job["chat_id"], job["progress_message_id"], text)
188
                last_update = now
189
    return local_path
190

191
def strip_ansi(s):
192
    return re.sub(r"\x1b\[[0-9;]*[A-Za-z]", "", s).replace("\r", "").replace("\n", "").strip()
193

194
def get_queue_size():
195
    with queue_cond:
196
        return len(job_queue)
197

198
def format_progress_message(job, line):
199
    line = strip_ansi(line) or "等待 rclone 输出进度..."
200
    if len(line) > 900:
201
        line = line[-900:]
202
    return (
203
        f"正在上传：\n{job['file_name']}\n\n"
204
        f"目标目录：\n{job['dest_dir']}\n\n"
205
        f"rclone 进度：\n{line}\n\n"
206
        f"队列中等待：{get_queue_size()} 个\n"
207
        f"可发送 /cancel 中止当前任务"
208
    )
209

210
def terminate_process(proc):
211
    if not proc:
212
        return
213
    try:
214
        proc.terminate()
215
        proc.wait(timeout=8)
216
    except Exception:
217
        try:
218
            proc.kill()
219
        except Exception:
220
            pass
221

222
def upload_with_rclone_progress(src, job):
223
    src = Path(src)
224
    dest_path = rclone_join(job["dest_dir"], job["file_name"])
225
    ensure_remote_dir(job["dest_dir"])
226

227
    cmd = [
228
        "rclone", "copyto", str(src), dest_path,
229
        "-P",
230
        "--stats=1s",
231
        "--stats-one-line",
232
        "--stats-unit=bytes",
233
        "--stats-log-level=NOTICE",
234
        "--transfers=1",
235
        "--checkers=1",
236
        "--tpslimit=3",
237
        "--tpslimit-burst=3",
238
        "--drive-pacer-min-sleep=200ms",
239
        "--drive-pacer-burst=10",
240
        "--retries=20",
241
        "--retries-sleep=30s",
242
        "--low-level-retries=20",
243
        "--log-level=NOTICE"
244
    ]
245

246
    proc = subprocess.Popen(cmd, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, bufsize=0)
247
    job["process"] = proc
248
    job["stage"] = "uploading"
249

250
    last_edit = 0
251
    line_buf = ""
252
    last_line = "等待 rclone 输出进度..."
253

254
    try:
255
        while True:
256
            if job["cancel_event"].is_set():
257
                terminate_process(proc)
258
                raise Cancelled("已中止当前任务")
259

260
            if proc.poll() is not None:
261
                break
262

263
            ready, _, _ = select.select([proc.stdout], [], [], 1.0)
264
            if not ready:
265
                continue
266

267
            ch = proc.stdout.read(1)
268
            if not ch:
269
                continue
270

271
            if ch in ["\r", "\n"]:
272
                clean = strip_ansi(line_buf)
273
                line_buf = ""
274
                if clean:
275
                    last_line = clean
276
                now = time.time()
277
                if now - last_edit >= PROGRESS_INTERVAL:
278
                    edit(job["chat_id"], job["progress_message_id"], format_progress_message(job, last_line))
279
                    last_edit = now
280
            else:
281
                line_buf += ch
282
                if len(line_buf) > 3000:
283
                    line_buf = line_buf[-3000:]
284

285
        rc = proc.wait()
286
        if job["cancel_event"].is_set():
287
            raise Cancelled("已中止当前任务")
288
        if rc != 0:
289
            raise RuntimeError(f"rclone 上传失败，退出码：{rc}\n最后输出：{last_line}")
290

291
        edit(
292
            job["chat_id"],
293
            job["progress_message_id"],
294
            f"上传完成：\n{job['file_name']}\n\n目标目录：\n{job['dest_dir']}\n\n网盘路径：\n{dest_path}\n\n队列中等待：{get_queue_size()} 个"
295
        )
296
        return dest_path
297
    finally:
298
        job["process"] = None
299

300
def queue_snapshot(limit=10):
301
    with queue_cond:
302
        items = list(job_queue)[:limit]
303
        total = len(job_queue)
304
    if not items:
305
        return "当前没有等待中的任务。"
306
    lines = [f"等待队列：共 {total} 个任务"]
307
    for i, job in enumerate(items, 1):
308
        lines.append(f"{i}. #{job['id']} {job['file_name']} -> {job['dest_dir']}")
309
    if total > limit:
310
        lines.append(f"... 还有 {total - limit} 个未显示")
311
    return "\n".join(lines)
312

313
def status_text():
314
    with queue_cond:
315
        cur = current_job
316
        total = len(job_queue)
317
    if cur:
318
        cur_text = f"当前任务：\n#{cur['id']} {cur['file_name']}\n阶段：{cur.get('stage', '未知')}\n目标目录：{cur['dest_dir']}\n"
319
    else:
320
        cur_text = "当前没有正在上传的任务。\n"
321
    return f"{cur_text}\n等待队列：{total} 个\n\n命令：\n/queue 查看队列\n/cancel 中止当前任务\n/clear 清空等待队列"
322

323
def help_text(user_id):
324
    current = get_user_dest(user_id)
325
    return (
326
        "上传机器人使用说明\n\n"
327
        "直接发送文件、视频或音频给我，我会自动上传到当前网盘目录。\n"
328
        "多个文件会自动排队，按顺序依次上传。\n\n"
329
        "目录命令：\n"
330
        "/dir 查看当前上传目录\n"
331
        "/setdir gdrive:TelegramUploads/待整理 设置上传目录\n"
332
        "/setdir gdrive:媒体/电视剧/剧名 (年份)/Season 01 切换到指定目录\n\n"
333
        "队列命令：\n"
334
        "/status 查看当前任务和队列数量\n"
335
        "/queue 查看等待队列\n"
336
        "/cancel 中止当前正在上传的任务\n"
337
        "/clear 清空等待队列，不影响当前正在上传的任务\n\n"
338
        f"当前上传目录：\n{current}\n\n"
339
        "建议发送时选择“作为文件发送 / Send as File”，不要选择压缩视频。"
340
    )
341

342
def normalize_command(text):
343
    if not text:
344
        return "", ""
345
    parts = text.strip().split(maxsplit=1)
346
    cmd = parts[0].split("@", 1)[0]
347
    arg = parts[1].strip() if len(parts) > 1 else ""
348
    return cmd, arg
349

350
def add_job(message, chat_id, user_id):
351
    global job_seq
352
    file_id, file_name, size = get_media(message)
353
    if not file_id:
354
        send(chat_id, help_text(user_id))
355
        return
356

357
    dest_dir = get_user_dest(user_id)
358

359
    with queue_cond:
360
        job_seq += 1
361
        job_id = job_seq
362
        position = len(job_queue) + (1 if current_job else 0) + 1
363

364
    progress_message_id = send(
365
        chat_id,
366
        f"已加入上传队列：\n#{job_id} {file_name}\n\n"
367
        f"大小：{human_size(size) if size else '未知'}\n"
368
        f"目标目录：\n{dest_dir}\n\n"
369
        f"当前排队位置：{position}\n"
370
        f"发送 /queue 查看队列，/cancel 中止当前上传。"
371
    )
372

373
    job = {
374
        "id": job_id,
375
        "chat_id": chat_id,
376
        "user_id": user_id,
377
        "file_id": file_id,
378
        "file_name": file_name,
379
        "size": size,
380
        "dest_dir": dest_dir,
381
        "progress_message_id": progress_message_id,
382
        "stage": "queued",
383
        "cancel_event": threading.Event(),
384
        "process": None,
385
    }
386

387
    with queue_cond:
388
        job_queue.append(job)
389
        queue_cond.notify()
390

391
def handle_message(message):
392
    chat_id = message.get("chat", {}).get("id")
393
    user_id = message.get("from", {}).get("id")
394
    if not chat_id or not user_id:
395
        return
396

397
    if ALLOWED_USER_IDS and user_id not in ALLOWED_USER_IDS:
398
        send(chat_id, "你没有权限使用这个上传机器人。")
399
        return
400

401
    text = (message.get("text") or "").strip()
402
    cmd, arg = normalize_command(text)
403

404
    if cmd in ["/start", "/help"]:
405
        send(chat_id, help_text(user_id))
406
        return
407
    if cmd == "/dir":
408
        send(chat_id, f"当前上传目录：\n{get_user_dest(user_id)}")
409
        return
410
    if cmd == "/setdir":
411
        if not arg:
412
            send(chat_id, "用法：\n/setdir gdrive:TelegramUploads/待整理\n/setdir gdrive:媒体/电视剧/剧名 (年份)/Season 01")
413
            return
414
        try:
415
            set_user_dest(user_id, arg)
416
            ensure_remote_dir(arg)
417
            send(chat_id, f"已切换上传目录：\n{arg}")
418
        except Exception as e:
419
            send(chat_id, f"设置失败：{e}")
420
        return
421
    if cmd == "/queue":
422
        send(chat_id, queue_snapshot())
423
        return
424
    if cmd == "/status":
425
        send(chat_id, status_text())
426
        return
427
    if cmd == "/clear":
428
        with queue_cond:
429
            count = len(job_queue)
430
            job_queue.clear()
431
        send(chat_id, f"已清空等待队列：{count} 个任务。当前正在上传的任务不受影响。")
432
        return
433
    if cmd == "/cancel":
434
        with queue_cond:
435
            cur = current_job
436
        if not cur:
437
            send(chat_id, "当前没有正在上传的任务。")
438
            return
439
        cur["cancel_event"].set()
440
        if cur.get("process"):
441
            terminate_process(cur["process"])
442
        send(chat_id, f"已请求中止当前任务：\n#{cur['id']} {cur['file_name']}")
443
        return
444

445
    add_job(message, chat_id, user_id)
446

447
def worker_loop():
448
    global current_job
449
    while True:
450
        with queue_cond:
451
            while not job_queue:
452
                queue_cond.wait()
453
            job = job_queue.popleft()
454
            current_job = job
455

456
        src = None
457
        should_delete = False
458

459
        try:
460
            job["stage"] = "preparing"
461
            edit(job["chat_id"], job["progress_message_id"], f"开始处理：\n#{job['id']} {job['file_name']}\n\n目标目录：\n{job['dest_dir']}\n\n正在获取 Telegram 文件信息...")
462

463
            if job["cancel_event"].is_set():
464
                raise Cancelled("已中止当前任务")
465

466
            file_path = get_file_path(job["file_id"])
467
            local_path = resolve_local_path(file_path)
468

469
            if local_path:
470
                src = local_path
471
                should_delete = False
472
                job["stage"] = "ready"
473
            else:
474
                job["stage"] = "downloading"
475
                src = download_via_http(file_path, job["file_name"], job)
476
                should_delete = True
477

478
            if job["cancel_event"].is_set():
479
                raise Cancelled("已中止当前任务")
480

481
            upload_with_rclone_progress(src, job)
482

483
        except Cancelled as e:
484
            edit(job["chat_id"], job["progress_message_id"], f"任务已中止：\n#{job['id']} {job['file_name']}\n\n{e}\n\n队列中等待：{get_queue_size()} 个")
485
        except Exception as e:
486
            edit(job["chat_id"], job["progress_message_id"], f"任务失败：\n#{job['id']} {job['file_name']}\n\n错误：{e}\n\n队列中等待：{get_queue_size()} 个")
487
            print("worker error:", repr(e), flush=True)
488
        finally:
489
            if should_delete and src and Path(src).exists():
490
                try:
491
                    Path(src).unlink()
492
                except Exception:
493
                    pass
494
            with queue_cond:
495
                current_job = None
496
                queue_cond.notify_all()
497

498
def initialize_offset():
499
    last = get_last_update_id()
500
    if last is not None:
501
        return int(last) + 1
502
    if not SKIP_OLD:
503
        return 0
504
    try:
505
        res = api("getUpdates", {"timeout": 0, "limit": 100}, timeout=30)
506
        updates = res.get("result", [])
507
        if updates:
508
            max_id = max(u["update_id"] for u in updates)
509
            set_last_update_id(max_id)
510
            return max_id + 1
511
    except Exception as e:
512
        print("initialize_offset error:", repr(e), flush=True)
513
    return 0
514

515
def polling_loop():
516
    offset = initialize_offset()
517
    print(f"polling started, offset={offset}", flush=True)
518
    while True:
519
        try:
520
            res = api("getUpdates", {"offset": offset, "timeout": 50, "allowed_updates": ["message"]}, timeout=70)
521
            for upd in res.get("result", []):
522
                update_id = upd["update_id"]
523
                offset = update_id + 1
524
                set_last_update_id(update_id)
525
                msg = upd.get("message") or {}
526
                if msg:
527
                    handle_message(msg)
528
        except Exception as e:
529
            print("polling error:", repr(e), flush=True)
530
            time.sleep(5)
531

532
def main():
533
    print("tg-uploader started", flush=True)
534
    worker = threading.Thread(target=worker_loop, daemon=True)
535
    worker.start()
536
    polling_loop()
537

538
if __name__ == "__main__":
539
    main()
540
PY

1
/help
2
查看帮助
3

4
/dir
5
查看当前上传目录
6

7
/setdir gdrive:TelegramUploads/待整理
8
设置上传目录
9

10
/setdir gdrive:媒体/电视剧/剧名 (年份)/Season 01
11
切换到指定目录
12

13
/status
14
查看当前任务
15

16
/queue
17
查看等待队列
18

19
/cancel
20
中止当前正在上传的任务
21

22
/clear
23
清空等待队列

1
管理服务器
2
插件
3
目录 / Catalog
4
搜索 Playback Reporting
5
安装
6
重启 Emby

1
管理服务器
2
服务器
3
API
4
新增 API Key
5
名称：EmbyPulse

1
services:
2
  emby-pulse:
3
    image: zeyu8023/embypulse-pro:latest
4
    container_name: emby-pulse
5
    restart: unless-stopped
6
    ports:
7
      - "127.0.0.1:10307:10307"
8
      - "127.0.0.1:10308:10308"
9
    extra_hosts:
10
      - "host.docker.internal:host-gateway"
11
    volumes:
12
      - /opt/embypulse/config:/workspace/config
13
      - /opt/embypulse/data:/workspace/data
14
    environment:
15
      TZ: Asia/Shanghai
16
      PORT: "10307"
17
      REQUEST_PORT: "10308"
18
      LOCAL_AUTH_ENABLED: "true"
19
      LOCAL_ADMIN_USERNAME: "${LOCAL_ADMIN_USERNAME}"
20
      LOCAL_ADMIN_PASSWORD: "${LOCAL_ADMIN_PASSWORD}"
21
      EMBY_HOST: "${EMBY_HOST}"
22
      EMBY_API_KEY: "${EMBY_API_KEY}"

1
admin.example.com {
2
  reverse_proxy 127.0.0.1:10307
3
}
4

5
user.example.com {
6
  reverse_proxy 127.0.0.1:10308
7
}

1
Emby API Key
2
Emby 模板用户 testone
3
管理员 Bot Token
4
客户端 Bot Token
5
管理员 Telegram ID

1
用户名：testone
2
用途：新用户复制它的权限和配置