data-ark 0.1.0 → 0.1.1

package/README.md

@@ -1,50 +1,50 @@
 # data-ark
 
-Cắt file lớn thành từng chunk 1.8GB và lưu trữ trên Telegram, khôi phục lại được nguyên vẹn.
+Split large files into 1.8GB chunks, store them on Telegram, and restore them intact.
 
-## Dùng ngay
+## Quick start
 
 ```bash
-npx data-ark login                        # chỉ cần một lần
-npx data-ark data.tar --to @kho_backup    # đích được ghi nhớ cho lần sau
-npx data-ark data.tar                     # từ lần thứ hai trở đi
+npx data-ark login                        # once only
+npx data-ark data.tar --to @my_backups    # the destination is remembered
+npx data-ark data.tar                     # from the second run on
 npx data-ark restore ark-20260905-7f3a91
 ```
 
-## Cần chuẩn bị
+## What you need
 
-- Node.js 18 trở lên.
-- `api_id` và `api_hash` lấy tại <https://my.telegram.org> → API development tools. Lệnh `login` sẽ hỏi hai giá trị này, kèm số điện thoại và mã xác nhận.
+- Node.js 18 or newer.
+- An `api_id` and `api_hash` from <https://my.telegram.org> → API development tools. The `login` command asks for both, plus your phone number and the verification code.
 
-data-ark đăng nhập bằng chính tài khoản Telegram của bạn (MTProto), không phải bot. Đây là điều kiện bắt buộc: Bot API chỉ cho upload 50MB mỗi file, còn tài khoản người dùng được 2GB.
+data-ark signs in with your own Telegram account (MTProto), not a bot. That is a hard requirement: the Bot API caps uploads at 50MB per file, while a user account gets 2GB.
 
-## Tuỳ chọn
+## Options
 
-| Cờ | Mặc định | Ý nghĩa |
+| Flag | Default | Meaning |
 |---|---|---|
-| `--to <chat>` | đích đã ghi nhớ | `@username`, `-100123…`, hoặc `me` |
-| `--chunk-size <n>` | `1800MB` | Ví dụ `1.8GB`, `500MB`. Trần cứng 1950MB. |
-| `--concurrency <n>` | `8` | Số phần 512KB gửi song song. Phải là số nguyên từ 1 đến 64. |
-| `--out <đường-dẫn>` | basename của tên trong manifest | Nơi ghi file khi restore, tính từ thư mục hiện tại nếu là đường dẫn tương đối |
+| `--to <chat>` | the remembered destination | `@username`, `-100123…`, or `me` |
+| `--chunk-size <n>` | `1800MB` | e.g. `1.8GB`, `500MB`. Hard ceiling 1950MB. |
+| `--concurrency <n>` | `8` | 512KB parts sent in parallel. An integer from 1 to 64. |
+| `--out <path>` | the basename from the manifest | Where to write the restored file; relative paths resolve against the current directory |
 
-## Hoạt động thế nào
+## How it works
 
-Mỗi lần chạy sinh ra một `backupId`. File được đọc thẳng theo offset, không tạo file tạm, và đẩy lên thành các document tên `<backupId>.partNNNN`. Xong hết, data-ark gửi thêm một manifest JSON liệt kê message id và sha256 của từng chunk. Restore chỉ cần `backupId`: nó tìm manifest trong chat, tải từng chunk về đúng vị trí trong một file `.partial`, đối chiếu sha256 và kích thước từng chunk, và chỉ đổi tên thành file thật sau khi *toàn bộ* chunk đã khớp.
+Every run mints a `backupId`. The file is read directly by offset — no temporary copies — and uploaded as documents named `<backupId>.partNNNN`. Once every chunk is up, data-ark sends a JSON manifest listing the message id and sha256 of each one. Restore needs only the `backupId`: it finds the manifest in the chat, downloads each chunk to its exact position in a `.partial` file, checks every chunk's sha256 and size, and renames it to the real file only after *all* chunks match.
 
-Đứt mạng giữa chừng lúc **upload** thì cứ chạy lại đúng lệnh cũ — tiến độ nằm ở `~/.data-ark/state/`, những chunk đã xong sẽ được bỏ qua (`backupId` giữ nguyên). Vài lưu ý về việc chạy lại:
+If the connection drops during an **upload**, just run the same command again — progress lives in `~/.data-ark/state/` and finished chunks are skipped, keeping the same `backupId`. Two things to know about rerunning:
 
-- Nếu chạy lại với `--to` khác với đích đã lưu trong tiến độ dở dang, data-ark **từ chối chạy** thay vì tự chuyển hướng — một backup không thể tách làm hai đích. Thông báo lỗi chỉ đường: bỏ `--to` để tiếp tục gửi vào đích cũ, hoặc xoá file trạng thái để bắt đầu backup mới.
-- Nếu chạy lại với `--chunk-size` khác, data-ark coi đó là một backup mới hoàn toàn (backup id mới), không resume.
+- Running again with a `--to` that differs from the destination stored in the unfinished progress makes data-ark **refuse to run** rather than silently redirect — one backup cannot be split across two destinations. The error points the way out: drop `--to` to keep sending to the original destination, or delete the state file to start a new backup.
+- Running again with a different `--chunk-size` is treated as an entirely new backup (new backup id), not a resume.
 
-**Restore không có trạng thái để resume.** Nhấn `Ctrl-C` giữa lúc restore thì không có gì được lưu — chạy lại sẽ tải lại từ đầu.
+**Restore keeps no state to resume from.** Pressing `Ctrl-C` mid-restore saves nothing — running again starts over.
 
-## Giới hạn cần biết
+## Limits worth knowing
 
