pixivflow 2.20.0 → 2.20.2

package/dist/commands/SchedulerCommand.js

@@ -166,6 +166,14 @@ class SchedulerCommand extends Command_1.BaseCommand {
                             throw new Error('ambiguous target');
                         const plan = plans[0];
                         const target = (0, schedules_1.selectScheduleTargets)(cfg.targets, plan).find((item) => item.id === targetId);
+                        const deliveryName = target.delivery?.target;
+                        const delivery = deliveryName ? cfg.delivery?.targets?.[deliveryName] : undefined;
+                        if (delivery?.type !== 'httpMultipart' || !delivery.refetchOutcomeUrl?.trim()) {
+                            throw new Error('refetch outcome endpoint not configured');
+                        }
+                        if ((target.delivery?.fields?.refetch_request_id ?? delivery.fields?.refetch_request_id) !== '{{refetchRequestId}}') {
+                            throw new Error('refetch_request_id delivery field not configured');
+                        }
                         const now = new Date();
                         const date = new Intl.DateTimeFormat('en-CA', {
                             timeZone: plan.timezone ?? 'UTC', year: 'numeric', month: '2-digit', day: '2-digit',
@@ -193,6 +201,13 @@ class SchedulerCommand extends Command_1.BaseCommand {
                         const started = manager.triggerSchedule(plan.id, { slot, onlyTarget: targetId, triggerSource: 'manual' });
                         return { slotId: slot.slotId, disposition: started ? 'accepted' : 'queued' };
                     },
+                    refetchStatus: (targetId, requestId) => {
+                        const slot = runtime.database.slots.findManualSlot(requestId, targetId);
+                        const cell = slot && runtime.database.slots.getCell(slot.id, targetId);
+                        return slot && cell
+                            ? { requestId, slotId: slot.id, state: cell.status, slotStatus: slot.status }
+                            : null;
+                    },
                     status: (scheduleId) => {
                         const cfg = resolveConfig();
                         const plan = findPlan(cfg, scheduleId);

package/dist/commands/scheduler-runtime.js

@@ -239,6 +239,7 @@ async function createSchedulerRuntime(configPathArg) {
     // Independently-pumped durable outbox (content + notifications). Started in
     // the long-running scheduler daemon; run-once drains explicitly before exit.
     const deliveryDispatcher = new DeliveryDispatcher_1.DeliveryDispatcher(config.delivery, buildProxyUrl(config.network));
+    const notificationPolicy = new NotificationPolicy_1.NotificationPolicy(database, config);
     const outboxWorker = new OutboxWorker_1.OutboxWorker(database, deliveryDispatcher, {
         retryBaseMs: config.delivery?.outboxRetryBaseMs,
         retryMaxMs: config.delivery?.outboxRetryMaxMs,
@@ -246,9 +247,22 @@ async function createSchedulerRuntime(configPathArg) {
         // failed); see settleDeliveryTerminal for the invariant it enforces.
         onDeliveryTerminal: (deliveryId, ack) => {
             (0, settleDeliveryTerminal_1.settleDeliveryTerminal)(database, deliveryId, ack);
+            const delivery = database.deliveries.getById(deliveryId);
+            if (delivery?.slotId && delivery.targetId)
+                notificationPolicy.noteTerminalRefetchCell(delivery.slotId, delivery.targetId);
+        },
+        onDead: (row, error) => {
+            if (!row.deliveryId)
+                return;
+            const delivery = database.deliveries.getById(row.deliveryId);
+            if (!delivery?.slotId || !delivery.targetId)
+                return;
+            new SlotCoordinator_1.SlotCoordinator(database).applyOutcome(delivery.slotId, delivery.targetId, {
+                kind: 'failed', retryable: false, error,
+            });
+            notificationPolicy.noteTerminalRefetchCell(delivery.slotId, delivery.targetId);
         },
     });
-    const notificationPolicy = new NotificationPolicy_1.NotificationPolicy(database, config);
     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.
@@ -363,6 +377,14 @@ async function createSchedulerRuntime(configPathArg) {
                     cancelled = true;
                     slotAbandoned = true;
                     clearInterval(heartbeat);
+                    for (const target of targets) {
+                        if (!target.id)
+                            continue;
+                        if (database.slots.getCell(activeSlot.slotId, target.id)?.status === 'delivery_pending')
+                            continue;
+                        coordinator.applyOutcome(activeSlot.slotId, target.id, { kind: 'failed', retryable: false, error: reason });
+                        notificationPolicy.noteTerminalRefetchCell(activeSlot.slotId, target.id);
+                    }
                     database.slots.markSlotStatus(activeSlot.slotId, 'failed', `abandoned after scheduler timeout; no delivery (${reason})`);
                     coordinator.releaseRunLease(activeSlot.slotId, runOwner);
                     activeLeaseHooks = null;
@@ -384,6 +406,9 @@ async function createSchedulerRuntime(configPathArg) {
         if (slotCtx && runTargets.length === 0) {
             logger_1.logger.info('All slot cells already complete', { slot: slotCtx.slotId });
             coordinator.finish(slotCtx, schedule, targets);
+            for (const target of targets)
+                if (target.id)
+                    notificationPolicy.noteTerminalRefetchCell(slotCtx.slotId, target.id);
             // Release LAST: the slot must stay owned until its aggregate state has
             // been rolled up, otherwise a concurrent trigger could claim and re-run it
             // against a half-finished ledger.
@@ -444,19 +469,11 @@ async function createSchedulerRuntime(configPathArg) {
             }
             coordinator.applyOutcome(scheduleSlot.slotId, target.id, outcome);
             notificationPolicy.noteOutcome(scheduleSlot.slotId, scheduleSlot, schedule, target, outcome);
-            // A remote manual replacement ("重抓") must report its terminal verdict
-            // back to the reviewer. Only terminal outcomes are reported: a candidate
-            // the scan skipped is not a verdict, and a durable delivery intent
-            // ('delivery_pending' / later 'submitted') is reported through the
-            // replacement submission itself (the caller correlates on requestId).
-            const manualRequestId = scheduleSlot.manualRequestId;
-            if (manualRequestId) {
-                const terminal = outcome.kind === 'no_candidate' ||
-                    outcome.kind === 'duplicate' ||
-                    (outcome.kind === 'failed' && !outcome.retryable);
-                if (terminal) {
-                    notificationPolicy.noteRefetchOutcome(scheduleSlot, schedule, target, manualRequestId, outcome);
-                }
+            if (scheduleSlot.manualRequestId && (outcome.kind === 'no_candidate' || outcome.kind === 'duplicate' ||
+                (outcome.kind === 'failed' && !outcome.retryable))) {
+                // Preserve scan bookkeeping; later durable-cell reporting is the
+                // fallback for retry exhaustion, timeout, and outbox dead-letter.
+                notificationPolicy.noteRefetchOutcome(scheduleSlot, schedule, target, scheduleSlot.manualRequestId, outcome);
             }
         });
         if (scheduleSlot) {
@@ -509,6 +526,9 @@ async function createSchedulerRuntime(configPathArg) {
                 //    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.
@@ -527,6 +547,9 @@ async function createSchedulerRuntime(configPathArg) {
         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);
             notificationPolicy.sendSlotSummary(slotCtx, schedule, summary.cells.map((c) => {
                 const t = targets.find((x) => x.id === c.targetId);
                 return {

package/dist/delivery/DeliveryDispatcher.js

@@ -53,8 +53,8 @@ class DeliveryDispatcher {
         if (target.type !== 'httpMultipart') {
             throw new errors_1.ConfigError(`Unsupported delivery target type: ${target.type}`);
         }
-        if (!target.notificationUrl?.trim()) {
-            throw new errors_1.ConfigError(`Delivery target does not configure notificationUrl: ${name}`);
+        if (!(request.refetchOutcome ? target.refetchOutcomeUrl : target.notificationUrl)?.trim()) {
+            throw new errors_1.ConfigError(`Delivery target does not configure ${request.refetchOutcome ? 'refetchOutcomeUrl' : 'notificationUrl'}: ${name}`);
         }
         return new HttpMultipartDelivery_1.HttpMultipartDelivery(target, this.proxyUrl).notifyOnce(request);
     }

package/dist/delivery/HttpMultipartDelivery.js

@@ -161,6 +161,7 @@ class HttpMultipartDelivery {
             method: 'POST',
             headers,
             body: JSON.stringify(body),
+            signal: AbortSignal.timeout(5 * 60_000),
         };
         if (this.dispatcher)
             options.dispatcher = this.dispatcher;
@@ -195,6 +196,7 @@ class HttpMultipartDelivery {
             body: multipart.body,
             headers,
             duplex: 'half',
+            signal: AbortSignal.timeout(5 * 60_000),
         };
         if (this.dispatcher)
             options.dispatcher = this.dispatcher;
@@ -255,6 +257,9 @@ class HttpMultipartDelivery {
         return Object.fromEntries(Object.entries(fields).map(([name, value]) => {
             const values = Array.isArray(value) ? value : [value];
             const rendered = values.map((item) => renderDeliveryTemplate(String(item), variables));
+            if (name === 'refetch_request_id' && rendered.some((item) => /\{\{[^{}]+\}\}/.test(item))) {
+                throw new Error('Unresolved refetch_request_id template');
+            }
             switch (this.config.arrayFormat ?? 'comma') {
                 case 'repeat':
                     return [name, rendered];
@@ -411,6 +416,10 @@ function buildTemplateVariables(request) {
         // key) converges remotely as idempotent_replay instead of being mistaken for
         // a historical duplicate or, worse, double-posting.
         idempotencyKey: c.idempotencyKey ?? '',
+        // Remote manual replacement ("重抓") request UUID; empty for scheduled runs.
+        // Carried through the delivery payload context (extraContext) so the
+        // receiving service can correlate the review with its refetch attempt.
+        refetchRequestId: c.refetchRequestId ?? '',
     };
 }
 /**

package/dist/delivery/types.d.ts

@@ -48,6 +48,12 @@ export interface DeliveryContext {
     bookmarkCount?: number;
     /** Pixiv view count — rendered as {{viewCount}}. */
     viewCount?: number;
+    /**
+     * Request UUID of the remote manual replacement ("重抓") that produced this
+     * delivery; EMPTY for scheduled/original runs. The receiving service uses it
+     * to correlate the review with its durable refetch attempt.
+     */
+    refetchRequestId?: string;
     /**
      * Generic schedule-execution provenance. Attached to scheduled runs only
      * (absent for ad-hoc/manual runs). Delivery-agnostic: any adapter may surface

package/dist/notification/NotificationPolicy.d.ts

@@ -56,6 +56,8 @@ export declare class NotificationPolicy {
      * never enqueue a second verdict for the same logical attempt, and helpers
      * that already returned remain idempotent.
      */
-    noteRefetchOutcome(slot: SlotContext, _schedule: ScheduleConfig, target: TargetConfig, requestId: string, outcome: TargetOutcome): void;
+    noteRefetchOutcome(slot: Pick<SlotContext, 'slotId'>, _schedule: ScheduleConfig, target: TargetConfig, requestId: string, outcome: TargetOutcome): void;
+    /** Report the durable terminal cell, including failures finalized after retry exhaustion. */
+    noteTerminalRefetchCell(slotId: string, targetId: string): void;
 }
 //# sourceMappingURL=NotificationPolicy.d.ts.map

package/dist/notification/NotificationPolicy.js

@@ -172,6 +172,25 @@ class NotificationPolicy {
             });
         }
     }
+    /** Report the durable terminal cell, including failures finalized after retry exhaustion. */
+    noteTerminalRefetchCell(slotId, targetId) {
+        const slot = this.database.slots.getSlot(slotId);
+        const cell = this.database.slots.getCell(slotId, targetId);
+        if (!slot?.manualRequestId || !cell)
+            return;
+        const target = this.config.targets.find((item) => item.id === targetId);
+        if (!target)
+            return;
+        const outcome = cell.status === 'no_candidate'
+            ? { kind: 'no_candidate', reason: cell.lastError ?? 'no eligible candidate' }
+            : cell.status === 'duplicate'
+                ? { kind: 'duplicate', workId: cell.workId ?? '', reason: cell.lastError ?? 'historical duplicate' }
+                : cell.status === 'failed'
+                    ? { kind: 'failed', retryable: false, error: cell.lastError ?? slot.lastError ?? 'manual refetch failed' }
+                    : null;
+        if (outcome)
+            this.noteRefetchOutcome({ slotId }, { id: slot.scheduleId }, target, slot.manualRequestId, outcome);
+    }
 }
 exports.NotificationPolicy = NotificationPolicy;
 /** Fold a CandidateScanSummary into the refetch-outcome bookkeeping (bounded). */

package/dist/package.json

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

package/dist/scheduler/ScheduleTriggerServer.d.ts

@@ -105,6 +105,12 @@ export interface TriggerHandlers {
         slotId: string;
         disposition: string;
     }>;
+    refetchStatus?(targetId: string, requestId: string): {
+        requestId: string;
+        slotId: string;
+        state: string;
+        slotStatus: string;
+    } | null;
 }
 export declare class ScheduleTriggerServer {
     private readonly token;

package/dist/scheduler/ScheduleTriggerServer.js

@@ -194,6 +194,19 @@ class ScheduleTriggerServer {
                 res.status(status).json({ status: 'error', error: status === 500 ? 'refetch admission failed' : message });
             }
         });
+        app.get('/internal/targets/:targetId/refetch/:requestId', this.refetchAuth, (req, res) => {
+            const { targetId, requestId } = req.params;
+            if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(requestId)) {
+                res.status(400).json({ status: 'error', error: 'requestId must be a UUID' });
+                return;
+            }
+            const status = this.handlers.refetchStatus?.(targetId, requestId);
+            if (!status) {
+                res.status(404).json({ status: 'error', error: 'manual refetch not found' });
+                return;
+            }
+            res.json(status);
+        });
         // Convergence endpoint: after a machine stop/start, an operator or an
         // external watcher can ask the process to flush due deliveries/notifications
         // without running candidate selection. Deployment-agnostic (no platform refs).

package/dist/scheduler/SlotCoordinator.js

@@ -168,7 +168,7 @@ class SlotCoordinator {
             const cell = this.database.slots.getCell(slotId, target.id);
             if (!cell)
                 continue;
-            if (cell.status === 'submitted' || cell.status === 'no_candidate')
+            if (cell.status === 'submitted' || cell.status === 'no_candidate' || cell.status === 'duplicate' || cell.status === 'failed')
                 continue;
             // A cell whose work already has a durable delivery intent is NOT the
             // scheduler's to re-run: the OutboxWorker retries the SAME work to a

package/dist/storage/repositories/SlotRepository.d.ts

@@ -53,6 +53,8 @@ export interface SlotItemRecord {
  * the same row instead of emitting a second work for the same slot/target.
  */
 export declare class SlotRepository extends BaseRepository {
+    /** Exact manual request/target lookup for authenticated convergence checks. */
+    findManualSlot(requestId: string, targetId: string): SlotRecord | null;
     /**
      * Fetch an existing slot or create it. On creation the schedule's target
      * membership is snapshotted (target_ids); a later config reload never mutates

package/dist/storage/repositories/SlotRepository.js

@@ -12,6 +12,11 @@ const BaseRepository_1 = require("./BaseRepository");
  * the same row instead of emitting a second work for the same slot/target.
  */
 class SlotRepository extends BaseRepository_1.BaseRepository {
+    /** Exact manual request/target lookup for authenticated convergence checks. */
+    findManualSlot(requestId, targetId) {
+        const rows = this.db.prepare(`SELECT * FROM schedule_slots WHERE manual_request_id = ?`).all(requestId);
+        return rows.map((row) => this.toSlot(row)).find((slot) => slot.targetIds.includes(targetId)) ?? null;
+    }
     /**
      * Fetch an existing slot or create it. On creation the schedule's target
      * membership is snapshotted (target_ids); a later config reload never mutates

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.0', commit: '2229fb7b45a6' };
+exports.BUILD = { version: '2.20.2', commit: 'cdaedd018e4d' };
 //# sourceMappingURL=version.js.map

package/dist/webui/package.json

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

package/package.json

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