telstore 0.1.0

package/src/cli.js

@@ -0,0 +1,161 @@
+import { parseArgs } from 'node:util'
+
+const SUBCOMMANDS = new Set([
+  'login',
+  'logout',
+  'list',
+  'restore',
+  'delete',
+  'status',
+  'config',
+  'help',
+])
+
+const OPTIONS = {
+  to: { type: 'string' },
+  'chunk-size': { type: 'string' },
+  concurrency: { type: 'string' },
+  out: { type: 'string' },
+  limit: { type: 'string' },
+  verbose: { type: 'boolean' },
+  unset: { type: 'boolean' },
+  yes: { type: 'boolean' },
+  help: { type: 'boolean', short: 'h' },
+}
+
+export const HELP = `telark — split large files into chunks and store them on Telegram
+
+Usage:
+  npx telark login                        Log in to Telegram, only needed once
+  npx telark <file>                       Split a file and upload it to Telegram
+  npx telark list                         List the backups stored in the destination
+  npx telark restore <backup-id>          Download the chunks and reassemble the file
+  npx telark delete <backup-id>           Remove a backup's chunks and manifest from the chat
+  npx telark status                       Show the account, the destination and unfinished backups
+  npx telark config                       Show every setting and where its value comes from
+  npx telark logout                       Remove the saved session
+
+Settings:
+  npx telark config <name>                Print one setting's value
+  npx telark config <name> <value>        Change it for good
+  npx telark config <name> --unset        Drop it and fall back to the default
+
+  chat          Where backups go: @username, -100123..., or me. No default.
+  chunkSize     Size of each chunk, default 1800MB. Examples: 1.8GB, 500MB.
+  concurrency   512KB parts sent in parallel, default 8, max 64. Upload only.
+  limit         How many backups list shows, default 20.
+  verbose       Show Telegram connection logs, default false.
+
+Options apply to one run and are never saved. Use config to change a setting for good.
+  --to <chat>            Destination for this run only.
+  --chunk-size <n>       Chunk size for this run only. An unfinished backup keeps the size
+                         it started with.
+  --concurrency <n>      Parts in parallel for this run only. Upload only — restore always
+                         downloads with its own fixed pool of workers.
+  --out <path>           Where to write the restored file. Defaults to the basename in the manifest.
+  --limit <n>            How many backups list shows this run.
+  --yes                  Delete without asking to confirm first.
+  --verbose              Show Telegram connection logs for this run.
+  -h, --help             Show this help.
+`
+
+// What Ctrl-C means depends on the command that was running: upload has written every
+// finished chunk to a state file, restore has not. Naming the backup matters because the
+// id is what `status` lists and what a later `restore` needs — the chunks are already in
+// the chat under that id, whether or not this run ever finishes.
+export function interruptMessage(command, { backupId } = {}) {
+  if (command === 'upload') {
+    const backup = backupId ? `Backup ${backupId} is saved` : 'Progress is saved'
+
+    return (
+      `\n${backup} — run the same command again to continue, ` +
+      'or "npx telark status" to see what is left.\n'
+    )
+  }
+
+  if (command === 'restore') {
+    return '\nStopped. Download progress is not saved, running again starts over.\n'
+  }
+
+  // A delete has already destroyed messages for good by the time Ctrl-C lands, and the
+  // manifest is deliberately still there — it is what a second run reads to finish. Saying
+  // only "Stopped." would read as "nothing happened", which is the one thing it never means.
+  if (command === 'delete') {
+    return (
+      '\nStopped. Some chunk messages are already gone — run the same command again to ' +
+      'finish removing the backup.\n'
+    )
+  }
+
+  return '\nStopped.\n'
+}
+
+// A channel id is negative, and typing it separated by a space is the natural reflex — but
+// parseArgs rejects anything starting with a dash as an option, and reports it as one:
+// `config chat -100123` fails with "Unknown option '-1'", naming a flag nobody typed.
+//
+// Two shapes need rescuing, and they are rescued differently. As a flag value, `--to -100123`
+// is joined into `--to=-100123`; only a bare negative integer qualifies, so `--to --verbose`
+// still reports the missing value instead of eating the next flag. As a positional —
+// `config chat -100123` — there is nothing to join it to, so `--` goes in front and the rest
+// of the line is handed over verbatim. That is greedy on purpose: a flag written after the
+// id becomes a positional too, and runConfig refuses the extra argument by name, which beats
+// an error about `-1`.
+//
+// Everything after an explicit `--` is left alone, because it is no longer an option there.
+function protectNegativeChatIds(argv) {
+  const safe = []
+
+  for (let i = 0; i < argv.length; i += 1) {
+    if (argv[i] === '--') {
+      safe.push(...argv.slice(i))
+      return safe
+    }
+
+    if (argv[i] === '--to' && /^-\d+$/.test(argv[i + 1] ?? '')) {
+      safe.push(`--to=${argv[i + 1]}`)
+      i += 1
+      continue
+    }
+
+    if (/^-\d+$/.test(argv[i])) {
+      safe.push('--', ...argv.slice(i))
+      return safe
+    }
+
+    safe.push(argv[i])
+  }
+
+  return safe
+}
+
+export function route(argv) {
+  const { values, positionals } = parseArgs({
+    args: protectNegativeChatIds(argv),
+    options: OPTIONS,
+    allowPositionals: true,
+  })
+
+  const [first, ...rest] = positionals
+
+  // `telark --to @chan` with no file used to mean "remember this destination". Flags no
+  // longer write anything, so that line now asks for a run that has nothing to upload —
+  // say where the destination actually lives instead of printing help at someone who was
+  // perfectly clear about what they wanted.
+  if (first === undefined && values.to && !values.help) {
+    throw new Error(
+      `Nothing to upload. To change the destination for good, run "npx telark config chat ${values.to}". ` +
+        'To use it for one run, pass --to alongside a file or a command.',
+    )
+  }
+
+  if (values.help || first === undefined || first === 'help') {
+    return { command: 'help', args: [], options: values }
+  }
+
+  if (SUBCOMMANDS.has(first)) {
+    return { command: first, args: rest, options: values }
+  }
+
+  return { command: 'upload', args: [first], options: values }
+}