-- Chunk không thể vượt 1950MB: Telegram nhận tối đa 4000 phần 512KB mỗi file, tức trần số học khoảng 1953MB, và data-ark chốt ở 1950MB để chừa biên an toàn.
-- Dữ liệu **không** được mã hoá. Đừng đẩy thứ gì bạn không muốn nằm trên hạ tầng của người khác.
-- Xoá message chunk trên Telegram là mất backup, không có cách cứu.
-- Giữ lấy `backupId`. Không có nó thì phải tự tìm manifest trong chat bằng tay.
+- A chunk cannot exceed 1950MB: Telegram accepts at most 4000 parts of 512KB per file, an arithmetic ceiling of about 1953MB, and data-ark stops at 1950MB to leave a safety margin.
+- The data is **not** encrypted. Don't upload anything you would mind sitting on someone else's infrastructure.
+- Deleting a chunk message on Telegram destroys the backup, with no way to recover it.
+- Keep the `backupId`. Without it you have to hunt for the manifest in the chat by hand.
 
-## Cấu hình lưu ở đâu
+## Where the config lives
 
-`~/.data-ark/config.json` (quyền 600) chứa `apiId`, `apiHash`, session và đích lưu mặc định. `npx data-ark logout` **chỉ xoá bản session lưu dưới máy** và giữ lại phần còn lại — phiên đăng nhập vẫn còn sống phía Telegram. Muốn cắt hẳn quyền truy cập thì vào Telegram → Settings → Devices (Active sessions) và thu hồi phiên đó.
+`~/.data-ark/config.json` (mode 600) holds `apiId`, `apiHash`, the session and the default destination. `npx data-ark logout` **only deletes the locally stored session** and keeps the rest — the session is still alive on Telegram's side. To revoke access for good, open Telegram → Settings → Devices (Active sessions) and terminate that session.

package/bin/data-ark.js

@@ -7,20 +7,20 @@ import { runUpload } from '../src/commands/upload.js'
 
 const SIGINT_EXIT_CODE = 130
 
