pixivflow 2.20.4 → 2.20.5

package/README.en.md

@@ -22,7 +22,9 @@ pixivflow --help
 ```
 
 For servers, prefer the Docker Compose setup described in
-[DOCKER.md](docs/DOCKER.md). To build from source:
+[DOCKER.md](docs/DOCKER.md). To compose PixivFlow with TelePost, use the optional
+[pixivflow-telepost-deploy](https://github.com/redtidev1918/pixivflow-telepost-deploy)
+deployment and operations kit. To build from source:
 
 ```bash
 git clone https://github.com/redtidev1918/PixivFlow.git
@@ -92,8 +94,10 @@ conflict.
 
 Each target can use `storageMode: "persistent"` (the default, keep files) or
 `storageMode: "cache"` (send files to a named delivery target and delete them
-only after success). The delivery layer is service-independent; this example
-merely translates an HTTP multipart submission API into configuration:
+only after success). The delivery layer is service-independent;
+[TelePost](https://github.com/redtidev1918/TelePost) and
+[telepress](https://github.com/redtidev1918/telepress) are example downstreams,
+not dependencies. This example merely translates an HTTP multipart submission API into configuration:
 
 ```json
 {

package/README.md

@@ -22,10 +22,9 @@ npm install -g pixivflow
 pixivflow --help
 ```
 
-服务器部署推荐 Docker Compose，见 [DOCKER.md](docs/DOCKER.md)；
-PixivFlow + TelePost 联合部署套件（含可选代理）：
-[redtidev1918/pixivflow-telepost-deploy](https://github.com/redtidev1918/pixivflow-telepost-deploy)
-—— 一套配置，支持国内/海外、有/无公网 IP、VPS/Fly.io 任意场景。
+服务器部署见 [DOCKER.md](docs/DOCKER.md)。需要把 PixivFlow 与 TelePost 组合运行时，再使用
+[pixivflow-telepost-deploy](https://github.com/redtidev1918/pixivflow-telepost-deploy)；
+它是可选的部署与运维套件。
 从源码构建：
 
 ```bash
@@ -111,7 +110,9 @@ pixivflow scheduler             # 按 cron 配置长期挂机自动收集
 - **`cache`**：下载后投给一个「交付目标」（比如投稿机器人），对方确认收到后才删本地文件，省磁盘。
 
 「交付目标」就是一段配置：告诉 PixivFlow 把文件 POST 到哪个地址、带哪些字段。
-它不绑定具体服务，可指向任何 HTTP 投稿接口（TelePost、telepress 等）。示例：
+它不绑定具体服务，可指向任意兼容的 HTTP 接口；
+[TelePost](https://github.com/redtidev1918/TelePost) 与
+[telepress](https://github.com/redtidev1918/telepress) 只是示例下游。示例：
 
 ```json
 {

package/dist/commands/SchedulerCommand.js

@@ -255,6 +255,9 @@ class SchedulerCommand extends Command_1.BaseCommand {
                             // attempts are exhausted, which does not block exit), so this
                             // cannot hold the machine open indefinitely.
                             pendingOutbox: outbox.pending,
+                            // Second belt: never exit underneath an in-flight slot execution
+                            // even if a durable row ever looks a beat early (§idle-inflight).
+                            activeExecutions: runtime.activeExecutionCount(),
                         };
                     },
                     idleGraceMs: scheduling.idleGraceMs,

package/dist/commands/SchedulerIdleLifecycle.d.ts

@@ -41,6 +41,15 @@ export interface IdleSnapshot {
     processingOutbox: number;
     /** Undelivered outbox rows (pending, or waiting on a bounded retry backoff). */
     pendingOutbox: number;
+    /**
+     * In-process slot executions currently awaiting async work (candidate scan,
+     * download, delivery). This is a SECOND belt behind the durable ledger: even
+     * if a DB row is an instant ahead of its awaiting Promise (or a mis-write
+     * ever terminalized a row early), the idle detector must not exit underneath
+     * a live execution. In-memory only — a process crash still resumes from the
+     * durable slot/outbox rows.
+     */
+    activeExecutions: number;
 }
 /** True only when the worker has no work of any kind left. */
 export declare function isIdle(snapshot: IdleSnapshot): boolean;

package/dist/commands/SchedulerIdleLifecycle.js

@@ -38,7 +38,8 @@ const logger_1 = require("../logger");
 function isIdle(snapshot) {
     return (snapshot.activeSlots === 0 &&
         snapshot.processingOutbox === 0 &&
-        snapshot.pendingOutbox === 0);
+        snapshot.pendingOutbox === 0 &&
+        snapshot.activeExecutions === 0);
 }
 /** Default idle grace: long enough to merge two schedules ~10 minutes apart. */
 exports.DEFAULT_IDLE_GRACE_MS = 10 * 60 * 1000;

package/dist/commands/scheduler-runtime.d.ts

@@ -100,6 +100,14 @@ export interface SchedulerRuntime {
     notifyScheduleFailure(snapshot: StandaloneConfig, schedule: ScheduleConfig, failure: JobFailure): Promise<void>;
     /** Start the independent outbox pump (long-running daemon). */
     startOutboxWorker(): void;
+    /**
+     * Number of slot executions currently awaiting async work in THIS process
+     * (candidate scan / download / delivery). Bounded second belt for the idle
+     * lifecycle: exit is only allowed when this is 0 AND the durable ledger is
+     * empty (§idle-inflight). In-memory only; crash recovery still rides the
+     * durable slot/outbox rows.
+     */
+    activeExecutionCount(): number;
     /** Drain due outbox rows once (run-once / watchdog wake). */
     drainOutbox(): Promise<{
         processed: number;

package/dist/commands/scheduler-runtime.js

@@ -275,6 +275,7 @@ async function createSchedulerRuntime(configPathArg) {
             notificationPolicy.noteTerminalRefetchCell(delivery.slotId, delivery.targetId);
         },
     });
+    let activeExecutions = 0;
     const runJob = async (snapshot, schedule, options = {}) => {
         const { onlyTarget, adhoc = false, slot: providedSlot } = options;
         // A scheduled run is cron by default; an HTTP/manual trigger passes its own.
@@ -546,107 +547,115 @@ async function createSchedulerRuntime(configPathArg) {
             });
             await new Promise((resolve) => setTimeout(resolve, runtimeConfig.initialDelay));
         }
-        logger_1.logger.info('='.repeat(60));
-        logger_1.logger.info('Starting scheduled Pixiv download plan', {
-            scheduleId: schedule.id,
-            slot: slotCtx?.slotId ?? '(ad-hoc)',
-            trigger: triggerSource,
-            targets: runTargets.map((target) => target.id ?? target.tag ?? target.filterTag ?? target.type),
-        });
-        logger_1.logger.info('='.repeat(60));
-        const startTime = Date.now();
-        let allTargetsFailed;
-        let releaseLease = () => undefined;
-        if (slotCtx && varReleaseLease)
-            releaseLease = varReleaseLease;
+        // Execution belt (§idle-inflight): this run is live until releaseLease
+        // completes. The idle detector must see it even if a durable row lags.
+        activeExecutions += 1;
         try {
-            // Candidate fallback passes (§schedule-recovery): after each pass, cells
-            // still mid-fallback (advanced stages) are re-selected with expanded,
-            // still-bounded scan limits. Successful sibling cells are NEVER re-run:
-            // pendingTargets only returns unconverged cells of this slot.
-            for (let pass = 0;; pass += 1) {
-                await downloadManager.runAllTargets();
-                if (!slotCtx || pass >= maxFallbackStages - 1)
-                    break;
-                const pendingFallback = coordinator
-                    .pendingTargets(slotCtx.slotId, targets)
-                    .filter((p) => p.cell &&
-                    p.cell.fallback_stage > 0 &&
-                    p.cell.fallback_stage < maxFallbackStages);
-                if (pendingFallback.length === 0)
-                    break;
-                downloadManager = buildManager(boostedTargets(pendingFallback.map((p) => p.target)));
-                activeDownloadManager = downloadManager;
-                await downloadManager.initialise();
+            logger_1.logger.info('='.repeat(60));
+            logger_1.logger.info('Starting scheduled Pixiv download plan', {
+                scheduleId: schedule.id,
+                slot: slotCtx?.slotId ?? '(ad-hoc)',
+                trigger: triggerSource,
+                targets: runTargets.map((target) => target.id ?? target.tag ?? target.filterTag ?? target.type),
+            });
+            logger_1.logger.info('='.repeat(60));
+            const startTime = Date.now();
+            let allTargetsFailed;
+            let releaseLease = () => undefined;
+            if (slotCtx && varReleaseLease)
+                releaseLease = varReleaseLease;
+            try {
+                // Candidate fallback passes (§schedule-recovery): after each pass, cells
+                // still mid-fallback (advanced stages) are re-selected with expanded,
+                // still-bounded scan limits. Successful sibling cells are NEVER re-run:
+                // pendingTargets only returns unconverged cells of this slot.
+                for (let pass = 0;; pass += 1) {
+                    await downloadManager.runAllTargets();
+                    if (!slotCtx || pass >= maxFallbackStages - 1)
+                        break;
+                    const pendingFallback = coordinator
+                        .pendingTargets(slotCtx.slotId, targets)
+                        .filter((p) => p.cell &&
+                        p.cell.fallback_stage > 0 &&
+                        p.cell.fallback_stage < maxFallbackStages);
+                    if (pendingFallback.length === 0)
+                        break;
+                    downloadManager = buildManager(boostedTargets(pendingFallback.map((p) => p.target)));
+                    activeDownloadManager = downloadManager;
+                    await downloadManager.initialise();
+                }
             }
-        }
-        catch (error) {
-            if (!slotCtx || !(error instanceof Error) || !/^All \d+ target\(s\) failed\./.test(error.message)) {
-                // Abnormal abort. Two very different situations land here, and treating
-                // them as one is what produced the production loop:
-                //
-                //  - this process cancelled itself (scheduler timeout / watchdog) and is
-                //    still alive. It will never touch the Slot again, so releasing the
-                //    lease while leaving the status `running` makes the Slot look exactly
-                //    like a crashed worker: `recoverableSlots()` matches a NULL lease on
-                //    purpose (its "recorded but never claimed" case), so the recovery
-                //    sweep re-dispatches the SAME occurrence on every tick, forever.
-                //    Terminalise it instead: the occurrence is finished, and failed.
-                //
-                //  - the process is going away (`shutdown`). Deliberately leave the Slot
-                //    non-terminal so recovery resumes the same occurrence after restart.
-                if (slotCtx && shouldTerminaliseAbortedSlot(activeAbortOrigin, slotAbandoned)) {
-                    coordinator.finish(slotCtx, schedule, targets);
-                    for (const target of targets)
-                        if (target.id)
-                            notificationPolicy.noteTerminalRefetchCell(slotCtx.slotId, target.id);
+            catch (error) {
+                if (!slotCtx || !(error instanceof Error) || !/^All \d+ target\(s\) failed\./.test(error.message)) {
+                    // Abnormal abort. Two very different situations land here, and treating
+                    // them as one is what produced the production loop:
+                    //
+                    //  - this process cancelled itself (scheduler timeout / watchdog) and is
+                    //    still alive. It will never touch the Slot again, so releasing the
+                    //    lease while leaving the status `running` makes the Slot look exactly
+                    //    like a crashed worker: `recoverableSlots()` matches a NULL lease on
+                    //    purpose (its "recorded but never claimed" case), so the recovery
+                    //    sweep re-dispatches the SAME occurrence on every tick, forever.
+                    //    Terminalise it instead: the occurrence is finished, and failed.
+                    //
+                    //  - the process is going away (`shutdown`). Deliberately leave the Slot
+                    //    non-terminal so recovery resumes the same occurrence after restart.
+                    if (slotCtx && shouldTerminaliseAbortedSlot(activeAbortOrigin, slotAbandoned)) {
+                        coordinator.finish(slotCtx, schedule, targets);
+                        for (const target of targets)
+                            if (target.id)
+                                notificationPolicy.noteTerminalRefetchCell(slotCtx.slotId, target.id);
+                    }
+                    // Hand the lease back either way: a terminal Slot cannot be re-dispatched,
+                    // and a non-terminal one (shutdown) must not wait for its TTL to expire.
+                    releaseLease?.();
+                    throw error;
+                }
+                // Scheduled Slots treat terminal target failures (failed/no_candidate) as
+                // a finished partial/failed aggregate. Finish before returning so the HTTP
+                // trigger can report the durable state instead of 500 and never roll up.
+                allTargetsFailed = error;
+            }
+            finally {
+                if (activeDownloadManager === downloadManager)
+                    activeDownloadManager = null;
+            }
+            const duration = Math.round((Date.now() - startTime) / 1000);
+            if (slotCtx && !slotAbandoned) {
+                const summary = coordinator.finish(slotCtx, schedule, targets);
+                for (const target of targets)
+                    if (target.id)
+                        notificationPolicy.noteTerminalRefetchCell(slotCtx.slotId, target.id);
+                // Terminal summaries are for SCHEDULED occurrences (P0-B). Remote manual
+                // replacements already report through their own verdict channel
+                // (refetchOutcomeUrl); a schedule summary would double-notify the group.
+                if (!slotCtx.manualRequestId) {
+                    notificationPolicy.sendSlotSummary(slotCtx, schedule, summary.cells.map((c) => {
+                        const t = targets.find((x) => x.id === c.targetId);
+                        return {
+                            targetId: c.targetId,
+                            label: c.targetId,
+                            workType: t?.type ?? 'unknown',
+                            status: c.status,
+                            workId: c.workId,
+                            error: c.error ?? null,
+                        };
+                    }));
                 }
-                // Hand the lease back either way: a terminal Slot cannot be re-dispatched,
-                // and a non-terminal one (shutdown) must not wait for its TTL to expire.
-                releaseLease?.();
-                throw error;
+                releaseLease();
             }
-            // Scheduled Slots treat terminal target failures (failed/no_candidate) as
-            // a finished partial/failed aggregate. Finish before returning so the HTTP
-            // trigger can report the durable state instead of 500 and never roll up.
-            allTargetsFailed = error;
+            if (!slotCtx && allTargetsFailed)
+                throw allTargetsFailed;
+            logger_1.logger.info('='.repeat(60));
+            logger_1.logger.info(`Scheduled download plan finished (took ${duration}s)`, {
+                scheduleId: schedule.id,
+                slot: slotCtx?.slotId ?? '(ad-hoc)',
+            });
+            logger_1.logger.info('='.repeat(60));
         }
         finally {
-            if (activeDownloadManager === downloadManager)
-                activeDownloadManager = null;
-        }
-        const duration = Math.round((Date.now() - startTime) / 1000);
-        if (slotCtx && !slotAbandoned) {
-            const summary = coordinator.finish(slotCtx, schedule, targets);
-            for (const target of targets)
-                if (target.id)
-                    notificationPolicy.noteTerminalRefetchCell(slotCtx.slotId, target.id);
-            // Terminal summaries are for SCHEDULED occurrences (P0-B). Remote manual
-            // replacements already report through their own verdict channel
-            // (refetchOutcomeUrl); a schedule summary would double-notify the group.
-            if (!slotCtx.manualRequestId) {
-                notificationPolicy.sendSlotSummary(slotCtx, schedule, summary.cells.map((c) => {
-                    const t = targets.find((x) => x.id === c.targetId);
-                    return {
-                        targetId: c.targetId,
-                        label: c.targetId,
-                        workType: t?.type ?? 'unknown',
-                        status: c.status,
-                        workId: c.workId,
-                        error: c.error ?? null,
-                    };
-                }));
-            }
-            releaseLease();
+            activeExecutions -= 1;
         }
-        if (!slotCtx && allTargetsFailed)
-            throw allTargetsFailed;
-        logger_1.logger.info('='.repeat(60));
-        logger_1.logger.info(`Scheduled download plan finished (took ${duration}s)`, {
-            scheduleId: schedule.id,
-            slot: slotCtx?.slotId ?? '(ad-hoc)',
-        });
-        logger_1.logger.info('='.repeat(60));
     };
     const cancelActive = (reason, origin = 'timeout') => {
         activeAbortOrigin = origin;
@@ -680,6 +689,7 @@ async function createSchedulerRuntime(configPathArg) {
         runJob,
         cancelActive,
         abandonActiveRun,
+        activeExecutionCount: () => activeExecutions,
         startOutboxWorker: () => outboxWorker.start(),
         drainOutbox: () => outboxWorker.drainOnce(),
         notifyScheduleFailure: (snapshot, schedule, failure) => notifyScheduleFailure(snapshot, database, schedule, failure),

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "type": "commonjs",
   "name": "pixivflow",
-  "version": "2.20.4",
+  "version": "2.20.5",
   "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.20.4', commit: '5bb73436b670' };
+exports.BUILD = { version: '2.20.5', commit: '9352c0253571' };
 //# sourceMappingURL=version.js.map

package/dist/webui/package.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pixivflow",
-  "version": "2.20.4",
+  "version": "2.20.5",
   "description": "🎨 智能的 Pixiv 自动化下载工具 - 支持批量下载插画和小说、定时任务、Docker部署 | Intelligent Pixiv Automation Downloader with batch download, scheduler, and Docker support",
   "repository": {
     "type": "git",