#!/usr/bin/env bun /** * Backfill: `manual_review` bugs whose Meego ticket is already Close / Done. * * Marks them `fix_succeeded` (看板「修复成功 / Fixed」), writes the live Meego * state, and scans the bound Bits MR the same way mr_sync does. No Lark card, * no Meego comment, no Meego transition — the ticket is already closed. * * bun scripts/backfill_meego_closed_review.ts # dry-run * bun scripts/backfill_meego_closed_review.ts --commit # write * * Routing after the write (comboTaskStateOf): * Meego resolved/open → awaiting_qa * Meego close/done + MR closed → merged (DONE) * Meego close/done (else) → awaiting_merge * Bits merged → merged (DONE) * Merged MRs stamp `mrMergedAt` from Bits merged_time, then create_time — * never Date.now(), so the dashboard doesn't pile every merge on today. * * Pass `--resolved` to also accept Meego RESOLVED (→ 待 QA), not just close/done. */ import { readFileSync } from "node:fs"; import { getTask, updateTask, listTasks } from "../control-server/src/db"; import { BITS_FIXED_OPERATOR, getMrInfo, extractMrIdFromUrl, mrStatePatchFromInfo } from "../control-server/src/bits"; import { broadcast } from "../control-server/src/bus"; import { enrichTask } from "../control-server/src/enrich"; import { comboTaskStateOf, meegoIsClosed } from "../control-server/src/types"; import type { Task } from "../control-server/src/types"; /** * meegoId → live Meego state_key. Default file is written by the investigation * (CLOSE/DONE only). Plugin OpenAPI from a laptop often can't mint a token * against meego.larkoffice.com, so we don't re-fetch here — the file is the * live snapshot. Override with --states PATH (JSON object). */ function loadStates(): Map { const idx = process.argv.indexOf("--states"); const path = idx >= 0 ? process.argv[idx + 1] : "/tmp/sl-meego-closed-states.json"; const allowResolved = process.argv.includes("--resolved"); const raw = JSON.parse(readFileSync(path, "utf8")) as Record; const m = new Map(); for (const [id, state] of Object.entries(raw)) { const s = String(state).toLowerCase(); if (meegoIsClosed(state) || (allowResolved && s === "resolved")) m.set(String(id), state); } return m; } const COMMIT = process.argv.includes("--commit"); interface Plan { id: string; title: string; meegoId: string; meegoLive: string; mrUrl: string | null; patch: Partial; combo: ReturnType; bitsError?: string; } function comboOf(t: Task, patch: Partial) { return comboTaskStateOf({ mrState: patch.mrState !== undefined ? (patch.mrState as string | null) : t.mrState, meegoState: patch.meegoState !== undefined ? (patch.meegoState as string | null) : t.meegoState, }); } async function planOne(t: Task, meegoLive: string): Promise { const patch: Partial = { status: "fix_succeeded", meegoState: meegoLive, mrSyncedAt: Date.now(), failureReason: null, }; let bitsError: string | undefined; const mrId = t.mrUrl ? extractMrIdFromUrl(t.mrUrl) : null; if (mrId) { const info = await getMrInfo(mrId, null, BITS_FIXED_OPERATOR); if (!info.ok) bitsError = info.error || "getMrInfo failed"; else Object.assign(patch, mrStatePatchFromInfo(t, info)); } return { id: t.id, title: t.title, meegoId: t.meegoId!, meegoLive, mrUrl: t.mrUrl, patch, combo: comboOf(t, patch), bitsError, }; } const states = loadStates(); console.log(`[backfill] loaded ${states.size} close/done Meego id(s) from snapshot`); const all = await listTasks(); const review = all.filter((t) => t.status === "manual_review" && t.meegoId); console.log(`[backfill] ${review.length} manual_review bug(s) with a Meego id (commit=${COMMIT})`); const plans: Plan[] = []; let notInSnapshot = 0; for (const t of review) { const live = states.get(String(t.meegoId)); if (!live) { notInSnapshot++; continue; } plans.push(await planOne(t, live)); } const byCombo: Record = {}; for (const p of plans) byCombo[p.combo ?? "null"] = (byCombo[p.combo ?? "null"] ?? 0) + 1; const withMr = plans.filter((p) => p.mrUrl).length; const mergedAtSet = plans.filter((p) => p.patch.mrMergedAt != null).length; const bitsFail = plans.filter((p) => p.bitsError).length; console.log(`[backfill] eligible close/done: ${plans.length} not in snapshot: ${notInSnapshot}`); console.log(`[backfill] with MR: ${withMr} no MR: ${plans.length - withMr} mrMergedAt stamped: ${mergedAtSet} bits errors: ${bitsFail}`); console.log(`[backfill] combo after write:`, byCombo); const sample = (rows: Plan[], n = 8) => { for (const p of rows.slice(0, n)) { const mr = p.patch.mrState ?? "(none)"; const at = p.patch.mrMergedAt ? new Date(p.patch.mrMergedAt as number).toISOString() : "-"; console.log(` ${p.combo ?? "?"} meego=${p.meegoLive} mr=${mr} mergedAt=${at} ${p.meegoId} ${p.id.slice(0, 8)} ${p.title.slice(0, 60)}`); if (p.bitsError) console.log(` bits: ${p.bitsError}`); } if (rows.length > n) console.log(` … +${rows.length - n} more`); }; console.log("\n— awaiting_merge (MR still open) —"); sample(plans.filter((p) => p.combo === "awaiting_merge")); console.log("\n— awaiting_qa (Meego resolved / open) —"); sample(plans.filter((p) => p.combo === "awaiting_qa"), 12); console.log("\n— merged / DONE (no open MR) —"); sample(plans.filter((p) => p.combo === "merged"), 12); if (!COMMIT) { console.log("\n[backfill] dry-run. pass --commit to write."); process.exit(0); } let ok = 0; let fail = 0; for (const p of plans) { try { const fresh = await getTask(p.id); if (!fresh || fresh.status !== "manual_review") { console.warn(`[backfill] skip ${p.id}: status is now ${fresh?.status ?? "gone"}`); continue; } await updateTask(p.id, p.patch); const next = await getTask(p.id); if (next) broadcast({ type: "task:updated", payload: await enrichTask(next) }); ok++; } catch (err) { fail++; console.warn(`[backfill] ${p.id}: ${(err as Error).message}`); } } console.log(`[backfill] wrote ${ok}, failed ${fail}`); process.exit(fail ? 1 : 0);