542 lines
16 KiB
JavaScript
542 lines
16 KiB
JavaScript
import { createRequire } from "node:module";
|
||
import fs from "node:fs";
|
||
import path from "node:path";
|
||
import process from "node:process";
|
||
import { pathToFileURL } from "node:url";
|
||
|
||
const require = createRequire(import.meta.url);
|
||
const ROOT = process.cwd();
|
||
const TERMINAL_PAGE_PATH = path.join(ROOT, "apps/miniprogram/pages/terminal/index.js");
|
||
const TERMINAL_FIXTURE_PATH = path.join(ROOT, "apps/miniprogram/pages/terminal/codexCaptureFixture.js");
|
||
const TERMINAL_BUFFER_STATE_PATH = path.join(
|
||
ROOT,
|
||
"apps/miniprogram/pages/terminal/terminalBufferState.js"
|
||
);
|
||
|
||
const DEFAULT_CHUNK_SIZE = 97;
|
||
const DEFAULT_CADENCE_MS = 8;
|
||
const DEFAULT_REPEAT = 4;
|
||
const DEFAULT_SETTLE_MS = 1600;
|
||
const DEFAULT_CAPTURE_SPEED = 1;
|
||
const DEFAULT_RECT = Object.freeze({
|
||
left: 0,
|
||
top: 0,
|
||
right: 375,
|
||
bottom: 520,
|
||
width: 375,
|
||
height: 520
|
||
});
|
||
|
||
function parsePositiveInteger(raw, fallback) {
|
||
const value = Number(raw);
|
||
if (!Number.isFinite(value) || value <= 0) {
|
||
return fallback;
|
||
}
|
||
return Math.round(value);
|
||
}
|
||
|
||
function parseArgs(argv) {
|
||
const args = Array.isArray(argv) ? argv : [];
|
||
const parsed = {
|
||
chunkSize: DEFAULT_CHUNK_SIZE,
|
||
cadenceMs: DEFAULT_CADENCE_MS,
|
||
repeat: DEFAULT_REPEAT,
|
||
settleMs: DEFAULT_SETTLE_MS,
|
||
fixture: "20260311",
|
||
captureFile: "",
|
||
captureSpeed: DEFAULT_CAPTURE_SPEED,
|
||
quiet: false
|
||
};
|
||
args.forEach((item) => {
|
||
const source = String(item || "");
|
||
if (!source.startsWith("--")) {
|
||
return;
|
||
}
|
||
const [key, rawValue = ""] = source.slice(2).split("=");
|
||
if (key === "chunk-size") {
|
||
parsed.chunkSize = parsePositiveInteger(rawValue, DEFAULT_CHUNK_SIZE);
|
||
return;
|
||
}
|
||
if (key === "cadence-ms") {
|
||
parsed.cadenceMs = Math.max(0, parsePositiveInteger(rawValue, DEFAULT_CADENCE_MS));
|
||
return;
|
||
}
|
||
if (key === "repeat") {
|
||
parsed.repeat = parsePositiveInteger(rawValue, DEFAULT_REPEAT);
|
||
return;
|
||
}
|
||
if (key === "settle-ms") {
|
||
parsed.settleMs = Math.max(0, parsePositiveInteger(rawValue, DEFAULT_SETTLE_MS));
|
||
return;
|
||
}
|
||
if (key === "fixture" && rawValue) {
|
||
parsed.fixture = rawValue;
|
||
return;
|
||
}
|
||
if (key === "capture-file" && rawValue) {
|
||
parsed.captureFile = path.isAbsolute(rawValue) ? rawValue : path.join(ROOT, rawValue);
|
||
return;
|
||
}
|
||
if (key === "capture-speed") {
|
||
const value = Number(rawValue);
|
||
parsed.captureSpeed = Number.isFinite(value) && value > 0 ? value : DEFAULT_CAPTURE_SPEED;
|
||
return;
|
||
}
|
||
if (key === "quiet") {
|
||
parsed.quiet = rawValue !== "false";
|
||
}
|
||
});
|
||
return parsed;
|
||
}
|
||
|
||
function splitTextIntoChunks(text, chunkSize) {
|
||
const chunks = [];
|
||
const size = Math.max(1, parsePositiveInteger(chunkSize, DEFAULT_CHUNK_SIZE));
|
||
for (let index = 0; index < text.length; index += size) {
|
||
chunks.push(text.slice(index, index + size));
|
||
}
|
||
return chunks;
|
||
}
|
||
|
||
function wait(ms) {
|
||
const delay = Math.max(0, Number(ms) || 0);
|
||
return new Promise((resolve) => {
|
||
setTimeout(resolve, delay);
|
||
});
|
||
}
|
||
|
||
function loadCaptureRecording(filePath) {
|
||
const resolvedPath = path.isAbsolute(filePath) ? filePath : path.join(ROOT, filePath);
|
||
const lines = fs
|
||
.readFileSync(resolvedPath, "utf8")
|
||
.split(/\r?\n/)
|
||
.filter(Boolean);
|
||
const events = [];
|
||
let meta = null;
|
||
|
||
lines.forEach((line, index) => {
|
||
let parsed = null;
|
||
try {
|
||
parsed = JSON.parse(line);
|
||
} catch (error) {
|
||
throw new Error(`录制文件解析失败，第 ${index + 1} 行不是合法 JSON: ${(error && error.message) || error}`);
|
||
}
|
||
if (!parsed || typeof parsed !== "object") {
|
||
return;
|
||
}
|
||
if (parsed.kind === "meta") {
|
||
meta = parsed;
|
||
return;
|
||
}
|
||
if (parsed.kind === "frame" && typeof parsed.type === "string" && typeof parsed.data === "string") {
|
||
events.push({
|
||
offsetMs: Math.max(0, Number(parsed.offsetMs) || 0),
|
||
type: parsed.type,
|
||
data: parsed.data
|
||
});
|
||
}
|
||
});
|
||
|
||
return {
|
||
filePath: resolvedPath,
|
||
meta,
|
||
events
|
||
};
|
||
}
|
||
|
||
function cloneRect(rect) {
|
||
const source = rect && typeof rect === "object" ? rect : DEFAULT_RECT;
|
||
return {
|
||
left: Number(source.left) || 0,
|
||
top: Number(source.top) || 0,
|
||
right: Number(source.right) || 0,
|
||
bottom: Number(source.bottom) || 0,
|
||
width: Number(source.width) || DEFAULT_RECT.width,
|
||
height: Number(source.height) || DEFAULT_RECT.height
|
||
};
|
||
}
|
||
|
||
function createSelectorQueryStub() {
|
||
const queue = [];
|
||
const api = {
|
||
in() {
|
||
return api;
|
||
},
|
||
select() {
|
||
return {
|
||
boundingClientRect(callback) {
|
||
queue.push({
|
||
type: "rect",
|
||
callback: typeof callback === "function" ? callback : null
|
||
});
|
||
return api;
|
||
},
|
||
scrollOffset(callback) {
|
||
queue.push({
|
||
type: "scroll",
|
||
callback: typeof callback === "function" ? callback : null
|
||
});
|
||
return api;
|
||
}
|
||
};
|
||
},
|
||
exec(callback) {
|
||
const results = queue.map((item) =>
|
||
item.type === "rect"
|
||
? cloneRect(DEFAULT_RECT)
|
||
: {
|
||
scrollTop: 0,
|
||
scrollLeft: 0
|
||
}
|
||
);
|
||
queue.forEach((item, index) => {
|
||
if (item.callback) {
|
||
item.callback(results[index]);
|
||
}
|
||
});
|
||
if (typeof callback === "function") {
|
||
callback(results);
|
||
}
|
||
}
|
||
};
|
||
return api;
|
||
}
|
||
|
||
function installMiniprogramGlobals() {
|
||
const globalState = globalThis;
|
||
const previousPage = globalState.Page;
|
||
const previousWx = globalState.wx;
|
||
let capturedPageOptions = null;
|
||
const noop = () => {};
|
||
// 回放脚本只需要一个轻量的内存存储桩，避免触发真实小程序存储分支。
|
||
const storage = new Map();
|
||
|
||
globalState.Page = (options) => {
|
||
capturedPageOptions = options;
|
||
};
|
||
globalState.wx = {
|
||
env: {
|
||
USER_DATA_PATH: "/tmp"
|
||
},
|
||
getRecorderManager: () => ({
|
||
onStart: noop,
|
||
onStop: noop,
|
||
onError: noop,
|
||
onFrameRecorded: noop,
|
||
start: noop,
|
||
stop: noop
|
||
}),
|
||
createInnerAudioContext: () => ({
|
||
onCanplay: noop,
|
||
onPlay: noop,
|
||
onEnded: noop,
|
||
onStop: noop,
|
||
onError: noop,
|
||
stop: noop,
|
||
destroy: noop
|
||
}),
|
||
setInnerAudioOption: noop,
|
||
createSelectorQuery: () => createSelectorQueryStub(),
|
||
nextTick: (callback) => {
|
||
if (typeof callback === "function") {
|
||
callback();
|
||
}
|
||
},
|
||
getSystemInfoSync: () => ({
|
||
windowWidth: DEFAULT_RECT.width,
|
||
windowHeight: 667,
|
||
screenWidth: DEFAULT_RECT.width,
|
||
screenHeight: 667,
|
||
pixelRatio: 2
|
||
}),
|
||
canIUse: () => false,
|
||
getStorageSync: (key) => storage.get(String(key)),
|
||
setStorageSync: (key, value) => {
|
||
storage.set(String(key), value);
|
||
},
|
||
removeStorageSync: (key) => {
|
||
storage.delete(String(key));
|
||
},
|
||
clearStorageSync: () => {
|
||
storage.clear();
|
||
},
|
||
getStorageInfoSync: () => ({
|
||
keys: Array.from(storage.keys()),
|
||
currentSize: storage.size,
|
||
limitSize: 10240
|
||
}),
|
||
setNavigationBarTitle: noop,
|
||
showToast: noop,
|
||
showModal: noop,
|
||
hideKeyboard: noop
|
||
};
|
||
|
||
delete require.cache[require.resolve(TERMINAL_PAGE_PATH)];
|
||
require(TERMINAL_PAGE_PATH);
|
||
|
||
return {
|
||
capturedPageOptions,
|
||
restore() {
|
||
if (previousPage === undefined) {
|
||
delete globalState.Page;
|
||
} else {
|
||
globalState.Page = previousPage;
|
||
}
|
||
if (previousWx === undefined) {
|
||
delete globalState.wx;
|
||
} else {
|
||
globalState.wx = previousWx;
|
||
}
|
||
}
|
||
};
|
||
}
|
||
|
||
function createTerminalPageHarness() {
|
||
const { createEmptyTerminalBufferState, cloneAnsiState, ANSI_RESET_STATE } = require(
|
||
TERMINAL_BUFFER_STATE_PATH
|
||
);
|
||
const { capturedPageOptions, restore } = installMiniprogramGlobals();
|
||
if (!capturedPageOptions) {
|
||
restore();
|
||
throw new Error("terminal page not captured");
|
||
}
|
||
|
||
const captured = capturedPageOptions;
|
||
const page = {
|
||
...captured,
|
||
data: JSON.parse(JSON.stringify(captured.data || {})),
|
||
setData(patch, callback) {
|
||
Object.assign(this.data, patch || {});
|
||
if (typeof callback === "function") {
|
||
callback();
|
||
}
|
||
}
|
||
};
|
||
|
||
page.initTerminalPerfState();
|
||
page.initTerminalRenderScheduler();
|
||
page.connectionDiagnosticNetworkProbeTimer = null;
|
||
page.connectionDiagnosticNetworkProbePending = false;
|
||
page.connectionDiagnosticKeepSamplesOnNextConnect = false;
|
||
page.outputCursorRow = 0;
|
||
page.outputCursorCol = 0;
|
||
page.outputCells = [[]];
|
||
page.outputReplayText = "";
|
||
page.outputReplayBytes = 0;
|
||
page.outputAnsiState = cloneAnsiState(ANSI_RESET_STATE);
|
||
page.outputRectWidth = DEFAULT_RECT.width;
|
||
page.outputRectHeight = DEFAULT_RECT.height;
|
||
page.stdoutReplayCarryText = "";
|
||
page.terminalSyncUpdateState = page.terminalSyncUpdateState || { depth: 0, carryText: "", bufferedText: "" };
|
||
page.terminalStdoutUserInputPending = false;
|
||
page.terminalCols = 80;
|
||
page.terminalRows = 24;
|
||
page.outputTerminalState = createEmptyTerminalBufferState({
|
||
bufferCols: page.terminalCols,
|
||
bufferRows: page.terminalRows
|
||
});
|
||
page.applyTerminalBufferState(page.outputTerminalState);
|
||
page.currentOutputScrollTop = 0;
|
||
page.outputRectSnapshot = cloneRect(DEFAULT_RECT);
|
||
page.outputViewportWindow = null;
|
||
page.outputViewportScrollRefreshPending = false;
|
||
page.terminalScrollOverlayTimer = null;
|
||
page.terminalScrollIdleTimer = null;
|
||
page.terminalScrollViewportPrefetchTimer = null;
|
||
page.terminalScrollLastOverlayAt = 0;
|
||
page.terminalScrollLastViewportRefreshAt = 0;
|
||
page.terminalScrollDirection = 0;
|
||
page.shellFontSizePx = 15;
|
||
page.shellLineHeightRatio = 1.4;
|
||
page.shellLineHeightPx = 21;
|
||
page.shellCharWidthPx = 9;
|
||
page.outputHorizontalPaddingPx = 8;
|
||
page.outputRightPaddingPx = 8;
|
||
page.windowWidth = DEFAULT_RECT.width;
|
||
page.windowHeight = 667;
|
||
page.keyboardVisibleHeightPx = 0;
|
||
page.keyboardRestoreScrollTop = null;
|
||
page.keyboardSessionActive = false;
|
||
page.sessionSuspended = false;
|
||
page.codexBootstrapGuard = null;
|
||
page.activeAiProvider = "codex";
|
||
page.activeCodexSandboxMode = "";
|
||
page.aiSessionShellReady = true;
|
||
page.aiRuntimeExitCarry = "";
|
||
page.pendingCodexResumeAfterReconnect = false;
|
||
page.client = null;
|
||
page.data.statusText = "connected";
|
||
page.data.statusClass = "connected";
|
||
page.data.serverId = "terminal-replay";
|
||
page.data.sessionId = "terminal-replay-session";
|
||
page.data.serverLabel = "terminal-replay";
|
||
|
||
page.queryOutputRect = function queryOutputRect(callback) {
|
||
this.currentOutputScrollTop = Math.max(0, Number(this.currentOutputScrollTop) || 0);
|
||
this.outputRectSnapshot = cloneRect(DEFAULT_RECT);
|
||
if (typeof callback === "function") {
|
||
callback(cloneRect(DEFAULT_RECT));
|
||
}
|
||
};
|
||
page.runAfterTerminalLayout = function runAfterTerminalLayout(callback) {
|
||
if (typeof callback === "function") {
|
||
callback();
|
||
}
|
||
};
|
||
page.measureShellMetrics = function measureShellMetrics(callback) {
|
||
if (typeof callback === "function") {
|
||
callback();
|
||
}
|
||
};
|
||
page.setStatus = function setStatus(status) {
|
||
const nextStatus = String(status || "");
|
||
this.data.statusText = nextStatus;
|
||
this.data.statusClass = nextStatus === "connected" ? "connected" : "idle";
|
||
};
|
||
page.syncConnectionAction = () => {};
|
||
page.persistTerminalSessionStatus = () => {};
|
||
page.persistConnectionDiagnosticSamples = () => {};
|
||
page.resetTtsRoundState = () => {};
|
||
page.appendTtsRoundOutput = () => {};
|
||
page.handleError = (error) => {
|
||
throw error instanceof Error ? error : new Error(String(error || "terminal replay error"));
|
||
};
|
||
|
||
return {
|
||
page,
|
||
restore
|
||
};
|
||
}
|
||
|
||
function loadFixture(name) {
|
||
const fixtureModule = require(TERMINAL_FIXTURE_PATH);
|
||
if (name === "20260311" && typeof fixtureModule.decodeCodexTtyCapture20260311 === "function") {
|
||
return fixtureModule.decodeCodexTtyCapture20260311();
|
||
}
|
||
throw new Error(`未知 fixture：${name}`);
|
||
}
|
||
|
||
function parsePerfLine(line) {
|
||
const source = String(line || "");
|
||
const marker = "[terminal.perf] ";
|
||
const index = source.indexOf(marker);
|
||
if (index < 0) {
|
||
return null;
|
||
}
|
||
const jsonText = source.slice(index + marker.length).trim();
|
||
try {
|
||
return JSON.parse(jsonText);
|
||
} catch {
|
||
return null;
|
||
}
|
||
}
|
||
|
||
async function runReplay(options) {
|
||
const config = options && typeof options === "object" ? options : {};
|
||
const recording = config.captureFile ? loadCaptureRecording(config.captureFile) : null;
|
||
const capture = recording ? "" : loadFixture(config.fixture || "20260311");
|
||
const chunks = recording ? [] : splitTextIntoChunks(capture, config.chunkSize);
|
||
const { page, restore } = createTerminalPageHarness();
|
||
const originalConsoleInfo = console.info;
|
||
const perfRecords = [];
|
||
|
||
console.info = (...args) => {
|
||
const line = args.map((item) => String(item)).join(" ");
|
||
const parsed = parsePerfLine(line);
|
||
if (parsed) {
|
||
perfRecords.push(parsed);
|
||
}
|
||
if (!config.quiet) {
|
||
originalConsoleInfo(...args);
|
||
}
|
||
};
|
||
|
||
try {
|
||
for (let round = 0; round < config.repeat; round += 1) {
|
||
if (recording) {
|
||
let previousOffsetMs = 0;
|
||
for (let index = 0; index < recording.events.length; index += 1) {
|
||
const event = recording.events[index];
|
||
const deltaMs = Math.max(0, event.offsetMs - previousOffsetMs);
|
||
previousOffsetMs = event.offsetMs;
|
||
if (deltaMs > 0) {
|
||
await wait(deltaMs / config.captureSpeed);
|
||
}
|
||
if (event.type === "stdout" || event.type === "stderr") {
|
||
page.handleFrame({
|
||
type: event.type,
|
||
payload: {
|
||
data: event.data
|
||
}
|
||
});
|
||
}
|
||
}
|
||
} else {
|
||
for (let index = 0; index < chunks.length; index += 1) {
|
||
page.handleFrame({
|
||
type: "stdout",
|
||
payload: {
|
||
data: chunks[index]
|
||
}
|
||
});
|
||
if (config.cadenceMs > 0) {
|
||
await wait(config.cadenceMs);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (config.settleMs > 0) {
|
||
await wait(config.settleMs);
|
||
}
|
||
const flushedSummary = page.flushTerminalPerfLogs("script_end");
|
||
const scheduler = page.getTerminalRenderSchedulerSnapshot();
|
||
const activeTask = page.getActiveStdoutTaskSnapshot();
|
||
const summaries = perfRecords.filter((item) => item && item.event === "perf.summary");
|
||
const snapshots = perfRecords.filter((item) => item && item.event === "perf.snapshot");
|
||
return {
|
||
captureFile: recording ? recording.filePath : "",
|
||
captureMeta: recording ? recording.meta : null,
|
||
fixture: config.fixture,
|
||
chunkSize: config.chunkSize,
|
||
cadenceMs: config.cadenceMs,
|
||
captureSpeed: config.captureSpeed,
|
||
repeat: config.repeat,
|
||
settleMs: config.settleMs,
|
||
chunkCount: recording ? recording.events.length : chunks.length,
|
||
captureChars: capture.length,
|
||
perfSummaryCount: summaries.length,
|
||
perfSnapshotCount: snapshots.length,
|
||
lastPerfSummary: flushedSummary || summaries.at(-1) || null,
|
||
lastPerfSnapshot: snapshots.at(-1) || null,
|
||
scheduler,
|
||
activeTask,
|
||
outputLineCount: Array.isArray(page.data.outputRenderLines) ? page.data.outputRenderLines.length : 0,
|
||
outputTopSpacerPx: Number(page.data.outputTopSpacerPx) || 0,
|
||
outputBottomSpacerPx: Number(page.data.outputBottomSpacerPx) || 0
|
||
};
|
||
} finally {
|
||
console.info = originalConsoleInfo;
|
||
restore();
|
||
}
|
||
}
|
||
|
||
async function main() {
|
||
const options = parseArgs(process.argv.slice(2));
|
||
const result = await runReplay(options);
|
||
console.log(JSON.stringify(result, null, 2));
|
||
}
|
||
|
||
export {
|
||
createTerminalPageHarness,
|
||
parseArgs,
|
||
runReplay,
|
||
splitTextIntoChunks
|
||
};
|
||
|
||
if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
|
||
main().catch((error) => {
|
||
console.error(error);
|
||
process.exit(1);
|
||
});
|
||
}
|