package/src/client.js

@@ -0,0 +1,146 @@
+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 { manifestFileName } from './manifest.js'
+import { withRetry } from './retry.js'
+import { DEFAULT_STALL_MS, withStallTimeout } from './stall.js'
+
+// GramJS 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.
+export function createLogger(verbose) {
+  return new Logger(verbose ? LogLevel.INFO : LogLevel.NONE)
+}
+
+// The name Telegram shows under a document lives in an attribute, not on the message.
+export function documentFileName(message) {
+  const attributes = message?.media?.document?.attributes ?? []
+  const named = attributes.find((a) => a instanceof Api.DocumentAttributeFilename)
+  return named?.fileName ?? null
+}
+
+// The one place telark searches a chat. Both callers want documents and nothing else,
+// and getMessages is preferred over a raw Api.messages.Search because it handles offsets,
+// hashes and pagination itself, so we don't hand-build easily mistyped fields. The raw
+// message is kept alongside the flat fields because downloading needs it whole.
+export async function searchDocuments(client, peer, { search, limit }) {
+  const messages = await client.getMessages(peer, {
+    search,
+    filter: new Api.InputMessagesFilterDocument(),
+    limit,
+  })
+
+  return messages.map((message) => ({
+    id: message.id,
+    fileName: documentFileName(message),
+    caption: message.message ?? '',
+    date: message.date,
+    message,
+  }))
+}
+
+// How telark finds a backup's manifest, in one place because restore and delete must not
+// disagree about it. The search is by backup id, but the answer is decided by the file name
+// telark itself wrote — a caption is text a person can edit, a file name is not.
+export async function findManifestMessage(client, peer, backupId) {
+  const wanted = manifestFileName(backupId)
+  const found = await searchDocuments(client, peer, { search: backupId, limit: 100 })
+
+  return found.find((doc) => doc.fileName === wanted)?.message ?? null
+}
+
+export async function readMessageBytes(client, message) {
+  return await client.downloadMedia(message)
+}
+
+// The one place telark 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
+// the peer and picks between channels.DeleteMessages and messages.DeleteMessages, which is
+// exactly the choice a fake client would never catch us getting wrong.
+//
+// What it does on top of that is the problem: it splits the ids into batches of a hundred
+// and fires every batch at once through Promise.all. A ten-thousand-chunk backup would put
+// a hundred requests in flight together, none of them under the retry policy or the stall
+// deadline that every other network wait in telark carries. Batching here instead keeps
+// one request outstanding at a time, under both.
+//
+// Telegram does not complain about an id that is no longer there, so sending a batch twice
+// costs nothing: a delete interrupted halfway is finished by running it again.
+export const DELETE_BATCH_SIZE = 100
+
+export async function deleteMessages(client, peer, ids, options = {}) {
+  const {
+    batchSize = DELETE_BATCH_SIZE,
+    retryOptions = {},
+    stallMs = DEFAULT_STALL_MS,
+    onBatch,
+  } = options
+
+  let deleted = 0
+
+  for (let start = 0; start < ids.length; start += batchSize) {
+    const batch = ids.slice(start, start + batchSize)
+
+    await withRetry(
+      () =>
+        // The options object is not optional: GramJS 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
+        // a dependency's default.
+        withStallTimeout(
+          client.deleteMessages(peer, batch, { revoke: true }),
+          stallMs,
+          () =>
+            `Telegram stopped answering while removing messages ${start + 1}-` +
+            `${start + batch.length} of ${ids.length}: nothing back for ` +
+            `${Math.round(stallMs / 1000)}s.`,
+        ),
+      retryOptions,
+    )
+
+    deleted += batch.length
+    onBatch?.(deleted, ids.length)
+  }
+
+  return deleted
+}
+
+// Every command ends by putting the connection down, and a failure there must never
+// swallow the real error already on its way up. Commands that print progress hand in an
+// onWarn to say so; the quieter ones let it pass, because a connection that will not
+// close cleanly says nothing about the work that already succeeded.
+export async function closeQuietly(client, disconnect, onWarn) {
+  try {
+    await disconnect(client)
+  } catch (err) {
+    if (onWarn) onWarn(err)
+  }
+}
+
+export function assertLoggedIn(config) {
+  if (!config.session || !config.apiId || !config.apiHash) {
+    throw new Error('Not logged in — run "npx telark login" first.')
+  }
+}
+
+export async function connect(config, { verbose = false } = {}) {
+  assertLoggedIn(config)
+
+  const client = new TelegramClient(new StringSession(config.session), config.apiId, config.apiHash, {
+    connectionRetries: 5,
+    floodSleepThreshold: 60,
+    baseLogger: createLogger(verbose),
+  })
+
+  await client.connect()
+
+  if (!(await client.isUserAuthorized())) {
+    throw new Error('Session expired — run "npx telark login".')
+  }
+
+  return client
+}

