supertelegram 0.2.0 → 0.3.0

package/README.md

@@ -27,21 +27,36 @@ that's it! now you're ready to use telegram from the cli.
 
 ## usage
 
+### messages
+
 ```bash
 # send a message
-telegram send <username> <message>
+telegram send @username "hello there"
 
-# read messages
-telegram read <username> [limit]
+# read messages (shows [photo], [video], [file] indicators)
+telegram read @username 10
 
 # reply to latest message
-telegram reply <username> <message>
+telegram reply "John" "hey back!"
 
-# get unread messages (json output)
-telegram unread [limit]
+# get unread messages (json output with media info)
+telegram unread 20
 
 # list dialogs
-telegram dialogs [limit]
+telegram dialogs 10
+```
+
+### media (images/videos/files)
+
+```bash
+# send a file with optional caption
+telegram send-file @username photo.jpg
+telegram send-file @username video.mp4 "check this out!"
+
+# download media from a message
+# (use 'read' command to get message IDs)
+telegram download @username 12345 ./downloaded.jpg
+telegram download @username 12346  # auto-named file
 ```
 
 ### config

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supertelegram",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "telegram cli for humans and bots",
   "module": "index.ts",
   "type": "module",

package/src/cli/commands.ts

@@ -6,9 +6,12 @@ import {
   disconnect,
   getClient,
   login as telegramLogin,
+  sendFile as telegramSendFile,
+  downloadMedia as telegramDownloadMedia,
 } from "../client/telegram";
 import { askPhoneNumber, askPhoneCode, askPassword, askAppId, askAppHash } from "./prompts";
 import { getApiCredentials, setConfig } from "../config/manager";
