pixivflow 2.25.0 → 2.27.0

package/config/fly-two-bots.example.json

@@ -168,7 +168,14 @@
       "limit": 1,
       "storageMode": "cache",
       "delivery": {
-        "target": "telepost-bot1"
+        "target": "telepost-bot1",
+        "richNovelPreview": {
+          "url": "http://127.0.0.1:8000/publish/rich-novel",
+          "headers": {
+            "Authorization": "Bearer ${TELEPRESS_API_KEY}"
+          },
+          "field": "novel_preview_url"
+        }
       }
     },
     {

package/dist/config/types.d.ts

@@ -43,6 +43,8 @@ export interface TargetDeliveryConfig {
     target: string;
     /** 覆盖该交付目标的表单字段，支持 {{title}} 等模板变量 */
     fields?: Record<string, DeliveryFieldValue>;
+    /** Optional rich-novel preview enrichment before the submission. */
+    richNovelPreview?: RichNovelPreviewConfig;
     /**
      * Schedule slot provenance injected at runtime for scheduled/external runs
      * (not authored in config). Rendered as {{slotId}}/{{slotName}}/{{slotDate}}.
@@ -538,6 +540,23 @@ export interface HttpMultipartSuccessConfig {
     /** jsonPath 对应的期望值 */
     equals?: string | number | boolean | null;
 }
+/**
+ * Optional rich-novel preview publish step performed BEFORE the multipart
+ * submission is enqueued. Widget is TelePress (/publish/rich-novel): the novel
+ * markdown sidecar + inline images are posted there and the returned Telegraph
+ * URL is injected into the submission's `fields` under `field`. It is an
+ * enrichment — a failure never fails the submission; TXT/ZIP stay authoritative.
+ */
+export interface RichNovelPreviewConfig {
+    /** TelePress `/publish/rich-novel` endpoint (http(s), supports ${ENV_NAME}). */
+    url: string;
+    /** Request headers (e.g. Authorization: Bearer ${TELEPRESS_API_KEY}). */
+    headers?: Record<string, string>;
+    /** Per-request timeout in milliseconds (default 60000). */
+    timeoutMs?: number;
+    /** Submission field receiving the Telegraph URL (default novel_preview_url). */
+    field?: string;
+}
 export interface HttpMultipartDeliveryConfig {
     type: 'httpMultipart';
     url: string;

package/dist/config/validation.js

@@ -269,6 +269,21 @@ function validateConfig(config, location, databasePath) {
                     errors.push(`targets[${index}].delivery.target: Unknown delivery target "${deliveryTarget}"`);
                 }
             }
+            if (target.delivery?.richNovelPreview) {
+                if (!target.delivery.richNovelPreview.url?.trim()) {
+                    errors.push(`targets[${index}].delivery.richNovelPreview.url: Required field is missing or empty`);
+                }
+                else {
+                    try {
+                        const url = new URL(target.delivery.richNovelPreview.url);
+                        if (!['http:', 'https:'].includes(url.protocol))
+                            throw new Error('unsupported protocol');
+                    }
+                    catch {
+                        errors.push(`targets[${index}].delivery.richNovelPreview.url: Must be a valid HTTP or HTTPS URL`);
+                    }
+                }
+            }
         });
     }
     for (const [name, delivery] of Object.entries(config.delivery?.targets ?? {})) {

package/dist/delivery/TelePressRichNovel.d.ts

@@ -0,0 +1,40 @@
+import type { DownloadedArtifact } from './types';
+export interface RichNovelPreviewResult {
+    /** Telegraph "read online" URL for the published page. */
+    url: string;
+    /** Per-asset diagnostic returned by TelePress ({local, remote, status}). */
+    assets?: Array<{
+        local: string;
+        remote?: string | null;
+        status: string;
+    }>;
+}
+export interface RichNovelPublishOptions {
+    url: string;
+    headers?: Record<string, string>;
+    timeoutMs?: number;
+}
+/**
+ * Locate the rich-markdown sidecar and its inline image directory for a novel
+ * artifact. Pure-text novels (no images dir / no sidecar) return undefined so
+ * the caller can skip enrichment with zero behaviour change.
+ */
+export declare function interpolateEnv(value: string): string;
+export declare function findRichNovelSources(artifact: DownloadedArtifact): {
+    txtPath: string;
+    mdPath: string;
+    imagePaths: string[];
+} | undefined;
+/**
+ * Publish a rich novel (markdown + inline images) to TelePress and return the
+ * Telegraph URL. Client-side only — TelePress owns rendering/Catbox/Telegraph.
+ *
+ * Failures classify as retryable when the endpoint was reached but answered
+ * non-2xx (Transient), and non-retryable when local input is unusable.
+ */
+export declare function publishRichNovelPreview(artifact: DownloadedArtifact, options: RichNovelPublishOptions): Promise<{
+    url: string;
+    retryable: boolean;
+    operatorHint?: string;
+}>;
+//# sourceMappingURL=TelePressRichNovel.d.ts.map

package/dist/delivery/TelePressRichNovel.js

@@ -0,0 +1,167 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interpolateEnv = interpolateEnv;
+exports.findRichNovelSources = findRichNovelSources;
+exports.publishRichNovelPreview = publishRichNovelPreview;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const logger_1 = require("../logger");
+const redact_1 = require("../utils/redact");
+/**
+ * Locate the rich-markdown sidecar and its inline image directory for a novel
+ * artifact. Pure-text novels (no images dir / no sidecar) return undefined so
+ * the caller can skip enrichment with zero behaviour change.
+ */
+function interpolateEnv(value) {
+    return value.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_match, name) => {
+        const resolved = process.env[name];
+        if (resolved === undefined) {
+            throw new Error(`Required TelePress environment variable is not set: ${name}`);
+        }
+        return resolved;
+    });
+}
+function findRichNovelSources(artifact) {
+    if (artifact.type !== 'novel')
+        return undefined;
+    const txtPath = artifact.files.find((f) => /\.txt$/i.test(f));
+    if (!txtPath)
+        return undefined;
+    const mdPath = txtPath.replace(/\.txt$/i, '.md');
+    if (!fs.existsSync(mdPath))
+        return undefined;
+    const imagesDir = path.join(path.dirname(txtPath), 'images');
+    let imagePaths = [];
+    if (fs.existsSync(imagesDir)) {
+        imagePaths = fs
+            .readdirSync(imagesDir)
+            .filter((name) => /\.(jpe?g|png|gif|webp|bmp)$/i.test(name))
+            .map((name) => path.join(imagesDir, name))
+            .sort((a, b) => a.localeCompare(b, undefined, { numeric: true }));
+    }
+    return { txtPath, mdPath, imagePaths };
+}
+/**
+ * Publish a rich novel (markdown + inline images) to TelePress and return the
+ * Telegraph URL. Client-side only — TelePress owns rendering/Catbox/Telegraph.
+ *
+ * Failures classify as retryable when the endpoint was reached but answered
+ * non-2xx (Transient), and non-retryable when local input is unusable.
+ */
+async function publishRichNovelPreview(artifact, options) {
+    const sources = findRichNovelSources(artifact);
+    if (!sources)
+        return { url: '', retryable: false, operatorHint: 'no_rich_novel_assets' };
+    if (sources.imagePaths.length === 0) {
+        return { url: '', retryable: false, operatorHint: 'no_rich_novel_assets' };
+    }
+    const mdName = path.basename(sources.mdPath);
+    const boundary = `telepress-${(0, node_crypto_1.randomUUID)()}`;
+    const fields = [];
+    // Text part for the markdown file.
+    fields.push(Buffer.from(`--${boundary}\r\n` +
+        `Content-Disposition: form-data; name="md"; filename="${escape(mdName)}"\r\n` +
+        `Content-Type: text/markdown\r\n\r\n`));
+    fields.push(await fs.promises.readFile(sources.mdPath));
+    fields.push(Buffer.from('\r\n'));
+    // File parts for each inline image, named with the `images/` prefix so the
+    // relative markdown refs resolve on the receiving side.
+    for (const imagePath of sources.imagePaths) {
+        const name = `images/${path.basename(imagePath)}`;
+        const stat = await fs.promises.stat(imagePath);
+        if (stat.size <= 0)
+            continue;
+        const header = Buffer.from(`--${boundary}\r\n` +
+            `Content-Disposition: form-data; name="images"; filename="${escape(name)}"\r\n` +
+            `Content-Type: application/octet-stream\r\n\r\n`);
+        const data = await fs.promises.readFile(imagePath);
+        fields.push(header, data, Buffer.from('\r\n'));
+    }
+    fields.push(Buffer.from(`--${boundary}--\r\n`));
+    const timeoutMs = options.timeoutMs ?? 60_000;
+    const headers = {
+        'Content-Type': `multipart/form-data; boundary=${boundary}`,
+        'Content-Length': String(fields.reduce((n, b) => n + b.length, 0)),
+        ...options.headers,
+    };
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    timer.unref?.();
+    try {
+        const response = await fetch(options.url, { method: 'POST', headers, body: Buffer.concat(fields), signal: controller.signal });
+        const text = await response.text();
+        let body = text;
+        try {
+            body = JSON.parse(text);
+        }
+        catch { /* plain text */ }
+        if (!response.ok) {
+            logger_1.logger.warn('TelePress rich novel publish returned an error status', {
+                url: (0, redact_1.redactUrl)(options.url),
+                status: response.status,
+                body: String(body).slice(0, 300),
+            });
+            return { url: '', retryable: response.status >= 500 || response.status === 408 || response.status === 429, operatorHint: `telepress_http_${response.status}` };
+        }
+        const data = (body && typeof body === 'object' ? body : undefined);
+        const url = typeof data?.url === 'string' ? data.url : '';
+        if (!url.startsWith('http://') && !url.startsWith('https://')) {
+            return { url: '', retryable: true, operatorHint: 'telepress_invalid_response' };
+        }
+        logger_1.logger.info('TelePress rich novel publish succeeded', {
+            url: (0, redact_1.redactUrl)(url),
+            images: sources.imagePaths.length,
+        });
+        return { url, retryable: false };
+    }
+    catch (error) {
+        const aborted = error?.name === 'AbortError';
+        logger_1.logger.warn('TelePress rich novel publish failed', {
+            url: (0, redact_1.redactUrl)(options.url),
+            retryable: !aborted,
+            reason: aborted ? 'timeout' : String(error),
+        });
+        return { url: '', retryable: !aborted, operatorHint: aborted ? 'telepress_timeout' : 'telepress_network_error' };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function escape(value) {
+    return value.replace(/[\r\n]/g, ' ').replace(/"/g, '%22');
+}
+//# sourceMappingURL=TelePressRichNovel.js.map

package/dist/download/NovelDownloader.js

@@ -38,6 +38,7 @@ const logger_1 = require("../logger");
 const node_path_1 = require("node:path");
 const language_detection_1 = require("../utils/language-detection");
 const novelMarkers_1 = require("./novelMarkers");
+const zip_1 = require("../utils/zip");
 const LANGUAGE_CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
 class NovelDownloader {
     client;
@@ -188,9 +189,11 @@ class NovelDownloader {
         // Rich-media markdown sidecar (RFC 1 Phase 2): same path as the .txt
         // (compat format stays), inline images become relative ![](images/x.jpg)
         // refs so a later TelePress/TelePost phase can render the Telegraph page.
+        let richMediaPath;
         if (assets.some((a) => a.status === 'downloaded')) {
             try {
                 const mdPath = await this.fileService.saveText(`${header}\n${(0, novelMarkers_1.renderNovelMarkdown)(text, assets)}`, fileName.replace(/\.txt$/, '.md'), metadata);
+                richMediaPath = mdPath;
                 logger_1.logger.info(`Saved novel ${detail.id} rich-media markdown sidecar`, { filePath: mdPath });
             }
             catch (error) {
@@ -243,6 +246,33 @@ class NovelDownloader {
         catch (error) {
             logger_1.logger.warn(`Failed to save metadata for novel ${detail.id}: ${error instanceof Error ? error.message : String(error)}`);
         }
+        // Rich-media ZIP archive (Phase 3): a save-only download package carrying
+        // txt + md + metadata + images. The md stays an internal render input, never
+        // a user-facing attachment; txt remains the authoritative/compat file.
+        let archivePath;
+        if (assets.some((a) => a.status === 'downloaded')) {
+            const zipName = this.fileService.sanitizeFileName(`${detail.id}_${detail.title}.zip`);
+            const dest = (0, node_path_1.join)((0, node_path_1.dirname)(filePath), zipName);
+            const entries = [
+                { name: fileName, sourcePath: filePath },
+            ];
+            if (richMediaPath)
+                entries.push({ name: `${fileName.replace(/\.txt$/, '.md')}`, sourcePath: richMediaPath });
+            if (metadataPath)
+                entries.push({ name: `${fileName}.json`, sourcePath: metadataPath });
+            for (const a of assets) {
+                if (a.status === 'downloaded' && a.localPath) {
+                    entries.push({ name: `images/${(0, node_path_1.basename)(a.localPath)}`, sourcePath: a.localPath });
+                }
+            }
+            try {
+                archivePath = await (0, zip_1.createZipArchive)(dest, entries);
+                logger_1.logger.info(`Saved novel ${detail.id} zip archive`, { filePath: archivePath });
+            }
+            catch (error) {
+                logger_1.logger.warn(`Failed to save zip archive for novel ${detail.id}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
         this.database.insertDownload({
             pixivId: String(detail.id),
             type: 'novel',
@@ -264,7 +294,7 @@ class NovelDownloader {
             type: 'novel',
             title: detail.title,
             tags: tags.map((item) => item.name).filter(Boolean),
-            files: [filePath],
+            files: archivePath ? [filePath, archivePath] : [filePath],
             cleanupFiles: metadataPath ? [metadataPath] : [],
             spoiler: (detail.x_restrict ?? 0) > 0,
             xRestrict: detail.x_restrict,

package/dist/download/handlers/NovelTargetHandler.d.ts

@@ -108,5 +108,11 @@ export declare class NovelTargetHandler {
      * second concurrent worker lose this race instead of double-submitting.
      */
     private recordArtifactOutcome;
+    /**
+     * Optional rich-novel preview enrichment (TelePress /publish/rich-novel).
+     * Non-fatal by design: a preview failure never blocks the TXT/ZIP
+     * submission, but it is surfaced with the operational result contract.
+     */
+    private enrichRichNovelPreview;
 }
 //# sourceMappingURL=NovelTargetHandler.d.ts.map

package/dist/download/handlers/NovelTargetHandler.js

@@ -12,6 +12,7 @@ const observability_1 = require("../../observability");
 const context_1 = require("../../observability/context");
 const DownloadPlanner_1 = require("../plan/DownloadPlanner");
 const deliveryContext_1 = require("./deliveryContext");
+const TelePressRichNovel_1 = require("../../delivery/TelePressRichNovel");
 class NovelTargetHandler {
     client;
     database;
@@ -678,7 +679,7 @@ class NovelTargetHandler {
         // candidate and the scan could never advance — the whole point of this
         // change. `releaseCellWork` itself refuses once the cell moved on
         // (delivery_pending/submitted), so a committed identity stays stable.
-        const attempt = this.recordArtifactOutcome(artifact, target);
+        const attempt = await this.recordArtifactOutcome(artifact, target);
         if (attempt.kind === 'skipped' && execution && !recovering) {
             execution.release(workId);
         }
@@ -692,7 +693,7 @@ class NovelTargetHandler {
      * slot as a `duplicate`. The delivery idempotency ledger is what makes the
      * second concurrent worker lose this race instead of double-submitting.
      */
-    recordArtifactOutcome(artifact, target) {
+    async recordArtifactOutcome(artifact, target) {
         const isDelivery = target.storageMode === 'cache' && target.delivery?.target?.trim();
         if (!isDelivery || !this.deliveryService) {
             this.outcomes.push({ kind: 'stored', workId: artifact.pixivId, workType: artifact.type });
@@ -710,9 +711,10 @@ class NovelTargetHandler {
                 },
             };
         }
+        const fields = await this.enrichRichNovelPreview(artifact, target);
         const res = this.deliveryService.enqueue(artifact, target, {
             slotId,
-            fields: target.delivery?.fields,
+            fields: fields ?? target.delivery?.fields,
             extraContext: (0, deliveryContext_1.deliveryContextFields)(target),
         });
         if (res.duplicate) {
@@ -733,6 +735,45 @@ class NovelTargetHandler {
         });
         return { kind: 'selected', workId: artifact.pixivId, workType: artifact.type };
     }
+    /**
+     * Optional rich-novel preview enrichment (TelePress /publish/rich-novel).
+     * Non-fatal by design: a preview failure never blocks the TXT/ZIP
+     * submission, but it is surfaced with the operational result contract.
+     */
+    async enrichRichNovelPreview(artifact, target) {
+        const delivery = target.delivery;
+        if (!delivery?.richNovelPreview?.url)
+            return undefined;
+        if (!(0, TelePressRichNovel_1.findRichNovelSources)(artifact))
+            return undefined;
+        const cfg = delivery.richNovelPreview;
+        const headers = {};
+        for (const [key, value] of Object.entries(cfg.headers ?? {})) {
+            headers[key] = (0, TelePressRichNovel_1.interpolateEnv)(String(value));
+        }
+        const result = await (0, TelePressRichNovel_1.publishRichNovelPreview)(artifact, {
+            url: (0, TelePressRichNovel_1.interpolateEnv)(cfg.url),
+            headers,
+            timeoutMs: cfg.timeoutMs,
+        });
+        const field = cfg.field ?? 'novel_preview_url';
+        if (result.url) {
+            logger_1.logger.info('Rich novel preview URL ready', {
+                pixivId: artifact.pixivId,
+                field,
+                url: result.url.slice(0, 120),
+            });
+            return { ...(target.delivery?.fields ?? {}), [field]: result.url };
+        }
+        logger_1.logger.warn('Rich novel preview skipped', {
+            code: 'NOVEL_PUBLISH_FAILED',
+            stage: 'telepress_publish',
+            retryable: result.retryable,
+            operator_hint: result.operatorHint ?? 'unknown',
+            pixivId: artifact.pixivId,
+        });
+        return undefined;
+    }
 }
 exports.NovelTargetHandler = NovelTargetHandler;
 //# sourceMappingURL=NovelTargetHandler.js.map

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "type": "commonjs",
   "name": "pixivflow",
-  "version": "2.25.0",
+  "version": "2.27.0",
   "private": true
 }

package/dist/utils/zip.d.ts

@@ -0,0 +1,14 @@
+export interface ArchiveEntry {
+    /** Path the file is stored under inside the zip (e.g. "images/001.jpg"). */
+    name: string;
+    /** Absolute path of the file on disk. */
+    sourcePath: string;
+}
+/**
+ * Create a zip archive at `destPath` containing `entries` (order preserved).
+ * Returns destPath on success; on failure removes a partial destination so a
+ * caller never hands a half-written archive to a delivery. Pure FS helper — no
+ * domain logic.
+ */
+export declare function createZipArchive(destPath: string, entries: ArchiveEntry[]): Promise<string>;
+//# sourceMappingURL=zip.d.ts.map

package/dist/utils/zip.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createZipArchive = createZipArchive;
+const node_fs_1 = require("node:fs");
+const node_fs_2 = require("node:fs");
+const node_module_1 = require("node:module");
+// archiver ships no matching TS factory types; bind it at runtime via
+// createRequire and keep a minimal local contract (nothing Pixiv-specific).
+const archiver = (0, node_module_1.createRequire)(__filename)('archiver');
+/**
+ * Create a zip archive at `destPath` containing `entries` (order preserved).
+ * Returns destPath on success; on failure removes a partial destination so a
+ * caller never hands a half-written archive to a delivery. Pure FS helper — no
+ * domain logic.
+ */
+async function createZipArchive(destPath, entries) {
+    const output = (0, node_fs_1.createWriteStream)(destPath);
+    const archive = archiver('zip', { zlib: { level: 9 } });
+    const settled = new Promise((resolve, reject) => {
+        output.on('close', () => resolve(destPath));
+        output.on('error', reject);
+        archive.on('error', reject);
+    });
+    try {
+        archive.pipe(output);
+        for (const e of entries) {
+            archive.file(e.sourcePath, { name: e.name });
+        }
+        await archive.finalize();
+        await settled;
+        await node_fs_2.promises.access(destPath);
+        return destPath;
+    }
+    catch (error) {
+        try {
+            await node_fs_2.promises.rm(destPath, { force: true });
+        }
+        catch {
+            /* best-effort cleanup */
+        }
+        throw new Error(`Failed to create zip archive: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+//# sourceMappingURL=zip.js.map

package/dist/version.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BUILD = void 0;
 // GENERATED by scripts/write-version.js — do not edit manually.
-exports.BUILD = { version: '2.25.0', commit: '532ba3534889' };
+exports.BUILD = { version: '2.27.0', commit: '491a2a8f7abd' };
 //# sourceMappingURL=version.js.map

package/dist/webui/package.json

@@ -1,6 +1,6 @@
 {
   "type": "commonjs",
   "name": "pixivflow-webui-backend",
-  "version": "2.25.0",
+  "version": "2.27.0",
   "description": "PixivFlow WebUI Backend - CommonJS module"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pixivflow",
-  "version": "2.25.0",
-  "description": "\ud83c\udfa8 Pixiv \u4e0b\u8f7d\u3001\u7b5b\u9009\u4e0e\u81ea\u52a8\u6536\u96c6\u5de5\u5177 - \u6279\u91cf\u4e0b\u8f7d\u63d2\u753b\u548c\u5c0f\u8bf4\u3001\u6309\u6807\u7b7e/\u70ed\u5ea6/\u65e5\u671f\u7b5b\u9009\u3001\u5b9a\u65f6\u4efb\u52a1\u4e0e\u53ef\u9760 HTTP \u4ea4\u4ed8 | Pixiv downloader and automation toolkit with filtering, scheduling and reliable HTTP delivery",
+  "version": "2.27.0",
+  "description": "🎨 Pixiv 下载、筛选与自动收集工具 - 批量下载插画和小说、按标签/热度/日期筛选、定时任务与可靠 HTTP 交付 | Pixiv downloader and automation toolkit with filtering, scheduling and reliable HTTP delivery",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/redtidev1918/PixivFlow.git"
@@ -116,6 +116,7 @@
   },
   "dependencies": {
     "@redtidev/pixiv-client": "0.1.0",
+    "archiver": "^7.0.1",
     "axios": "^1.20.0",
     "cors": "^2.8.6",
     "cron-parser": "^4.9.0",