pixivflow 2.19.5 → 2.20.1

package/dist/scheduler/SlotCoordinator.js

@@ -25,6 +25,31 @@ function deliveryTargetOf(target) {
     const name = target.delivery?.target;
     return typeof name === 'string' && name.trim() ? name.trim() : null;
 }
+/**
+ * SQLite `CURRENT_TIMESTAMP` is UTC "YYYY-MM-DD HH:MM:SS". It carries no zone
+ * marker, and `Date.parse` reads that shape as LOCAL time — so the zone is
+ * added explicitly instead of being trusted to the engine.
+ */
+function sqliteUtcMs(value) {
+    if (!value)
+        return undefined;
+    const normalized = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/.test(value)
+        ? `${value.replace(' ', 'T')}Z`
+        : value;
+    const ms = Date.parse(normalized);
+    return Number.isNaN(ms) ? undefined : ms;
+}
+/**
+ * Epoch ms -> ISO 8601 UTC, or undefined when it is not a usable instant.
+ * `toISOString` throws on an out-of-range Date, and a throw here would abort the
+ * terminal rollup — a logging field must never be able to break dispatch.
+ */
+function isoUtcOrUndefined(epochMs) {
+    if (typeof epochMs !== 'number' || !Number.isFinite(epochMs))
+        return undefined;
+    const date = new Date(epochMs);
+    return Number.isNaN(date.getTime()) ? undefined : date.toISOString();
+}
 /**
  * Owns the Schedule Slot ledger for one scheduler run. A Slot is one durable
  * execution occurrence of a Schedule (NOT a morning/evening row). It ensures
@@ -102,6 +127,8 @@ class SlotCoordinator {
             triggerSource: slot.triggerSource,
             slotDate: slot.slotDate,
             slotName: slot.slotName,
+            manualRequestId: slot.manualRequestId ?? null,
+            correlationId: slot.correlationId ?? null,
         });
         if (created) {
             // Freeze membership: materialize one cell per target id from the snapshot.
@@ -347,25 +374,139 @@ class SlotCoordinator {
         }
         const status = this.database.slots.deriveSlotStatus(slot.slotId);
         this.database.slots.markSlotStatus(slot.slotId, status);
-        this.persistExecutionSummary(slot.slotId, status);
         const cells = this.database.slots.getCells(slot.slotId).map((c) => ({
             targetId: c.targetId,
             status: c.status,
             workId: c.workId,
             error: c.lastError,
         }));
+        // Rolled up AFTER the slot row carries its terminal status/completed_at, so
+        // the outcome reports the durable timestamps rather than a fresh clock read.
+        this.persistExecutionSummary(slot.slotId, status, this.scheduleOutcome(slot, status, targets));
         const icon = (s) => s === 'submitted' ? '✅' : s === 'no_candidate' ? '⚠️ no_candidate' : '❌ failed';
         logger_1.logger.info(`Slot ${slot.slotId} ${status}\n` +
             cells.map((c) => `  ${c.targetId.padEnd(28)} ${icon(c.status)} ${c.workId ? '#' + c.workId : ''} ${c.error ? '(' + c.error + ')' : ''}`).join('\n'), { slot: slot.slotId, status });
         return { scheduleId: schedule.id, slotId: slot.slotId, status, alreadyCompleted: false, cells };
     }
+    /**
+     * Project the terminal slot row into the one structured outcome record. Every
+     * field comes from durable state — the slot row, its cells, and the delivery
+     * ledger. Nothing is inferred from error-message text.
+     */
+    scheduleOutcome(slot, status, targets) {
+        const slotRec = this.database.slots.getSlot(slot.slotId);
+        const cellRows = this.database.slots.getCells(slot.slotId);
+        // Only targets the caller still knows about can name a delivery channel; a
+        // cell with no known channel has no delivery fact to consult.
+        const deliveryTargetByTargetId = new Map();
+        for (const target of targets) {
+            const deliveryTarget = deliveryTargetOf(target);
+            if (target.id && deliveryTarget)
+                deliveryTargetByTargetId.set(target.id, deliveryTarget);
+        }
+        let submitted = 0;
+        let no_match = 0;
+        let duplicate = 0;
+        let executor_failed = 0;
+        let delivery_failed = 0;
+        const targetsDetail = cellRows.map((cell) => {
+            const classified = this.classifyCell(cell.status, slot.slotId, cell.targetId, deliveryTargetByTargetId);
+            if (classified === 'submitted')
+                submitted += 1;
+            else if (classified === 'no_match')
+                no_match += 1;
+            else if (classified === 'duplicate')
+                duplicate += 1;
+            else if (classified === 'delivery_failed')
+                delivery_failed += 1;
+            else if (classified === 'executor_failed')
+                executor_failed += 1;
+            return {
+                target_id: cell.targetId,
+                status: cell.status,
+                work_id: cell.workId,
+                error: cell.lastError,
+            };
+        });
+        // A fully-submitted slot has no non-submitted cell at all, and reporting
+        // `all_duplicates` there would be a lie — so the count must be non-zero.
+        const nonSubmitted = cellRows.length - submitted;
+        const all_duplicates = nonSubmitted > 0 && duplicate === nonSubmitted;
+        const startedMs = sqliteUtcMs(slotRec?.startedAt);
+        const completedMs = sqliteUtcMs(slotRec?.completedAt);
+        const duration_ms = startedMs !== undefined && completedMs !== undefined
+            ? Math.max(0, completedMs - startedMs)
+            : undefined;
+        const occurrenceAt = slotRec?.occurrenceAt ?? slot.occurrenceAt;
+        return {
+            event: 'schedule.outcome',
+            schedule_id: slotRec?.scheduleId ?? slot.scheduleId,
+            slot_id: slot.slotId,
+            occurrence_at: isoUtcOrUndefined(occurrenceAt),
+            occurrence_date: slotRec?.occurrenceDate ?? slot.occurrenceDate,
+            status: status,
+            duration_ms,
+            cells: {
+                total: cellRows.length,
+                submitted,
+                no_match,
+                duplicate,
+                all_duplicates,
+                executor_failed,
+                delivery_failed,
+                targets: targetsDetail,
+            },
+        };
+    }
+    /**
+     * One cell -> one business category. `delivery_failed` is derived from the
+     * durable delivery ledger through the SAME port the FSM already uses, never
+     * from an error string, and it is decided BEFORE `executor_failed` because a
+     * terminally lost delivery also leaves the cell `failed`: one cause, one count.
+     */
+    classifyCell(cellStatus, slotId, targetId, deliveryTargetByTargetId) {
+        if (cellStatus === 'submitted')
+            return 'submitted';
+        if (cellStatus === 'no_candidate')
+            return 'no_match';
+        if (cellStatus === 'duplicate')
+            return 'duplicate';
+        const deliveryTarget = deliveryTargetByTargetId.get(targetId);
+        if (deliveryTarget && this.delivery) {
+            try {
+                const state = this.delivery.stateFor({ deliveryTarget, slotId, targetId });
+                if (state.kind === 'lost')
+                    return 'delivery_failed';
+            }
+            catch (error) {
+                // Observability must never break the rollup.
+                logger_1.logger.debug('Delivery state unavailable for outcome rollup', {
+                    slot: slotId,
+                    target: targetId,
+                    error: error.message,
+                });
+            }
+        }
+        if (cellStatus === 'failed')
+            return 'executor_failed';
+        // Non-terminal (delivery_pending / artifact_ready): such a slot is not
+        // terminal either, so no outcome record is written for it at all.
+        return 'other';
+    }
     /**
      * Persist a one-row incident/execution summary into delivery_events
      * (event='execution.summary') at the terminal rollup only. Event-row storage
      * reuses the audit table + `runs show` read path instead of inventing a
      * summary table or overloading execution_log's illustration/novel typing.
+     *
+     * The `schedule.outcome` line is emitted HERE, immediately after that durable
+     * write and behind the SAME `hasExecutionSummary` dedupe, because the summary
+     * row is the occurrence-level terminal identity that already exists. Recovery
+     * that re-rolls the same terminal slot therefore logs nothing a second time,
+     * with no shadow ledger and no second event name. The identical object goes to
+     * both sinks, so the line and the row cannot disagree.
      */
