proteum 2.3.0 → 2.4.2

package/tests/cli-mcp-command.test.cjs

@@ -0,0 +1,327 @@
+const assert = require('node:assert/strict');
+const { spawn, spawnSync } = require('node:child_process');
+const fs = require('node:fs');
+const http = require('node:http');
+const os = require('node:os');
+const path = require('node:path');
+
+const coreRoot = path.resolve(__dirname, '..');
+const cliBin = path.join(coreRoot, 'cli', 'bin.js');
+
+const writeFile = (filepath, content) => {
+    fs.mkdirSync(path.dirname(filepath), { recursive: true });
+    fs.writeFileSync(filepath, content);
+};
+
+const createProteumApp = (appRoot, { routerPort = 3020 } = {}) => {
+    writeFile(path.join(appRoot, 'package.json'), '{"name":"fixture"}\n');
+    writeFile(path.join(appRoot, 'identity.config.ts'), 'export default {};\n');
+    writeFile(path.join(appRoot, 'proteum.config.ts'), 'export default {};\n');
+    fs.mkdirSync(path.join(appRoot, 'client'), { recursive: true });
+    fs.mkdirSync(path.join(appRoot, 'server'), { recursive: true });
+    writeFile(
+        path.join(appRoot, '.proteum', 'manifest.json'),
+        JSON.stringify({
+            version: 10,
+            app: {
+                root: appRoot,
+                coreRoot,
+                identityFilepath: path.join(appRoot, 'identity.config.ts'),
+                setupFilepath: path.join(appRoot, 'proteum.config.ts'),
+                identity: { name: 'Product', identifier: 'ProductApp', description: '' },
+                setup: {},
+            },
+            conventions: { routeOptionKeys: [], reservedRouteOptionKeys: [] },
+            env: {
+                source: 'test',
+                loadedVariableKeys: [],
+                requiredVariables: [],
+                resolved: {
+                    name: 'test',
+                    profile: 'dev',
+                    routerPort,
+                    routerCurrentDomain: 'localhost',
+                    routerInternalUrl: `http://localhost:${routerPort}`,
+                },
+            },
+            connectedProjects: [],
+            services: { app: [], routerPlugins: [] },
+            controllers: [],
+            commands: [],
+            routes: { client: [], server: [] },
+            layouts: [],
+            diagnostics: [],
+        }),
+    );
+};
+
+const listen = async (server, port = 0) =>
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(port, '127.0.0.1', () => resolve(server.address().port));
+    });
+
+const closeServer = async (server) =>
+    await new Promise((resolve, reject) => {
+        server.close((error) => (error ? reject(error) : resolve()));
+    });
+
+const runCli = async (args, { cwd }) =>
+    await new Promise((resolve, reject) => {
+        const child = spawn(process.execPath, [cliBin, ...args], {
+            cwd,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+
+        child.stdout.on('data', (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.once('error', reject);
+        child.once('close', (status) => resolve({ status, stdout, stderr }));
+    });
+
+test('top-level help lists the machine-scope mcp router', () => {
+    const result = spawnSync(process.execPath, [cliBin, '--help'], {
+        cwd: coreRoot,
+        encoding: 'utf8',
+    });
+
+    assert.equal(result.status, 0);
+    assert.match(result.stdout, /proteum mcp\b/);
+    assert.match(result.stdout, /machine-scope MCP router/);
+});
+
+test('mcp help describes projectId routing', () => {
+    const result = spawnSync(process.execPath, [cliBin, 'mcp', '--help'], {
+        cwd: coreRoot,
+        encoding: 'utf8',
+    });
+    const output = `${result.stdout}\n${result.stderr}`;
+
+    assert.equal(result.status, 0);
+    assert.match(output, /machine-scope MCP router/);
+    assert.match(output, /projectId/);
+    assert.match(output, /--daemon/);
+    assert.match(output, /--stdio/);
+});
+
+test('db help describes read-only SQL diagnostics', () => {
+    const result = spawnSync(process.execPath, [cliBin, 'db', '--help'], {
+        cwd: coreRoot,
+        encoding: 'utf8',
+    });
+    const output = `${result.stdout}\n${result.stderr}`;
+
+    assert.equal(result.status, 0);
+    assert.match(output, /SELECT, SHOW, and EXPLAIN/);
+    assert.match(output, /--limit/);
+    assert.match(output, /--timeout/);
+});
+
+test('explain help describes compact section summaries', () => {
+    const result = spawnSync(process.execPath, [cliBin, 'explain', '--help'], {
+        cwd: coreRoot,
+        encoding: 'utf8',
+    });
+    const output = `${result.stdout}\n${result.stderr}`;
+
+    assert.equal(result.status, 0);
+    assert.match(output, /Summarize generated routes, controllers, and commands together/);
+    assert.match(output, /--routes --controllers --commands --full/);
+    assert.match(output, /Explicit section flags summarize those sections by default/);
+});
+
+test('runtime status from a monorepo wrapper returns app candidates instead of treating wrapper as app', () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'proteum-cli-wrapper-'));
+    createProteumApp(path.join(repoRoot, 'apps', 'product'));
+
+    const result = spawnSync(process.execPath, [cliBin, 'runtime', 'status'], {
+        cwd: repoRoot,
+        encoding: 'utf8',
+    });
+    const payload = JSON.parse(result.stdout);
+
+    assert.equal(result.status, 1);
+    assert.equal(payload.ok, false);
+    assert.equal(payload.data.appCandidates.length, 1);
+    assert.match(payload.nextActions[0].command, /cd "apps\/product"/);
+    assert.match(payload.nextActions[0].command, /npx proteum runtime status/);
+});
+
+test('dev from a monorepo wrapper returns exact app-root start command', () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'proteum-cli-dev-wrapper-'));
+    createProteumApp(path.join(repoRoot, 'apps', 'product'));
+
+    const result = spawnSync(process.execPath, [cliBin, 'dev', 'list'], {
+        cwd: repoRoot,
+        encoding: 'utf8',
+    });
+    const payload = JSON.parse(result.stdout);
+
+    assert.equal(result.status, 1);
+    assert.equal(payload.ok, false);
+    assert.match(payload.nextActions[0].command, /cd "apps\/product"/);
+    assert.match(payload.nextActions[0].command, /npx proteum dev --session-file/);
+});
+
+test('runtime status manifest guard points to explain manifest', () => {
+    const result = spawnSync(process.execPath, [cliBin, 'runtime', 'status', '--manifest'], {
+        cwd: coreRoot,
+        encoding: 'utf8',
+    });
+    const payload = JSON.parse(result.stdout);
+
+    assert.equal(result.status, 1);
+    assert.equal(payload.ok, false);
+    assert.match(payload.summary, /not supported/);
+    assert.match(payload.nextActions[0].command, /proteum explain --manifest/);
+});
+
+test('runtime status reports occupied configured port without probing page bodies', async () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'proteum-cli-port-'));
+    const otherRoot = path.join(repoRoot, 'apps', 'other');
+    const appRoot = path.join(repoRoot, 'apps', 'product');
+    const server = http.createServer((req, res) => {
+        if (req.url && req.url.startsWith('/__proteum/explain')) {
+            res.setHeader('content-type', 'application/json');
+            res.end(
+                JSON.stringify({
+                    app: {
+                        root: otherRoot,
+                        identity: { identifier: 'OtherApp', name: 'Other' },
+                    },
+                }),
+            );
+            return;
+        }
+
+        res.setHeader('content-type', 'text/html');
+        res.end('<html><body>large wrong app page that should never be included</body></html>');
+    });
+    const occupiedPort = await listen(server);
+
+    try {
+        createProteumApp(appRoot, { routerPort: occupiedPort });
+
+        const result = await runCli(['runtime', 'status'], {
+            cwd: appRoot,
+        });
+        const payload = JSON.parse(result.stdout);
+
+        assert.equal(result.status, 0);
+        assert.equal(payload.ok, true);
+        assert.equal(payload.data.configuredDevPort.router.port, occupiedPort);
+        assert.equal(payload.data.configuredDevPort.router.available, false);
+        assert.equal(payload.data.configuredDevPort.router.proteum, true);
+        assert.equal(payload.data.configuredDevPort.router.matchesApp, false);
+        assert.equal(payload.data.configuredDevPort.router.app.identifier, 'OtherApp');
+        assert.notEqual(payload.data.configuredDevPort.recommendedPort, occupiedPort);
+        assert.match(payload.summary, /occupied by OtherApp/);
+        assert.match(payload.nextActions[0].command, /(npx )?proteum dev --session-file/);
+        assert.doesNotMatch(payload.nextActions[0].command, new RegExp(`--port ${occupiedPort}(\\D|$)`));
+        assert.match(payload.nextActions[0].reason, /do not probe page bodies/);
+        assert.doesNotMatch(result.stdout, /large wrong app page/);
+        assert.doesNotMatch(result.stdout, /<html>/);
+    } finally {
+        await closeServer(server);
+    }
+});
+
+test('db query posts one read-only SQL statement to the running dev endpoint', async () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'proteum-cli-db-'));
+    const appRoot = path.join(repoRoot, 'apps', 'product');
+    let receivedBody = '';
+    const server = http.createServer((req, res) => {
+        if (req.url === '/__proteum/db/query' && req.method === 'POST') {
+            req.on('data', (chunk) => {
+                receivedBody += chunk.toString();
+            });
+            req.on('end', () => {
+                res.setHeader('content-type', 'application/json');
+                res.end(
+                    JSON.stringify({
+                        kind: 'select',
+                        sql: 'SELECT 1',
+                        elapsedMs: 7,
+                        limit: 5,
+                        limited: false,
+                        rowCount: 1,
+                        columns: [{ name: 'value', type: 3 }],
+                        rows: [{ value: 1 }],
+                    }),
+                );
+            });
+            return;
+        }
+
+        res.statusCode = 404;
+        res.end('not found');
+    });
+    const port = await listen(server);
+
+    try {
+        createProteumApp(appRoot, { routerPort: port });
+
+        const result = await runCli(['db', 'query', 'SELECT 1', '--limit', '5'], {
+            cwd: appRoot,
+        });
+        const payload = JSON.parse(result.stdout);
+        const body = JSON.parse(receivedBody);
+
+        assert.equal(result.status, 0);
+        assert.equal(body.sql, 'SELECT 1');
+        assert.equal(body.limit, 5);
+        assert.equal(payload.ok, true);
+        assert.equal(payload.data.elapsedMs, 7);
+        assert.deepEqual(payload.data.rows, [{ value: 1 }]);
+    } finally {
+        await closeServer(server);
+    }
+});
+
+test('runtime status avoids starting a second dev server when the same app owns the port', async () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'proteum-cli-same-port-'));
+    const appRoot = path.join(repoRoot, 'apps', 'product');
+    const server = http.createServer((req, res) => {
+        if (req.url && req.url.startsWith('/__proteum/explain')) {
+            res.setHeader('content-type', 'application/json');
+            res.end(
+                JSON.stringify({
+                    app: {
+                        root: appRoot,
+                        identity: { identifier: 'ProductApp', name: 'Product' },
+                    },
+                }),
+            );
+            return;
+        }
+
+        res.setHeader('content-type', 'text/html');
+        res.end('<html><body>same app page body that should not be included</body></html>');
+    });
+    const occupiedPort = await listen(server);
+
+    try {
+        createProteumApp(appRoot, { routerPort: occupiedPort });
+
+        const result = await runCli(['runtime', 'status'], {
+            cwd: appRoot,
+        });
+        const payload = JSON.parse(result.stdout);
+
+        assert.equal(result.status, 0);
+        assert.equal(payload.data.configuredDevPort.router.matchesApp, true);
+        assert.equal(payload.nextActions[0].label, 'Use Existing Runtime');
+        assert.match(payload.nextActions[0].command, new RegExp(`proteum diagnose "/" --port ${occupiedPort}`));
+        assert.match(payload.nextActions[0].reason, /Do not start a second dev server/);
+        assert.equal(payload.nextActions.some((action) => action.label === 'Start Dev'), false);
+        assert.doesNotMatch(result.stdout, /same app page body/);
+    } finally {
+        await closeServer(server);
+    }
+});

