pixivflow 2.22.0 → 2.23.0

package/dist/observability/index.js

@@ -0,0 +1,36 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifySystemError = void 0;
+exports.recordSystemError = recordSystemError;
+const logger_1 = require("../logger");
+const classify_1 = require("./classify");
+var classify_2 = require("./classify");
+Object.defineProperty(exports, "classifySystemError", { enumerable: true, get: function () { return classify_2.classifySystemError; } });
+__exportStar(require("./types"), exports);
+/** Record a structured system error with taxonomy; never throws. */
+function recordSystemError(database, input, classified = null) {
+    try {
+        const cls = classified ?? (0, classify_1.classifySystemError)(new Error(input.message), input.http_status ?? null, input.stage);
+        database.systemErrors.record({ ...input, ...cls });
+        logger_1.logger.error(`system_error recorded`, { error_type: cls.error_type, retryable: cls.retryable, ...input });
+    }
+    catch (error) {
+        // Observability must never break the business path.
+        console.error('Failed to persist system error', error);
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/observability/types.d.ts

@@ -0,0 +1,23 @@
+export type SystemErrorType = 'PIXIV_AUTH_FAILED' | 'PIXIV_RATE_LIMITED' | 'PIXIV_NOT_FOUND' | 'PIXIV_CDN_FORBIDDEN' | 'NETWORK_TIMEOUT' | 'DOWNLOAD_CORRUPTED' | 'IMAGE_PROCESS_FAILED' | 'TELEGRAM_UPLOAD_FAILED' | 'CONFIG_ERROR' | 'INTERNAL_ERROR';
+export interface SystemErrorClassification {
+    error_type: SystemErrorType;
+    retryable: boolean;
+}
+export interface SystemErrorInput extends Partial<SystemErrorClassification> {
+    service?: string;
+    component?: string;
+    bot_id?: string;
+    schedule_id?: string;
+    slot_id?: string;
+    pixiv_id?: string;
+    stage?: string;
+    message: string;
+    http_status?: number | null;
+    trace_id?: string;
+}
+export interface SystemErrorRow extends SystemErrorInput {
+    id: number;
+    created_at: string;
+    resolved_at: string | null;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/observability/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/package.json

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

package/dist/scheduler/RecoveryOutcome.d.ts

@@ -0,0 +1,24 @@
+import type { SlotItemRecord } from '../storage/repositories/SlotRepository';
+/**
+ * Business outcome for one manual recovery request (「放宽条件重试」).
+ *
+ * Deliberately NOT the raw execution cell status: a recovery that found only
+ * already-published works is a NORMAL end (`recovery_duplicate_only`), never an
+ * `internal_error`. Callers (ScheduleTriggerServer / Mini App) get the
+ * user-facing `message` and admin-facing `business_state` together so the UI
+ * never has to translate internal terms.
+ */
+export type RecoveryOutcomeState = 'recovery_pending' | 'recovery_running' | 'recovery_success' | 'recovery_no_candidate' | 'recovery_duplicate_only' | 'recovery_failed';
+export declare function recoveryUserMessage(state: RecoveryOutcomeState): string;
+/**
+ * Map one durable recovery cell to a recovery business outcome.
+ *
+ * - terminal `submitted` (+ workId) → success
+ * - terminal `no_candidate` with terminal reason `duplicate_exhausted` →
+ *   duplicate_only
+ * - terminal `no_candidate` otherwise → no_candidate
+ * - terminal `failed` → failed
+ * - non-terminal (`pending`/`selected`/`running`/`delivery_pending`) → running/pending
+ */
+export declare function recoveryOutcomeFor(cell: SlotItemRecord | null): RecoveryOutcomeState;
+//# sourceMappingURL=RecoveryOutcome.d.ts.map

package/dist/scheduler/RecoveryOutcome.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recoveryUserMessage = recoveryUserMessage;
+exports.recoveryOutcomeFor = recoveryOutcomeFor;
+const USER_MESSAGES = {
+    recovery_pending: '正在等待恢复任务...',
+    recovery_running: '正在尝试扩大搜索范围...',
+    recovery_success: '恢复成功，已找到并发布新作品。',
+    recovery_no_candidate: '扩大搜索范围后，仍未找到符合条件的新作品。\n任务已正常结束。',
+    recovery_duplicate_only: '扩大搜索范围后，找到的作品均已发布过。\n没有新的内容可发布。',
+    recovery_failed: '恢复任务执行失败。\n请查看日志或稍后重试。',
+};
+function recoveryUserMessage(state) {
+    return USER_MESSAGES[state];
+}
+/**
+ * Map one durable recovery cell to a recovery business outcome.
+ *
+ * - terminal `submitted` (+ workId) → success
+ * - terminal `no_candidate` with terminal reason `duplicate_exhausted` →
+ *   duplicate_only
+ * - terminal `no_candidate` otherwise → no_candidate
+ * - terminal `failed` → failed
+ * - non-terminal (`pending`/`selected`/`running`/`delivery_pending`) → running/pending
+ */
+function recoveryOutcomeFor(cell) {
+    if (!cell)
+        return 'recovery_pending';
+    if (cell.status === 'submitted')
+        return 'recovery_success';
+    if (cell.status === 'no_candidate') {
+        return cell.terminalReasonCode === 'duplicate_exhausted'
+            ? 'recovery_duplicate_only'
+            : 'recovery_no_candidate';
+    }
+    if (cell.status === 'duplicate')
+        return 'recovery_duplicate_only';
+    if (cell.status === 'failed')
+        return 'recovery_failed';
+    if (['pending', 'selected', 'artifact_ready', 'delivery_pending'].includes(cell.status))
+        return 'recovery_running';
+    return 'recovery_pending';
+}
+//# sourceMappingURL=RecoveryOutcome.js.map

package/dist/scheduler/ScheduleTriggerServer.d.ts

@@ -126,6 +126,10 @@ export interface TriggerHandlers {
         slotId: string;
         state: string;
         slotStatus: string;
+        /** Recovery business outcome (recovery_success / no_candidate / duplicate_only / failed / running / pending). */
+        business_state?: string;
+        /** User-facing copy; never leaks internal error names. */
+        message?: string;
     } | null;
 }
 export declare class ScheduleTriggerServer {

package/dist/scheduler/SlotBusinessStatus.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Business outcome taxonomy for one schedule occurrence.
+ *
+ * RULES (intent):
+ * - "no content to publish" is a NORMAL endpoint, not a system failure.
+ * - System failures (pixiv/network/download/processing/delivery) must be kept
+ *   disjoint from business no-content states so monitoring and Mini App never
+ *   show "internal_error" for an empty but healthy run.
+ *
+ * This is a DERIVED verdict over the existing terminal cell ledger; it does not
+ * change the persisted slot phase machine (pending/running/success/partial/
+ * failed remain untouched for ledger compatibility).
+ */
+export type SlotBusinessStatus = 'success' | 'partial_success' | 'no_candidate' | 'duplicate_only' | 'failed';
+export interface SlotBusinessCounts {
+    total: number;
+    submitted: number;
+    no_match: number;
+    duplicate: number;
+    /** Count of no_candidate cells whose terminal reason is duplicate_exhausted. */
+    duplicate_exhausted?: number;
+    executor_failed: number;
+    delivery_failed: number;
+}
+/** Pure projection: durable cell counts -> one business verdict. No I/O. */
+export declare function classifySlotBusinessStatus(counts: SlotBusinessCounts): SlotBusinessStatus;
+/**
+ * User-facing (Mini App / notification) copy for a terminal business status.
+ * Internal error names (OperationCancelledError, internal_error) never leak.
+ */
+export declare function userMessageForSlotBusinessStatus(status: SlotBusinessStatus): string;
+//# sourceMappingURL=SlotBusinessStatus.d.ts.map

package/dist/scheduler/SlotBusinessStatus.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifySlotBusinessStatus = classifySlotBusinessStatus;
+exports.userMessageForSlotBusinessStatus = userMessageForSlotBusinessStatus;
+/** Pure projection: durable cell counts -> one business verdict. No I/O. */
+function classifySlotBusinessStatus(counts) {
+    const nonSubmitted = counts.total - counts.submitted;
+    const systemFailed = counts.executor_failed > 0 || counts.delivery_failed > 0;
+    const allNoContentAsDuplicate = counts.duplicate + (counts.duplicate_exhausted ?? 0) === nonSubmitted;
+    if (counts.submitted > 0 && nonSubmitted === 0)
+        return 'success';
+    if (counts.submitted > 0)
+        return 'partial_success';
+    if (nonSubmitted === 0)
+        return 'success'; // defensive: 0 targets / all submitted
+    if (!systemFailed) {
+        // Every non-submitted cell was a BUSINESS no-content verdict; all of them
+        // came from already-delivered candidates => duplicate_only.
+        if (allNoContentAsDuplicate)
+            return 'duplicate_only';
+        return 'no_candidate';
+    }
+    return 'failed';
+}
+/**
+ * User-facing (Mini App / notification) copy for a terminal business status.
+ * Internal error names (OperationCancelledError, internal_error) never leak.
+ */
+function userMessageForSlotBusinessStatus(status) {
+    switch (status) {
+        case 'success':
+            return '任务完成，已发布本轮内容。';
+        case 'partial_success':
+            return '任务部分完成，部分内容已发布。';
+        case 'no_candidate':
+            return '本轮没有发现新的可发布作品。任务已正常完成。';
+        case 'duplicate_only':
+            return '本轮没有发现新的可发布作品。任务已正常完成。';
+        case 'failed':
+            return '本轮任务遇到系统异常，请稍后重试或检查日志。';
+    }
+}
+//# sourceMappingURL=SlotBusinessStatus.js.map

package/dist/scheduler/SlotCoordinator.d.ts

@@ -3,6 +3,7 @@ import { Database } from '../storage/Database';
 import { CellStatus, SlotItemRecord, SlotRecord, SlotStatus } from '../storage/repositories/SlotRepository';
 import { TriggerSource } from './OccurrenceResolver';
 import { TargetOutcome } from './TargetOutcome';
+import { SlotBusinessStatus } from './SlotBusinessStatus';
 import { TargetExecutionContext, WorkBinding } from './WorkIdentity';
 /**
  * Execution-lease TTL and heartbeat cadence.
@@ -113,11 +114,17 @@ export interface ScheduleOutcomeCells {
  */
 export interface ScheduleOutcomeRecord {
     event: 'schedule.outcome';
+    /** Outcome taxonomy version; bump when business_status/reason gains codes. */
+    outcome_version: 1;
     schedule_id: string;
     slot_id: string;
     occurrence_at: string | undefined;
     occurrence_date: string;
     status: ScheduleOutcomeStatus;
+    /** Derived business verdict: success / partial_success / no_candidate / duplicate_only / failed. */
+    business_status: SlotBusinessStatus;
+    /** Monitoring gate: true only for system failures (business_status === 'failed'). */
+    alertable: boolean;
     /** From the slot row's own started_at/completed_at columns, when both exist. */
     duration_ms: number | undefined;
     cells: ScheduleOutcomeCells;

package/dist/scheduler/SlotCoordinator.js

@@ -5,6 +5,7 @@ exports.timezoneForSchedule = timezoneForSchedule;
 const logger_1 = require("../logger");
 const OccurrenceResolver_1 = require("./OccurrenceResolver");
 const TargetOutcome_1 = require("./TargetOutcome");
+const SlotBusinessStatus_1 = require("./SlotBusinessStatus");
 const WorkIdentity_1 = require("./WorkIdentity");
 /**
  * Execution-lease TTL and heartbeat cadence.
@@ -504,13 +505,25 @@ class SlotCoordinator {
             ? Math.max(0, completedMs - startedMs)
             : undefined;
         const occurrenceAt = slotRec?.occurrenceAt ?? slot.occurrenceAt;
+        const businessStatus = (0, SlotBusinessStatus_1.classifySlotBusinessStatus)({
+            total: cellRows.length,
+            submitted,
+            no_match,
+            duplicate,
+            duplicate_exhausted: targetsDetail.filter((t) => t.terminal_reason_code === 'duplicate_exhausted').length,
+            executor_failed,
+            delivery_failed,
+        });
         return {
             event: 'schedule.outcome',
+            outcome_version: 1,
             schedule_id: slotRec?.scheduleId ?? slot.scheduleId,
             slot_id: slot.slotId,
             occurrence_at: isoUtcOrUndefined(occurrenceAt),
             occurrence_date: slotRec?.occurrenceDate ?? slot.occurrenceDate,
             status: status,
+            business_status: businessStatus,
+            alertable: businessStatus === 'failed',
             duration_ms,
             cells: {
                 total: cellRows.length,

package/dist/storage/Database.d.ts

@@ -4,6 +4,7 @@ import { DeliveryRepository } from './repositories/DeliveryRepository';
 import { OutboxRepository } from './repositories/OutboxRepository';
 import { MetadataRepository } from './repositories/MetadataRepository';
 import { SQLiteRateLimitStateStore } from './repositories/RateLimitStateRepository';
+import { SystemErrorRepository } from './repositories/SystemErrorRepository';
 export interface AccessTokenStore {
     accessToken: string;
     expiresAt: number;
@@ -46,6 +47,7 @@ export declare class Database implements IDatabase {
     private outboxRepo;
     private metadataRepo;
     private rateLimitStateStore;
+    private systemErrorRepo;
     constructor(databasePath: string);
     migrate(): void;
     /** Absolute path of the SQLite file (used to locate sibling cache dirs). */
@@ -60,6 +62,8 @@ export declare class Database implements IDatabase {
     get metadata(): MetadataRepository;
     /** Persistent 429 gate state adapter for @redtidev/pixiv-client. */
     get rateLimitState(): SQLiteRateLimitStateStore;
+    /** Durable system-error ledger (observability; never throws). */
+    get systemErrors(): SystemErrorRepository;
     /** Raw transactional boundary for atomic multi-table intents. */
     transaction<T>(fn: () => T): T;
     /** Expose a prepared-statement helper if needed by services (pragmas etc). */

package/dist/storage/Database.js

@@ -17,6 +17,7 @@ const DeliveryRepository_1 = require("./repositories/DeliveryRepository");
 const OutboxRepository_1 = require("./repositories/OutboxRepository");
 const MetadataRepository_1 = require("./repositories/MetadataRepository");
 const RateLimitStateRepository_1 = require("./repositories/RateLimitStateRepository");
+const SystemErrorRepository_1 = require("./repositories/SystemErrorRepository");
 const NodeSqliteDriver_1 = require("./drivers/NodeSqliteDriver");
 class Database {
     databasePath;
@@ -33,6 +34,7 @@ class Database {
     outboxRepo;
     metadataRepo;
     rateLimitStateStore;
+    systemErrorRepo;
     constructor(databasePath) {
         this.databasePath = databasePath;
         try {
@@ -60,6 +62,7 @@ class Database {
             this.outboxRepo = new OutboxRepository_1.OutboxRepository(this.db);
             this.metadataRepo = new MetadataRepository_1.MetadataRepository(this.db);
             this.rateLimitStateStore = new RateLimitStateRepository_1.SQLiteRateLimitStateStore(this.db);
+            this.systemErrorRepo = new SystemErrorRepository_1.SystemErrorRepository(this.db);
         }
         catch (error) {
             throw new errors_1.DatabaseError(`Failed to initialize database at ${this.databasePath}`, error instanceof Error ? error : undefined);
@@ -95,6 +98,10 @@ class Database {
     get rateLimitState() {
         return this.rateLimitStateStore;
     }
+    /** Durable system-error ledger (observability; never throws). */
+    get systemErrors() {
+        return this.systemErrorRepo;
+    }
     /** Raw transactional boundary for atomic multi-table intents. */
     transaction(fn) {
         return this.db.transaction(fn)();

package/dist/storage/DatabaseMigration.js

@@ -222,6 +222,27 @@ class DatabaseMigration {
             state TEXT NOT NULL,
             updated_at INTEGER NOT NULL
           )`,
+                // Durable error event ledger for observability (structured error
+                // taxonomy; populated by download/system handlers and shown in the
+                // admin API). Append-only until an operator marks a row resolved.
+                `CREATE TABLE IF NOT EXISTS system_errors (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            service TEXT NOT NULL DEFAULT 'pixivflow',
+            component TEXT,
+            bot_id TEXT,
+            schedule_id TEXT,
+            slot_id TEXT,
+            pixiv_id TEXT,
+            stage TEXT,
+            error_type TEXT NOT NULL,
+            message TEXT,
+            http_status INTEGER,
+            retryable INTEGER NOT NULL DEFAULT 0,
+            trace_id TEXT,
+            created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+            resolved_at DATETIME
+          )`,
+                `CREATE INDEX IF NOT EXISTS idx_system_errors_bot_created ON system_errors(bot_id, created_at)`,
             ];
             // Phase 1: create tables (idempotent). Must run before any PRAGMA-based
             // column check, otherwise a fresh DB would report the table as missing and

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

@@ -0,0 +1,19 @@
+import { BaseRepository } from './BaseRepository';
+import { SystemErrorInput, SystemErrorRow } from '../../observability/types';
+export declare class SystemErrorRepository extends BaseRepository {
+    record(input: SystemErrorInput): void;
+    list(opts?: {
+        limit?: number;
+        errorType?: string;
+        botId?: string;
+        stage?: string;
+        resolved?: boolean;
+        from?: string;
+        to?: string;
+    }): SystemErrorRow[];
+    markResolved(id: number): {
+        changes: number;
+    };
+    countSince(botId: string | null, hours: number): number;
+}
+//# sourceMappingURL=SystemErrorRepository.d.ts.map

package/dist/storage/repositories/SystemErrorRepository.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SystemErrorRepository = void 0;
+const BaseRepository_1 = require("./BaseRepository");
+class SystemErrorRepository extends BaseRepository_1.BaseRepository {
+    record(input) {
+        this.db
+            .prepare(`INSERT INTO system_errors
+           (service, component, bot_id, schedule_id, slot_id, pixiv_id, stage, error_type, message, http_status, retryable, trace_id)
+         VALUES
+           (@service, @component, @botId, @scheduleId, @slotId, @pixivId, @stage, @errorType, @message, @httpStatus, @retryable, @traceId)`)
+            .run({
+            service: input.service ?? 'pixivflow',
+            component: input.component ?? null,
+            botId: input.bot_id ?? null,
+            scheduleId: input.schedule_id ?? null,
+            slotId: input.slot_id ?? null,
+            pixivId: input.pixiv_id ?? null,
+            stage: input.stage ?? null,
+            errorType: input.error_type ?? 'INTERNAL_ERROR',
+            message: input.message.slice(0, 5000),
+            httpStatus: input.http_status ?? null,
+            retryable: input.retryable ? 1 : 0,
+            traceId: input.trace_id ?? null,
+        });
+    }
+    list(opts = {}) {
+        const where = [];
+        const params = [];
+        if (opts.errorType) {
+            where.push('error_type = ?');
+            params.push(opts.errorType);
+        }
+        if (opts.botId) {
+            where.push('bot_id = ?');
+            params.push(opts.botId);
+        }
+        if (opts.stage) {
+            where.push('stage = ?');
+            params.push(opts.stage);
+        }
+        if (typeof opts.resolved === 'boolean') {
+            where.push(opts.resolved ? 'resolved_at IS NOT NULL' : 'resolved_at IS NULL');
+        }
+        if (opts.from) {
+            where.push('created_at >= ?');
+            params.push(opts.from);
+        }
+        if (opts.to) {
+            where.push('created_at <= ?');
+            params.push(opts.to);
+        }
+        const limit = Math.max(1, Math.min(Number(opts.limit) || 50, 500));
+        const sql = `SELECT * FROM system_errors${where.length ? ' WHERE ' + where.join(' AND ') : ''} ORDER BY id DESC LIMIT ${limit}`;
+        return this.db.prepare(sql).all(...params).map(toRow);
+    }
+    markResolved(id) {
+        const info = this.db.prepare(`UPDATE system_errors SET resolved_at = CURRENT_TIMESTAMP WHERE id = ? AND resolved_at IS NULL`).run(id);
+        return { changes: Number(info.changes ?? 0) };
+    }
+    countSince(botId, hours) {
+        const cutoffMs = Date.now() - hours * 60 * 60 * 1000;
+        const cutoff = new Date(cutoffMs).toISOString().replace('T', ' ').slice(0, 19);
+        if (botId) {
+            const row = this.db.prepare(`SELECT COUNT(*) AS n FROM system_errors WHERE bot_id = ? AND created_at >= ?`).get(botId, cutoff);
+            return Number(row.n ?? 0);
+        }
+        const row = this.db.prepare(`SELECT COUNT(*) AS n FROM system_errors WHERE created_at >= ?`).get(cutoff);
+        return Number(row.n ?? 0);
+    }
+}
+exports.SystemErrorRepository = SystemErrorRepository;
+function toRow(r) {
+    return {
+        id: Number(r.id),
+        service: r.service,
+        component: r.component ?? undefined,
+        bot_id: r.bot_id ?? undefined,
+        schedule_id: r.schedule_id ?? undefined,
+        slot_id: r.slot_id ?? undefined,
+        pixiv_id: r.pixiv_id ?? undefined,
+        stage: r.stage ?? undefined,
+        error_type: r.error_type,
+        message: r.message,
+        http_status: r.http_status ?? null,
+        retryable: Boolean(r.retryable),
+        trace_id: r.trace_id ?? undefined,
+        created_at: r.created_at,
+        resolved_at: r.resolved_at,
+    };
+}
+//# sourceMappingURL=SystemErrorRepository.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.22.0', commit: 'e6cd6211dba7' };
+exports.BUILD = { version: '2.23.0', commit: 'f664f8cc1c6a' };
 //# sourceMappingURL=version.js.map

package/dist/webui/package.json

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

package/dist/webui/routes/admin-logs.d.ts

@@ -0,0 +1,3 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;
+//# sourceMappingURL=admin-logs.d.ts.map

package/dist/webui/routes/admin-logs.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const admin_logs_handlers_1 = require("./handlers/admin-logs-handlers");
+const router = (0, express_1.Router)();
+router.get('/', admin_logs_handlers_1.getAdminLogs);
+router.get('/download', admin_logs_handlers_1.downloadLogs);
+exports.default = router;
+//# sourceMappingURL=admin-logs.js.map

package/dist/webui/routes/handlers/admin-logs-handlers.d.ts

@@ -0,0 +1,6 @@
+import { Request, Response } from 'express';
+/** GET /admin/logs — list log files (size + mtime) in the data dir. */
+export declare function getAdminLogs(_req: Request, res: Response): Promise<void>;
+/** GET /admin/logs/download[?service=&bot_id=&level=&stage=&from=&to=&file=] */
+export declare function downloadLogs(req: Request, res: Response): Promise<void>;
+//# sourceMappingURL=admin-logs-handlers.d.ts.map

package/dist/webui/routes/handlers/admin-logs-handlers.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAdminLogs = getAdminLogs;
+exports.downloadLogs = downloadLogs;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const node_zlib_1 = require("node:zlib");
+const logger_1 = require("../../../logger");
+const config_1 = require("../../../config");
+function logDir() {
+    const config = (0, config_1.loadConfig)((0, config_1.getConfigPath)());
+    if (config.storage?.databasePath && config.storage.databasePath.startsWith('/')) {
+        return (0, path_1.dirname)(config.storage.databasePath);
+    }
+    const candidate = (0, path_1.join)(process.cwd(), 'data');
+    return (0, fs_1.existsSync)(candidate) ? candidate : (0, path_1.dirname)((0, path_1.join)(process.cwd(), 'data', 'pixiv-downloader.log'));
+}
+function parseOrRaw(line) {
+    try {
+        return { parsed: JSON.parse(line), raw: line };
+    }
+    catch {
+        return { raw: line };
+    }
+}
+function matchesFilter(line, q) {
+    const { parsed, raw } = parseOrRaw(line);
+    const val = (key) => (parsed ? parsed[key] : undefined);
+    const timestamp = parsed?.timestamp ?? raw.match(/\[([\d\-T:.]+Z)\]/)?.[1] ?? '';
+    if (q.service && !(val('service') === q.service || raw.includes(q.service)))
+        return false;
+    if (q.bot_id && !(val('bot_id') === q.bot_id || raw.includes(q.bot_id)))
+        return false;
+    if (q.stage && !(val('stage') === q.stage || raw.includes(q.stage)))
+        return false;
+    if (q.level) {
+        const lvl = val('level');
+        if (lvl) {
+            if (String(lvl).toLowerCase() !== q.level.toLowerCase())
+                return false;
+        }
+        else if (!raw.includes(`[${q.level.toUpperCase()}]`))
+            return false;
+    }
+    if (q.from && timestamp && timestamp < q.from)
+        return false;
+    if (q.to && timestamp && timestamp > q.to)
+        return false;
+    return true;
+}
+function fileInfo(full) {
+    const st = (0, fs_1.statSync)(full);
+    return { name: full.split('/').pop(), size: st.size, updated: st.mtime.toISOString() };
+}
+/** GET /admin/logs — list log files (size + mtime) in the data dir. */
+async function getAdminLogs(_req, res) {
+    try {
+        const dir = logDir();
+        let names = [];
+        try {
+            names = (0, fs_1.readdirSync)(dir);
+        }
+        catch {
+            names = [];
+        }
+        const files = names
+            .filter((n) => /^pixiv-downloader.*\.(log|gz)$/.test(n))
+            .map((n) => fileInfo((0, path_1.join)(dir, n)))
+            .sort((a, b) => b.updated.localeCompare(a.updated));
+        res.json({ files });
+    }
+    catch (error) {
+        logger_1.logger.error('admin logs list failed', { error: error instanceof Error ? error.message : String(error) });
+        res.status(500).json({ error: 'list failed' });
+    }
+}
+/** GET /admin/logs/download[?service=&bot_id=&level=&stage=&from=&to=&file=] */
+async function downloadLogs(req, res) {
+    try {
+        const requested = String(req.query.file ?? '');
+        const file = requested && !requested.includes('/') && !requested.includes('..') ? requested : 'pixiv-downloader.log';
+        const full = (0, path_1.join)(logDir(), file);
+        if (!(0, fs_1.existsSync)(full)) {
+            res.status(404).json({ error: `log file not found: ${file}` });
+            return;
+        }
+        const lines = (0, fs_1.readFileSync)(full, 'utf-8').split('\n').filter((l) => l.trim());
+        const filtered = lines.filter((l) => matchesFilter(l, {
+            service: req.query.service ? String(req.query.service) : undefined,
+            bot_id: req.query.bot_id ? String(req.query.bot_id) : undefined,
+            level: req.query.level ? String(req.query.level) : undefined,
+            stage: req.query.stage ? String(req.query.stage) : undefined,
+            from: req.query.from ? String(req.query.from) : undefined,
+            to: req.query.to ? String(req.query.to) : undefined,
+        }));
+        const gz = (0, node_zlib_1.gzipSync)(filtered.join('\n') + (filtered.length ? '\n' : ''));
+        res.setHeader('Content-Type', 'application/gzip');
+        res.setHeader('Content-Disposition', `attachment; filename="${file}.filtered.gz"`);
+        res.send(gz);
+    }
+    catch (error) {
+        logger_1.logger.error('admin logs download failed', { error: error instanceof Error ? error.message : String(error) });
+        res.status(500).json({ error: 'download failed' });
+    }
+}
+//# sourceMappingURL=admin-logs-handlers.js.map

package/dist/webui/routes/handlers/system-errors-handlers.d.ts

@@ -0,0 +1,6 @@
+import { Request, Response } from 'express';
+/** GET /admin/system-errors?limit=&error_type=&bot_id=&stage=&resolved=&from=&to= */
+export declare function listSystemErrors(req: Request, res: Response): Promise<void>;
+/** POST /admin/system-errors/:id/resolve */
+export declare function resolveSystemError(req: Request, res: Response): Promise<void>;
+//# sourceMappingURL=system-errors-handlers.d.ts.map