@tequila99/githuman 0.8.0 → 0.9.1

package/README.md

@@ -210,12 +210,25 @@ MIT, см. [LICENSE](LICENSE).
 каталога запуска приложения. Поддерживаются папки, визуальный редактор, полный
 исходник Markdown, редактируемые свойства YAML frontmatter и обычные относительные ссылки.
 Внутренние ссылки активируют заметку в текущем окне; внешние открываются в новой вкладке.
+**Add to agent** в контекстном меню заметки и панели редактора добавляет её в чат
+как удаляемый бейдж. При отправке агент получает актуальный Markdown вместе
+с YAML-свойствами; связанные заметки и изображения не включаются.
+Несохранённые изменения сохраняются перед отправкой, ошибки сохранения её блокируют.
 Кнопка **Link to note** помогает выбрать заметку для ссылки; теги со счётчиками
 в дереве фильтруют список. Изменения автоматически сохраняются после паузы ввода.
 
 Другой каталог задаётся через `serve --notes-dir ./notes` или
 `GITHUMAN_NOTES_DIR`; относительный путь считается от каталога запуска.
-Такой каталог можно версионировать. Личное хранилище по умолчанию
+Такой каталог можно версионировать.
+При создании вводится короткое имя без пути: файл создаётся в выбранном каталоге,
+расширение `.md` добавляется автоматически. Заметки можно перетаскивать между
+каталогами в дереве слева и в обзоре каталога справа, в том числе между панелями.
+Кнопка корня слева и кнопка родительского каталога справа также принимают заметки.
+Перенос сохраняет UUID и обновляет относительные ссылки; совпадающий файл не перезаписывается.
+**Delete** в контекстном меню скрывает заметку в приложении: отметка хранится в БД,
+сам Markdown остаётся на диске. Сканирование и перезапуск не возвращают её в список;
+восстановление через интерфейс пока не предусмотрено.
+Личное хранилище по умолчанию
 исключается локально через Git `info/exclude`; уже отслеживаемые файлы
 автоматически из индекса не удаляются.
 
@@ -226,16 +239,39 @@ MIT, см. [LICENSE](LICENSE).
 в дереве. При альтернативном Git-хранилище исключите `.history/` из Git,
 если резервные копии не нужно публиковать.
 
+Полный Markdown с YAML-шапкой можно вставить в пустое тело визуального редактора
+или вместо всего выделенного тела: свойства импортируются в Properties, UUID
+заметки сохраняется. Некорректный YAML отклоняется с сообщением об ошибке.
+При неподдерживаемой разметке сохраняется полный исходник
+и включается режим Markdown.
+
 Визуальное редактирование может нормализовать оформление списков, таблиц
 и reference-ссылок. Открытие и переключение режимов без правок файл не
 перезаписывают. Если при открытии визуальный редактор теряет конструкции,
 приложение сохраняет исходный текст и переключается в Markdown. Вставленные PNG, JPEG, GIF и WebP (до 10 МБ) сохраняются в `assets/` внутри
 хранилища заметок и доступны в визуальном редакторе после перезапуска. Ссылки
-на вложения не зависят от хоста или порта сервиса. Внешние изображения
-остаются в исходном режиме. Размер заметки ограничен 1 МБ; символические ссылки в
+на вложения не зависят от хоста или порта сервиса. Внешние HTTP/HTTPS-изображения доступны в визуальном редакторе. Размер заметки ограничен 1 МБ; символические ссылки в
 пути хранилища не поддерживаются. Черновик после аварии браузера пока
 не восстанавливается.
 
+Команда **Download external attachments** в панели заметки или **Ctrl+Shift+D**, пока заметка открыта на экране, независимо от фокуса,
+открывает список внешних вложений.
+Клавиша определяется по физическому коду, независимо от раскладки.
+Картинки и ссылки на PNG/JPEG/GIF/WebP/PDF можно выбрать перед загрузкой;
+одинаковые адреса скачиваются один раз. Размер картинок ограничен 10 МБ,
+PDF до 50 МБ загружаются без дополнительного вопроса, от 50 до 100 МБ требуют
+подтверждения, свыше 100 МБ отклоняются. При неизвестном размере подтверждение
+запрашивается после остановки на пороге 50 МБ; согласие запускает загрузку заново.
+Лимит одной операции — 200 МБ сохранённых файлов. Проверка размера действует
+и во время скачивания, не только по заголовкам сервера.
+
+Успешные загрузки заменяют адреса в текущем Markdown, ошибки оставляют внешние
+ссылки. PDF остаются обычными ссылками, свойства и подписи сохраняются.
+Скачивание работает с публичными HTTP/HTTPS-адресами без браузерных cookies;
+обычные ссылки определяются по расширению в пути URL. **Restore external links**
+возвращает последнюю замену, пока текст не изменён. Обновление визуального
+редактора после импорта сбрасывает его прежнюю историю Ctrl+Z.
+
 Заметки имеют UUID в SQLite-каталоге; необязательный `githuman_id` в YAML помогает
 распознавать внешние перемещения. Back/Forward и история браузера возвращают между
 заметками. Rename в контекстном меню сохраняет ID и исправляет относительные ссылки;

