telstore 0.1.6 → 0.1.8

package/src/commands/delete.js

@@ -1,3 +1,5 @@
+import { promises as fs } from 'node:fs'
+
 import { chatName, describeChat } from '../chat.js'
 import {
   DELETE_BATCH_SIZE,
@@ -13,7 +15,7 @@ import { manifestFileName, manifestMessageIds, parseManifestJson } from '../mani
 import { formatBytes, formatDuration } from '../progress.js'
 import { assertLoggedIn } from '../session.js'
 import { requireChat, resolveSettings } from '../settings.js'
-import { clearState, findStates } from '../state.js'
+import { clearRestore, clearState, findRestores, 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
@@ -120,7 +122,7 @@ export async function runDelete(backupId, options = {}, deps = {}) {
     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 telstore list", or use --to to point at the ' +
+          'this machine. Check the id with "npx telstore list", or use --chat to point at the ' +
           'right chat.',
       )
     }
@@ -223,6 +225,30 @@ export async function runDelete(backupId, options = {}, deps = {}) {
 
     if (record) await clearState(record.key, configDir)
 
+    // The chunks are gone from the chat, so a restore record pointing at this backup now
+    // names messages nobody can fetch: `status` would keep offering a resume command that
+    // can only fail. Dropped here rather than earlier for the same reason the upload record
+    // is — anything that throws above leaves the way back intact.
+    //
+    // The .partial itself stays. It is the user's data, sometimes gigabytes of it, and this
+    // command removes what was asked for and nothing else. But it can never be completed
+    // now, so it is named on the way out: that is the difference between a file they can
+    // reclaim and one they will never think to look for.
+    const stranded = []
+
+    for (const found of await findRestores(backupId, configDir)) {
+      await clearRestore(found.key, configDir)
+
+      const partial = `${found.record.target}.partial`
+
+      try {
+        await fs.stat(partial)
+        stranded.push(partial)
+      } catch {
+        // Nothing there to tell them about.
+      }
+    }
+
     if (manifestMessage) {
       log(
         `\nDone. Removed ${backupId} from ${chatName(chat)}: ` +
@@ -236,6 +262,13 @@ export async function runDelete(backupId, options = {}, deps = {}) {
       )
     }
 
+    for (const partial of stranded) {
+      log(
+        `${partial} is a half-finished restore of this backup. Nothing can finish it now — ` +
+          'delete it when you want the space back.',
+      )
+    }
+
     return {
       id: backupId,
       chunks: chunkIds.length,
@@ -248,3 +281,198 @@ export async function runDelete(backupId, options = {}, deps = {}) {
     )
   }
 }
+
+
+// `telstore delete a b c` is three deletes, and the question that guards them is asked once —
+// which means it has to be able to say what all three are. So the batch looks every id up
+// before it asks: the manifest for the finished ones, the local record for the unfinished, and
+// an id that neither knows about refuses the whole run rather than half of it. runDelete then
+// does exactly what it does alone, having already been told the answer.
+export async function runDeletes(backupIds, options = {}, deps = {}) {
+  const {
+    connect = realConnect,
+    disconnect = (client) => client.destroy(),
+    configDir = defaultConfigDir(),
+    searchManifest = findManifestMessage,
+    readMessageBytes = realReadMessageBytes,
+    confirm = askConfirm,
+    interactive = () => Boolean(process.stdin.isTTY),
+    writeErr = (line) => process.stderr.write(line),
+    log: writeLog = (line) => console.log(line),
+    silent = false,
+  } = deps
+
+  // One id keeps its own wording, its own question and its own thrown error.
+  if (backupIds.length === 1) {
+    const result = await runDelete(backupIds[0], options, deps)
+    return { results: [result], failed: 0 }
+  }
+
+  const duplicate = backupIds.find((id, index) => backupIds.indexOf(id) !== index)
+
+  if (duplicate) {
+    throw new Error(
+      `${duplicate} is named twice. Deleting one backup twice does nothing the first pass ` +
+        'did not already do — name it once.',
+    )
+  }
+
+  const config = await loadConfig(configDir)
+
+  assertLoggedIn(config)
+
+  const { values: settings } = resolveSettings(options, config, { file: configFile(configDir) })
+  const chat = 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 {
+    const client = await perId.connect(config, { verbose: settings.verbose })
+    const rows = []
+    const unknown = []
+
+    for (const backupId of backupIds) {
+      const message = await searchManifest(client, chat, backupId)
+      const records = await findStates(backupId, configDir)
+
+      if (!message && records.length === 0) {
+        unknown.push(backupId)
+        continue
+      }
+
+      // A manifest too damaged to read is exactly the backup somebody is here to remove, so
+      // it costs the row its name and size, not the run. runDelete refuses the ones that
+      // cannot name their message ids, which is the check that actually protects anything.
+      let manifest = null
+
+      if (message) {
+        try {
+          manifest = parseManifestJson(await readMessageBytes(client, message))
+        } catch {
+          manifest = null
+        }
+      }
+
+      rows.push({ id: backupId, manifest, record: records[0] ?? null })
+    }
+
+    if (unknown.length > 0) {
+      throw new Error(
+        `Nothing was deleted: ${unknown.join(', ')} — not found in ${chatName(chat)}, and no ` +
+          'local record of it on this machine either. Check the ids with "npx telstore list".',
+      )
+    }
+
+    if (!options.yes) {
+      if (!interactive()) {
+        throw new Error(
+          `${backupIds.length} backups to delete, and no terminal to confirm that in. Run ` +
+            'again with --yes to delete them without being asked.',
+        )
+      }
+
+      for (const line of listingLines(rows, chat)) log(line)
+
+      if (
+        !(await confirm(
+          `The chunks cannot be recovered. Delete all ${backupIds.length}? [y/N] `,
+        ))
+      ) {
+        throw new Error('Cancelled on request.')
+      }
+    }
+
+    for (const [index, backupId] of backupIds.entries()) {
+      if (index > 0) log('')
+      log(`[${index + 1}/${backupIds.length}] ${backupId}`)
+
+      try {
+        // The question was asked about the whole list a moment ago; asking again per backup
+        // would be asking the same thing three times.
+        results.push(await runDelete(backupId, { ...options, yes: true }, perId))
+      } catch (err) {
+        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 }
+}
+
+// What is about to be destroyed, spelled out before the one question that authorises it. An
+// unfinished backup has no manifest to describe it, so its own record speaks for it.
+function listingLines(rows, chat) {
+  const described = rows.map(({ id, manifest, record }) => ({
+    id,
+    name: manifest
+      ? describeName(manifest.name)
+      : `${describeName(record?.state?.path)} (unfinished)`,
+    size: manifest ? describeSize(manifest.size) : UNKNOWN,
+    chunks: plural(countChunks(manifest, record), 'chunk'),
+  }))
+
+  const width = (key) => Math.max(...described.map((row) => row[key].length))
+  const [idWidth, nameWidth, sizeWidth] = [width('id'), width('name'), width('size')]
+
+  return [
+    `Deleting ${rows.length} backups from ${describeChat(chat)}`,
+    '',
+    ...described.map(
+      (row) =>
+        `  ${row.id.padEnd(idWidth)}  ${row.name.padEnd(nameWidth)}  ` +
+        `${row.size.padStart(sizeWidth)}  ${row.chunks}`,
+    ),
+    '',
+  ]
+}
+
+function countChunks(manifest, record) {
+  if (Array.isArray(manifest?.chunks)) return manifest.chunks.length
+
+  const done = record?.state?.done
+
+  return typeof done === 'object' && done !== null ? Object.keys(done).length : 0
+}
+
+// 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 deleted = results.length - failed
+
+  return [
+    `${results.length} backups: ${deleted} deleted, ${failed} failed.`,
+    '',
+    ...results.map((result) => {
+      const id = result.id.padEnd(width)
+
+      return result.error
+        ? `  ${id}  failed: ${result.error}`
+        : `  ${id}  ${plural(result.chunks, 'chunk message')} removed` +
+            (result.manifestDeleted ? ' with its manifest' : '')
+    }),
+  ]
+}

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]))),
   ]
 }