PRINTFILM: AI short-video marketing and AI short-drama creation platform
import type { AdminTaskEvent, AdminTaskRow } from "../api/types/tasks";
const TERMINAL = new Set(["succeeded", "failed", "cancelled"]);
const SENSITIVE_KEY = /(?:authorization|cookie|apikey|accesstoken|refreshtoken|securitytoken|password|passwd|secret|signature|credential|privatekey)|^(?:(?:api|x)?token|sig|sign|auth|sessionkey)$/i;
/** Redact credentials and every URL query value before data reaches text or tooltips. */
export function redactTaskText(text: string): string {
return text
.replace(/https?:\/\/[^\s"'<>]+/gi, (raw) => {
try {
const url = new URL(raw);
url.username = "";
url.password = "";
for (const key of [...url.searchParams.keys()]) url.searchParams.set(key, "[REDACTED]");
if (url.hash) url.hash = "#REDACTED";
return url.toString();
} catch {
return "[URL REDACTED]";
}
})
.replace(/(["'](?:authorization|api[-_]?key|access[-_]?token|refresh[-_]?token|token|secret|signature|password)["']\s*:\s*["'])[^"']*/gi, "$1[REDACTED]")
.replace(/\b(Bearer|Basic)\s+[A-Za-z0-9._~+\/-]+=*/gi, "$1 [REDACTED]")
.replace(/\b((?:authorization|cookie|api[-_ ]?key|access[-_ ]?token|refresh[-_ ]?token|secret|signature|password)\s*[=:]\s*)[^\s,;"'}]+/gi, "$1[REDACTED]");
}
export function redactTaskData(value: unknown, depth = 0): unknown {
if (depth > 12) return "[TRUNCATED]";
if (typeof value === "string") {
const safe = redactTaskText(value);
return safe.length > 32_000 ? `${safe.slice(0, 32_000)}…[TRUNCATED]` : safe;
}
if (Array.isArray(value)) return value.slice(0, 100).map((item) => redactTaskData(item, depth + 1));
if (!value || typeof value !== "object") return value;
return Object.fromEntries(Object.entries(value).slice(0, 150).map(([key, item]) => {
const normalized = key.replace(/[^a-z0-9]/gi, "");
const sensitive = SENSITIVE_KEY.test(normalized) || (typeof item === "string" && /token$/i.test(normalized)) || /^(?:xamz|xoss).*(?:signature|credential|securitytoken)$/i.test(normalized);
return [key, sensitive ? "[REDACTED]" : redactTaskData(item, depth + 1)];
}));
}
/** 任务可取消:后端允许且未进入终态 */
export function canCancelTask(task: Pick<AdminTaskRow, "cancelable" | "status">): boolean {
return task.cancelable && !TERMINAL.has(task.status);
}
export type TaskStatusTone = "run" | "done" | "fail" | "warn";
/** 任务状态归为四种色调,列表色条、状态 pill 与详情摘要共用 */
export function taskStatusTone(status: string): TaskStatusTone {
if (status === "running" || status === "leased" || status === "awaiting_poll") return "run";
if (status === "succeeded") return "done";
if (status === "failed") return "fail";
return "warn";
}
/** 列表只展示路径部分,域名固定为 TokenFree,完整地址放 title */
export function shortEndpoint(endpoint: string): string {
try {
const url = new URL(endpoint);
return `${url.pathname}${url.search}`;
} catch {
return endpoint;
}
}
export function formatTaskDuration(milliseconds: number | null | undefined): string {
if (milliseconds == null || !Number.isFinite(milliseconds)) return "未记录";
const seconds = Math.max(0, Math.floor(milliseconds / 1000));
if (seconds < 60) return `${seconds}秒`;
if (seconds < 3600) return `${Math.floor(seconds / 60)}分${seconds % 60}秒`;
return `${Math.floor(seconds / 3600)}小时${Math.floor((seconds % 3600) / 60)}分`;
}
function timestamp(value: string | null | undefined): number | null {
if (!value) return null;
const result = Date.parse(value);
return Number.isFinite(result) ? result : null;
}
export function taskDurations(task: Pick<AdminTaskRow, "status" | "created_at" | "started_at" | "finished_at">, now = Date.now()) {
const created = timestamp(task.created_at);
const started = timestamp(task.started_at);
const end = timestamp(task.finished_at) ?? (TERMINAL.has(task.status) ? null : now);
const difference = (a: number | null, b: number | null) => a == null || b == null ? null : Math.max(0, a - b);
return {
waitingMs: difference(started ?? end, created),
runningMs: difference(end, started),
totalMs: difference(end, created),
live: !TERMINAL.has(task.status),
};
}
export function taskBilling(task: Pick<AdminTaskRow, "billing_status" | "billing_estimate_fen" | "billing_charged_fen" | "billing_refunded_fen">) {
const status = task.billing_status;
const labels: Record<string, string> = { none: "未预扣 · 尚未结算", frozen: "已冻结 · 尚未结算", settled: "已结算", skipped: "已跳过预扣 · 尚未结算" };
return {
label: status ? labels[status] || status : "计费状态未记录",
settled: status === "settled",
estimateFen: task.billing_estimate_fen,
frozenFen: status === "frozen" ? task.billing_estimate_fen : status ? 0 : undefined,
chargedFen: task.billing_charged_fen,
refundedFen: task.billing_refunded_fen,
};
}
export type UpstreamPhase = "started" | "accepted" | "failed" | "poll" | "simulated";
export type UpstreamRecord = {
id: number;
phase: UpstreamPhase;
createdAt?: string | null;
requestId?: string;
method?: string;
endpoint?: string;
operation?: string;
model?: string;
provider?: string;
providerTaskId?: string;
elapsedMs?: number;
httpStatus?: number;
upstreamStatus?: string;
request?: unknown;
response?: unknown;
error?: unknown;
};
function textField(value: unknown): string | undefined {
return typeof value === "string" && value.trim() ? redactTaskText(value.trim()) : undefined;
}
export function upstreamRecords(events: AdminTaskEvent[] | undefined): UpstreamRecord[] {
return (events || []).flatMap((event) => {
const match = event.event_type.match(/^upstream\.request\.(started|accepted|failed|poll|simulated)$/);
if (!match) return [];
const payload = event.payload || {};
const response = payload.response && typeof payload.response === "object" ? payload.response as Record<string, unknown> : {};
const body = response.body && typeof response.body === "object" ? response.body as Record<string, unknown> : {};
const data = body.data && typeof body.data === "object" ? body.data as Record<string, unknown> : {};
const statusCode = payload.http_status ?? payload.status_code ?? response.status_code;
return [{
id: event.id,
phase: match[1] as UpstreamPhase,
createdAt: event.created_at,
requestId: textField(payload.request_id),
method: textField(payload.method),
endpoint: textField(payload.endpoint),
operation: textField(payload.operation),
model: textField(payload.model),
provider: textField(payload.provider),
providerTaskId: textField(payload.provider_task_id),
elapsedMs: typeof payload.elapsed_ms === "number" ? payload.elapsed_ms : undefined,
httpStatus: typeof statusCode === "number" ? statusCode : undefined,
upstreamStatus: textField(payload.upstream_status) || textField(body.status) || textField(data.status),
request: payload.request == null ? undefined : redactTaskData(payload.request),
response: payload.response == null ? undefined : redactTaskData(payload.response),
error: payload.error == null ? undefined : redactTaskData(payload.error),
}];
}).sort((a, b) => a.id - b.id);
}
export const UPSTREAM_PHASE_LABELS: Record<UpstreamPhase, string> = {
started: "开始请求", accepted: "上游响应", failed: "请求失败", poll: "查询结果",
simulated: "本地模拟 · 参数已记录",
};
export function upstreamStateLabel(status: string): string {
const labels: Record<string, string> = {
pending: "上游排队", queued: "上游排队", submitted: "上游排队", waiting: "上游排队",
running: "上游生成中", processing: "上游生成中", generating: "上游生成中", in_progress: "上游生成中",
succeeded: "上游完成", success: "上游完成", completed: "上游完成", done: "上游完成", finished: "上游完成",
failed: "上游失败", error: "上游失败", failure: "上游失败", cancelled: "上游已取消", canceled: "上游已取消",
};
return labels[status.toLowerCase()] || `上游状态:${redactTaskText(status)}`;
}
export function groupUpstreamRecords(records: UpstreamRecord[]) {
const grouped = new Map<string, UpstreamRecord[]>();
for (const record of records) {
const key = record.requestId || `event-${record.id}`;
grouped.set(key, [...(grouped.get(key) || []), record]);
}
return [...grouped.entries()].map(([key, items]) => {
const latest = items.at(-1)!;
const reverse = [...items].reverse();
return {
key, records: items, latest,
requestId: latest.requestId,
method: reverse.find((item) => item.method)?.method,
endpoint: reverse.find((item) => item.endpoint)?.endpoint,
operation: reverse.find((item) => item.operation)?.operation,
model: reverse.find((item) => item.model)?.model,
provider: reverse.find((item) => item.provider)?.provider,
providerTaskId: reverse.find((item) => item.providerTaskId)?.providerTaskId,
request: reverse.find((item) => item.request !== undefined)?.request,
response: reverse.find((item) => item.response !== undefined)?.response,
error: reverse.find((item) => item.error !== undefined)?.error,
elapsedMs: reverse.find((item) => item.elapsedMs !== undefined)?.elapsedMs,
httpStatus: reverse.find((item) => item.httpStatus !== undefined)?.httpStatus,
};
}).reverse();
}
export function taskUpstream(task: Pick<AdminTaskRow, "events" | "upstream_events" | "steps" | "payload" | "provider_task_id">) {
// Dedicated bounded evidence remains available when the general event list is omitted or paginated.
const records = upstreamRecords(task.upstream_events ?? task.events);
const latest = records.at(-1);
const modelRecord = [...records].reverse().find((record) => record.model);
const providerRecord = [...records].reverse().find((record) => record.provider);
const taskIdRecord = [...records].reverse().find((record) => record.providerTaskId);
const providerStep = [...(task.steps || [])].reverse().find((step) => step.provider_name);
const taskIdStep = [...(task.steps || [])].reverse().find((step) => step.provider_task_id);
const providerTaskId = taskIdRecord?.providerTaskId || textField(task.provider_task_id) || textField(taskIdStep?.provider_task_id);
return {
records,
latest,
model: modelRecord?.model || textField(task.payload?.model_id) || textField(task.payload?.model),
modelFromRequest: Boolean(modelRecord),
provider: providerRecord?.provider || textField(providerStep?.provider_name),
providerTaskId,
phase: latest?.upstreamStatus ? upstreamStateLabel(latest.upstreamStatus) : latest ? UPSTREAM_PHASE_LABELS[latest.phase] : providerTaskId ? "已有上游任务 · HTTP未记录" : "尚无上游请求记录",
};
}