-// Lệnh đang chạy khi Ctrl-C xảy ra — mỗi lệnh có một sự thật khác nhau về việc
-// tiến độ có được lưu hay không, nên phải biết đang ở lệnh nào mới chọn đúng câu.
+// Which command is running when Ctrl-C arrives — each one tells a different truth
+// about whether progress was saved, so we need to know which to pick the right line.
 let currentCommand = null
 
 function sigintMessage(command) {
   if (command === 'upload') {
-    return '\nĐã dừng. Tiến độ đã lưu, chạy lại lệnh cũ để đi tiếp.\n'
+    return '\nStopped. Progress is saved, run the same command again to continue.\n'
   }
 
   if (command === 'restore') {
-    return '\nĐã dừng. Chưa lưu tiến độ tải, chạy lại sẽ tải lại từ đầu.\n'
+    return '\nStopped. Download progress is not saved, running again starts over.\n'
   }
 
-  return '\nĐã dừng.\n'
+  return '\nStopped.\n'
 }
 
 process.on('SIGINT', () => {
@@ -34,7 +34,7 @@ async function main() {
   try {
     parsed = route(process.argv.slice(2))
   } catch (err) {
-    process.stderr.write(`Lỗi: ${err.message}\n\n${HELP}`)
+    process.stderr.write(`Error: ${err.message}\n\n${HELP}`)
     process.exitCode = 2
     return
   }
@@ -60,24 +60,24 @@ async function main() {
 
     case 'restore':
       if (!parsed.args[0]) {
-        throw new Error('Thiếu backup id. Ví dụ: npx data-ark restore ark-20260905-7f3a91')
+        throw new Error('Missing backup id. Example: npx data-ark restore ark-20260905-7f3a91')
       }
       await runRestore(parsed.args[0], parsed.options)
       return
 
     default:
-      throw new Error(`Lệnh không nhận ra: ${parsed.command}`)
+      throw new Error(`Unknown command: ${parsed.command}`)
   }
 }
 
-// GramJS giữ lại các "exported sender" cùng một timer 30 giây để giải phóng
-// chúng, và client.disconnect()/destroy() không dọn nổi: cả hai map đó là Map
-// nhưng code duyệt bằng Object.values nên bỏ sót sạch. Hệ quả: lệnh in "Xong"
-// rồi vẫn treo thêm ~30 giây, và Ctrl-C trong khoảng đó lại báo sai rằng chưa
-// lưu được gì. Chạy xong việc là thoát hẳn, không nấn ná.
+// 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.
 function exitWhenFlushed(code) {
-  // Ghi rỗng chỉ để mượn callback: nó chạy sau khi mọi thứ xếp hàng trước đó đã
-  // xả xuống pipe, nên không mất chữ nào khi stdout/stderr không phải TTY.
+  // 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.
   let pending = 2
 
   const done = () => {
@@ -85,7 +85,7 @@ function exitWhenFlushed(code) {
     if (pending === 0) process.exit(code)
   }
 
-  // Lưới an toàn: nếu callback không bao giờ tới (pipe đã đóng) thì vẫn thoát.
+  // Safety net: exit anyway if a callback never arrives (the pipe is already closed).
   setTimeout(() => process.exit(code), 2000).unref()
 
   process.stdout.write('', done)
@@ -97,7 +97,7 @@ main().then(
     exitWhenFlushed(process.exitCode ?? 0)
   },
   (err) => {
-    process.stderr.write(`Lỗi: ${err.message}\n`)
+    process.stderr.write(`Error: ${err.message}\n`)
     process.exitCode = 1
     exitWhenFlushed(1)
   },

package/package.json

@@ -1,9 +1,27 @@
 {
   "name": "data-ark",
-  "version": "0.1.0",
-  "description": "Cắt file lớn thành chunk và lưu trữ trên Telegram",
+  "version": "0.1.1",
+  "description": "Split large files into chunks and store them on Telegram",
+  "keywords": [
+    "telegram",
+    "backup",
+    "chunk",
+    "split",
+    "restore",
+    "cli",
+    "mtproto"
+  ],
+  "homepage": "https://github.com/shovity/data-ark#readme",
+  "bugs": {
+    "url": "https://github.com/shovity/data-ark/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shovity/data-ark.git"
+  },
   "type": "module",
   "license": "MIT",
+  "author": "shovity",
   "bin": {
     "data-ark": "bin/data-ark.js"
   },

package/src/chunking.js

@@ -17,19 +17,19 @@ export function parseSize(input) {
   const match = text.match(/^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb)?$/)
 
   if (!match) {
-    throw new Error(`Kích thước không hợp lệ: "${input}". Ví dụ hợp lệ: 1800MB, 1.8GB, 524288.`)
+    throw new Error(`Invalid size: "${input}". Valid examples: 1800MB, 1.8GB, 524288.`)
   }
 
   const bytes = Math.floor(Number(match[1]) * UNITS[match[2] ?? 'b'])
 
   if (bytes <= 0) {
-    throw new Error('Kích thước phải lớn hơn 0.')
+    throw new Error('Size must be greater than 0.')
   }
 
   if (bytes > MAX_CHUNK_SIZE) {
     throw new Error(
-      'Chunk tối đa là 1950MB. Telegram chỉ nhận 4000 phần 512KB cho mỗi file, ' +
-        'tức trần số học khoảng 1953MB, nên cần chừa biên an toàn.',
+      'Maximum chunk size is 1950MB. Telegram accepts only 4000 parts of 512KB per file, ' +
+        'an arithmetic ceiling of about 1953MB, so a safety margin is needed.',
     )
   }
 
@@ -38,7 +38,7 @@ export function parseSize(input) {
 
 export function planChunks(fileSize, chunkSize) {
   if (fileSize <= 0) {
-    throw new Error('File rỗng, không có gì để upload.')
+    throw new Error('File is empty, nothing to upload.')
   }
 
   const chunks = []

package/src/cli.js

@@ -10,20 +10,20 @@ const OPTIONS = {
   help: { type: 'boolean', short: 'h' },
 }
 
-export const HELP = `data-ark — cắt file lớn thành chunk và lưu trữ trên Telegram
-
-Cách dùng:
-  npx data-ark login                        Đăng nhập Telegram, chỉ cần chạy một lần
-  npx data-ark <file>                       Cắt file và đẩy lên Telegram
-  npx data-ark restore <backup-id>          Tải về và ghép lại file gốc
-  npx data-ark logout                       Xoá phiên đăng nhập đã lưu
-
-Tuỳ chọn:
-  --to <chat>            Đích lưu: @username, -100123..., hoặc me. Được ghi nhớ cho lần sau.
-  --chunk-size <n>       Kích thước mỗi chunk, mặc định 1800MB. Ví dụ: 1.8GB, 500MB.
-  --concurrency <n>      Số phần 512KB gửi song song, mặc định 8, tối đa 64.
-  --out <đường-dẫn>      Nơi ghi file khi restore. Mặc định lấy basename của tên trong manifest.
-  -h, --help             Hiện trợ giúp này.
+export const HELP = `data-ark — split large files into chunks and store them on Telegram
+
+Usage:
+  npx data-ark login                        Log in to Telegram, only needed once
+  npx data-ark <file>                       Split a file and upload it to Telegram
+  npx data-ark restore <backup-id>          Download the chunks and reassemble the file
+  npx data-ark logout                       Remove the saved session
+
+Options:
+  --to <chat>            Destination: @username, -100123..., or me. Remembered for next time.
+  --chunk-size <n>       Size of each chunk, default 1800MB. Examples: 1.8GB, 500MB.
+  --concurrency <n>      512KB parts sent in parallel, default 8, max 64.
+  --out <path>           Where to write the restored file. Defaults to the basename in the manifest.
+  -h, --help             Show this help.
 `
 
 export function route(argv) {

package/src/client.js

@@ -5,7 +5,7 @@ export function normalizeChatTarget(input) {
   const text = String(input).trim()
 
   if (text === '') {
-    throw new Error('Đích lưu không được để rỗng.')
+    throw new Error('Destination must not be empty.')
   }
 
   if (/^-?\d+$/.test(text)) {
@@ -20,8 +20,8 @@ export function requireChat(options, config) {
 
   if (!raw) {
     throw new Error(
-      'Chưa có đích lưu — chạy lại với --to @kho_backup (hoặc --to me để dùng Saved Messages). ' +
-        'Lần sau data-ark sẽ tự nhớ.',
+      'No destination set — run again with --to @my_backups (or --to me for Saved Messages). ' +
+        'data-ark will remember it next time.',
     )
   }
 
@@ -30,7 +30,7 @@ export function requireChat(options, config) {
 
 export function assertLoggedIn(config) {
   if (!config.session || !config.apiId || !config.apiHash) {
-    throw new Error('Chưa đăng nhập — chạy "npx data-ark login" trước.')
+    throw new Error('Not logged in — run "npx data-ark login" first.')
   }
 }
 
@@ -45,7 +45,7 @@ export async function connect(config) {
   await client.connect()
 
   if (!(await client.isUserAuthorized())) {
-    throw new Error('Phiên đăng nhập đã hết hạn — chạy "npx data-ark login".')
+    throw new Error('Session expired — run "npx data-ark login".')
   }
 
   return client

package/src/commands/login.js

@@ -16,11 +16,11 @@ function createPrompts() {
 }
 
 const LOGIN_ERROR_MESSAGES = {
-  PHONE_NUMBER_INVALID: 'số điện thoại không hợp lệ',
-  PHONE_CODE_INVALID: 'mã xác nhận sai',
-  PHONE_CODE_EXPIRED: 'mã xác nhận đã hết hạn',
-  PASSWORD_HASH_INVALID: 'mật khẩu hai lớp sai',
-  FLOOD_WAIT: 'bị Telegram giới hạn tần suất, cần chờ',
+  PHONE_NUMBER_INVALID: 'invalid phone number',
+  PHONE_CODE_INVALID: 'wrong verification code',
+  PHONE_CODE_EXPIRED: 'verification code expired',
+  PASSWORD_HASH_INVALID: 'wrong two-step password',
+  FLOOD_WAIT: 'rate limited by Telegram, need to wait',
 }
 
 export function describeLoginError(err) {
@@ -36,30 +36,30 @@ export function describeLoginError(err) {
 export async function runLogin({ configDir = defaultConfigDir(), prompts = createPrompts() } = {}) {
   const config = await loadConfig(configDir)
 
-  console.log('Cần api_id và api_hash của riêng bạn. Lấy tại https://my.telegram.org → API development tools.\n')
+  console.log('You need your own api_id and api_hash. Get them at https://my.telegram.org → API development tools.\n')
 
   const apiIdAnswer = (await prompts.ask(`api_id${config.apiId ? ` [${config.apiId}]` : ''}: `)).trim()
 
   if (apiIdAnswer !== '' && !/^\d+$/.test(apiIdAnswer)) {
     prompts.close()
-    throw new Error('api_id phải là số nguyên.')
+    throw new Error('api_id must be an integer.')
   }
 
   const apiId = apiIdAnswer === '' ? config.apiId : Number(apiIdAnswer)
-  const apiHash = (await prompts.ask(`api_hash${config.apiHash ? ' [giữ nguyên]' : ''}: `)) || config.apiHash
+  const apiHash = (await prompts.ask(`api_hash${config.apiHash ? ' [keep current]' : ''}: `)) || config.apiHash
 
   if (!apiId || !apiHash) {
     prompts.close()
-    throw new Error('Thiếu api_id hoặc api_hash.')
+    throw new Error('Missing api_id or api_hash.')
   }
 
   const client = new TelegramClient(new StringSession(''), apiId, apiHash, { connectionRetries: 5 })
 
   await client.start({
-    phoneNumber: () => prompts.ask('Số điện thoại (dạng +84...): '),
-    phoneCode: () => prompts.ask('Mã xác nhận Telegram vừa gửi: '),
-    password: () => prompts.ask('Mật khẩu hai lớp (bỏ trống nếu không bật): '),
-    onError: (err) => console.error(`Lỗi đăng nhập: ${describeLoginError(err)}`),
+    phoneNumber: () => prompts.ask('Phone number (e.g. +1...): '),
+    phoneCode: () => prompts.ask('Verification code Telegram just sent: '),
+    password: () => prompts.ask('Two-step password (leave blank if not enabled): '),
+    onError: (err) => console.error(`Login failed: ${describeLoginError(err)}`),
   })
 
   const me = await client.getMe()
@@ -68,7 +68,7 @@ export async function runLogin({ configDir = defaultConfigDir(), prompts = creat
 
   const chatAnswer = (
     await prompts.ask(
-      `Đẩy backup vào chat nào? (@username, -100..., hoặc me)${config.defaultChat ? ` [${config.defaultChat}]` : ''}, Enter để bỏ qua: `,
+      `Which chat should backups go to? (@username, -100..., or me)${config.defaultChat ? ` [${config.defaultChat}]` : ''}, Enter to skip: `,
     )
   ).trim()
 
@@ -82,6 +82,6 @@ export async function runLogin({ configDir = defaultConfigDir(), prompts = creat
 
   await saveConfig(next, configDir)
 
-  console.log(`\nĐã đăng nhập với tài khoản ${me.username ? `@${me.username}` : me.firstName}.`)
-  console.log(`Cấu hình đã lưu vào ${configDir}/config.json`)
+  console.log(`\nLogged in as ${me.username ? `@${me.username}` : me.firstName}.`)
+  console.log(`Config saved to ${configDir}/config.json`)
 }

package/src/commands/logout.js

@@ -3,11 +3,11 @@ import { clearSession, defaultConfigDir } from '../config.js'
 export async function runLogout({ configDir = defaultConfigDir() } = {}) {
   await clearSession(configDir)
   console.log(
-    'Đã xoá phiên đăng nhập lưu trên máy này. api_id, api_hash và đích lưu vẫn được giữ lại.',
+    'Removed the session stored on this machine. api_id, api_hash and the destination are kept.',
   )
   console.log(
-    'Lưu ý: lệnh này chỉ xoá bản lưu dưới máy, phiên vẫn còn sống phía Telegram. ' +
-      'Muốn cắt hẳn quyền truy cập, mở Telegram → Settings → Devices (Active sessions) ' +
-      'và thu hồi phiên đó.',
+    'Note: this only deletes the local copy — the session is still alive on Telegram\'s side. ' +
+      'To revoke access for good, open Telegram → Settings → Devices (Active sessions) ' +
+      'and terminate that session.',
   )
 }

package/src/commands/restore.js

@@ -20,8 +20,8 @@ function documentFileName(message) {
 async function realSearchManifest(client, peer, backupId) {
   const wanted = manifestFileName(backupId)
 
-  // Dùng client.getMessages thay vì raw Api.messages.Search: nó tự lo offset,
-  // hash và phân trang, nên không phải tự dựng các trường dễ sai kiểu.
+  // Use client.getMessages instead of a raw Api.messages.Search: it handles offsets,
+  // hashes and pagination itself, so we don't hand-build easily mistyped fields.
   const messages = await client.getMessages(peer, {
     search: backupId,
     filter: new Api.InputMessagesFilterDocument(),
@@ -44,17 +44,17 @@ export async function realDownloadChunk(client, message, handle, offset, onProgr
   return await downloadToFile(client, message, handle.fd, { offset, onProgress })
 }
 
-// manifest.name đến từ dữ liệu tải về Telegram — không tin nó khi tự chọn đường
-// dẫn. path.basename chặn được "../../x" nhưng vẫn trả về "..", "." hay "" cho
-// vài tên bệnh: path.resolve('..') là thư mục cha, nên file .partial hàng GB sẽ
-// nằm ngoài thư mục hiện tại và chỉ vỡ ra ở bước rename.
+// manifest.name comes from data downloaded off Telegram — don't trust it when picking
+// a path ourselves. path.basename stops "../../x" but still returns "..", "." or "" for
+// a few pathological names: path.resolve('..') is the parent directory, so a multi-GB
+// .partial file would land outside the current directory and only blow up at rename.
 function safeOutName(name) {
   const base = path.basename(String(name ?? ''))
 
   if (base === '' || base === '.' || base === '..') {
     throw new Error(
-      `Tên file trong manifest ("${name}") không dùng được làm tên file. ` +
-        'Chạy lại kèm --out <đường-dẫn> để tự chỉ định nơi ghi.',
+      `The name in the manifest ("${name}") cannot be used as a file name. ` +
+        'Run again with --out <path> to choose where to write.',
     )
   }
 
@@ -65,7 +65,7 @@ async function askConfirm(question) {
   const rl = readline.createInterface({ input: stdin, output: stdout })
   const answer = await rl.question(question)
   rl.close()
-  return /^(c|y)/i.test(answer.trim())
+  return /^y/i.test(answer.trim())
 }
 
 export async function runRestore(backupId, options = {}, deps = {}) {
@@ -94,18 +94,18 @@ export async function runRestore(backupId, options = {}, deps = {}) {
 
     if (!manifestMessage) {
       throw new Error(
-        `Không tìm thấy manifest của ${backupId} trong ${chat}. ` +
-          'Kiểm tra lại backup id, hoặc dùng --to để trỏ đúng chat.',
+        `No manifest found for ${backupId} in ${chat}. ` +
+          'Check the backup id, or use --to to point at the right chat.',
       )
     }
 
     const manifest = parseManifest(await readMessageBytes(client, manifestMessage))
-    // Khi người dùng tự chỉ định --out thì tôn trọng nguyên văn đường dẫn đó.
+    // When the user passes --out, respect that path verbatim.
     const target = path.resolve(options.out ?? safeOutName(manifest.name))
     const partial = `${target}.partial`
 
-    // Chỉ ENOENT mới có nghĩa là "chưa có file". Lỗi quyền hay lỗi I/O mà bị coi
-    // là vắng mặt thì data-ark sẽ ghi đè file của người dùng mà không hỏi.
+    // Only ENOENT means "no file yet". Treating a permission or I/O error as absence
+    // would have data-ark overwrite the user's file without asking.
     let exists = true
     try {
       await fs.stat(target)
@@ -114,12 +114,12 @@ export async function runRestore(backupId, options = {}, deps = {}) {
       exists = false
     }
 
-    if (exists && !(await confirm(`${target} đã tồn tại. Ghi đè? [c/K] `))) {
-      throw new Error('Đã huỷ theo yêu cầu.')
+    if (exists && !(await confirm(`${target} already exists. Overwrite? [y/N] `))) {
+      throw new Error('Cancelled on request.')
     }
 
     log(`Backup ${manifest.id}`)
-    log(`File   ${target} (${formatBytes(manifest.size)}, ${manifest.chunks.length} chunk)\n`)
+    log(`File   ${target} (${formatBytes(manifest.size)}, ${manifest.chunks.length} chunks)\n`)
 
     const handle = await fs.open(partial, 'w+')
 
@@ -131,8 +131,8 @@ export async function runRestore(backupId, options = {}, deps = {}) {
 
         if (!message) {
           throw new Error(
-            `Thiếu chunk ${chunk.i + 1}/${manifest.chunks.length}: message ${chunk.msgId} không còn trong ${chat}. ` +
-              'Backup này không khôi phục được.',
+            `Missing chunk ${chunk.i + 1}/${manifest.chunks.length}: message ${chunk.msgId} is no longer in ${chat}. ` +
+              'This backup cannot be restored.',
           )
         }
 
@@ -156,13 +156,13 @@ export async function runRestore(backupId, options = {}, deps = {}) {
 
         if (size !== chunk.size) {
           throw new Error(
-            `Chunk ${chunk.i + 1} có ${size} byte, manifest ghi ${chunk.size} byte — không khớp.`,
+            `Chunk ${chunk.i + 1} has ${size} bytes, the manifest records ${chunk.size} bytes — mismatch.`,
           )
         }
 
         if (sha256 !== chunk.sha256) {
           throw new Error(
-            `Chunk ${chunk.i + 1} có sha256 không khớp manifest. File tải về giữ ở ${partial} để kiểm tra.`,
+            `Chunk ${chunk.i + 1} has a sha256 that does not match the manifest. The download is kept at ${partial} for inspection.`,
           )
         }
       }
@@ -170,28 +170,29 @@ export async function runRestore(backupId, options = {}, deps = {}) {
       await handle.close()
     }
 
-    // Chốt chặn cuối: mọi chunk khớp sha256 mà file vẫn sai độ dài thì bố cục đã
-    // lệch ở đâu đó. Thà báo lỗi còn hơn đổi tên một file sai thành file thật.
+    // Last line of defence: if every chunk matched its sha256 and the file is still the
+    // wrong length, the layout went wrong somewhere. Better to fail than to rename a
+    // wrong file into the real one.
     const written = await fs.stat(partial)
 
     if (written.size !== manifest.size) {
       throw new Error(
-        `File ghép xong có ${written.size} byte, manifest ghi ${manifest.size} byte — không khớp. ` +
-          `File tải về giữ ở ${partial} để kiểm tra.`,
+        `The assembled file has ${written.size} bytes, the manifest records ${manifest.size} bytes — mismatch. ` +
+          `The download is kept at ${partial} for inspection.`,
       )
     }
 
     await fs.rename(partial, target)
 
-    log(`\nXong. Đã ghi ${formatBytes(manifest.size)} vào ${target}`)
+    log(`\nDone. Wrote ${formatBytes(manifest.size)} to ${target}`)
 
     return { path: target, size: manifest.size }
   } finally {
-    // Ngắt kết nối hỏng thì cũng không được nuốt mất lỗi thật đang bay lên.
+    // A failing disconnect must not swallow the real error already on its way up.
     try {
       await disconnect(client)
     } catch (err) {
-      warn(`\nCảnh báo: không đóng được kết nối Telegram: ${err.message}\n`)
+      warn(`\nWarning: could not close the Telegram connection: ${err.message}\n`)
     }
   }
 }

package/src/commands/upload.js

@@ -25,7 +25,7 @@ import { createProgress, formatBytes, formatDuration } from '../progress.js'
 import { clearState, loadState, markChunkDone, saveState, stateDir, stateKey } from '../state.js'
 import { uploadRange } from '../uploader.js'
 
-// Trên ngưỡng này thì phải nói rõ đang chờ bao lâu, theo spec §8.
+// Above this threshold the wait must be spelled out, per spec §8.
 const LONG_WAIT_MS = 60_000
 
 async function realSendChunk(client, peer, { inputFile, fileName, caption }) {
@@ -65,12 +65,12 @@ export async function runUpload(filePath, options = {}, deps = {}) {
   try {
     stat = await fs.stat(absPath)
   } catch (err) {
-    if (err.code === 'ENOENT') throw new Error(`File không tồn tại: ${absPath}`)
+    if (err.code === 'ENOENT') throw new Error(`File does not exist: ${absPath}`)
     throw err
   }
 
   if (!stat.isFile()) {
-    throw new Error(`${absPath} không phải là file.`)
+    throw new Error(`${absPath} is not a file.`)
   }
 
   const config = await loadConfig(configDir)
@@ -80,9 +80,9 @@ export async function runUpload(filePath, options = {}, deps = {}) {
 
   if (!Number.isInteger(concurrency) || concurrency < 1 || concurrency > MAX_CONCURRENCY) {
     throw new Error(
-      `--concurrency không hợp lệ: "${options.concurrency}". ` +
-        `Phải là số nguyên từ 1 đến ${MAX_CONCURRENCY} — mỗi luồng giữ một phần 512KB trong RAM ` +
-        'và Telegram sẽ bắt chờ FLOOD_WAIT nếu bắn quá nhiều request cùng lúc.',
+      `Invalid --concurrency: "${options.concurrency}". ` +
+        `Must be an integer from 1 to ${MAX_CONCURRENCY} — each slot holds a 512KB part in RAM ` +
+        'and Telegram answers with FLOOD_WAIT if too many requests go out at once.',
     )
   }
 
@@ -95,9 +95,9 @@ export async function runUpload(filePath, options = {}, deps = {}) {
   if (resuming && state.chat !== String(chat)) {
     const stateFile = path.join(stateDir(configDir), `${key}.json`)
     throw new Error(
-      `Backup dở dang này đang gửi vào ${state.chat}, nhưng lệnh hiện tại chỉ định đích ${chat} — ` +
-        `không thể tách một backup ra hai đích khác nhau. Chạy lại không kèm --to để tiếp tục gửi vào ` +
-        `${state.chat}, hoặc xoá ${stateFile} rồi chạy lại để bắt đầu backup mới vào ${chat}.`,
+      `This unfinished backup is going to ${state.chat}, but the current command targets ${chat} — ` +
+        `a single backup cannot be split across two destinations. Run again without --to to keep ` +
+        `sending to ${state.chat}, or delete ${stateFile} and run again to start a new backup in ${chat}.`,
     )
   }
 
@@ -121,33 +121,33 @@ export async function runUpload(filePath, options = {}, deps = {}) {
   const log = silent ? () => {} : (line) => console.log(line)
   const warn = silent ? () => {} : writeErr
 
-  // Thử lại và FLOOD_WAIT phải nói ra: một FLOOD_WAIT_3600 mà im lặng thì người
-  // dùng chỉ thấy thanh tiến độ đứng hình cả tiếng và tưởng máy treo.
+  // Retries and FLOOD_WAIT must be announced: a silent FLOOD_WAIT_3600 leaves the user
+  // staring at a frozen progress bar for an hour, assuming the process has hung.
   function onRetry(err, attempt, delayMs) {
     if (delayMs > LONG_WAIT_MS) {
       warn(
-        `\nTelegram bắt chờ ${formatDuration(delayMs / 1000)} rồi mới cho gửi tiếp ` +
-          `(${err.message}). data-ark đang đợi và sẽ tự đi tiếp, đừng tắt.\n`,
+        `\nTelegram wants ${formatDuration(delayMs / 1000)} of waiting before the next send ` +
+          `(${err.message}). data-ark is waiting and will carry on by itself, leave it running.\n`,
       )
       return
     }
 
     warn(
-      `\nLỗi tạm thời (${err.message}), thử lại lần ${attempt} sau ` +
+      `\nTemporary error (${err.message}), retry ${attempt} in ` +
         `${formatDuration(delayMs / 1000)}.\n`,
     )
   }
 
   log(`Backup ${state.id}`)
-  log(`File   ${absPath} (${formatBytes(stat.size)}, ${chunks.length} chunk)`)
-  log(`Đích   ${chat}\n`)
+  log(`File   ${absPath} (${formatBytes(stat.size)}, ${chunks.length} chunks)`)
+  log(`To     ${chat}\n`)
 
   const client = await connect(config)
 
   try {
     for (const chunk of chunks) {
       if (state.done[String(chunk.i)]) {
-        log(`Chunk ${chunk.i + 1}/${chunks.length} đã có, bỏ qua.`)
+        log(`Chunk ${chunk.i + 1}/${chunks.length} already uploaded, skipping.`)
         continue
       }
 
@@ -193,17 +193,17 @@ export async function runUpload(filePath, options = {}, deps = {}) {
       }
     }
 
-    // File có thể bị ghi đè trong lúc upload — với file 50GB thì cả tiếng đồng
-    // hồ trôi qua giữa chunk đầu và chunk cuối. Khi đó manifest mô tả một file
-    // lai chưa từng tồn tại: restore vẫn khớp sha256 nhưng dữ liệu là rác.
+    // The file can be overwritten mid-upload — with a 50GB file an hour passes between
+    // the first and last chunk. The manifest would then describe a hybrid file that never
+    // existed: restore still matches every sha256, but the data is garbage.
     const after = await fs.stat(absPath)
 
     if (after.size !== stat.size || after.mtimeMs !== stat.mtimeMs) {
       throw new Error(
-        `${absPath} đã thay đổi trong lúc upload ` +
-          `(kích thước ${stat.size} → ${after.size}, mtime ${stat.mtimeMs} → ${after.mtimeMs}). ` +
-          'Backup này trộn dữ liệu cũ với dữ liệu mới nên không đáng tin — data-ark không gửi manifest. ' +
-          'Chờ file ổn định rồi chạy lại để tạo một backup mới.',
+        `${absPath} changed during the upload ` +
+          `(size ${stat.size} → ${after.size}, mtime ${stat.mtimeMs} → ${after.mtimeMs}). ` +
+          'This backup mixes old and new data and cannot be trusted — data-ark is not sending the manifest. ' +
+          'Wait until the file settles, then run again to create a new backup.',
       )
     }
 
@@ -223,15 +223,15 @@ export async function runUpload(filePath, options = {}, deps = {}) {
 
     await clearState(key, configDir)
 
-    log(`\nXong. Khôi phục bằng:\n  npx data-ark restore ${state.id}`)
+    log(`\nDone. Restore with:\n  npx data-ark restore ${state.id}`)
 
     return { id: state.id, chunks: chunks.length }
   } finally {
-    // Ngắt kết nối hỏng thì cũng không được nuốt mất lỗi thật đang bay lên.
+    // A failing disconnect must not swallow the real error already on its way up.
     try {
       await disconnect(client)
     } catch (err) {
-      warn(`\nCảnh báo: không đóng được kết nối Telegram: ${err.message}\n`)
+      warn(`\nWarning: could not close the Telegram connection: ${err.message}\n`)
     }
   }
 }

package/src/config.js

@@ -22,7 +22,7 @@ export async function loadConfig(dir = defaultConfigDir()) {
   try {
     return JSON.parse(raw)
   } catch {
-    throw new Error(`File cấu hình hỏng: ${file}. Xoá nó rồi chạy lại "data-ark login".`)
+    throw new Error(`Corrupt config file: ${file}. Delete it and run "data-ark login" again.`)
   }
 }
 

package/src/downloader.js

@@ -19,17 +19,17 @@ export async function downloadToFile(client, message, fd, { offset, onProgress }
   const document = message?.media?.document
 
   if (!document) {
-    throw new Error(`Message ${message?.id} không chứa file đính kèm.`)
+    throw new Error(`Message ${message?.id} has no file attached.`)
   }
 
   if (!Number.isFinite(offset)) {
-    throw new Error(`offset phải là một số hữu hạn, nhận được: ${offset}`)
+    throw new Error(`offset must be a finite number, got: ${offset}`)
   }
 
   const hash = createHash('sha256')
   let written = 0
 
-  for await (const buffer of client.iterDownload({ file: document, requestSize: PART_SIZE })) {
+  for await (const buffer of client.iterDownload({ file: message.media, requestSize: PART_SIZE })) {
     await writeExactly(fd, buffer, offset + written)
     hash.update(buffer)
     written += buffer.length

package/src/manifest.js

@@ -42,48 +42,49 @@ export function parseManifest(input) {
   try {
     manifest = JSON.parse(text)
   } catch {
-    throw new Error('Không đọc được manifest: nội dung không phải JSON hợp lệ.')
+    throw new Error('Cannot read manifest: content is not valid JSON.')
   }
 
   if (manifest.v !== MANIFEST_VERSION) {
     throw new Error(
-      `Manifest dùng phiên bản ${manifest.v}, bản data-ark này chỉ hiểu phiên bản ${MANIFEST_VERSION}.`,
+      `Manifest uses version ${manifest.v}, this build of data-ark only understands version ${MANIFEST_VERSION}.`,
     )
   }
 
   if (!Array.isArray(manifest.chunks) || manifest.chunks.length === 0) {
-    throw new Error('Manifest thiếu danh sách chunk.')
+    throw new Error('Manifest has no chunk list.')
   }
 
   manifest.chunks.forEach((chunk, index) => {
     if (chunk.i !== index) {
-      throw new Error(`Manifest thiếu chunk số ${index}: danh sách chunk không liên tục.`)
+      throw new Error(`Manifest is missing chunk ${index}: the chunk list is not contiguous.`)
     }
   })
 
   const expectedChunks = Math.ceil(manifest.size / manifest.chunkSize)
   if (manifest.chunks.length !== expectedChunks) {
-    throw new Error(`Manifest thiếu ${expectedChunks - manifest.chunks.length} chunk(s).`)
+    throw new Error(`Manifest is missing ${expectedChunks - manifest.chunks.length} chunk(s).`)
   }
 
   const total = manifest.chunks.reduce((sum, chunk) => sum + chunk.size, 0)
   if (total !== manifest.size) {
     throw new Error(
-      `Tổng kích thước các chunk (${total}) không khớp kích thước file trong manifest (${manifest.size}).`,
+      `Chunk sizes add up to ${total}, but the manifest records a file size of ${manifest.size}.`,
     )
   }
 
-  // Restore ghi chunk i vào đúng offset i * chunkSize, nên bố cục phải đều:
-  // mọi chunk đúng bằng chunkSize, riêng chunk cuối là phần dư. Tổng đúng mà
-  // từng chunk lệch thì file ghép ra sẽ thủng lỗ hoặc dài thêm mà sha256 từng
-  // chunk vẫn khớp — sai âm thầm, đúng thứ data-ark không được phép để xảy ra.
+  // Restore writes chunk i at exactly offset i * chunkSize, so the layout must be
+  // uniform: every chunk is chunkSize, except the last one which is the remainder.
+  // A correct total with individually wrong sizes yields a file with a hole or
+  // extra length while every per-chunk sha256 still matches — silently wrong data,
+  // precisely what data-ark must never produce.
   manifest.chunks.forEach((chunk, index) => {
     const expected = Math.min(manifest.chunkSize, manifest.size - index * manifest.chunkSize)
     if (chunk.size !== expected) {
       throw new Error(
-        `Chunk ${index + 1} trong manifest ghi ${chunk.size} byte, nhưng theo bố cục ` +
-          `${manifest.chunkSize} byte mỗi chunk thì phải là ${expected} byte. ` +
-          'Manifest này mô tả sai vị trí các chunk, khôi phục sẽ ra file hỏng.',
+        `Manifest records ${chunk.size} bytes for chunk ${index + 1}, but a layout of ` +
+          `${manifest.chunkSize} bytes per chunk requires ${expected} bytes. ` +
+          'This manifest describes the wrong chunk positions; restoring it would produce a corrupt file.',
       )
     }
   })

package/src/progress.js

@@ -33,13 +33,13 @@ export function renderProgress({ done, total, elapsedMs, label, width = 24 }) {
   const bar = `${'█'.repeat(filled)}${'░'.repeat(width - filled)}`
 
   const bytesPerSecond = elapsedMs > 0 ? done / (elapsedMs / 1000) : 0
-  // Kẹp về 0: done có thể vượt total (đếm dư một nhịp) và ETA âm thì vô nghĩa.
+  // Clamp to 0: done can overshoot total (one extra tick) and a negative ETA is meaningless.
   const remaining = bytesPerSecond > 0 ? Math.max(0, (total - done) / bytesPerSecond) : Infinity
 
   const percent = String(Math.floor(ratio * 100)).padStart(3)
   const speed = `${formatBytes(Math.round(bytesPerSecond))}/s`
 
-  return `${label} ${bar} ${percent}% ${formatBytes(done)}/${formatBytes(total)} ${speed} còn ${formatDuration(remaining)}`
+  return `${label} ${bar} ${percent}% ${formatBytes(done)}/${formatBytes(total)} ${speed} ETA ${formatDuration(remaining)}`
 }
 
 export function createProgress({

package/src/uploader.js

@@ -10,9 +10,9 @@ import { withRetry } from './retry.js'
 
 const read = promisify(readCallback)
 
-// Telegram tách hai API upload theo kích thước file: trên 10MB mới được dùng
-// nhóm "big". GramJS chọn đúng ngưỡng này (LARGE_FILE_THRESHOLD trong
-// node_modules/telegram/client/uploads.js), data-ark bám theo.
+// 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 data-ark follows it.
 export const LARGE_FILE_THRESHOLD = 10 * 1024 * 1024
 
 async function readExactly(fd, length, position) {
@@ -22,7 +22,7 @@ async function readExactly(fd, length, position) {
   while (filled < length) {
     const { bytesRead } = await read(fd, buffer, filled, length - filled, position + filled)
     if (bytesRead === 0) {
-      throw new Error(`Đọc hụt: cần ${length} byte từ vị trí ${position} nhưng file đã hết.`)
+      throw new Error(`Short read: needed ${length} bytes at offset ${position} but the file ended.`)
     }
     filled += bytesRead
   }
@@ -45,7 +45,7 @@ export async function uploadRange(client, fd, options) {
 
   if (totalParts > MAX_PARTS) {
     throw new Error(
-      `Dải byte này cần ${totalParts} phần, trong khi Telegram chỉ nhận tối đa 4000 phần mỗi file.`,
+      `This byte range needs ${totalParts} parts, but Telegram accepts at most 4000 parts per file.`,
     )
   }
 
@@ -73,7 +73,7 @@ export async function uploadRange(client, fd, options) {
     let sendFailed = false
     let readError = null
 
-    // Đọc tuần tự để hash đúng thứ tự, gửi song song.
+    // Read sequentially so the hash sees parts in order, but send in parallel.
     try {
       for (let part = start; part < end; part += 1) {
         const partOffset = part * partSize
@@ -82,17 +82,18 @@ export async function uploadRange(client, fd, options) {
 
         hash.update(bytes)
 
-        // Gắn handler ngay lúc tạo promise, không đợi Promise.all ở cuối lô:
-        // nếu readExactly ném ở part sau, một promise đã push mà chưa ai bắt sẽ
-        // nổ thành unhandledRejection và che mất lỗi thật.
+        // Attach the handler when the promise is created rather than waiting for the
+        // Promise.all at the end of the batch: if readExactly throws on a later part,
+        // an already-pushed promise with no handler becomes an unhandledRejection and
+        // hides the real error.
         sending.push(
           withRetry(() => client.invoke(partRequest(part, bytes)), retryOptions).then(
             () => onProgress?.(partLength),
             (err) => {
-              // Không dùng `sendError ??= err`: nếu lý do reject là falsy
-              // (undefined/null), phép gán đó vẫn set sendError = err (falsy)
-              // rồi `if (sendError)` bên dưới coi như không có lỗi — nuốt mất
-              // một lần gửi thất bại và biến nó thành "thành công" giả.
+              // Not `sendError ??= err`: if the rejection reason is falsy
+              // (undefined/null), that assignment still sets sendError to a falsy
+              // value and the `if (sendError)` below reads as "no error" — swallowing
+              // a failed send and turning it into a fake success.
               if (!sendFailed) {
                 sendFailed = true
                 sendError = err
@@ -105,8 +106,8 @@ export async function uploadRange(client, fd, options) {
       readError = err
     }
 
-    // Mọi promise trong sending đều đã tự nuốt lỗi ở trên nên luôn resolve;
-    // await ở đây chỉ để chắc chắn không còn request nào đang bay khi ném lỗi.
+    // Every promise in `sending` already absorbed its own error above, so they all
+    // resolve; this await only guarantees no request is still in flight when we throw.
     await Promise.all(sending)
 
     if (readError) throw readError