telstore 0.1.4 → 0.1.5

package/bin/telstore.js

@@ -1,14 +1,10 @@
 #!/usr/bin/env node
 import { route, HELP, interruptMessage } from '../src/cli.js'
-import { runLogin } from '../src/commands/login.js'
-import { runConfig } from '../src/commands/config.js'
-import { runDelete } from '../src/commands/delete.js'
-import { runList } from '../src/commands/list.js'
-import { runLogout } from '../src/commands/logout.js'
-import { runRestore } from '../src/commands/restore.js'
-import { runStatus } from '../src/commands/status.js'
-import { runToken } from '../src/commands/token.js'
-import { runUpload } from '../src/commands/upload.js'
+
+// Each command is imported where it runs, not here. Importing all nine up front pulled
+// teleproto into every invocation — about 0.3s and 45MB — including `--help`, `config` and
+// `logout`, which never open a socket. `src/cli.js` stays a static import because parsing the
+// arguments is the one thing every run does, and nothing it touches reaches the network.
 
 const SIGINT_EXIT_CODE = 130
 
@@ -45,66 +41,97 @@ async function main() {
       process.stdout.write(HELP)
       return
 
-    case 'login':
+    case 'login': {
+      const { runLogin } = await import('../src/commands/login.js')
+
       await runLogin({
         args: parsed.args,
         token: Boolean(parsed.options.token),
         verbose: Boolean(parsed.options.verbose),
       })
       return
+    }
+
+    case 'logout': {
+      const { runLogout } = await import('../src/commands/logout.js')
 
-    case 'logout':
       await runLogout()
       return
+    }
+
+    case 'list': {
+      const { runList } = await import('../src/commands/list.js')
 
-    case 'list':
       await runList(parsed.options)
       return
+    }
+
+    case 'status': {
+      const { runStatus } = await import('../src/commands/status.js')
 
-    case 'status':
       await runStatus(parsed.options)
       return
+    }
+
+    case 'config': {
+      const { runConfig } = await import('../src/commands/config.js')
 
-    case 'config':
       await runConfig(parsed.args, parsed.options)
       return
+    }
+
+    case 'token': {
+      const { runToken } = await import('../src/commands/token.js')
 
-    case 'token':
       await runToken(parsed.args, parsed.options)
       return
+    }
+
+    case 'upload': {
+      const { runUpload } = await import('../src/commands/upload.js')
 
-    case 'upload':
       await runUpload(parsed.args[0], parsed.options, {
         onBackupId: (id) => {
           currentBackupId = id
         },
       })
       return
+    }
 
-    case 'restore':
+    case 'restore': {
       if (!parsed.args[0]) {
         throw new Error('Missing backup id. Example: npx telstore restore telstore-20260905-7f3a91')
       }
+
+      const { runRestore } = await import('../src/commands/restore.js')
+
       await runRestore(parsed.args[0], parsed.options)
       return
+    }
 
-    case 'delete':
+    case 'delete': {
       if (!parsed.args[0]) {
         throw new Error('Missing backup id. Example: npx telstore delete telstore-20260905-7f3a91')
       }
+
+      const { runDelete } = await import('../src/commands/delete.js')
+
       await runDelete(parsed.args[0], parsed.options)
       return
+    }
 
     default:
       throw new Error(`Unknown command: ${parsed.command}`)
   }
 }
 
