supertelegram 0.1.3 → 0.2.0

package/README.md

@@ -8,23 +8,22 @@ telegram cli for ai to read/write messages using gramjs.
 npm install -g supertelegram
 ```
 
-## setup
+## quick start
 
-create `.env` file in your current directory:
-```bash
-TELEGRAM_APP_ID="your_app_id"
-TELEGRAM_APP_HASH="your_app_hash"
-```
-
-get credentials from https://my.telegram.org/apps
-
-## login
+just run login and follow the prompts:
 
 ```bash
 telegram login
 ```
 
-session is saved to `session.txt` in current directory.
+if you don't have API credentials configured, it will:
+1. prompt you to get them from https://my.telegram.org/apps
+2. ask for your app_id and app_hash
+3. save them to `~/.supertelegram/config.json`
+4. continue with telegram phone/code login
+5. save session to `~/.supertelegram/session.txt`
+
+that's it! now you're ready to use telegram from the cli.
 
 ## usage
 
@@ -45,12 +44,41 @@ telegram unread [limit]
 telegram dialogs [limit]
 ```
 
+### config
+
+manually set API credentials (optional):
+```bash
+telegram config set appId "12345678"
+telegram config set appHash "abc123..."
+```
+
 ### flags
 
 - `-v, --verbose` - show debug logs
 - `--help` - show help
 - `--version` - show version
 
+### advanced
+
+**multi-account / custom session location:**
+```bash
+# use env var
+TELEGRAM_SESSION=./custom.txt telegram send @friend "hey"
+
+# or pass flag (todo)
+telegram send @friend "hey" --session ./custom.txt
+```
+
+**precedence for API credentials:**
+1. `TELEGRAM_APP_ID` and `TELEGRAM_APP_HASH` env vars
+2. `~/.supertelegram/config.json` (global)
+3. `.env` file in current directory (for dev)
+
+**precedence for session file:**
+1. `TELEGRAM_SESSION` env var
+2. `~/.supertelegram/session.txt` (global default)
+3. `./session.txt` (backwards compat)
+
 ## development
 
 clone repo and install:

package/package.json

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

package/src/cli/commands.ts

@@ -7,7 +7,8 @@ import {
   getClient,
   login as telegramLogin,
 } from "../client/telegram";
