pixivflow 2.26.0 → 2.27.1

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/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.26.0",
+  "version": "2.27.1",
   "private": true
 }

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.26.0', commit: '299b0e29cecb' };
+exports.BUILD = { version: '2.27.1', commit: 'f16587443719' };
 //# sourceMappingURL=version.js.map

package/dist/webui/package.json

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pixivflow",
-  "version": "2.26.0",
-  "description": "🎨 Pixiv 下载、筛选与自动收集工具 - 批量下载插画和小说、按标签/热度/日期筛选、定时任务与可靠 HTTP 交付 | Pixiv downloader and automation toolkit with filtering, scheduling and reliable HTTP delivery",
+  "version": "2.27.1",
+  "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",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/redtidev1918/PixivFlow.git"