package/tests/codex-mcp-usage.test.cjs

@@ -0,0 +1,307 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawn } = require('node:child_process');
+
+const TEST_PROMPT = `Follow this project's agent instructions exactly.
+
+Do a read-only runtime orientation and health pass for this app.
+
+1. Confirm the intended app/worktree and whether exactly one usable dev server is running for it. If no usable dev server exists, start one using the project's prescribed dev-session workflow. Do not start a second live server for the same worktree.
+2. Report compact runtime status: app root, dev URL, package manager, route count, controller count, connected apps, and manifest freshness.
+3. Resolve selected project instruction files and briefly say why each one was selected.
+4. Pick one real browser route from the compact project map, prefer a public route; explain which page/controller owns it, then reproduce one request to that route.
+5. Diagnose that request and summarize only the important result: status, owner, hot calls, SQL count, error events, and likely next action.
+6. Show the latest trace/perf summary for that same request or route, capped to the smallest useful detail.
+7. Include recent dev log lines only if they explain a warning or failure.
+8. Do not edit files. Do not run broad tests unless the runtime evidence points to a concrete failure.
+
+Return a compact report with:
+- Runtime
+- Selected Instructions
+- Route Owner
+- Diagnosis
+- Trace/Perf
+- Any Follow-up Needed
+`;
+
+const enabled = process.env.PROTEUM_RUN_CODEX_MCP_USAGE_TEST === '1';
+const codexUsageTest = enabled ? test : test.skip;
+
+const parsePositiveInteger = (value, fallback) => {
+	const parsed = Number.parseInt(String(value || ''), 10);
+	return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+};
+
+const createOutputDir = () => {
+	const configured = process.env.PROTEUM_CODEX_MCP_USAGE_OUTPUT_DIR;
+	if (configured) {
+		fs.mkdirSync(configured, { recursive: true });
+		return configured;
+	}
+
+	return fs.mkdtempSync(path.join(os.tmpdir(), 'proteum-codex-mcp-usage-'));
+};
+
+const runCodex = async ({ appRoot, codexCli, outputDir, timeoutMs }) =>
+	await new Promise((resolve, reject) => {
+		const lastMessageFile = path.join(outputDir, 'last-message.md');
+		const child = spawn(
+			codexCli,
+			[
+				'exec',
+				'--json',
+				'--color',
+				'never',
+				'--cd',
+				appRoot,
+				'--skip-git-repo-check',
+				'--sandbox',
+				'workspace-write',
+				'--ask-for-approval',
+				'never',
+				'--output-last-message',
+				lastMessageFile,
+				'-',
+			],
+			{
+				cwd: appRoot,
+				env: {
+					...process.env,
+					NO_COLOR: '1',
+				},
+				stdio: ['pipe', 'pipe', 'pipe'],
+			},
+		);
+		let stdout = '';
+		let stderr = '';
+		let timedOut = false;
+		const timeout = setTimeout(() => {
+			timedOut = true;
+			child.kill('SIGTERM');
+			setTimeout(() => child.kill('SIGKILL'), 5000).unref();
+		}, timeoutMs);
+
+		child.stdout.on('data', (chunk) => {
+			stdout += chunk.toString();
+		});
+		child.stderr.on('data', (chunk) => {
+			stderr += chunk.toString();
+		});
+		child.stdin.end(TEST_PROMPT);
+		child.once('error', reject);
+		child.once('close', (status) => {
+			clearTimeout(timeout);
+			resolve({
+				lastMessage: fs.existsSync(lastMessageFile) ? fs.readFileSync(lastMessageFile, 'utf8') : '',
+				lastMessageFile,
+				status,
+				stderr,
+				stdout,
+				timedOut,
+			});
+		});
+	});
+
+const parseJsonl = (content) =>
+	content
+		.split(/\r?\n/)
+		.map((line) => line.trim())
+		.filter(Boolean)
+		.map((line) => {
+			try {
+				return { json: JSON.parse(line), line };
+			} catch {
+				return { json: undefined, line };
+			}
+		});
+
+const walk = (value, visitor, seen = new Set()) => {
+	if (value === null || value === undefined) return;
+	if (typeof value !== 'object') {
+		visitor(value, undefined);
+		return;
+	}
+	if (seen.has(value)) return;
+	seen.add(value);
+
+	if (Array.isArray(value)) {
+		for (const entry of value) walk(entry, visitor, seen);
+		return;
+	}
+
+	for (const [key, entry] of Object.entries(value)) {
+		visitor(entry, key);
+		walk(entry, visitor, seen);
+	}
+};
+
+const tokenKeys = {
+	cached: ['cached_input_tokens', 'cachedInputTokens', 'cached_tokens'],
+	input: ['input_tokens', 'inputTokens', 'prompt_tokens', 'promptTokens'],
+	output: ['output_tokens', 'outputTokens', 'completion_tokens', 'completionTokens'],
+	reasoning: ['reasoning_tokens', 'reasoningTokens', 'reasoning_output_tokens', 'reasoningOutputTokens'],
+	total: ['total_tokens', 'totalTokens'],
+};
+
+const getNumericTokenField = (object, keys) => {
+	for (const key of keys) {
+		if (typeof object[key] === 'number' && Number.isFinite(object[key])) return object[key];
+	}
+
+	return 0;
+};
+
+const collectTokenUsage = (events) => {
+	const samples = [];
+
+	for (const event of events) {
+		walk(event.json, (value) => {
+			if (!value || typeof value !== 'object' || Array.isArray(value)) return;
+			const sample = {
+				cached: getNumericTokenField(value, tokenKeys.cached),
+				input: getNumericTokenField(value, tokenKeys.input),
+				output: getNumericTokenField(value, tokenKeys.output),
+				reasoning: getNumericTokenField(value, tokenKeys.reasoning),
+				total: getNumericTokenField(value, tokenKeys.total),
+			};
+			if (!sample.total) sample.total = sample.input + sample.output;
+			if (sample.total || sample.input || sample.output || sample.cached || sample.reasoning) samples.push(sample);
+		});
+	}
+
+	return samples.reduce(
+		(summary, sample) => ({
+			cached: Math.max(summary.cached, sample.cached),
+			input: Math.max(summary.input, sample.input),
+			output: Math.max(summary.output, sample.output),
+			reasoning: Math.max(summary.reasoning, sample.reasoning),
+			samples: summary.samples + 1,
+			total: Math.max(summary.total, sample.total),
+		}),
+		{ cached: 0, input: 0, output: 0, reasoning: 0, samples: 0, total: 0 },
+	);
+};
+
+const countByName = (names) =>
+	names.reduce((counts, name) => {
+		counts[name] = (counts[name] || 0) + 1;
+		return counts;
+	}, {});
+
+const collectProteumMcpCalls = (events) => {
+	const calls = [];
+
+	for (const [index, event] of events.entries()) {
+		const names = new Set();
+		walk(event.json, (value, key) => {
+			if (typeof value !== 'string') return;
+			if (!['name', 'toolName', 'tool_name', 'recipient', 'recipient_name'].includes(String(key))) return;
+
+			const match = value.match(/(?:mcp__proteum__|proteum[.:/])([A-Za-z0-9_]+)/);
+			if (match) names.add(match[1]);
+		});
+
+		if (names.size === 0 && event.line.includes('mcp__proteum__')) {
+			for (const match of event.line.matchAll(/mcp__proteum__([A-Za-z0-9_]+)/g)) names.add(match[1]);
+		}
+
+		for (const name of names) calls.push({ event: index, name });
+	}
+
+	const names = calls.map((call) => call.name);
+	return { byName: countByName(names), calls, total: calls.length };
+};
+
+const collectProteumCliCalls = (events) => {
+	const commands = [];
+	const commandPattern = /(?:^|\s)(?:npx\s+)?proteum\s+[A-Za-z0-9:_-]+|node\s+\S*cli\/bin\.js\s+[A-Za-z0-9:_-]+/;
+
+	for (const [index, event] of events.entries()) {
+		const eventCommands = new Set();
+		walk(event.json, (value, key) => {
+			if (typeof value !== 'string') return;
+			if (!['cmd', 'command', 'shell', 'args', 'arguments'].includes(String(key))) return;
+			const match = value.match(commandPattern);
+			if (match) eventCommands.add(match[0].trim());
+		});
+
+		for (const command of eventCommands) commands.push({ command, event: index });
+	}
+
+	return {
+		byCommand: countByName(commands.map((entry) => entry.command)),
+		commands,
+		total: commands.length,
+	};
+};
+
+const analyzeCodexOutput = ({ stdout, stderr, lastMessage }) => {
+	const events = parseJsonl(stdout);
+	const parseErrors = events.filter((event) => !event.json).length;
+	const mcpCalls = collectProteumMcpCalls(events);
+	const cliCalls = collectProteumCliCalls(events);
+
+	return {
+		cliCalls,
+		eventCount: events.length,
+		lastMessageCharacters: lastMessage.length,
+		mcpCalls,
+		parseErrors,
+		stderrCharacters: stderr.length,
+		tokenUsage: collectTokenUsage(events),
+	};
+};
+
+codexUsageTest('Codex runtime health prompt uses Proteum MCP before CLI fallbacks', async () => {
+	const appRoot = process.env.PROTEUM_CODEX_MCP_USAGE_CWD;
+	assert.ok(appRoot, 'Set PROTEUM_CODEX_MCP_USAGE_CWD to the Proteum app root to test.');
+	assert.equal(fs.existsSync(appRoot), true, `Proteum app root does not exist: ${appRoot}`);
+
+	const outputDir = createOutputDir();
+	const codexCli = process.env.CODEX_CLI || 'codex';
+	const timeoutMs = parsePositiveInteger(process.env.PROTEUM_CODEX_MCP_USAGE_TIMEOUT_MS, 20 * 60 * 1000);
+	const minMcpCalls = parsePositiveInteger(process.env.PROTEUM_CODEX_MCP_MIN_MCP_CALLS, 4);
+	const maxCliCalls = parsePositiveInteger(process.env.PROTEUM_CODEX_MCP_MAX_CLI_CALLS, 4);
+
+	const result = await runCodex({ appRoot, codexCli, outputDir, timeoutMs });
+	const transcriptFile = path.join(outputDir, 'codex-events.jsonl');
+	const stderrFile = path.join(outputDir, 'stderr.txt');
+	const summaryFile = path.join(outputDir, 'summary.json');
+	fs.writeFileSync(transcriptFile, result.stdout);
+	fs.writeFileSync(stderrFile, result.stderr);
+
+	const summary = analyzeCodexOutput(result);
+	fs.writeFileSync(
+		summaryFile,
+		JSON.stringify(
+			{
+				...summary,
+				appRoot,
+				codexCli,
+				status: result.status,
+				timedOut: result.timedOut,
+				transcriptFile,
+				stderrFile,
+				lastMessageFile: result.lastMessageFile,
+			},
+			null,
+			2,
+		),
+	);
+
+	assert.equal(result.timedOut, false, `Codex CLI timed out. Summary: ${summaryFile}`);
+	assert.equal(result.status, 0, `Codex CLI exited with ${result.status}. Summary: ${summaryFile}`);
+	assert.equal(summary.parseErrors, 0, `Codex JSONL output contained parse errors. Summary: ${summaryFile}`);
+	assert.ok(summary.tokenUsage.samples > 0, `Codex JSONL output did not include token usage. Summary: ${summaryFile}`);
+	assert.ok(summary.tokenUsage.total > 0, `Codex token usage was not quantified. Summary: ${summaryFile}`);
+	assert.ok(summary.mcpCalls.total >= minMcpCalls, `Expected at least ${minMcpCalls} Proteum MCP calls. Summary: ${summaryFile}`);
+	assert.ok(
+		(summary.mcpCalls.byName.workflow_start || 0) >= 1,
+		`Expected at least one Proteum MCP workflow_start call. Summary: ${summaryFile}`,
+	);
+	assert.ok(summary.cliCalls.total <= maxCliCalls, `Expected at most ${maxCliCalls} Proteum CLI calls. Summary: ${summaryFile}`);
+
+	console.log(`Codex MCP usage summary: ${summaryFile}`);
+}, 25 * 60 * 1000);