-import { askPhoneNumber, askPhoneCode, askPassword } from "./prompts";
+import { askPhoneNumber, askPhoneCode, askPassword, askAppId, askAppHash } from "./prompts";
+import { getApiCredentials, setConfig } from "../config/manager";
 
 export async function send(username: string, message: string) {
   if (!(await isLoggedIn())) {
@@ -124,6 +125,18 @@ export async function reply(chatName: string, message: string) {
 }
 
 export async function login() {
+  // check if API credentials are configured
+  const creds = getApiCredentials();
+  if (!creds) {
+    console.log("no API credentials found. let's set them up first.");
+    const appId = await askAppId();
+    const appHash = await askAppHash();
+    
+    setConfig("appId", appId);
+    setConfig("appHash", appHash);
+    console.log("credentials saved to ~/.supertelegram/config.json\n");
+  }
+
   const loggedIn = await isLoggedIn();
   if (loggedIn) {
     console.log("already logged in!");
@@ -141,3 +154,28 @@ export async function login() {
   console.log("login complete!");
   await disconnect();
 }
+
+export async function config(action?: string, key?: string, value?: string) {
+  if (action === "set" && key && value) {
+    setConfig(key, value);
+    console.log(`set ${key} = ${value}`);
+    return;
+  }
+  
+  if (action === "get" && key) {
+    const cfg = getApiCredentials();
+    if (key === "appId" && cfg) {
+      console.log(cfg.appId);
+    } else if (key === "appHash" && cfg) {
+      console.log(cfg.appHash);
+    } else {
+      console.log("not found");
+    }
+    return;
+  }
+  
+  console.log("usage:");
+  console.log("  telegram config set appId <id>");
+  console.log("  telegram config set appHash <hash>");
+  console.log("  telegram config get appId");
+}

package/src/cli/prompts.ts

@@ -23,3 +23,12 @@ export async function askUsername(): Promise<string> {
 export async function askCommand(): Promise<string> {
   return input.text("command (send/read/dialogs/quit):");
 }
+
+export async function askAppId(): Promise<string> {
+  console.log("\nget your API credentials from: https://my.telegram.org/apps\n");
+  return input.text("enter TELEGRAM_APP_ID:");
+}
+
+export async function askAppHash(): Promise<string> {
+  return input.text("enter TELEGRAM_APP_HASH:");
+}

package/src/cli/run.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env bun
-import { send, read, dialogs, unread, reply, login } from "./commands";
-import { setVerbose } from "../client/telegram";
+import { send, read, dialogs, unread, reply, login, config } from "./commands";
+import { setVerbose, setSessionPath } from "../client/telegram";
 
 const VERSION = "0.1.0";
 const NAME = "telegram";
@@ -17,7 +17,8 @@ commands:
   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 (run separately)
+  login                    authenticate with telegram
+  config set <key> <val>   set API credentials (appId, appHash)
 
 options:
   -v, --verbose            show debug logs
@@ -56,7 +57,7 @@ if (verbose) {
 async function main() {
   switch (command) {
     case "send":
-      if (rest.length < 2) {
+      if (rest.length < 2 || !rest[0]) {
         console.error("usage: telegram send <chat> <message>");
         process.exit(1);
       }
@@ -64,7 +65,7 @@ async function main() {
       break;
 
     case "read":
-      if (rest.length < 1) {
+      if (rest.length < 1 || !rest[0]) {
         console.error("usage: telegram read <chat> [limit]");
         process.exit(1);
       }
@@ -80,7 +81,7 @@ async function main() {
       break;
 
     case "reply":
-      if (rest.length < 2) {
+      if (rest.length < 2 || !rest[0]) {
         console.error("usage: telegram reply <chat> <message>");
         process.exit(1);
       }
@@ -91,6 +92,10 @@ async function main() {
       await login();
       break;
 
+    case "config":
+      await config(rest[0], rest[1], rest[2]);
+      break;
+
     case "help":
       console.log(HELP);
       break;

package/src/client/telegram.ts

@@ -3,6 +3,7 @@ import { StringSession } from "telegram/sessions";
 import { Logger } from "telegram/extensions/Logger";
 import type { LogLevel } from "telegram/extensions/Logger";
 import { loadSession, saveSession } from "../session/storage";
+import { getApiCredentials } from "../config/manager";
 
 let verbose = false;
 
@@ -11,25 +12,38 @@ export function setVerbose(v: boolean) {
 }
 
 class SilentLogger extends Logger {
-  log(_level: LogLevel, _message: string, _color: string): void {
+  override log(_level: LogLevel, _message: string, _color: string): void {
     if (verbose) {
       super.log(_level, _message, _color);
     }
   }
 }
 
-const API_ID = Number(process.env.TELEGRAM_APP_ID);
-const API_HASH = process.env.TELEGRAM_APP_HASH ?? "";
-
 let client: TelegramClient | null = null;
+let customSessionPath: string | undefined;
+
+export function setSessionPath(path: string) {
+  customSessionPath = path;
+}
 
 export async function getClient(): Promise<TelegramClient> {
   if (client) return client;
 
-  const sessionStr = loadSession();
+  const creds = getApiCredentials();
+  if (!creds) {
+    throw new Error(
+      "telegram API credentials not found.\n" +
+      "get them from: https://my.telegram.org/apps\n" +
+      "then run: telegram config set appId <id>\n" +
+      "         telegram config set appHash <hash>\n" +
+      "or set env vars: TELEGRAM_APP_ID, TELEGRAM_APP_HASH"
+    );
+  }
+
+  const sessionStr = loadSession(customSessionPath);
   const session = new StringSession(sessionStr);
 
-  client = new TelegramClient(session, API_ID, API_HASH, {
+  client = new TelegramClient(session, creds.appId, creds.appHash, {
     connectionRetries: 5,
     baseLogger: new SilentLogger(),
   });
@@ -58,7 +72,7 @@ export async function login(callbacks: {
   });
 
   const sessionStr = c.session.save() as unknown as string;
-  saveSession(sessionStr);
+  saveSession(sessionStr, customSessionPath);
   console.log("session saved!");
 }
 

package/src/config/manager.ts

@@ -0,0 +1,95 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const CONFIG_DIR = join(homedir(), ".supertelegram");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+const SESSION_FILE = join(CONFIG_DIR, "session.txt");
+
+export interface Config {
+  appId?: string;
+  appHash?: string;
+}
+
+function ensureConfigDir() {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+
+export function getConfig(): Config {
+  ensureConfigDir();
+  
+  if (!existsSync(CONFIG_FILE)) {
+    return {};
+  }
+  
+  try {
+    const content = readFileSync(CONFIG_FILE, "utf-8");
+    return JSON.parse(content);
+  } catch (err) {
+    console.error("failed to read config:", err);
+    return {};
+  }
+}
+
+export function setConfig(key: string, value: string) {
+  ensureConfigDir();
+  
+  const config = getConfig();
+  config[key as keyof Config] = value;
+  
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+export function getSessionPath(customPath?: string): string {
+  // precedence:
+  // 1. custom path from flag
+  // 2. TELEGRAM_SESSION env var
+  // 3. global ~/.supertelegram/session.txt
+  // 4. local ./session.txt (backwards compat)
+  
+  if (customPath) {
+    return customPath;
+  }
+  
+  if (process.env.TELEGRAM_SESSION) {
+    return process.env.TELEGRAM_SESSION;
+  }
+  
+  // check if local session.txt exists (backwards compat)
+  if (existsSync("./session.txt")) {
+    return "./session.txt";
+  }
+  
+  return SESSION_FILE;
+}
+
+export function getApiCredentials(): { appId: number; appHash: string } | null {
+  // precedence:
+  // 1. env vars
+  // 2. global config
+  // 3. local .env (handled by process.env already)
+  
+  const envAppId = process.env.TELEGRAM_APP_ID;
+  const envAppHash = process.env.TELEGRAM_APP_HASH;
+  
+  if (envAppId && envAppHash) {
+    return {
+      appId: Number.parseInt(envAppId),
+      appHash: envAppHash,
+    };
+  }
+  
+  const config = getConfig();
+  if (config.appId && config.appHash) {
+    return {
+      appId: Number.parseInt(config.appId),
+      appHash: config.appHash,
+    };
+  }
+  
+  return null;
+}
+
+export { CONFIG_DIR, CONFIG_FILE, SESSION_FILE };

package/src/session/storage.ts

@@ -1,14 +1,24 @@
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { getSessionPath } from "../config/manager";
 
-const SESSION_FILE = "./session.txt";
-
-export function loadSession(): string {
-  if (existsSync(SESSION_FILE)) {
-    return readFileSync(SESSION_FILE, "utf-8").trim();
+export function loadSession(customPath?: string): string {
+  const sessionFile = getSessionPath(customPath);
+  
+  if (existsSync(sessionFile)) {
+    return readFileSync(sessionFile, "utf-8").trim();
   }
   return "";
 }
 
-export function saveSession(session: string): void {
-  writeFileSync(SESSION_FILE, session, "utf-8");
+export function saveSession(session: string, customPath?: string): void {
+  const sessionFile = getSessionPath(customPath);
+  
+  // ensure directory exists
+  const dir = dirname(sessionFile);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  
+  writeFileSync(sessionFile, session, "utf-8");
 }