-    persistExecutionSummary(slotId, status) {
+    persistExecutionSummary(slotId, status, outcome) {
         if (status !== 'success' && status !== 'partial' && status !== 'failed')
             return;
         try {
@@ -377,8 +518,9 @@ class SlotCoordinator {
                 slotId,
                 event: 'execution.summary',
                 countsAsAttempt: 0,
-                detail: { summary },
+                detail: { summary, outcome },
             });
+            logger_1.logger.info('Schedule occurrence reached a terminal outcome', outcome);
         }
         catch (error) {
             logger_1.logger.debug('Failed to persist execution summary', { slot: slotId, error: error.message });

package/dist/storage/DatabaseMigration.js

@@ -99,6 +99,15 @@ class DatabaseMigration {
             lease_owner TEXT,
             lease_until INTEGER,
             heartbeat_at INTEGER,
+            -- Request UUID of a remote manual replacement ("重抓"). NULL for a
+            -- scheduled occurrence. Persisted in the SAME transaction that
+            -- opens the manual slot, so the acceptance ACK and the caller's
+            -- retry converge on one row instead of racing a second slot.
+            manual_request_id TEXT,
+            -- Opaque caller correlation (review chain / review id). Recorded so
+            -- the terminal outcome can be reported back to the requester
+            -- without this service learning anything about the review.
+            correlation_id TEXT,
             created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
             started_at DATETIME,
             completed_at DATETIME,
@@ -227,6 +236,8 @@ class DatabaseMigration {
                 lease_owner: 'ALTER TABLE schedule_slots ADD COLUMN lease_owner TEXT',
                 lease_until: 'ALTER TABLE schedule_slots ADD COLUMN lease_until INTEGER',
                 heartbeat_at: 'ALTER TABLE schedule_slots ADD COLUMN heartbeat_at INTEGER',
+                manual_request_id: 'ALTER TABLE schedule_slots ADD COLUMN manual_request_id TEXT',
+                correlation_id: 'ALTER TABLE schedule_slots ADD COLUMN correlation_id TEXT',
             };
             const columnAlters = [];
             for (const [col, sql] of Object.entries(slotColumnMigrations)) {

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

@@ -25,6 +25,10 @@ export interface SlotRecord {
     leaseOwner: string | null;
     leaseUntil: number | null;
     heartbeatAt: number | null;
+    /** Request UUID of a remote manual replacement; null for scheduled slots. */
+    manualRequestId: string | null;
+    /** Opaque caller correlation (review chain / review id); null unless manual. */
+    correlationId: string | null;
 }
 export interface SlotItemRecord {
     id: number;
@@ -65,6 +69,10 @@ export declare class SlotRepository extends BaseRepository {
         triggerSource?: string;
         slotDate?: string;
         slotName?: string;
+        /** Remote manual replacement request UUID (opens a `manual-` slot). */
+        manualRequestId?: string | null;
+        /** Opaque caller correlation recorded with a manual slot. */
+        correlationId?: string | null;
     }): {
         slot: SlotRecord;
         created: boolean;

package/dist/storage/repositories/SlotRepository.js

@@ -21,10 +21,10 @@ class SlotRepository extends BaseRepository_1.BaseRepository {
     getOrCreateSlot(id, data) {
         const insert = this.db.prepare(`INSERT INTO schedule_slots
          (id, schedule_id, occurrence_at, occurrence_date, occurrence_label, timezone, target_ids,
-          status, trigger_source, slot_date, slot_name)
+          status, trigger_source, slot_date, slot_name, manual_request_id, correlation_id)
        VALUES
          (@id, @scheduleId, @occurrenceAt, @occurrenceDate, @occurrenceLabel, @timezone, @targetIds,
-          'pending', @triggerSource, @slotDate, @slotName)
+          'pending', @triggerSource, @slotDate, @slotName, @manualRequestId, @correlationId)
        ON CONFLICT(id) DO NOTHING`);
         const info = insert.run({
             id,
@@ -37,6 +37,8 @@ class SlotRepository extends BaseRepository_1.BaseRepository {
             triggerSource: data.triggerSource ?? null,
             slotDate: data.slotDate ?? data.occurrenceDate ?? '',
             slotName: data.slotName ?? '',
+            manualRequestId: data.manualRequestId ?? null,
+            correlationId: data.correlationId ?? null,
         });
         const created = info.changes > 0;
         return { slot: this.getSlot(id), created };
@@ -359,6 +361,8 @@ class SlotRepository extends BaseRepository_1.BaseRepository {
             leaseOwner: row.lease_owner ?? null,
             leaseUntil: row.lease_until ?? null,
             heartbeatAt: row.heartbeat_at ?? null,
+            manualRequestId: row.manual_request_id ?? null,
+            correlationId: row.correlation_id ?? null,
         };
     }
     toItem(row) {

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.19.5', commit: '945772649d9f' };
+exports.BUILD = { version: '2.20.1', commit: '834a545f7368' };
 //# sourceMappingURL=version.js.map

package/dist/webui/package.json

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

package/package.json

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