-// GramJS keeps "exported senders" around together with a 30-second timer to release
-// them, and neither client.disconnect() nor destroy() cleans them up: both of those
-// maps are Maps, but the code walks them with Object.values and so misses everything.
-// The result is a command that prints "Done" and then hangs for another ~30 seconds,
-// during which Ctrl-C falsely reports that nothing was saved. Finish the work, exit.
+// Written for GramJS, which kept "exported senders" alive behind a 30-second release timer
+// that neither disconnect() nor destroy() could clear — both walked a Map with Object.values
+// and missed every entry, so a command printed "Done" and then hung for half a minute, during
+// which Ctrl-C falsely reported that nothing had been saved. teleproto replaced that pool
+// wholesale and closes it on destroy(). This stays anyway: a CLI that has written its last
+// line has nothing left to wait for, and one stray timer in any dependency is all it takes
+// for the wait to come back.
 function exitWhenFlushed(code) {
   // The empty writes exist only to borrow their callbacks: they fire after everything
   // queued earlier has flushed, so nothing is lost when stdout/stderr is not a TTY.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "telstore",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Split large files into chunks and store them on Telegram",
   "keywords": [
     "telegram",
@@ -37,6 +37,6 @@
     "test": "node --test 'test/**/*.test.js'"
   },
   "dependencies": {
-    "telegram": "^2.26.22"
+    "teleproto": "^1.229.0"
   }
 }

package/src/client.js

@@ -1,14 +1,14 @@
-import { Api, TelegramClient } from 'telegram'
-import { Logger } from 'telegram/extensions/index.js'
-import { LogLevel } from 'telegram/extensions/Logger.js'
-import { StringSession } from 'telegram/sessions/index.js'
+import { Api, TelegramClient } from 'teleproto'
+import { Logger } from 'teleproto/extensions/index.js'
+import { LogLevel } from 'teleproto/extensions/Logger.js'
+import { StringSession } from 'teleproto/sessions/index.js'
 
 import { manifestFileName } from './manifest.js'
 import { withRetry } from './retry.js'
-import { unlockConfig } from './session.js'
+import { assertLoggedIn, unlockConfig } from './session.js'
 import { DEFAULT_STALL_MS, withStallTimeout } from './stall.js'
 
-// GramJS narrates its version, every connection and every disconnect at info level, and
+// teleproto narrates its version, every connection and every disconnect at info level, and
 // those timestamped lines land in the middle of the progress bar. The client reads this
 // logger before it prints anything, so LogLevel.NONE silences all of it; --verbose asks
 // for the running commentary back when a connection needs diagnosing.
@@ -58,7 +58,7 @@ export async function readMessageBytes(client, message) {
 }
 
 // The one place telstore removes messages from a chat, and the mirror of searchDocuments
-// above. GramJS has its own deleteMessages, and it is the right thing to call — it resolves
+// above. teleproto has its own deleteMessages, and it is the right thing to call — it resolves
 // the peer and picks between channels.DeleteMessages and messages.DeleteMessages, which is
 // exactly the choice a fake client would never catch us getting wrong.
 //