package/dist/server/app.js

@@ -105,6 +105,7 @@ export function buildApp(options = {}) {
     }
     if (options.agentPresets) {
         app.register(agentRoutes, {
+            notes,
             registry: createSessionRegistry({
                 presets: options.agentPresets,
                 repositoryPath

package/dist/server/db/migrations.js

@@ -88,6 +88,12 @@ export function applyMigrations(db) {
     CREATE INDEX IF NOT EXISTS review_files_review_id_idx
       ON review_files(review_id);
   `);
+    const noteColumns = db
+        .prepare('PRAGMA table_info(note_catalog)')
+        .all();
+    if (!noteColumns.some(column => column.name === 'deleted_at')) {
+        db.exec('ALTER TABLE note_catalog ADD COLUMN deleted_at TEXT');
+    }
     const commentColumns = db
         .prepare('PRAGMA table_info(comments)')
         .all();

package/dist/server/errors/note-assets.js

@@ -0,0 +1,3 @@
+import createError from '@fastify/error';
+export const NoteAssetLimitError = createError('GHT_NOTE_ASSET_LIMIT', '%s', 413);
+export const NoteAssetQueueError = createError('GHT_NOTE_ASSET_QUEUE', 'Attachment download queue is full', 429);

package/dist/server/repositories/notes-catalog.repo.js

@@ -7,6 +7,7 @@ function toNote(row) {
         version: row.version,
         createdAt: row.created_at,
         updatedAt: row.updated_at,
+        deletedAt: row.deleted_at,
         redirectId: row.redirect_id
     };
 }
@@ -48,9 +49,9 @@ export class NotesCatalogRepository {
     }
     put(note) {
         this.db
-            .prepare(`INSERT INTO note_catalog(storage_id,id,path,presence,version,created_at,updated_at,path_changed_at,redirect_id) VALUES(?,?,?,?,?,?,?,?,?)
-      ON CONFLICT(storage_id,id) DO UPDATE SET path=excluded.path,presence=excluded.presence,version=excluded.version,updated_at=excluded.updated_at,path_changed_at=CASE WHEN note_catalog.path != excluded.path THEN strftime('%Y-%m-%dT%H:%M:%fZ','now') ELSE note_catalog.path_changed_at END,redirect_id=excluded.redirect_id`)
-            .run(this.storageId, note.id, note.path, note.presence, note.version, note.createdAt, note.updatedAt, note.updatedAt, note.redirectId);
+            .prepare(`INSERT INTO note_catalog(storage_id,id,path,presence,version,created_at,updated_at,path_changed_at,redirect_id,deleted_at) VALUES(?,?,?,?,?,?,?,?,?,?)
+      ON CONFLICT(storage_id,id) DO UPDATE SET path=excluded.path,presence=excluded.presence,version=excluded.version,updated_at=excluded.updated_at,path_changed_at=CASE WHEN note_catalog.path != excluded.path THEN strftime('%Y-%m-%dT%H:%M:%fZ','now') ELSE note_catalog.path_changed_at END,redirect_id=excluded.redirect_id,deleted_at=excluded.deleted_at`)
+            .run(this.storageId, note.id, note.path, note.presence, note.version, note.createdAt, note.updatedAt, note.updatedAt, note.redirectId, note.deletedAt);
     }
     links(id) {
         const rows = this.db

package/dist/server/repositories/notes.repo.js

@@ -1,12 +1,13 @@
+import { noteChildPath, noteParentPath } from "../../shared/notes/note-path.js";
 import { constants } from 'node:fs';
-import { randomUUID } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 import { lstat, link, mkdir, open, readdir, realpath, rename, unlink, writeFile } from 'node:fs/promises';
 import { basename, dirname, join, resolve, sep } from 'node:path';
 import { BadRequestError, NotFoundError } from "../errors/http.js";
 import { isSystemError } from "../utils/system-error.js";
 import { sha256Hex } from "../utils/hash.js";
 import { NoteConflictError, NoteExistsError } from "../errors/notes.js";
-import { MAX_NOTE_ASSET_BYTES } from "../../shared/notes/constants.js";
+import { noteAssetFormat } from "../../shared/notes/asset-formats.js";
 // Bound file reads before allocating document buffers.
 const MAX_BYTES = 1000000;
 export class NotesRepository {
@@ -213,36 +214,72 @@ export class NotesRepository {
         });
     }
     async saveAsset(bytes, extension) {
-        const id = sha256Hex(bytes) + '.' + extension;
-        const target = await this.path('assets/' + id, false);
-        await mkdir(dirname(target), { recursive: true });
-        await this.path('assets/' + id, false);
-        const temporary = join(dirname(target), '.asset-' + randomUUID());
+        const staged = await this.stageAsset((async function* () {
+            yield bytes;
+        })(), extension, new AbortController().signal);
+        try {
+            return await staged.commit();
+        }
+        finally {
+            await staged.dispose();
+        }
+    }
+    async stageAsset(chunks, extension, signal) {
+        const format = noteAssetFormat(extension);
+        if (!format)
+            throw new BadRequestError('Unsupported attachment format');
+        const probe = await this.path('assets/probe.png', false);
+        await mkdir(dirname(probe), { recursive: true });
+        await this.path('assets/probe.png', false);
+        const temporary = join(dirname(probe), '.asset-' + randomUUID());
+        const dispose = async () => {
+            await unlink(temporary).catch(error => {
+                if (!isSystemError(error, 'ENOENT'))
+                    throw error;
+            });
+        };
         try {
             const file = await open(temporary, 'wx', 0o600);
+            const hash = createHash('sha256');
+            let bytes = 0;
             try {
-                await file.writeFile(bytes);
+                for await (const chunk of chunks) {
+                    signal.throwIfAborted();
+                    bytes += chunk.length;
+                    if (bytes > format.maxBytes) {
+                        throw new BadRequestError('Attachment exceeds its size limit');
+                    }
+                    hash.update(chunk);
+                    await file.writeFile(chunk);
+                }
+                if (!bytes)
+                    throw new BadRequestError('Empty attachment');
                 await file.sync();
             }
             finally {
                 await file.close();
             }
-            await this.path('assets/' + id, false);
-            try {
-                await link(temporary, target);
-            }
-            catch (error) {
-                if (!isSystemError(error, 'EEXIST'))
-                    throw error;
-            }
+            const id = hash.digest('hex') + '.' + extension;
+            return {
+                dispose,
+                commit: async () => {
+                    signal.throwIfAborted();
+                    const target = await this.path('assets/' + id, false);
+                    try {
+                        await link(temporary, target);
+                    }
+                    catch (error) {
+                        if (!isSystemError(error, 'EEXIST'))
+                            throw error;
+                    }
+                    return id;
+                }
+            };
         }
-        finally {
-            await unlink(temporary).catch(error => {
-                if (!isSystemError(error, 'ENOENT'))
-                    throw error;
-            });
+        catch (error) {
+            await dispose();
+            throw error;
         }
-        return id;
     }
     async readAsset(id) {
         const target = await this.path('assets/' + id, false);
@@ -250,13 +287,18 @@ export class NotesRepository {
             const file = await open(target, constants.O_RDONLY | constants.O_NOFOLLOW);
             try {
                 const stat = await file.stat();
-                if (!stat.isFile() || stat.size > MAX_NOTE_ASSET_BYTES) {
-                    throw new BadRequestError('Invalid image attachment');
+                const format = noteAssetFormat(id.split('.').at(-1));
+                if (!format ||
+                    !stat.isFile() ||
+                    !stat.size ||
+                    stat.size > format.maxBytes) {
+                    throw new BadRequestError('Invalid attachment');
                 }
-                return await file.readFile();
+                return file.createReadStream({ autoClose: true, end: stat.size - 1 });
             }
-            finally {
+            catch (error) {
                 await file.close();
+                throw error;
             }
         }
         catch (error) {
@@ -340,7 +382,7 @@ export class NotesRepository {
             if (path.split('/')[0] === 'assets') {
                 throw new BadRequestError('Cannot rename attachments');
             }
-            const targetPath = [...path.split('/').slice(0, -1), name].join('/');
+            const targetPath = noteChildPath(noteParentPath(path), name);
             if (targetPath.split('/')[0] === 'assets') {
                 throw new BadRequestError('Reserved folder name');
             }

package/dist/server/routes/agent.js

@@ -124,6 +124,7 @@ export async function agentRoutes(app, opts) {
         }
         session.assertCanPrompt();
         const blocks = await buildPromptBlocks(request.body, {
+            notes: opts.notes,
             db,
             repositoryPath,
             embeddedContext: session.supportsEmbeddedContext,

package/dist/server/routes/notes.js

@@ -1,11 +1,14 @@
+import { NotesExternalAssetsService } from "../services/notes-external-assets.service.js";
+import { InspectExternalAssetBody, PreviewExternalAssetBody, ImportExternalAssetBody, ExternalAssetInspectionSchema, ExternalAssetResultSchema } from "../../shared/notes/schemas.js";
 import multipart from '@fastify/multipart';
 import { MAX_NOTE_ASSET_BYTES } from "../../shared/notes/constants.js";
 import { noteAssetFormat } from "../../shared/notes/asset-formats.js";
 import { NoteRecordSchema, NoteIdQuery, NoteDescriptorSchema, NoteResolveBody, NoteResolutionSchema, NoteGraphSchema, ResolveIdentityBody, NoteMutationSchema, UploadNoteAssetBody, NoteAssetSchema, NoteAssetContentSchema, NoteAssetParams, NoteQuery, NoteSchema, NotesIndexSchema, CreateNoteBody, SaveNoteBody, RenameNoteBody, CreateFolderBody } from "../../shared/notes/schemas.js";
 import { ERROR_RESPONSES, NoContentSchema } from "../../shared/http/schemas.js";
 import { BadRequestError } from "../errors/http.js";
+import { withRequestSignal } from "../utils/request-abort.js";
 import { createNotesOriginHook } from "../hooks/notes/same-origin.js";
-export async function notesRoutes(app, { service, loopbackBind = false }) {
+export async function notesRoutes(app, { service, loopbackBind = false, externalAssets = new NotesExternalAssetsService() }) {
     await app.register(multipart, {
         attachFieldsToBody: true,
         limits: { fileSize: MAX_NOTE_ASSET_BYTES, files: 1, fields: 0, parts: 1 }
@@ -31,10 +34,42 @@ export async function notesRoutes(app, { service, loopbackBind = false }) {
         reply.code(201);
         return asset;
     });
+    typed.post('/api/notes/assets/inspect', {
+        schema: {
+            tags: ['notes'],
+            summary: 'Inspect an external attachment',
+            body: InspectExternalAssetBody,
+            response: { 200: ExternalAssetInspectionSchema, ...ERROR_RESPONSES }
+        }
+    }, (request, reply) => withRequestSignal(reply, signal => externalAssets.inspect(request.body.url, signal)));
+    typed.post('/api/notes/assets/import', {
+        schema: {
+            tags: ['notes'],
+            summary: 'Import an external attachment',
+            body: ImportExternalAssetBody,
+            response: { 200: ExternalAssetResultSchema, ...ERROR_RESPONSES }
+        }
+    }, (request, reply) => withRequestSignal(reply, signal => externalAssets.importAsset(request.body, signal, (chunks, extension, saveSignal) => service.importAsset(chunks, extension, saveSignal))));
+    // The typed provider rejects a binary payload for the content schema.
+    app.post('/api/notes/assets/preview', {
+        schema: {
+            tags: ['notes'],
+            summary: 'Preview an external image',
+            body: PreviewExternalAssetBody,
+            response: { 200: NoteAssetContentSchema, ...ERROR_RESPONSES }
+        }
+    }, async (request, reply) => {
+        const preview = await withRequestSignal(reply, signal => externalAssets.preview(request.body.url, signal));
+        reply
+            .header('Cache-Control', 'no-store')
+            .header('X-Content-Type-Options', 'nosniff')
+            .type(preview.mime);
+        return reply.send(preview.body);
+    });
     app.get('/api/notes/assets/:id', {
         schema: {
             tags: ['notes'],
-            summary: 'Read a stored note image',
+            summary: 'Read a stored note attachment',
             params: NoteAssetParams,
             response: { 200: NoteAssetContentSchema, ...ERROR_RESPONSES }
         }
@@ -143,6 +178,17 @@ export async function notesRoutes(app, { service, loopbackBind = false }) {
             response: { 200: NoteSchema, ...ERROR_RESPONSES }
         }
     }, request => service.save(request.body.path, request.body.text, request.body.version, request.body.id, request.body.storageId));
+    typed.post('/api/notes/delete', {
+        schema: {
+            tags: ['notes'],
+            summary: 'Hide a note without removing its file',
+            body: NoteIdQuery,
+            response: { 204: NoContentSchema, ...ERROR_RESPONSES }
+        }
+    }, async (request, reply) => {
+        await service.delete(request.body.id, request.body.storageId);
+        reply.code(204).send(null);
+    });
     typed.post('/api/notes/rename', {
         schema: {
             tags: ['notes'],

package/dist/server/services/agent/context-builder.js

@@ -162,7 +162,20 @@ async function buildAttachmentItem(item, deps) {
         ...(item.mimeType === '' ? {} : { mimeType: item.mimeType })
     };
 }
+async function buildNoteItem(item, deps) {
+    try {
+        if (!deps.notes)
+            throw new AgentContextError('Notes are unavailable');
+        const note = await deps.notes.identity.readId(item.noteId, item.storageId);
+        return embed(deps, `githuman://note/${encodeURIComponent(item.storageId)}/${encodeURIComponent(item.noteId)}`, `Note ${note.path}:`, 'text/markdown', `Note: ${note.path}\n\n${note.text}`);
+    }
+    catch (error) {
+        throw asContextError(error);
+    }
+}
 function buildItem(item, deps) {
+    if (item.kind === 'note')
+        return buildNoteItem(item, deps);
     if (item.kind === 'diff') {
         return buildDiffItem(item, deps);
     }

package/dist/server/services/notes-external-assets.service.js

@@ -0,0 +1,177 @@
+import PQueue from 'p-queue';
+import { BadRequestError } from "../errors/http.js";
+import { NoteAssetLimitError, NoteAssetQueueError } from "../errors/note-assets.js";
+import { remoteAssetRequest, translateRemoteAssetError } from "../utils/remote-asset-request.js";
+import { detectNoteAssetFormat } from "../utils/note-asset-format.js";
+import { MAX_NOTE_ASSET_BYTES, NOTE_PDF_WARNING_BYTES } from "../../shared/notes/constants.js";
+import { maxNoteAssetBytes } from "../../shared/notes/asset-formats.js";
+// Limit disk and memory pressure across imports and background previews.
+const ACTIVE_LIMIT = 3;
+const QUEUE_LIMIT = 30;
+// Bound active operations so stalled imports cannot occupy queue slots indefinitely.
+const OPERATION_TIMEOUT_MS = 120000;
+// A small prefix is sufficient for supported image and PDF signatures.
+const FORMAT_PREFIX_BYTES = 8192;
+// Explain the preview limit to the client in megabytes.
+const PREVIEW_LIMIT_MESSAGE = `Image exceeds ${MAX_NOTE_ASSET_BYTES / 1_000_000} MB`;
+// Yields Buffer chunks and fails once the total passes the limit.
+async function* boundedChunks(source, limit, counter, signal, message) {
+    for await (const value of source) {
+        signal.throwIfAborted();
+        const chunk = Buffer.isBuffer(value) ? value : Buffer.from(value);
+        counter.bytes += chunk.length;
+        if (counter.bytes > limit)
+            throw new NoteAssetLimitError(message);
+        yield chunk;
+    }
+}
+function isSuccess(response) {
+    return (!!response.statusCode &&
+        response.statusCode >= 200 &&
+        response.statusCode < 300);
+}
+export class NotesExternalAssetsService {
+    queue = new PQueue({ concurrency: ACTIVE_LIMIT });
+    request;
+    constructor(request = remoteAssetRequest) {
+        this.request = request;
+    }
+    run(signal, priority, work) {
+        signal.throwIfAborted();
+        if (this.queue.pending >= ACTIVE_LIMIT && this.queue.size >= QUEUE_LIMIT) {
+            throw new NoteAssetQueueError();
+        }
+        // The queue removes a task that waits when its signal aborts. A running
+        // task stops through the signal that it receives.
+        return this.queue.add(async () => {
+            try {
+                return await work(AbortSignal.any([signal, AbortSignal.timeout(OPERATION_TIMEOUT_MS)]));
+            }
+            catch (error) {
+                throw translateRemoteAssetError(error);
+            }
+        }, { priority: priority ? 1 : 0, signal });
+    }
+    async inspect(url, signal) {
+        return this.run(signal, false, async (abort) => {
+            const response = await this.request(url, 'HEAD', abort);
+            try {
+                return {
+                    size: isSuccess(response) ? this.length(response) : null
+                };
+            }
+            finally {
+                response.destroy();
+            }
+        });
+    }
+    length(response) {
+        const value = response.headers['content-length'];
+        if (!value || !/^\d+$/.test(value))
+            return null;
+        const size = Number(value);
+        return Number.isSafeInteger(size) ? size : null;
+    }
+    async importAsset(input, signal, save) {
+        return this.run(signal, true, async (abort) => {
+            const response = await this.request(input.url, 'GET', abort);
+            try {
+                this.checkResponse(response);
+                const fileLimit = maxNoteAssetBytes(input.kind);
+                const warningLimit = input.kind === 'pdf' && !input.allowLargePdf
+                    ? NOTE_PDF_WARNING_BYTES
+                    : fileLimit;
+                const limit = Math.min(input.remainingBytes, fileLimit, warningLimit);
+                const over = (size) => {
+                    if (size <= limit)
+                        return undefined;
+                    if (size > input.remainingBytes) {
+                        return { status: 'rejected', reason: 'operation-limit' };
+                    }
+                    if (size > fileLimit) {
+                        return { status: 'rejected', reason: 'file-too-large' };
+                    }
+                    return {
+                        status: 'confirmation-required',
+                        size: this.length(response)
+                    };
+                };
+                const known = this.length(response);
+                if (known !== null) {
+                    const result = over(known);
+                    if (result)
+                        return result;
+                }
+                const counter = { bytes: 0 };
+                const iterator = boundedChunks(response, limit, counter, abort, 'Attachment download limit reached');
+                const prefix = [];
+                let prefixBytes = 0;
+                try {
+                    while (prefixBytes < FORMAT_PREFIX_BYTES) {
+                        const next = await iterator.next();
+                        if (next.done)
+                            break;
+                        prefix.push(next.value);
+                        prefixBytes += next.value.length;
+                    }
+                    const format = await detectNoteAssetFormat(Buffer.concat(prefix));
+                    if ((format.display === 'link' ? 'pdf' : 'image') !== input.kind) {
+                        throw new BadRequestError('Attachment type does not match the selected resource');
+                    }
+                    const body = async function* () {
+                        yield* prefix;
+                        yield* iterator;
+                    };
+                    const url = await save(body(), format.extension, abort);
+                    return {
+                        status: 'stored',
+                        url,
+                        bytes: counter.bytes,
+                        format: format.extension
+                    };
+                }
+                catch (error) {
+                    if (error instanceof NoteAssetLimitError)
+                        return over(counter.bytes);
+                    throw error;
+                }
+            }
+            finally {
+                response.destroy();
+            }
+        });
+    }
+    async preview(url, signal) {
+        return this.run(signal, false, async (abort) => {
+            const response = await this.request(url, 'GET', abort);
+            try {
+                this.checkResponse(response);
+                if ((this.length(response) ?? 0) > MAX_NOTE_ASSET_BYTES) {
+                    throw new NoteAssetLimitError(PREVIEW_LIMIT_MESSAGE);
+                }
+                const chunks = [];
+                for await (const chunk of boundedChunks(response, MAX_NOTE_ASSET_BYTES, { bytes: 0 }, abort, PREVIEW_LIMIT_MESSAGE)) {
+                    chunks.push(chunk);
+                }
+                const body = Buffer.concat(chunks);
+                const format = await detectNoteAssetFormat(body);
+                if (format.display !== 'image') {
+                    throw new BadRequestError('Preview is not an image');
+                }
+                return { body, mime: format.mime };
+            }
+            finally {
+                response.destroy();
+            }
+        });
+    }
+    checkResponse(response) {
+        if (!isSuccess(response)) {
+            throw new BadRequestError('Attachment server returned HTTP ' + response.statusCode);
+        }
+        if (response.headers['content-encoding'] &&
+            response.headers['content-encoding'] !== 'identity') {
+            throw new BadRequestError('Compressed attachment responses are not supported');
+        }
+    }
+}