354 lines
11 KiB
Python
354 lines
11 KiB
Python
from __future__ import annotations
|
|
|
|
import sys
|
|
from pathlib import Path
|
|
from typing import Any, Dict, List, Optional, Sequence
|
|
|
|
from cmdlet._shared import Cmdlet, CmdletArg
|
|
from SYS.logger import log
|
|
from result_table import ResultTable
|
|
import pipeline as ctx
|
|
|
|
_TELEGRAM_PENDING_ITEMS_KEY = "telegram_pending_items"
|
|
|
|
|
|
def _has_flag(args: Sequence[str], flag: str) -> bool:
|
|
try:
|
|
want = str(flag or "").strip().lower()
|
|
if not want:
|
|
return False
|
|
return any(str(a).strip().lower() == want for a in (args or []))
|
|
except Exception:
|
|
return False
|
|
|
|
|
|
def _normalize_to_list(value: Any) -> List[Any]:
|
|
if value is None:
|
|
return []
|
|
if isinstance(value, list):
|
|
return value
|
|
return [value]
|
|
|
|
|
|
def _extract_chat_id(chat_obj: Any) -> Optional[int]:
|
|
try:
|
|
if isinstance(chat_obj, dict):
|
|
maybe_id = chat_obj.get("id")
|
|
if maybe_id is not None:
|
|
return int(maybe_id)
|
|
extra = chat_obj.get("extra")
|
|
if isinstance(extra, dict):
|
|
v = extra.get("id")
|
|
if v is not None:
|
|
return int(v)
|
|
v = extra.get("chat_id")
|
|
if v is not None:
|
|
return int(v)
|
|
# PipeObject stores unknown fields in .extra
|
|
if hasattr(chat_obj, "extra"):
|
|
extra = getattr(chat_obj, "extra")
|
|
if isinstance(extra, dict):
|
|
v = extra.get("id")
|
|
if v is not None:
|
|
return int(v)
|
|
v = extra.get("chat_id")
|
|
if v is not None:
|
|
return int(v)
|
|
if hasattr(chat_obj, "id"):
|
|
maybe_id = getattr(chat_obj, "id")
|
|
if maybe_id is not None:
|
|
return int(maybe_id)
|
|
except Exception:
|
|
return None
|
|
return None
|
|
|
|
|
|
def _extract_chat_username(chat_obj: Any) -> str:
|
|
try:
|
|
if isinstance(chat_obj, dict):
|
|
u = chat_obj.get("username")
|
|
return str(u or "").strip()
|
|
if hasattr(chat_obj, "extra"):
|
|
extra = getattr(chat_obj, "extra")
|
|
if isinstance(extra, dict):
|
|
u = extra.get("username")
|
|
if isinstance(u, str) and u.strip():
|
|
return u.strip()
|
|
if hasattr(chat_obj, "username"):
|
|
return str(getattr(chat_obj, "username") or "").strip()
|
|
except Exception:
|
|
return ""
|
|
return ""
|
|
|
|
|
|
def _extract_title(item: Any) -> str:
|
|
try:
|
|
if isinstance(item, dict):
|
|
return str(item.get("title") or "").strip()
|
|
if hasattr(item, "title"):
|
|
return str(getattr(item, "title") or "").strip()
|
|
# PipeObject stores some fields in .extra
|
|
if hasattr(item, "extra"):
|
|
extra = getattr(item, "extra")
|
|
if isinstance(extra, dict):
|
|
v = extra.get("title")
|
|
if isinstance(v, str) and v.strip():
|
|
return v.strip()
|
|
except Exception:
|
|
return ""
|
|
return ""
|
|
|
|
|
|
def _extract_file_path(item: Any) -> Optional[str]:
|
|
|
|
def _maybe(value: Any) -> Optional[str]:
|
|
if value is None:
|
|
return None
|
|
text = str(value).strip()
|
|
if not text:
|
|
return None
|
|
if text.startswith("http://") or text.startswith("https://"):
|
|
return None
|
|
try:
|
|
p = Path(text).expanduser()
|
|
if p.exists():
|
|
return str(p)
|
|
except Exception:
|
|
return None
|
|
return None
|
|
|
|
try:
|
|
if hasattr(item, "path"):
|
|
found = _maybe(getattr(item, "path"))
|
|
if found:
|
|
return found
|
|
if hasattr(item, "file_path"):
|
|
found = _maybe(getattr(item, "file_path"))
|
|
if found:
|
|
return found
|
|
if isinstance(item, dict):
|
|
for key in ("path", "file_path", "target"):
|
|
found = _maybe(item.get(key))
|
|
if found:
|
|
return found
|
|
except Exception:
|
|
return None
|
|
return None
|
|
|
|
|
|
def _run(_result: Any, args: Sequence[str], config: Dict[str, Any]) -> int:
|
|
from Provider.telegram import Telegram
|
|
|
|
try:
|
|
provider = Telegram(config)
|
|
except Exception as exc:
|
|
log(f"Telegram not available: {exc}", file=sys.stderr)
|
|
return 1
|
|
|
|
if _has_flag(args, "-login"):
|
|
ok = False
|
|
try:
|
|
ok = provider.ensure_session(prompt=True)
|
|
except Exception:
|
|
ok = False
|
|
if not ok:
|
|
err = getattr(provider, "_last_login_error", None)
|
|
if isinstance(err, str) and err.strip():
|
|
log(f"Telegram login failed: {err}", file=sys.stderr)
|
|
else:
|
|
log("Telegram login failed (no session created).", file=sys.stderr)
|
|
return 1
|
|
log("Telegram login OK (authorized session ready).", file=sys.stderr)
|
|
return 0
|
|
|
|
# Internal stage: send previously selected pipeline items to selected chats.
|
|
if _has_flag(args, "-send"):
|
|
# Ensure we don't keep showing the picker table on the send stage.
|
|
try:
|
|
if hasattr(ctx, "set_last_result_table_overlay"):
|
|
ctx.set_last_result_table_overlay(None, None, None)
|
|
except Exception:
|
|
pass
|
|
try:
|
|
if hasattr(ctx, "set_current_stage_table"):
|
|
ctx.set_current_stage_table(None)
|
|
except Exception:
|
|
pass
|
|
|
|
selected_chats = _normalize_to_list(_result)
|
|
chat_ids: List[int] = []
|
|
chat_usernames: List[str] = []
|
|
for c in selected_chats:
|
|
cid = _extract_chat_id(c)
|
|
if cid is not None:
|
|
chat_ids.append(cid)
|
|
else:
|
|
u = _extract_chat_username(c)
|
|
if u:
|
|
chat_usernames.append(u)
|
|
|
|
# De-dupe chat identifiers (preserve order).
|
|
try:
|
|
chat_ids = list(dict.fromkeys([int(x) for x in chat_ids]))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
chat_usernames = list(
|
|
dict.fromkeys(
|
|
[str(u).strip() for u in chat_usernames if str(u).strip()]
|
|
)
|
|
)
|
|
except Exception:
|
|
pass
|
|
|
|
if not chat_ids and not chat_usernames:
|
|
log(
|
|
"No Telegram chat selected (use @N on the Telegram table)",
|
|
file=sys.stderr
|
|
)
|
|
return 1
|
|
|
|
pending_items = ctx.load_value(_TELEGRAM_PENDING_ITEMS_KEY, default=[])
|
|
items = _normalize_to_list(pending_items)
|
|
if not items:
|
|
log("No pending items to send (use: @N | .telegram)", file=sys.stderr)
|
|
return 1
|
|
|
|
file_jobs: List[Dict[str, str]] = []
|
|
any_failed = False
|
|
for item in items:
|
|
p = _extract_file_path(item)
|
|
if not p:
|
|
any_failed = True
|
|
log(
|
|
"Telegram send requires local file path(s) on the piped item(s)",
|
|
file=sys.stderr,
|
|
)
|
|
continue
|
|
title = _extract_title(item)
|
|
file_jobs.append({
|
|
"path": p,
|
|
"title": title
|
|
})
|
|
|
|
# De-dupe file paths (preserve order).
|
|
try:
|
|
seen: set[str] = set()
|
|
unique_jobs: List[Dict[str, str]] = []
|
|
for j in file_jobs:
|
|
k = str(j.get("path") or "").strip().lower()
|
|
if not k or k in seen:
|
|
continue
|
|
seen.add(k)
|
|
unique_jobs.append(j)
|
|
file_jobs = unique_jobs
|
|
except Exception:
|
|
pass
|
|
|
|
if not file_jobs:
|
|
return 1
|
|
|
|
try:
|
|
provider.send_files_to_chats(
|
|
chat_ids=chat_ids,
|
|
usernames=chat_usernames,
|
|
files=file_jobs
|
|
)
|
|
except Exception as exc:
|
|
log(f"Telegram send failed: {exc}", file=sys.stderr)
|
|
any_failed = True
|
|
|
|
ctx.store_value(_TELEGRAM_PENDING_ITEMS_KEY, [])
|
|
return 1 if any_failed else 0
|
|
|
|
selected_items = _normalize_to_list(_result)
|
|
if selected_items:
|
|
ctx.store_value(_TELEGRAM_PENDING_ITEMS_KEY, selected_items)
|
|
else:
|
|
# Avoid stale sends if the user just wants to browse chats.
|
|
try:
|
|
ctx.store_value(_TELEGRAM_PENDING_ITEMS_KEY, [])
|
|
except Exception:
|
|
pass
|
|
try:
|
|
if hasattr(ctx, "clear_pending_pipeline_tail"):
|
|
ctx.clear_pending_pipeline_tail()
|
|
except Exception:
|
|
pass
|
|
|
|
# Default: list available chats/channels (requires an existing session or bot_token).
|
|
try:
|
|
rows = provider.list_chats(limit=200)
|
|
except Exception as exc:
|
|
log(f"Failed to list Telegram chats: {exc}", file=sys.stderr)
|
|
return 1
|
|
|
|
# Only show dialogs you can typically post to.
|
|
try:
|
|
rows = [
|
|
r for r in (rows or [])
|
|
if str(r.get("type") or "").strip().lower() in {"group", "user"}
|
|
]
|
|
except Exception:
|
|
pass
|
|
|
|
if not rows:
|
|
log(
|
|
"No Telegram groups/users available (or not logged in). Run: .telegram -login",
|
|
file=sys.stderr,
|
|
)
|
|
return 0
|
|
|
|
table = ResultTable("Telegram Chats")
|
|
table.set_table("telegram")
|
|
table.set_source_command(".telegram", [])
|
|
|
|
chat_items: List[Dict[str, Any]] = []
|
|
for item in rows:
|
|
row = table.add_row()
|
|
title = str(item.get("title") or "").strip()
|
|
username = str(item.get("username") or "").strip()
|
|
chat_id = item.get("id")
|
|
kind = str(item.get("type") or "").strip()
|
|
row.add_column("Type", kind)
|
|
row.add_column("Title", title)
|
|
row.add_column("Username", username)
|
|
row.add_column("Id", str(chat_id) if chat_id is not None else "")
|
|
chat_items.append(
|
|
{
|
|
**item,
|
|
"store": "telegram",
|
|
"title": title or username or str(chat_id) or "Telegram",
|
|
}
|
|
)
|
|
|
|
# Overlay table: ensures @N selection targets this Telegram picker, not a previous table.
|
|
ctx.set_last_result_table_overlay(table, chat_items)
|
|
ctx.set_current_stage_table(table)
|
|
if selected_items:
|
|
ctx.set_pending_pipeline_tail([[".telegram", "-send"]], ".telegram")
|
|
return 0
|
|
|
|
|
|
CMDLET = Cmdlet(
|
|
name=".telegram",
|
|
alias=["telegram"],
|
|
summary="Telegram login and chat listing",
|
|
usage="@N | .telegram (pick a chat, then send piped files)",
|
|
arg=[
|
|
CmdletArg(
|
|
name="login",
|
|
type="bool",
|
|
description="Create/refresh a Telegram session (prompts)",
|
|
required=False,
|
|
),
|
|
CmdletArg(
|
|
name="send",
|
|
type="bool",
|
|
description="(internal) Send to selected chat(s)",
|
|
required=False,
|
|
),
|
|
],
|
|
exec=_run,
|
|
)
|