telstore 0.1.6 → 0.1.7

package/src/commands/list.js

@@ -18,8 +18,18 @@ const COLUMNS = [
   { header: 'SIZE', key: 'size', right: true },
   { header: 'CHUNKS', key: 'chunks', right: true },
   { header: 'CREATED', key: 'created' },
+  { header: 'NOTE', key: 'note' },
 ]
 
+// The table is read at a glance, and the note is the one field with no shape at all — 500
+// characters of it would push every column off the side. The whole note is still in the
+// manifest and on the card in the chat, which is where anyone reading it properly will look.
+const NOTE_WIDTH = 40
+
+function shorten(note) {
+  return note.length > NOTE_WIDTH ? `${note.slice(0, NOTE_WIDTH - 1)}…` : note
+}
+
 // Telegram indexes the tag the manifest caption carries, so one search returns one hit
 // per backup instead of one per chunk. What comes back is still whatever the server
 // decided to match, which is why the caller filters on the file name afterwards.
@@ -44,7 +54,14 @@ function toRow(message) {
   const card = parseManifestCaption(message.caption)
 
   if (!card) {
-    return { id, name: UNKNOWN, size: UNKNOWN, chunks: UNKNOWN, created: utcDay(message.date) }
+    return {
+      id,
+      name: UNKNOWN,
+      size: UNKNOWN,
+      chunks: UNKNOWN,
+      created: utcDay(message.date),
+      note: UNKNOWN,
+    }
   }
 
   return {
@@ -53,23 +70,30 @@ function toRow(message) {
     size: card.size,
     chunks: String(card.chunks),
     created: card.createdAt.slice(0, 10),
+    note: card.note ? shorten(card.note) : UNKNOWN,
   }
 }
 
 function renderTable(rows) {
-  const widths = COLUMNS.map((column) =>
+  // Most people never write a note, and a column of dashes tells them nothing they did not
+  // already know while costing every other column the width it takes.
+  const columns = COLUMNS.filter(
+    (column) => column.key !== 'note' || rows.some((row) => row.note !== UNKNOWN),
+  )
+
+  const widths = columns.map((column) =>
     Math.max(column.header.length, ...rows.map((row) => row[column.key].length)),
   )
 
   const line = (cells) =>
     cells
-      .map((cell, i) => (COLUMNS[i].right ? cell.padStart(widths[i]) : cell.padEnd(widths[i])))
+      .map((cell, i) => (columns[i].right ? cell.padStart(widths[i]) : cell.padEnd(widths[i])))
       .join(GAP)
       .trimEnd()
 
   return [
-    line(COLUMNS.map((column) => column.header)),
-    ...rows.map((row) => line(COLUMNS.map((column) => row[column.key]))),
+    line(columns.map((column) => column.header)),
+    ...rows.map((row) => line(columns.map((column) => row[column.key]))),
   ]
 }
 

package/src/commands/restore.js

@@ -9,6 +9,7 @@ import {
 } from '../client.js'
 import { askConfirm } from '../confirm.js'
 import { configFile, defaultConfigDir, loadConfig } from '../config.js'
+import { assertLoggedIn } from '../session.js'
 import { requireChat, resolveSettings } from '../settings.js'
 import { downloadToFile } from '../downloader.js'
 import { parseManifest } from '../manifest.js'
@@ -102,7 +103,7 @@ export async function runRestore(backupId, options = {}, deps = {}) {
     if (!manifestMessage) {
       throw new Error(
         `No manifest found for ${backupId} in ${chat}. ` +
-          'Check the backup id, or use --to to point at the right chat.',
+          'Check the backup id, or use --chat to point at the right chat.',
       )
     }
 
@@ -216,3 +217,119 @@ export async function runRestore(backupId, options = {}, deps = {}) {
     )
   }
 }
+
+
+// `telstore restore a b c` is three restores, not one download: each backup keeps its own
+// manifest, its own name and its own verification, so a batch is what running the command
+// three times would have produced minus two logins. As with uploads, the connection is shared
+// through the deps seam, which leaves runRestore the only caller of connect.
+export async function runRestores(backupIds, options = {}, deps = {}) {
+  const {
+    connect = realConnect,
+    disconnect = (client) => client.destroy(),
+    configDir = defaultConfigDir(),
+    writeErr = (line) => process.stderr.write(line),
+    log: writeLog = (line) => console.log(line),
+    silent = false,
+  } = deps
+
+  // One id must read exactly as it did before this existed: --out still works, the error still
+  // reaches the caller, and nothing prints a summary of a list with one thing in it.
+  if (backupIds.length === 1) {
+    const { path: target, size } = await runRestore(backupIds[0], options, deps)
+    return { results: [{ id: backupIds[0], path: target, size }], failed: 0 }
+  }
+
+  // Everything knowable before the first byte arrives is settled here, so a batch never stops
+  // halfway over something that was already visible on the command line.
+  if (options.out !== undefined) {
+    throw new Error(
+      `--out names one file, and this run restores ${backupIds.length} backups. Leave it off ` +
+        'to write each one under the name in its own manifest, or restore them one command at ' +
+        'a time to choose the names yourself.',
+    )
+  }
+
+  const duplicate = backupIds.find((id, index) => backupIds.indexOf(id) !== index)
+
+  if (duplicate) {
+    throw new Error(
+      `${duplicate} is named twice. Restoring one backup twice would write the same file ` +
+        'over itself — name it once.',
+    )
+  }
+
+  const config = await loadConfig(configDir)
+
+  // Once for the batch. Reported from inside the loop, "Not logged in" would arrive once per
+  // id, each time as though that particular backup were the problem.
+  assertLoggedIn(config)
+
+  const { values: settings } = resolveSettings(options, config, { file: configFile(configDir) })
+  requireChat(settings)
+
+  const log = silent ? () => {} : writeLog
+  const warn = silent ? () => {} : writeErr
+
+  let shared = null
+  const perId = {
+    ...deps,
+    connect: async (theirConfig, connectOptions) =>
+      (shared ??= await connect(theirConfig, connectOptions)),
+    disconnect: async () => {},
+  }
+
+  const results = []
+
+  try {
+    for (const [index, backupId] of backupIds.entries()) {
+      if (index > 0) log('')
+      log(`[${index + 1}/${backupIds.length}] ${backupId}`)
+
+      try {
+        const { path: target, size } = await runRestore(backupId, options, perId)
+        results.push({ id: backupId, path: target, size })
+      } catch (err) {
+        // A backup whose chunks are gone says nothing about the next one, and the summary at
+        // the end would arrive an hour after the bar of the following id started scrolling
+        // over it — so it is named here, and again down there, and carried out as exit code 1.
+        results.push({ id: backupId, error: err.message })
+        warn(`\n${backupId} failed: ${err.message}\n`)
+      }
+    }
+  } finally {
+    if (shared) {
+      await closeQuietly(shared, disconnect, (err) =>
+        warn(`\nWarning: could not close the Telegram connection: ${err.message}\n`),
+      )
+    }
+  }
+
+  const failed = results.filter((result) => result.error).length
+
+  log('')
+  for (const line of summaryLines(results, failed)) log(line)
+
+  return { results, failed }
+}
+
+// Every id gets a line whether it worked or not: one missing from this list would be a backup
+// nobody could tell the fate of.
+function summaryLines(results, failed) {
+  const width = Math.max(...results.map((result) => result.id.length))
+  const restored = results.length - failed
+
+  const lines = [
+    `${results.length} backups: ${restored} restored, ${failed} failed.`,
+    '',
+    ...results.map((result) => {
+      const id = result.id.padEnd(width)
+
+      return result.error
+        ? `  ${id}  failed: ${result.error}`
+        : `  ${id}  ${result.path} (${formatBytes(result.size)})`
+    }),
+  ]
+
+  return lines
+}

package/src/commands/status.js

@@ -34,12 +34,12 @@ function shellArg(text) {
 
 // runUpload refuses to send the rest of a backup to a different chat, so the command has to
 // name the one the chunks are already in — unless the destination in force is that chat
-// anyway, where --to would just be noise. Not knowing the destination counts as not matching:
-// leaving --to out would be a guess about where a backup already in progress went.
+// anyway, where --chat would just be noise. Not knowing the destination counts as not matching:
+// leaving --chat out would be a guess about where a backup already in progress went.
 function resumeCommand(state, destination) {
   const matches = destination !== null && state.chat === String(destination)
 
-  return `npx telstore ${shellArg(state.path)}${matches ? '' : ` --to ${shellArg(state.chat)}`}`
+  return `npx telstore ${shellArg(state.path)}${matches ? '' : ` --chat ${shellArg(state.chat)}`}`
 }
 
 // Why a resume is off the table, in the words of the thing the user would have to fix. The
@@ -162,7 +162,7 @@ export async function runStatus(options = {}, deps = {}) {
 
   log(row('Unfinished', `${states.length} backup${states.length === 1 ? '' : 's'}`))
 
-  // The destination is what decides whether the resume command needs a --to. A row that
+  // The destination is what decides whether the resume command needs a --chat. A row that
   // failed to parse leaves nothing to compare against, which is not the same as a match.
   const destination = settings?.chat ?? null
 

package/src/commands/upload.js

@@ -5,10 +5,13 @@ import { Api } from 'teleproto'
 import { CustomFile } from 'teleproto/client/uploads.js'
 
 import { PART_SIZE, planChunks } from '../chunking.js'
-import { chunkCaption, manifestCaption } from '../caption.js'
+import { chunkCaption, manifestCaption, parseNote } from '../caption.js'
 import { describeChat } from '../chat.js'
 import { closeQuietly, connect as realConnect } from '../client.js'
+import { askConfirm } from '../confirm.js'
 import { configFile, defaultConfigDir, loadConfig } from '../config.js'
+import { expandSources } from '../sources.js'
+import { assertLoggedIn } from '../session.js'
 import { requireChat, resolveSettings } from '../settings.js'
 import {
   buildManifest,
@@ -61,6 +64,49 @@ async function realSendManifest(client, peer, { bytes, fileName, caption }) {
   })
 }
 
+// `--note quarterly accounts` is two arguments by the time node sees it: the note is
+// "quarterly", and "accounts" is a file telstore has been asked to upload. Nothing here can
+// put them back together — the shell dropped the quotes before the process started — so the
+// one useful thing left is to name the mistake this probably was.
+//
+// Two things have to be true before it is said, and neither is enough alone. The note must
+// still be one word — one that kept its spaces is one the shell was told to keep whole, so
+// this cannot have happened to it — and a file must have been named *after* the flag, which
+// is where an unquoted note's remaining words land. Without both, the file name is simply
+// wrong, and sending someone off after a quoting bug that is not there costs them the typo
+// waiting at the front of the same sentence.
+function splitNoteHint(note, filesAfterNote) {
+  if (!note || !filesAfterNote || /\s/.test(note)) return ''
+
+  return (
+    ` This run also carries --note ${JSON.stringify(note)}: a note with spaces in it has to be ` +
+    'quoted, or the shell hands every word after the first to telstore as another file. ' +
+    'Write it as --note "the whole note".'
+  )
+}
+
+// What telstore will read the bytes from. A batch checks every path through this before it
+// sends anything, so "File does not exist" reads the same whether it came from the one file
+// asked for or from the fourth of six — one definition, one wording.
+async function statSource(absPath, { note = null, filesAfterNote = false } = {}) {
+  let stat
+
+  try {
+    stat = await fs.stat(absPath)
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      throw new Error(`File does not exist: ${absPath}.${splitNoteHint(note, filesAfterNote)}`)
+    }
+    throw err
+  }
+
+  if (!stat.isFile()) {
+    throw new Error(`${absPath} is not a file.`)
+  }
+
+  return stat
+}
+
 export async function runUpload(filePath, options = {}, deps = {}) {
   const {
     connect = realConnect,
@@ -74,21 +120,20 @@ export async function runUpload(filePath, options = {}, deps = {}) {
     log: writeLog = (line) => console.log(line),
     silent = false,
     onBackupId = () => {},
+    // Where on the command line the note sat, as `route` saw it. Nothing else can know, and
+    // a run that never says leaves the advice unsaid rather than guessed at.
+    filesAfterNote = false,
   } = deps
 
   const absPath = path.resolve(filePath)
 
-  let stat
-  try {
-    stat = await fs.stat(absPath)
-  } catch (err) {
-    if (err.code === 'ENOENT') throw new Error(`File does not exist: ${absPath}`)
-    throw err
-  }
+  // Before the file is even looked at: the note is the only thing this command sends that a
+  // person typed by hand, and it is written into the manifest, which goes out last. A note
+  // Telegram would refuse has to stop the run here, not after an hour of chunks whose only
+  // list can no longer be sent.
+  const note = parseNote(options.note)
 
-  if (!stat.isFile()) {
-    throw new Error(`${absPath} is not a file.`)
-  }
+  const stat = await statSource(absPath, { note, filesAfterNote })
 
   const config = await loadConfig(configDir)
   const { values: settings, source } = resolveSettings(options, config, {
@@ -138,14 +183,14 @@ export async function runUpload(filePath, options = {}, deps = {}) {
   const resuming = Boolean(state)
 
   // Naming the way back rather than a flag to drop: the destination may have come from the
-  // command line or from the stored setting, and "run again without --to" is no help to
+  // command line or from the stored setting, and "run again without --chat" is no help to
   // someone who never typed one. Pointing at the chat itself is right either way.
   if (resuming && state.chat !== String(chat)) {
     const file = stateFile(key, configDir)
     throw new Error(
       `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 with ` +
-        `--to ${state.chat} to carry on sending there, or delete ${file} and run again to ` +
+        `--chat ${state.chat} to carry on sending there, or delete ${file} and run again to ` +
         `start a new backup in ${chat}.`,
     )
   }
@@ -299,6 +344,7 @@ export async function runUpload(filePath, options = {}, deps = {}) {
       name: path.basename(absPath),
       size: stat.size,
       chunkSize,
+      note,
       chunks: chunks.map((chunk) => ({ i: chunk.i, ...state.done[String(chunk.i)] })),
     })
 
@@ -311,6 +357,7 @@ export async function runUpload(filePath, options = {}, deps = {}) {
         size: manifest.size,
         chunks: manifest.chunks.length,
         createdAt: manifest.createdAt,
+        note: manifest.note ?? null,
       }),
     })
 
@@ -325,3 +372,198 @@ export async function runUpload(filePath, options = {}, deps = {}) {
     )
   }
 }