+import { Api } from "telegram";
 
 export async function send(username: string, message: string) {
   if (!(await isLoggedIn())) {
@@ -21,6 +24,29 @@ export async function send(username: string, message: string) {
   await disconnect();
 }
 
+function getMediaInfo(msg: Api.Message): string {
+  if (!msg.media) return "";
+  
+  if (msg.media instanceof Api.MessageMediaPhoto) {
+    return " [photo]";
+  }
+  if (msg.media instanceof Api.MessageMediaDocument) {
+    const doc = msg.media.document;
+    if (doc instanceof Api.Document) {
+      const attrs = doc.attributes;
+      const filenameAttr = attrs.find((a) => "fileName" in a && a.fileName);
+      const filename = filenameAttr && "fileName" in filenameAttr ? filenameAttr.fileName : undefined;
+      const isVideo = attrs.some((a) => a instanceof Api.DocumentAttributeVideo);
+      const isAudio = attrs.some((a) => a instanceof Api.DocumentAttributeAudio);
+      
+      if (isVideo) return ` [video${filename ? `: ${filename}` : ""}]`;
+      if (isAudio) return ` [audio${filename ? `: ${filename}` : ""}]`;
+      return ` [file${filename ? `: ${filename}` : ""}]`;
+    }
+  }
+  return " [media]";
+}
+
 export async function read(username: string, limit = 10) {
   if (!(await isLoggedIn())) {
     console.error("not logged in. run: telegram login");
@@ -31,7 +57,8 @@ export async function read(username: string, limit = 10) {
   for (const msg of messages.reverse()) {
     const sender = msg.senderId?.toString() ?? "unknown";
     const date = msg.date ? new Date(msg.date * 1000).toISOString() : "";
-    console.log(`[${date}] [${sender}]: ${msg.message}`);
+    const mediaInfo = getMediaInfo(msg);
+    console.log(`[${date}] [${sender}]: ${msg.message}${mediaInfo}`);
   }
   await disconnect();
 }
@@ -88,6 +115,7 @@ export async function unread(limit = 20) {
       messages: fromOthers.map((m) => ({
         id: m.id,
         text: m.message,
+        media: m.media ? getMediaInfo(m).trim() : null,
         date: m.date ? new Date(m.date * 1000).toISOString() : null,
       })),
     });
@@ -179,3 +207,41 @@ export async function config(action?: string, key?: string, value?: string) {
   console.log("  telegram config set appHash <hash>");
   console.log("  telegram config get appId");
 }
+
+export async function sendFile(username: string, filePath: string, caption?: string) {
+  if (!(await isLoggedIn())) {
+    console.error("not logged in. run: telegram login");
+    process.exit(1);
+  }
+
+  const result = await telegramSendFile(username, filePath, caption);
+  console.log(`sent file id: ${result.id}`);
+  await disconnect();
+}
+
+export async function downloadMedia(username: string, messageId: number, outputPath?: string) {
+  if (!(await isLoggedIn())) {
+    console.error("not logged in. run: telegram login");
+    process.exit(1);
+  }
+
+  const messages = await getMessages(username, 100);
+  const msg = messages.find((m) => m.id === messageId);
+  
+  if (!msg) {
+    console.error(`message ${messageId} not found`);
+    await disconnect();
+    process.exit(1);
+  }
+  
+  if (!msg.media) {
+    console.error(`message ${messageId} has no media`);
+    await disconnect();
+    process.exit(1);
+  }
+
+  console.log("downloading media...");
+  const path = await telegramDownloadMedia(msg, outputPath);
+  console.log(`saved to: ${path || outputPath || "unknown"}`);
+  await disconnect();
+}

package/src/cli/run.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
-import { send, read, dialogs, unread, reply, login, config } from "./commands";
+import { send, read, dialogs, unread, reply, login, config, sendFile, downloadMedia } from "./commands";
 import { setVerbose, setSessionPath } from "../client/telegram";
 
 const VERSION = "0.1.0";
@@ -12,13 +12,15 @@ usage:
   ${NAME} <command> [options]
 
 commands:
-  send <chat> <message>    send a message to a chat
-  read <chat> [limit]      read messages from a chat (default: 10)
-  reply <chat> <message>   reply to a chat by name (partial match)
-  dialogs [limit]          list recent dialogs (default: 10)
-  unread [limit]           show unread messages as json (default: 20)
-  login                    authenticate with telegram
-  config set <key> <val>   set API credentials (appId, appHash)
+  send <chat> <message>      send a message to a chat
+  send-file <chat> <path>    send a file/image/video (optional: caption)
+  read <chat> [limit]        read messages from a chat (default: 10)
+  download <chat> <id> [out] download media from message id
+  reply <chat> <message>     reply to a chat by name (partial match)
+  dialogs [limit]            list recent dialogs (default: 10)
+  unread [limit]             show unread messages as json (default: 20)
+  login                      authenticate with telegram
+  config set <key> <val>     set API credentials (appId, appHash)
 
 options:
   -v, --verbose            show debug logs
@@ -27,7 +29,9 @@ options:
 
 examples:
   ${NAME} send @username "hello there"
+  ${NAME} send-file @username photo.jpg "check this out"
   ${NAME} read @username 5
+  ${NAME} download @username 12345 ./photo.jpg
   ${NAME} reply "John" "hey!"
   ${NAME} unread
   ${NAME} dialogs 20
@@ -88,6 +92,22 @@ async function main() {
       await reply(rest[0], rest.slice(1).join(" "));
       break;
 
+    case "send-file":
+      if (rest.length < 2 || !rest[0] || !rest[1]) {
+        console.error("usage: telegram send-file <chat> <path> [caption]");
+        process.exit(1);
+      }
+      await sendFile(rest[0], rest[1], rest.slice(2).join(" ") || undefined);
+      break;
+
+    case "download":
+      if (rest.length < 2 || !rest[0] || !rest[1]) {
+        console.error("usage: telegram download <chat> <message-id> [output-path]");
+        process.exit(1);
+      }
+      await downloadMedia(rest[0], Number.parseInt(rest[1]), rest[2]);
+      break;
+
     case "login":
       await login();
       break;

package/src/client/telegram.ts

@@ -84,6 +84,34 @@ export async function sendMessage(
   return c.sendMessage(username, { message });
 }
 
+export async function sendFile(
+  username: string,
+  filePath: string,
+  caption?: string
+): Promise<Api.Message> {
+  const c = await getClient();
+  return c.sendFile(username, {
+    file: filePath,
+    caption: caption,
+  });
+}
+
+export async function downloadMedia(
+  message: Api.Message,
+  outputPath?: string
+): Promise<string | undefined> {
+  const c = await getClient();
+  if (!message.media) {
+    return undefined;
+  }
+  
+  const buffer = await c.downloadMedia(message, {
+    outputFile: outputPath,
+  });
+  
+  return buffer as string | undefined;
+}
+
 export async function getMessages(
   username: string,
   limit = 10