@@ -87,7 +87,7 @@ export async function deleteMessages(client, peer, ids, options = {}) {
 
     await withRetry(
       () =>
-        // The options object is not optional: GramJS destructures `{ revoke }` with no
+        // The options object is not optional: teleproto destructures `{ revoke }` with no
         // default of its own, so a two-argument call throws a TypeError before it ever
         // reaches the network. revoke is passed explicitly anyway — a backup has to go for
         // everyone who can see the chat, and that intent belongs in our code rather than in
@@ -122,18 +122,6 @@ export async function closeQuietly(client, disconnect, onWarn) {
   }
 }
 
-// Two shapes count as logged in: the ordinary one login writes, and the sealed blob that
-// "login --token" leaves, which holds the same three fields behind a passphrase. Checked
-// before anything asks for that passphrase, so somebody who never logged in is told so rather
-// than asked to type a secret for an account that is not there.
-export function assertLoggedIn(config) {
-  if (config.sealed) return
-
-  if (!config.session || !config.apiId || !config.apiHash) {
-    throw new Error('Not logged in — run "npx telstore login" first.')
-  }
-}
-
 // Every command that needs Telegram comes through here, which makes this the one place a
 // sealed session has to be opened. Doing it anywhere else would mean eight places to keep in
 // step, and a ninth command would simply forget.

package/src/commands/delete.js

@@ -1,7 +1,6 @@
 import { chatName, describeChat } from '../chat.js'
 import {
   DELETE_BATCH_SIZE,
-  assertLoggedIn,
   closeQuietly,
   connect as realConnect,
   deleteMessages as realDeleteMessages,
@@ -12,6 +11,7 @@ import { askConfirm } from '../confirm.js'
 import { configFile, defaultConfigDir, loadConfig } from '../config.js'
 import { manifestFileName, manifestMessageIds, parseManifestJson } from '../manifest.js'
 import { formatBytes, formatDuration } from '../progress.js'
+import { assertLoggedIn } from '../session.js'
 import { requireChat, resolveSettings } from '../settings.js'
 import { clearState, findStates } from '../state.js'
 

package/src/commands/list.js

@@ -1,12 +1,12 @@
 import { MANIFEST_TAG, parseManifestCaption } from '../caption.js'
 import { chatName, describeChat } from '../chat.js'
 import {
-  assertLoggedIn,
   closeQuietly,
   connect as realConnect,
   searchDocuments,
 } from '../client.js'
 import { configFile, defaultConfigDir, loadConfig } from '../config.js'
+import { assertLoggedIn } from '../session.js'
 import { requireChat, resolveSettings } from '../settings.js'
 
 const UNKNOWN = '—'

package/src/commands/login.js

@@ -1,5 +1,5 @@
-import { TelegramClient } from 'telegram'
-import { StringSession } from 'telegram/sessions/index.js'
+import { TelegramClient } from 'teleproto'
+import { StringSession } from 'teleproto/sessions/index.js'
 
 import { loadConfig, saveConfig, defaultConfigDir } from '../config.js'
 import { normalizeChatTarget } from '../chat.js'
@@ -26,11 +26,12 @@ export function describeLoginError(err) {
   return `${description} (${message})`
 }
 
-// GramJS starts an update loop the moment a client connects, and that loop only stops when
-// destroy() marks the client destroyed. disconnect() alone leaves it pinging a socket that is
-// already closed: every ping fails with "Error: TIMEOUT" and asks the sender to reconnect,
-// printed straight over the destination question login asks after signing in. Every other
-// command shuts down the same way, and login is the seam tests need to reach it.
+// An update loop starts the moment a client connects, and destroy() is what puts the whole
+// client down — the sender pools included. Under GramJS, disconnect() alone left that loop
+// pinging a closed socket, every ping failing with "Error: TIMEOUT" and asking for a
+// reconnect, printed straight over the destination question login asks after signing in.
+// Every command shuts down through destroy() for that reason, and login is the seam tests
+// need to reach it.
 const createTelegramClient = (apiId, apiHash, options) =>
   new TelegramClient(new StringSession(''), apiId, apiHash, options)
 

package/src/commands/status.js

@@ -1,8 +1,9 @@
 import { countChunks } from '../chunking.js'
 import { describeChat } from '../chat.js'
-import { assertLoggedIn, closeQuietly, connect as realConnect } from '../client.js'
+import { closeQuietly, connect as realConnect } from '../client.js'
 import { configFile, defaultConfigDir, loadConfig } from '../config.js'
 import { formatBytes } from '../progress.js'
+import { assertLoggedIn } from '../session.js'
 import { resolveSettings } from '../settings.js'
 import { canResume, listStates } from '../state.js'
 

package/src/commands/token.js

@@ -1,7 +1,6 @@
-import { assertLoggedIn } from '../client.js'
 import { defaultConfigDir, loadConfig } from '../config.js'
 import { createPrompts } from '../prompt.js'
-import { unlockConfig } from '../session.js'
+import { assertLoggedIn, unlockConfig } from '../session.js'
 import { knownSettings } from '../settings.js'
 import { encodeToken } from '../token.js'
 

package/src/commands/upload.js

@@ -1,8 +1,8 @@
 import { promises as fs } from 'node:fs'
 import path from 'node:path'
 
-import { Api } from 'telegram'
-import { CustomFile } from 'telegram/client/uploads.js'
+import { Api } from 'teleproto'
+import { CustomFile } from 'teleproto/client/uploads.js'
 
 import { PART_SIZE, planChunks } from '../chunking.js'
 import { chunkCaption, manifestCaption } from '../caption.js'

package/src/downloader.js

@@ -2,7 +2,7 @@ import { createHash } from 'node:crypto'
 import { read as readCallback, write as writeCallback } from 'node:fs'
 import { promisify } from 'node:util'
 
-import { returnBigInt } from 'telegram/Helpers.js'
+import { returnBigInt } from 'teleproto/Helpers.js'
 
 import { DEFAULT_DOWNLOAD_CONCURRENCY, PART_SIZE, SLICE_SIZE } from './chunking.js'
 import { withRetry } from './retry.js'
@@ -105,10 +105,14 @@ export async function downloadToFile(
       // Iterated by hand rather than with `for await` so each part can be given a deadline:
       // a stalled stream yields nothing and raises nothing, and only a race against a timer
       // turns that silence into an error withRetry can act on. Nothing is lost by stepping
-      // outside `for await` — GramJS's download iterator exposes `next` alone, so breaking
+      // outside `for await` — teleproto's download iterator exposes `next` alone, so breaking
       // out of the loop never closed anything either.
-      const stream = client.iterDownload({
-        file: message.media,
+      //
+      // The media goes in its own argument, not inside the options: teleproto takes
+      // `iterDownload(file, params)` where GramJS took a single `{ file, ... }` object, and
+      // the options object arriving where the file belongs is not something a fake client
+      // would ever refuse — it fails only against the real one, at getFileInfo.
+      const stream = client.iterDownload(message.media, {
         offset: returnBigInt(start + done),
         requestSize: PART_SIZE,
       })

package/src/retry.js

@@ -10,8 +10,14 @@ function defaultSleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms))
 }
 
+// Every "wait this long" answer Telegram gives arrives as code 420 with the seconds on the
+// error itself — FLOOD_WAIT_n, SLOW_MODE_WAIT_n and the rest. Those two fields are what this
+// reads, not how the message is spelled: under GramJS every flood error carried the literal
+// errorMessage "FLOOD", so a check for "FLOOD_WAIT" in it matched nothing and each one was
+// retried on the ordinary backoff — asking again inside a ban that was still running.
+// A 420 with no seconds (a frozen account) has nothing to wait for and takes the backoff.
 function floodWaitSeconds(err) {
-  if (typeof err?.seconds === 'number' && String(err?.errorMessage ?? '').includes('FLOOD_WAIT')) {
+  if (err?.code === 420 && typeof err.seconds === 'number') {
     return err.seconds
   }
   return null

package/src/session.js

@@ -1,7 +1,7 @@
 import { readSecret as realReadSecret } from './prompt.js'
 import { decodeToken } from './token.js'
 
-// How a stored config becomes the three things GramJS needs. There are two shapes on disk —
+// How a stored config becomes the three things teleproto needs. There are two shapes on disk —
 // the ordinary login, and the sealed blob `login --token` writes — and this is the one place
 // that knows the difference, so `connect` stays about Telegram and the commands stay about
 // their own narrative.
@@ -22,3 +22,16 @@ export async function unlockConfig(config, { readSecret = realReadSecret } = {})
 
   return { apiId, apiHash, session }
 }
+
+// Two shapes count as logged in: the ordinary one login writes, and the sealed blob that
+// "login --token" leaves, which holds the same three fields behind a passphrase. It lives
+// here rather than beside connect because knowing both shapes is this file's whole job, and
+// because `token` is an offline command: reaching for it through src/client.js pulled the
+// whole of teleproto into a run that never opens a socket.
+export function assertLoggedIn(config) {
+  if (config.sealed) return
+
+  if (!config.session || !config.apiId || !config.apiHash) {
+    throw new Error('Not logged in — run "npx telstore login" first.')
+  }
+}

package/src/stall.js

@@ -10,16 +10,18 @@ const MAX_TIMER_MS = 2 ** 31 - 1
 // A request that never comes back is not the same as one that fails, and only one of the
 // two is something withRetry can do anything about.
 //
-// GramJS can leave a request queued on a sender it has quietly given up on. Its own abort
-// path is unreachable: MTProtoSender rejects pending states only when
-// `_currentRetries > _reconnectRetries`, and `reconnectRetries` has no default to compare
-// against, so the test is never true (network/MTProtoSender.js:376). Nor does the reconnect
-// itself report failure — `connect()` exhausts its attempts and returns false rather than
-// throwing, so `_reconnect()` finishes as if it had worked and puts the request back on a
-// queue with no send loop left to drain it (network/MTProtoSender.js:148,795).
+// This was written for a GramJS bug that abandoned requests outright: its abort path tested
+// `_currentRetries > _reconnectRetries` against a `reconnectRetries` of Infinity and so never
+// fired, and `_reconnect()` read a `connect()` that merely returned false as success. A real
+// network cut mid-restore froze a transfer for eleven minutes on Linux and ended it without a
+// printed line on Windows. teleproto closes both halves — `connect()` throws once its attempts
+// are spent, and `_reconnect()` catches that and rejects every pending request.
 //
-// The promise then simply sits there. Nothing throws, nothing prints, and once no handle is
-// left the process ends mid-transfer without a word — the one outcome this project forbids.
+// The deadline stays because the library was never the only way to arrive here. A server that
+// accepts a request and answers nothing, a socket that stays open with nothing coming down it:
+// there is no failure for withRetry to see, only silence. The timer is what turns that silence
+// into an error — and, deliberately not unref'd, it is also the handle that stops the event
+// loop running dry and ending a transfer without a word.
 export async function withStallTimeout(promise, ms, describe) {
   if (!(ms > 0)) return await promise
 

package/src/token.js

@@ -46,7 +46,7 @@ function isPlainObject(value) {
 // A token is untrusted input in the same category as a manifest or a state file. Opening one
 // proves whoever made it knew the passphrase, not that they made it correctly — and the
 // unprotected format proves nothing at all. An apiId of undefined does not throw here; it
-// reaches GramJS and fails much later as something that reads like a network problem.
+// reaches teleproto and fails much later as something that reads like a network problem.
 export function checkTokenBundle(bundle) {
   if (!isPlainObject(bundle)) {
     throw new Error(

package/src/uploader.js

@@ -2,8 +2,8 @@ import { createHash, randomBytes } from 'node:crypto'
 import { read as readCallback } from 'node:fs'
 import { promisify } from 'node:util'
 
-import { Api } from 'telegram'
-import { readBigIntFromBuffer } from 'telegram/Helpers.js'
+import { Api } from 'teleproto'
+import { readBigIntFromBuffer } from 'teleproto/Helpers.js'
 
 import { DEFAULT_UPLOAD_CONCURRENCY, PART_SIZE, MAX_PARTS } from './chunking.js'
 import { withRetry } from './retry.js'
@@ -12,8 +12,8 @@ import { DEFAULT_STALL_MS, withStallTimeout } from './stall.js'
 const read = promisify(readCallback)
 
 // Telegram splits its upload API by file size: only files above 10MB may use the
-// "big" family. GramJS picks the same threshold (LARGE_FILE_THRESHOLD in
-// node_modules/telegram/client/uploads.js), and telstore follows it.
+// "big" family. teleproto picks the same threshold (LARGE_FILE_THRESHOLD in
+// node_modules/teleproto/client/uploads.js), and telstore follows it.
 export const LARGE_FILE_THRESHOLD = 10 * 1024 * 1024
 
 async function readExactly(fd, length, position) {
@@ -105,9 +105,9 @@ export async function uploadRange(client, fd, options) {
         sending.push(
           withRetry(
             () =>
-              // Same exposure as the download path: a request left on a sender GramJS has
-              // stopped draining never settles, so without a deadline this await would hold
-              // the batch open forever and the upload would end without a word.
+              // Same exposure as the download path: a request the server accepts and never
+              // answers settles neither way, so without a deadline this await would hold the
+              // batch open forever and the upload would end without a word.
               withStallTimeout(
                 client.invoke(partRequest(part, bytes)),
                 stallMs,