+
+// `telstore a b c` is three backups, not one: each file keeps its own id, its own manifest and
+// its own resumable record, so a batch is exactly what running the command three times would
+// have produced — minus two logins. The connection is the one thing worth sharing, and it is
+// shared through the same deps seam the tests drive, so runUpload stays the only caller of
+// connect and nothing here has to know what a client is.
+export async function runUploads(filePaths, options = {}, deps = {}) {
+  const {
+    connect = realConnect,
+    disconnect = (client) => client.destroy(),
+    configDir = defaultConfigDir(),
+    writeErr = (line) => process.stderr.write(line),
+    log: writeLog = (line) => console.log(line),
+    silent = false,
+    onFileDone = () => {},
+    confirm = askConfirm,
+    interactive = () => Boolean(process.stdin.isTTY),
+    filesAfterNote = false,
+  } = deps
+
+  const log = silent ? () => {} : writeLog
+  const warn = silent ? () => {} : writeErr
+
+  // One note covers the whole run, so a note telstore cannot send is one mistake, not one per
+  // file. Left to runUpload it would be caught per file and swallowed into the summary as a
+  // failed row, after the files ahead of it had already gone out labelled with nothing.
+  const note = parseNote(options.note)
+
+  // What was typed and what will be sent are two different lists once a folder or a pattern is
+  // allowed: resolve them here, before anything else has an opinion about them.
+  const { paths: found, skipped } = await expandSources(filePaths)
+  const paths = found.map((filePath) => path.resolve(filePath))
+
+  // Something inside a named folder that is not going to be uploaded is still something the
+  // user pointed at, so it is said out loud rather than quietly missing from the list.
+  const folders = skipped.filter((entry) => entry.reason === 'directory')
+
+  if (folders.length > 0) {
+    warn(
+      `\ntelstore reads one level down, so these folders were left alone: ` +
+        `${folders.map((entry) => path.basename(entry.path)).join(', ')}. ` +
+        'Name one of them to upload what is inside it.\n',
+    )
+  }
+
+  for (const entry of skipped) {
+    if (entry.reason !== 'directory') warn(`\n${entry.path} was skipped: ${entry.reason}.\n`)
+  }
+
+  // A single file is the common case and must read exactly as it did before this existed:
+  // no batch heading, no question, no summary, and an error that reaches the caller rather
+  // than a report.
+  if (paths.length === 1) {
+    const { id, chunks } = await runUpload(paths[0], options, deps)
+    return { results: [{ path: paths[0], id, chunks }], failed: 0 }
+  }
+
+  // Everything that can be known before the first byte goes out is settled here. A typo in the
+  // fourth name must not surface an hour into the third file, and a destination nobody set is
+  // one problem, not one per file — the report at the end is for what only the transfer can
+  // discover.
+  const duplicate = paths.find((absPath, index) => paths.indexOf(absPath) !== index)
+
+  if (duplicate) {
+    throw new Error(
+      `${duplicate} is named twice — a folder or a pattern can pick up a file that was ` +
+        'named on its own as well. Uploading one file twice would make two backups of the ' +
+        'same bytes, each with its own id: name it once, or run telstore again afterwards if ' +
+        'a second copy is really what you want.',
+    )
+  }
+
+  const config = await loadConfig(configDir)
+
+  // The login is checked here rather than left to the first connect: reported from inside the
+  // loop it would arrive once per file, each one having already written a state record for a
+  // backup that never sent a byte.
+  assertLoggedIn(config)
+
+  const { values: settings } = resolveSettings(options, config, { file: configFile(configDir) })
+  const chat = requireChat(settings)
+
+  const sizes = []
+
+  for (const absPath of paths) sizes.push((await statSource(absPath, { note, filesAfterNote })).size)
+
+  // The last thing before the first byte. A folder or a pattern hands telstore a list nobody
+  // has read yet, and even a hand-typed one is worth seeing added up: this is the moment where
+  // "23 files, 180 GB, to @family_photos" is still a question rather than an afternoon.
+  if (!options.yes) {
+    if (!interactive()) {
+      throw new Error(
+        `${paths.length} files to upload, and no terminal to confirm that in. Run again with ` +
+          '--yes to upload them without being asked.',
+      )
+    }
+
+    for (const line of listingLines(paths, sizes, chat)) log(line)
+
+    if (!(await confirm(`Upload these ${paths.length} files? [y/N] `))) {
+      throw new Error('Cancelled on request.')
+    }
+  }
+
+  let shared = null
+  const perFile = {
+    ...deps,
+    connect: async (theirConfig, connectOptions) =>
+      (shared ??= await connect(theirConfig, connectOptions)),
+    disconnect: async () => {},
+  }
+
+  const results = []
+
+  try {
+    for (const [index, absPath] of paths.entries()) {
+      if (index > 0) log('')
+      log(`[${index + 1}/${paths.length}] ${path.basename(absPath)}`)
+
+      let result
+      try {
+        const { id, chunks } = await runUpload(absPath, options, perFile)
+        result = { path: absPath, id, chunks }
+      } catch (err) {
+        // One file's trouble is that file's trouble. Stopping here would leave the files
+        // named after it untouched and unmentioned, which is the batch equivalent of the
+        // silent drop this command exists to end — so it is recorded and named in the
+        // summary, and the exit code carries it out to the shell.
+        //
+        // It is also said out loud here and now. Waiting for the summary would leave the bar
+        // of the next file scrolling for an hour over a failure nobody had been told about.
+        result = { path: absPath, error: err.message }
+        warn(`\n${path.basename(absPath)} failed: ${err.message}\n`)
+      }
+
+      results.push(result)
+      onFileDone(result)
+    }
+  } finally {
+    if (shared) {
+      await closeQuietly(shared, disconnect, (err) =>
+        warn(`\nWarning: could not close the Telegram connection: ${err.message}\n`),
+      )
+    }
+  }
+
+  const failed = results.filter((result) => result.error).length
+
+  log('')
+  for (const line of summaryLines(results, failed)) log(line)
+
+  return { results, failed }
+}
+
+// What the batch is about to do, in the shape the summary will report it afterwards: the same
+// names, the same order, so the two lists can be read against each other.
+function listingLines(paths, sizes, chat) {
+  const names = paths.map((absPath) => path.basename(absPath))
+  const amounts = sizes.map(formatBytes)
+  const width = Math.max(...names.map((name) => name.length))
+  const amountWidth = Math.max(...amounts.map((amount) => amount.length))
+  const total = sizes.reduce((sum, size) => sum + size, 0)
+
+  return [
+    `${paths.length} files, ${formatBytes(total)}, to ${describeChat(chat)}`,
+    '',
+    ...names.map((name, i) => `  ${name.padEnd(width)}  ${amounts[i].padStart(amountWidth)}`),
+    '',
+  ]
+}
+
+// The one place a batch says how it went. Every file gets a line whether it worked or not:
+// a name missing from this list would be a file nobody could tell the fate of.
+function summaryLines(results, failed) {
+  const width = Math.max(...results.map((result) => path.basename(result.path).length))
+  const uploaded = results.length - failed
+  const lines = [`${results.length} files: ${uploaded} uploaded, ${failed} failed.`, '']
+
+  for (const result of results) {
+    const name = path.basename(result.path).padEnd(width)
+
+    if (result.error) {
+      lines.push(`  ${name}  failed: ${result.error}`)
+      continue
+    }
+
+    lines.push(`  ${name}  ${result.id}  (${result.chunks} chunk${result.chunks === 1 ? '' : 's'})`)
+  }
+
+  if (uploaded > 0) {
+    lines.push('', 'Restore with: npx telstore restore <backup-id>')
+  }
+
+  return lines
+}