package/src/commands/config.js

@@ -0,0 +1,130 @@
+import {
+  SETTINGS,
+  SETTING_KEYS,
+  canonicalKey,
+  isManagedByLogin,
+  resolveSettings,
+} from '../settings.js'
+import { configFile, defaultConfigDir, loadConfig, saveConfig } from '../config.js'
+
+const GAP = '  '
+
+function unknownKey(name) {
+  if (isManagedByLogin(name)) {
+    return new Error(
+      `"${name}" is managed by "npx telark login", not by config. ` +
+        `Settings you can change: ${SETTING_KEYS.join(', ')}.`,
+    )
+  }
+
+  return new Error(`Unknown setting: "${name}". Settings are: ${SETTING_KEYS.join(', ')}.`)
+}
+
+// Every setting, resolved, with where the value came from. A stored value and a built-in
+// default look identical once resolved, and the difference is the whole question someone
+// runs this command to answer.
+function listLines(values, source, stored) {
+  const rows = SETTING_KEYS.map((key) => {
+    const spec = SETTINGS[key]
+    const value = values[key]
+
+    // chat is the one setting with no default, so "(default)" beside it would name a
+    // fallback that does not exist. It is either set or it is not.
+    if (value === null) return [key, 'not set', '']
+
+    const note = spec.describe ? ` (${spec.describe(value)})` : ''
+
+    return [key, `${spec.format(value)}${note}`, source(key) === 'settings' ? '' : '(default)']
+  })
+
+  // Keys telark does not know are left in the file untouched, but a value that silently
+  // does nothing is worse than one that is refused: show them, so a typo is visible from
+  // the command rather than only from opening the file that also holds the session.
+  const strays = Object.keys(stored).filter((key) => !SETTING_KEYS.includes(key))
+
+  const widths = [0, 1].map((i) => Math.max(...rows.map((row) => row[i].length)))
+  const lines = rows.map((row) =>
+    `${row[0].padEnd(widths[0])}${GAP}${row[1].padEnd(widths[1])}${GAP}${row[2]}`.trimEnd(),
+  )
+
+  if (strays.length > 0) {
+    lines.push('')
+    lines.push(
+      `Ignored, telark does not know these: ${strays.join(', ')}. ` +
+        'Remove one with: npx telark config <name> --unset',
+    )
+  }
+
+  return lines
+}
+
+export async function runConfig(args = [], options = {}, deps = {}) {
+  const { configDir = defaultConfigDir(), log = (line) => console.log(line) } = deps
+  const [name, value, ...extra] = args
+
+  if (extra.length > 0) {
+    throw new Error(
+      `Too many arguments: a setting takes one value, but got ${args.length}. ` +
+        `Did you mean: npx telark config ${name} "${[value, ...extra].join(' ')}"`,
+    )
+  }
+
+  // Both of these would otherwise be obeyed halfway and reported as a success: a listing
+  // that quietly dropped the --unset, or an unset that quietly dropped the value beside it.
+  if (options.unset && name === undefined) {
+    throw new Error('--unset needs the setting to drop. Try: npx telark config chat --unset')
+  }
+
+  if (options.unset && value !== undefined) {
+    throw new Error(
+      `--unset takes no value, but "${value}" was given. ` +
+        `Use "npx telark config ${name} --unset" to drop it, ` +
+        `or "npx telark config ${name} ${value}" to set it.`,
+    )
+  }
+
+  const file = configFile(configDir)
+  const config = await loadConfig(configDir)
+  const stored = config.settings ?? {}
+
+  if (name === undefined) {
+    const { values, source } = resolveSettings({}, config, { file })
+    for (const line of listLines(values, source, stored)) log(line)
+    return
+  }
+
+  const key = canonicalKey(name)
+
+  // --unset has to reach a key the registry does not know: the listing above points at
+  // strays, and this is the only way to remove one without opening the file by hand.
+  if (options.unset) {
+    if (!key && stored[name] === undefined) throw unknownKey(name)
+
+    const target = key ?? name
+    const next = { ...stored }
+    delete next[target]
+
+    await saveConfig({ ...config, settings: next }, configDir)
+    log(`${target} unset.`)
+    return
+  }
+
+  if (!key) throw unknownKey(name)
+
+  if (value === undefined) {
+    // The bare value and nothing else, so this can be read by a script. An unset key
+    // reports the default that will actually be used; chat has no default, so it says
+    // nothing rather than inventing one.
+    const { values } = resolveSettings({}, config, { file })
+    if (values[key] !== null) log(SETTINGS[key].format(values[key]))
+    return
+  }
+
+  // Parse before writing: an unusable value must never reach the file, or the next command
+  // fails over something the user was told had been saved.
+  const parsed = SETTINGS[key].parse(value, key)
+
+  await saveConfig({ ...config, settings: { ...stored, [key]: parsed } }, configDir)
+
+  log(`${key} = ${SETTINGS[key].format(parsed)}`)
+}