package/src/manifest.js

@@ -19,7 +19,15 @@ export function manifestFileName(id) {
   return `${id}.manifest.json`
 }
 
-export function buildManifest({ id, name, size, chunkSize, chunks, createdAt = new Date().toISOString() }) {
+export function buildManifest({
+  id,
+  name,
+  size,
+  chunkSize,
+  chunks,
+  createdAt = new Date().toISOString(),
+  note = null,
+}) {
   return {
     v: MANIFEST_VERSION,
     id,
@@ -27,6 +35,9 @@ export function buildManifest({ id, name, size, chunkSize, chunks, createdAt = n
     size,
     chunkSize,
     createdAt,
+    // Absent rather than null when there is none: a manifest without a note has to be the
+    // same file telstore wrote before the flag existed, down to the bytes.
+    ...(note ? { note } : {}),
     chunks: [...chunks]
       .sort((a, b) => a.i - b.i)
       .map(({ i, msgId, size: chunkBytes, sha256 }) => ({ i, msgId, size: chunkBytes, sha256 })),
@@ -105,6 +116,15 @@ export function parseManifest(input) {
     )
   }
 
+  // The note is decoration — nothing restores differently because of it — but a manifest is
+  // a file a person can edit and send back, and a field holding something other than what it
+  // claims to be is the point where telstore stops reading rather than guesses.
+  if (manifest.note !== undefined && typeof manifest.note !== 'string') {
+    throw new Error(
+      `Manifest records a note of ${JSON.stringify(manifest.note)}, which is not text.`,
+    )
+  }
+
   if (!Number.isSafeInteger(manifest.chunkSize) || manifest.chunkSize < 1) {
     throw new Error(
       `Manifest records a chunk size of ${JSON.stringify(manifest.chunkSize)}, ` +

package/src/settings.js

@@ -35,7 +35,7 @@ function wholeNumber(raw, where, minimum, maximum, explanation) {
 // which is why chunkSize prints bytes and leaves "1.8 GB" to `describe`.
 export const SETTINGS = {
   chat: {
-    flag: 'to',
+    flag: 'chat',
     default: null,
     // A number here is a chat id, and a chat id is a whole number. 42.5 would otherwise
     // slip through as the string "42.5" and only fail much later, at Telegram, as a chat
@@ -129,9 +129,9 @@ export const SETTINGS = {
 
 export const SETTING_KEYS = Object.keys(SETTINGS)
 
-// Someone who has been typing `--to` and `--chunk-size` for a week will type them at the
-// config command too. Accept the flag spelling as a way in, and canonicalise on the way to
-// disk so the file only ever holds one name per setting.
+// Someone who has been typing `--chunk-size` and `--upload-concurrency` for a week will type
+// them at the config command too. Accept the flag spelling as a way in, and canonicalise on
+// the way to disk so the file only ever holds one name per setting.
 const ALIASES = new Map()
 
 for (const [key, spec] of Object.entries(SETTINGS)) {
@@ -150,7 +150,7 @@ export function isManagedByLogin(input) {
 // Where a value came from, spelled the way the user would recognise it. A stored value that
 // fails to parse must not be reported as a bad flag: nobody typed a flag, and telling them
 // to fix one sends them off after the wrong thing — the same mistake the old
-// "run again without --to" advice made.
+// "run again without --chat" advice made.
 function origin(key, from, file) {
   return from === 'flag' ? `--${SETTINGS[key].flag}` : `${key} in ${file}`
 }
@@ -197,7 +197,7 @@ export function requireChat(values) {
   if (values.chat === null || values.chat === undefined) {
     throw new Error(
       'No destination set — run "npx telstore config chat @my_backups" to set one ' +
-        '("config chat me" for Saved Messages), or pass --to to choose one for this run.',
+        '("config chat me" for Saved Messages), or pass --chat to choose one for this run.',
     )
   }