package/src/commands/delete.js

@@ -0,0 +1,250 @@
+import { chatName, describeChat } from '../chat.js'
+import {
+  DELETE_BATCH_SIZE,
+  assertLoggedIn,
+  closeQuietly,
+  connect as realConnect,
+  deleteMessages as realDeleteMessages,
+  findManifestMessage,
+  readMessageBytes as realReadMessageBytes,
+} from '../client.js'
+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 { requireChat, resolveSettings } from '../settings.js'
+import { clearState, findStates } from '../state.js'
+
+// What list prints when a card cannot be read back. A manifest is text off a chat, and a
+// summary is not worth inventing: the numbers below only decorate a decision the backup id
+// has already settled.
+const UNKNOWN = '—'
+
+function describeName(name) {
+  return typeof name === 'string' && name.trim() !== '' ? name : UNKNOWN
+}
+
+function describeSize(size) {
+  return Number.isSafeInteger(size) && size >= 0 ? formatBytes(size) : UNKNOWN
+}
+
+function plural(n, word) {
+  return `${n} ${word}${n === 1 ? '' : 's'}`
+}
+
+// The same rule the manifest gets, for the same reason: a message id is the name of
+// something about to be destroyed for good, so a record that cannot say it exactly is
+// refused whole rather than half-obeyed. Sorted by chunk index so the batches — and the
+// error naming a chunk — are the same on every run.
+function stateMessageIds(record) {
+  const done = record.state.done
+
+  if (typeof done !== 'object' || done === null) {
+    throw new Error(
+      `The record of unfinished backup ${record.state.id} does not list the chunks it sent. ` +
+        `${record.file} is damaged — delete that file by hand to drop the record, which ` +
+        'leaves any chunks it did send sitting in the chat with nothing to point at them.',
+    )
+  }
+
+  return Object.entries(done)
+    .sort((a, b) => Number(a[0]) - Number(b[0]))
+    .map(([index, entry]) => {
+      const msgId = entry?.msgId
+
+      if (!Number.isSafeInteger(msgId) || msgId < 1) {
+        throw new Error(
+          `The record of unfinished backup ${record.state.id} gives ` +
+            `${JSON.stringify(msgId)} as the message id of chunk ${Number(index) + 1}, which ` +
+            `is not a message id. ${record.file} is damaged, so telark is not deleting ` +
+            'anything.',
+        )
+      }
+
+      return msgId
+    })
+}
+
+export async function runDelete(backupId, options = {}, deps = {}) {
+  const {
+    connect = realConnect,
+    disconnect = (client) => client.destroy(),
+    configDir = defaultConfigDir(),
+    searchManifest = findManifestMessage,
+    readMessageBytes = realReadMessageBytes,
+    deleteMessages = realDeleteMessages,
+    confirm = askConfirm,
+    retryOptions = {},
+    writeErr = (line) => process.stderr.write(line),
+    log: writeLog = (line) => console.log(line),
+    silent = false,
+  } = deps
+
+  const config = await loadConfig(configDir)
+  const { values: settings } = resolveSettings(options, config, { file: configFile(configDir) })
+  // Before requireChat, as in list: telling somebody who has never logged in to go and pick
+  // a destination sends them after the wrong thing.
+  assertLoggedIn(config)
+  const chat = requireChat(settings)
+
+  const log = silent ? () => {} : writeLog
+  const warn = silent ? () => {} : writeErr
+
+  // Upload and restore stay quiet until the third retry so a handful of -503s do not bury
+  // the progress bar. There is no bar here to bury, and a wait in the middle of destroying
+  // somebody's backup is always worth saying out loud — so this one announces from the first.
+  function onRetry(err, attempt, delayMs) {
+    warn(
+      `\nTemporary error (${err.message}), retry ${attempt} in ` +
+        `${formatDuration(delayMs / 1000)}.\n`,
+    )
+  }
+
+  // A local lookup that refuses should not cost a connection first.
+  const records = await findStates(backupId, configDir)
+
+  if (records.length > 1) {
+    throw new Error(
+      `Two local records both claim to be backup ${backupId}: ` +
+        `${records.map((r) => r.file).join(' and ')}. telark will not guess which one to ` +
+        'drop — remove the wrong one by hand and run again.',
+    )
+  }
+
+  const record = records[0] ?? null
+  const client = await connect(config, { verbose: settings.verbose })
+
+  try {
+    const manifestMessage = await searchManifest(client, chat, backupId)
+
+    if (!manifestMessage && !record) {
+      throw new Error(
+        `No backup ${backupId} found in ${chatName(chat)}, and no unfinished record of it on ` +
+          'this machine. Check the id with "npx telark list", or use --to to point at the ' +
+          'right chat.',
+      )
+    }
+
+    let manifest = null
+    const ids = new Set()
+
+    if (manifestMessage) {
+      manifest = parseManifestJson(await readMessageBytes(client, manifestMessage))
+
+      // The manifest was found by the file name telark itself wrote, and that name is the
+      // id this command was asked about. A body naming a different backup is a file that was
+      // renamed or replaced, and its message ids point at somebody else's chunks — the one
+      // mistake in this whole command that nothing can undo.
+      if (manifest?.id !== undefined && manifest.id !== backupId) {
+        throw new Error(
+          `The manifest named ${manifestFileName(backupId)} describes backup ` +
+            `${JSON.stringify(manifest.id)}, not ${backupId}. Its message ids point at ` +
+            'another backup\'s chunks, so telark is not deleting anything.',
+        )
+      }
+
+      for (const id of manifestMessageIds(manifest)) ids.add(id)
+    }
+
+    // Both sources describe the same backup, so an id in either is a message this backup put
+    // in the chat. In practice the record holds nothing the manifest does not — but it is a
+    // file on disk that a truncated write or a hand edit can mangle, and an id left out here
+    // is a chunk that nothing can point at ever again.
+    if (record) {
+      for (const id of stateMessageIds(record)) ids.add(id)
+    }
+
+    const chunkIds = [...ids]
+
+    if (manifest) {
+      log(`Backup ${backupId}`)
+      log(
+        `File   ${describeName(manifest.name)} ` +
+          `(${describeSize(manifest.size)}, ${plural(manifest.chunks.length, 'chunk')})`,
+      )
+    } else {
+      log(`Backup ${backupId} (unfinished — no manifest in the chat)`)
+      log(`File   ${describeName(record.state.path)}`)
+    }
+
+    log(`From   ${describeChat(chat)}`)
+    log('')
+
+    const prompt = manifest
+      ? `Delete this backup from ${chatName(chat)}? The chunks cannot be recovered. [y/N] `
+      : `Delete the ${plural(chunkIds.length, 'chunk message')} it sent, and its local ` +
+        `record? The chunks cannot be recovered. [y/N] `
+
+    if (!options.yes && !(await confirm(prompt))) {
+      throw new Error('Cancelled on request.')
+    }
+
+    const loud = chunkIds.length > DELETE_BATCH_SIZE
+    let removed = 0
+
+    try {
+      await deleteMessages(client, chat, chunkIds, {
+        retryOptions: { ...retryOptions, onRetry },
+        onBatch: (done, total) => {
+          removed = done
+          if (loud) warn(`\rRemoving chunk messages ${done}/${total}…`)
+        },
+      })
+    } catch (err) {
+      throw new Error(
+        `Removed ${removed} of ${plural(chunkIds.length, 'chunk message')} of ${backupId}, ` +
+          `then Telegram refused: ${err.message}. ` +
+          (manifestMessage
+            ? 'The manifest was left in place on purpose — it is the only list of the ' +
+              'messages that are still there. '
+            : 'The local record was left in place on purpose — it is the only list of the ' +
+              'messages that are still there. ') +
+          'Run the same command again to finish.',
+      )
+    }
+
+    if (loud) warn('\n')
+
+    // Only now. The manifest is the only index of the ids above, and where there is no
+    // manifest the local record is. Anything that throws before this line leaves the way
+    // back intact, and running delete again picks up where this run stopped.
+    if (manifestMessage) {
+      try {
+        await deleteMessages(client, chat, [manifestMessage.id], {
+          retryOptions: { ...retryOptions, onRetry },
+        })
+      } catch (err) {
+        throw new Error(
+          `Removed every chunk message of ${backupId}, but Telegram refused to remove its ` +
+            `manifest: ${err.message}. Run the same command again to finish.`,
+        )
+      }
+    }
+
+    if (record) await clearState(record.key, configDir)
+
+    if (manifestMessage) {
+      log(
+        `\nDone. Removed ${backupId} from ${chatName(chat)}: ` +
+          `${plural(chunkIds.length, 'chunk message')} and its manifest.`,
+      )
+      if (record) log('The local record of this backup was removed too.')
+    } else {
+      log(
+        `\nDone. Removed ${plural(chunkIds.length, 'chunk message')} from ${chatName(chat)} ` +
+          `and dropped the local record of ${backupId}.`,
+      )
+    }
+
+    return {
+      id: backupId,
+      chunks: chunkIds.length,
+      manifestDeleted: Boolean(manifestMessage),
+      stateCleared: Boolean(record),
+    }
+  } finally {
+    await closeQuietly(client, disconnect, (err) =>
+      warn(`\nWarning: could not close the Telegram connection: ${err.message}\n`),
+    )
+  }
+}