@rage-against-the-pixel/unity-cli 1.8.3 → 3.0.0

package/dist/logging.js

@@ -1,40 +1,511 @@
 "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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Logger = exports.LogLevel = void 0;
-const fs = __importStar(require("fs"));
+exports.mergeLogEntriesPreferringSeverity = mergeLogEntriesPreferringSeverity;
+exports.testStatusFromState = testStatusFromState;
+exports.utpToTestResultSummary = utpToTestResultSummary;
+exports.buildTestResultsTableMarkdown = buildTestResultsTableMarkdown;
+exports.buildUnitTestJobSummaryMarkdown = buildUnitTestJobSummaryMarkdown;
+exports.truncateStringToUtf8ByteLength = truncateStringToUtf8ByteLength;
+exports.stripSummaryNoiseFromLogMessage = stripSummaryNoiseFromLogMessage;
+const utp_1 = require("./utp");
+const github_actions_ci_1 = require("./github-actions-ci");
+const logger_provider_1 = require("./logger-provider");
+/** Severity order for display: Error first, then Warning, then Info. Undefined treats as Warning. */
+function severityRank(s) {
+    if (s === utp_1.Severity.Error || s === utp_1.Severity.Exception || s === utp_1.Severity.Assert)
+        return 0;
+    if (s === utp_1.Severity.Warning || s === undefined)
+        return 1;
+    return 2; // Info
+}
+function dedupeKey(e) {
+    const msg = (e.message || '').trim();
+    const file = (e.file || e.fileName || '').replace(/\\/g, '/');
+    const line = e.line ?? e.lineNumber ?? 0;
+    return `${msg}\n${file}\n${line}`;
+}
+/**
+ * Returns true if the path looks absolute (Unix / or Windows X:/).
+ */
+function isAbsolutePath(file) {
+    const norm = file.replace(/\\/g, '/');
+    if (norm.startsWith('/'))
+        return true;
+    return /^[a-zA-Z]:\//.test(norm);
+}
+/**
+ * Returns true if the entry's file is under the project path (or entry has no file).
+ * Relative paths (e.g. Assets/..., Packages/...) are always kept so Unity UTP log/compiler
+ * entries with relative file paths still appear in the summary.
+ */
+function isEntryUnderProjectPath(e, projectPath) {
+    const file = (e.file || e.fileName || '').trim();
+    if (!file)
+        return true;
+    const normFile = file.replace(/\\/g, '/');
+    if (!isAbsolutePath(normFile))
+        return true;
+    const normProject = projectPath.replace(/\\/g, '/');
+    const base = normProject.endsWith('/') ? normProject : normProject + '/';
+    return normFile === normProject || normFile.startsWith(base);
+}
+/**
+ * Returns true if the entry's file looks like a Unity engine path (should be omitted when not using projectPath).
+ */
+function isUnityEnginePath(file) {
+    const norm = file.replace(/\\/g, '/');
+    if (UNITY_ENGINE_PATH_PREFIXES.some(p => norm.startsWith(p)))
+        return true;
+    if (norm.includes('/Runtime/') || norm.includes('\\Runtime\\'))
+        return true;
+    if (!norm.endsWith('.cpp'))
+        return false;
+    const underProject = norm.includes('/Assets/') || norm.includes('/Packages/') || norm.includes('/Library/PackageCache/');
+    return !underProject;
+}
+/**
+ * Merges LogEntry/Compiler rows by message+file+line; on collision keeps the more severe entry.
+ * Exported for unit tests.
+ */
+function mergeLogEntriesPreferringSeverity(candidates) {
+    const byKey = new Map();
+    for (const e of candidates) {
+        const key = dedupeKey(e);
+        const existing = byKey.get(key);
+        if (!existing || severityRank(e.severity) < severityRank(existing.severity)) {
+            byKey.set(key, e);
+        }
+    }
+    const merged = [...byKey.values()];
+    merged.sort((a, b) => severityRank(a.severity) - severityRank(b.severity));
+    return merged;
+}
+/**
+ * Builds one merged list from LogEntry and Compiler entries.
+ * Deduplicated by message+file+line (keeping worse severity on collision), sorted by severity.
+ */
+function buildMergedLogList(filtered) {
+    const candidates = filtered.filter(e => e.type === 'LogEntry' || e.type === 'Compiler');
+    return mergeLogEntriesPreferringSeverity(candidates);
+}
+/**
+ * Filters merged list to project-relevant entries only.
+ * When projectPath is set: keep entries with no file or file under projectPath.
+ * When projectPath is not set: exclude Unity engine paths only (keep PackageCache and project paths).
+ */
+function filterMergedByPath(merged, options) {
+    if (options?.projectPath != null && options.projectPath !== '') {
+        return merged.filter(e => isEntryUnderProjectPath(e, options.projectPath));
+    }
+    return merged.filter(e => {
+        const file = (e.file || e.fileName || '').trim();
+        if (!file)
+            return true;
+        return !isUnityEnginePath(file);
+    });
+}
+/** Groups merged log by severity for foldouts (Error, Warning, Info). Missing severity is grouped as Warning. */
+function groupBySeverity(merged) {
+    const errorCritical = [];
+    const warning = [];
+    const info = [];
+    for (const e of merged) {
+        if (e.severity === utp_1.Severity.Error || e.severity === utp_1.Severity.Exception || e.severity === utp_1.Severity.Assert) {
+            errorCritical.push(e);
+        }
+        else if (e.severity === utp_1.Severity.Warning || e.severity === undefined) {
+            warning.push(e);
+        }
+        else {
+            info.push(e);
+        }
+    }
+    return { errorCritical, warning, info };
+}
+/** Maps UTPTestStatus.state to display status (Unity/NUnit-style: 0 Inconclusive, 1 Passed, 2 Failed, 3 Skipped). */
+function testStatusFromState(state) {
+    switch (state) {
+        case 1: return '✅';
+        case 2: return '❌';
+        case 3: return '⏭️';
+        case 0:
+        default: return '◯';
+    }
+}
+/** Converts a single TestStatus UTP to TestResultSummary. Exported for CLI use. */
+function utpToTestResultSummary(e) {
+    const state = e.state;
+    const durationMs = e.duration ?? (e.durationMicroseconds != null ? e.durationMicroseconds / 1000 : 0);
+    const description = (e.name || e.description || '-').trim();
+    const msg = (e.message || '').trim();
+    const summary = {
+        status: testStatusFromState(state),
+        durationMs,
+        description,
+    };
+    if (msg !== '') {
+        summary.message = msg;
+    }
+    const file = (e.file || e.fileName || '').trim();
+    const line = e.line ?? e.lineNumber;
+    if (file !== '') {
+        summary.file = file.replace(/\\/g, '/');
+    }
+    if (line !== undefined && line > 0) {
+        summary.line = line;
+    }
+    return summary;
+}
+/** Collects TestStatus entries from telemetry into TestResultSummary rows. */
+function collectTestResults(filtered) {
+    return filtered.filter(e => e.type === 'TestStatus').map(utpToTestResultSummary);
+}
+function escapeMarkdownTableCell(value) {
+    return value
+        .replace(/\\/g, '\\\\')
+        .replace(/\|/g, '\\|');
+}
+/** Builds a markdown table string for test results (Status | Duration | Test). Exported for CLI use. */
+function buildTestResultsTableMarkdown(testResults, byteLimit, prefix) {
+    if (testResults.length === 0)
+        return '';
+    const p = prefix ?? '';
+    let out = p + `### Test results\n\n`;
+    out += `| Status | Duration | Test |\n`;
+    out += `|--------|----------|------|\n`;
+    let shown = 0;
+    for (const row of testResults) {
+        const durationStr = row.durationMs >= 1000
+            ? `${(row.durationMs / 1000).toFixed(1)}s`
+            : `${Math.round(row.durationMs)} ms`;
+        const rawDesc = row.description.length > 80 ? row.description.slice(0, 77) + '…' : row.description;
+        const desc = escapeMarkdownTableCell(rawDesc);
+        const line = `| ${escapeMarkdownTableCell(row.status)} | ${escapeMarkdownTableCell(durationStr)} | ${desc} |\n`;
+        if (Buffer.byteLength(out + line, 'utf8') > byteLimit)
+            break;
+        out += line;
+        shown++;
+    }
+    if (shown < testResults.length) {
+        out += `| … | … | … and ${testResults.length - shown} more |\n`;
+    }
+    out += `\n`;
+    return out;
+}
+function summarizeTestOutcomes(testResults) {
+    let passed = 0;
+    let failed = 0;
+    let skipped = 0;
+    let inconclusive = 0;
+    let totalDurationMs = 0;
+    for (const t of testResults) {
+        totalDurationMs += t.durationMs;
+        switch (t.status) {
+            case '✅':
+                passed++;
+                break;
+            case '❌':
+                failed++;
+                break;
+            case '⏭️':
+                skipped++;
+                break;
+            default:
+                inconclusive++;
+                break;
+        }
+    }
+    return { passed, failed, skipped, inconclusive, totalDurationMs };
+}
+/**
+ * Rich unit-test markdown block used by workflow summary and stdout.
+ * Keeps byte-budget behavior and truncation hints.
+ */
+function buildUnitTestJobSummaryMarkdown(testResults, byteLimit, prefix) {
+    if (testResults.length === 0)
+        return '';
+    const p = prefix ?? '';
+    let out = p + '### Unit test results\n\n';
+    const counts = summarizeTestOutcomes(testResults);
+    const durationStr = counts.totalDurationMs >= 1000
+        ? `${(counts.totalDurationMs / 1000).toFixed(1)}s`
+        : `${Math.round(counts.totalDurationMs)} ms`;
+    out += `**${testResults.length}** tests - **${counts.passed}** ✓, **${counts.failed}** ✗, **${counts.skipped}** skipped, **${counts.inconclusive}** inconclusive - **${durationStr}** total\n\n`;
+    out += '| Test | Result | Time | Message |\n';
+    out += '| --- | --- | --- | --- |\n';
+    const ordered = [...testResults].sort((a, b) => {
+        const aFail = a.status === '❌' ? 0 : 1;
+        const bFail = b.status === '❌' ? 0 : 1;
+        if (aFail !== bFail)
+            return aFail - bFail;
+        return b.durationMs - a.durationMs;
+    });
+    let shown = 0;
+    for (const row of ordered) {
+        const durationText = row.durationMs >= 1000 ? `${(row.durationMs / 1000).toFixed(1)}s` : `${Math.round(row.durationMs)} ms`;
+        const loc = row.file && row.line ? ` (${row.file}:${row.line})` : '';
+        const rawName = `${row.description}${loc}`;
+        const name = escapeMarkdownTableCell(rawName.length > 90 ? `${rawName.slice(0, 87)}…` : rawName);
+        const msgRaw = (row.message ?? '').replace(/\r?\n/g, ' ').trim();
+        const msg = escapeMarkdownTableCell(msgRaw.length > 120 ? `${msgRaw.slice(0, 117)}…` : msgRaw);
+        const line = `| ${name} | ${escapeMarkdownTableCell(row.status)} | ${escapeMarkdownTableCell(durationText)} | ${msg} |\n`;
+        if (Buffer.byteLength(out + line, 'utf8') > byteLimit)
+            break;
+        out += line;
+        shown++;
+    }
+    if (shown < ordered.length) {
+        out += `| … | … | … | … and ${ordered.length - shown} more |\n`;
+    }
+    out += '\n';
+    return out;
+}
+function buildActionTimelineTableMarkdown(completedActions, byteLimit, prefix) {
+    if (completedActions.length === 0)
+        return { markdown: '', truncated: false };
+    const p = prefix ?? '';
+    let out = p + '| Status | Duration | Errors | Action |\n';
+    out += '| --- | --- | --- | --- |\n';
+    let shown = 0;
+    for (const a of completedActions) {
+        const durationMs = a.duration ?? (a.durationMicroseconds != null ? a.durationMicroseconds / 1000 : undefined);
+        const errCount = Array.isArray(a.errors) ? a.errors.length : 0;
+        const status = errCount > 0 ? '❌' : '✅';
+        const action = truncateStr(toSingleLineText(a.description || a.name || '-'), 120);
+        const row = `| ${escapeMarkdownTableCell(status)} | ${escapeMarkdownTableCell(formatDurationMsForSummary(durationMs))} | ${errCount} | ${escapeMarkdownTableCell(action)} |\n`;
+        if (Buffer.byteLength(out + row, 'utf8') > byteLimit)
+            break;
+        out += row;
+        shown++;
+    }
+    const truncated = shown < completedActions.length;
+    if (truncated) {
+        out += `| ... | ... | ... | ... and ${completedActions.length - shown} more actions |\n`;
+    }
+    out += '\n';
+    return { markdown: out, truncated };
+}
+function buildActionTimelineCodeblockMarkdown(completedActions, byteLimit, prefix) {
+    if (completedActions.length === 0)
+        return '';
+    const p = prefix ?? '';
+    let out = p + '```text\n';
+    let timelineShown = 0;
+    for (const a of completedActions) {
+        const durationMs = a.duration ?? (a.durationMicroseconds != null ? a.durationMicroseconds / 1000 : undefined);
+        const errCount = Array.isArray(a.errors) ? a.errors.length : 0;
+        const status = errCount > 0 ? '❌' : '✅';
+        const desc = toSingleLineText(a.description || a.name || '-');
+        const durationStr = formatDurationMsForSummary(durationMs);
+        const row = `${status} ${durationStr} ${errCount} - ${desc}\n`;
+        if (Buffer.byteLength(out + row, 'utf8') > byteLimit)
+            break;
+        out += row;
+        timelineShown++;
+    }
+    if (timelineShown < completedActions.length) {
+        out += `... and ${completedActions.length - timelineShown} more actions\n`;
+    }
+    out += '```\n\n';
+    return out;
+}
+function truncateStr(s, max) {
+    return s.length <= max ? s : s.slice(0, max) + '…';
+}
+/**
+ * Truncates s to fit within maxBytes in UTF-8. If truncated, appends an ellipsis (…).
+ * If s already fits, returns s unchanged.
+ * Exported for unit tests.
+ */
+function truncateStringToUtf8ByteLength(s, maxBytes) {
+    if (maxBytes <= 0)
+        return '';
+    const ellipsis = '…';
+    const ellBytes = Buffer.byteLength(ellipsis, 'utf8');
+    if (Buffer.byteLength(s, 'utf8') <= maxBytes)
+        return s;
+    if (maxBytes <= ellBytes) {
+        let end = 0;
+        for (let i = 1; i <= s.length; i++) {
+            const sub = s.slice(0, i);
+            if (Buffer.byteLength(sub, 'utf8') > maxBytes)
+                break;
+            end = i;
+        }
+        return s.slice(0, end);
+    }
+    let low = 0;
+    let high = s.length;
+    while (low < high) {
+        const mid = Math.floor((low + high + 1) / 2);
+        const sub = s.slice(0, mid);
+        if (Buffer.byteLength(sub, 'utf8') + ellBytes <= maxBytes)
+            low = mid;
+        else
+            high = mid - 1;
+    }
+    return s.slice(0, low) + ellipsis;
+}
+/**
+ * Appends one formatted log line per entry, truncating each line only when it would exceed the
+ * remaining bytes in the workflow summary (byteLimit is total cap for the final string starting from out).
+ */
+function appendWorkflowSummaryLogLines(out, entries, byteLimit) {
+    let o = out;
+    let shown = 0;
+    const newline = '\n';
+    const nlBytes = Buffer.byteLength(newline, 'utf8');
+    for (let i = 0; i < entries.length; i++) {
+        const entry = entries[i];
+        if (entry === undefined) {
+            return { out: o, shown, omitted: entries.length - shown };
+        }
+        const room = byteLimit - Buffer.byteLength(o, 'utf8');
+        if (room < nlBytes) {
+            return { out: o, shown, omitted: entries.length - shown };
+        }
+        const rawLine = formatLogEntryLine(entry, Number.POSITIVE_INFINITY).replace(/\n$/, '');
+        const maxContentBytes = room - nlBytes;
+        const lineBody = Buffer.byteLength(rawLine, 'utf8') <= maxContentBytes
+            ? rawLine
+            : truncateStringToUtf8ByteLength(rawLine, maxContentBytes);
+        o += lineBody + newline;
+        shown++;
+    }
+    return { out: o, shown, omitted: 0 };
+}
+function toSingleLineText(value) {
+    return value
+        .replace(/\r?\n+/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function formatDurationMsForSummary(ms) {
+    if (ms === undefined || !Number.isFinite(ms)) {
+        return '-';
+    }
+    if (ms < 1000) {
+        return `${Math.round(ms)}ms`;
+    }
+    return `${(ms / 1000).toFixed(1)}s`;
+}
+/** Unity/CI noise shown in logs; omit from workflow summary foldouts and counts. */
+const SUMMARY_NOISE_ACCESS_TOKEN = 'Access token is unavailable; failed to update';
+/**
+ * Removes known noise phrases from a log message for summary display.
+ * Exported for unit tests.
+ */
+function stripSummaryNoiseFromLogMessage(message) {
+    const flat = toSingleLineText(message);
+    if (!flat)
+        return '';
+    const pattern = SUMMARY_NOISE_ACCESS_TOKEN.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const out = flat.replace(new RegExp(pattern, 'gi'), ' ').replace(/\s+/g, ' ').trim();
+    return out;
+}
+function filterNoiseFromSummaryLogEntries(entries) {
+    const out = [];
+    for (const e of entries) {
+        const stripped = stripSummaryNoiseFromLogMessage(e.message || '');
+        if (stripped === '')
+            continue;
+        const originalFlat = toSingleLineText(e.message || '');
+        if (stripped !== originalFlat) {
+            out.push({ ...e, message: stripped });
+        }
+        else {
+            out.push(e);
+        }
+    }
+    return out;
+}
+function renderBuildActionsFoldoutMarkdown(completedActions, maxBytes) {
+    const n = completedActions.length;
+    const open = `<details open><summary>Build actions (${n})</summary>\n\n`;
+    const close = `</details>\n\n`;
+    const overhead = Buffer.byteLength(open + close, 'utf8');
+    const innerBudget = Math.max(0, maxBytes - overhead);
+    const table = buildActionTimelineTableMarkdown(completedActions, innerBudget, '');
+    const inner = !table.truncated
+        ? table.markdown
+        : buildActionTimelineCodeblockMarkdown(completedActions, innerBudget, '');
+    return open + inner + close;
+}
+/** Paths to treat as Unity engine (omit from summary when using heuristic filter). */
+const UNITY_ENGINE_PATH_PREFIXES = [
+    'Runtime/',
+    './Runtime/',
+    'Modules/',
+    './Modules/',
+];
+/**
+ * Normalizes a log message for display by stripping a redundant file:line prefix
+ * when it matches the entry's file/line so the path appears only once.
+ * Returns the normalized message and optional column if present in the prefix.
+ */
+function normalizeMessageForDisplay(message, file, line) {
+    const trimmed = message.trim();
+    const normFile = file.replace(/\\/g, '/');
+    if (!normFile && line === undefined)
+        return { message: trimmed };
+    // path(line,col): e.g. Assets/File.cs(2,8): error ...
+    const parenColon = trimmed.match(/^(.+?)\((\d+),(\d+)\):\s*/);
+    if (parenColon && parenColon[1] != null && parenColon[2] != null && parenColon[3] != null) {
+        const fullMatch = parenColon[0];
+        const msgPath = parenColon[1].replace(/\\/g, '/');
+        const msgLine = parseInt(parenColon[2], 10);
+        const msgCol = parseInt(parenColon[3], 10);
+        const pathMatches = msgPath === normFile || normFile.endsWith(msgPath) || msgPath.endsWith(normFile);
+        if (pathMatches && (line === undefined || line === msgLine)) {
+            return { message: trimmed.slice(fullMatch.length).trim(), column: msgCol };
+        }
+    }
+    // path(line): e.g. Assets/File.cs(2): ...
+    const parenOnly = trimmed.match(/^(.+?)\((\d+)\):\s*/);
+    if (parenOnly && parenOnly[1] != null && parenOnly[2] != null) {
+        const fullMatch = parenOnly[0];
+        const msgPath = parenOnly[1].replace(/\\/g, '/');
+        const msgLine = parseInt(parenOnly[2], 10);
+        const pathMatches = msgPath === normFile || normFile.endsWith(msgPath) || msgPath.endsWith(normFile);
+        if (pathMatches && (line === undefined || line === msgLine)) {
+            return { message: trimmed.slice(fullMatch.length).trim() };
+        }
+    }
+    // path:line: e.g. path/to/file.cs:10:
+    const pathLineColon = trimmed.match(/^(.+?):(\d+):\s*/);
+    if (pathLineColon && pathLineColon[1] != null && pathLineColon[2] != null) {
+        const fullMatch = pathLineColon[0];
+        const msgPath = pathLineColon[1].replace(/\\/g, '/');
+        const msgLine = parseInt(pathLineColon[2], 10);
+        const pathMatches = msgPath === normFile || normFile.endsWith(msgPath) || msgPath.endsWith(normFile);
+        if (pathMatches && (line === undefined || line === msgLine)) {
+            return { message: trimmed.slice(fullMatch.length).trim() };
+        }
+    }
+    return { message: trimmed };
+}
+/**
+ * One line per entry: path(line,col): &lt;message&gt; or path(line): &lt;message&gt; when column is missing.
+ * When file/line are missing, outputs: - &lt;message&gt;.
+ */
+function formatLogEntryLine(e, maxMsgLen = Number.POSITIVE_INFINITY) {
+    const file = (e.file || e.fileName || '').replace(/\\/g, '/');
+    const line = e.line ?? e.lineNumber;
+    const hasLocation = file && (line !== undefined && line > 0);
+    const rawMsg = toSingleLineText(e.message || '');
+    const { message: normalizedMsg, column } = hasLocation
+        ? normalizeMessageForDisplay(rawMsg, file, line)
+        : { message: rawMsg, column: undefined };
+    const msg = Number.isFinite(maxMsgLen) && maxMsgLen >= 0 && maxMsgLen < Number.POSITIVE_INFINITY
+        ? truncateStr(normalizedMsg, maxMsgLen)
+        : normalizedMsg;
+    if (hasLocation) {
+        const loc = column !== undefined ? `${file}(${line},${column})` : `${file}(${line})`;
+        return `${loc}: ${msg}\n`;
+    }
+    return `${msg}\n`;
+}
 var LogLevel;
 (function (LogLevel) {
     LogLevel["DEBUG"] = "debug";
@@ -46,22 +517,16 @@ var LogLevel;
 })(LogLevel || (exports.LogLevel = LogLevel = {}));
 class Logger {
     logLevel = LogLevel.INFO;
-    _ci;
+    _provider;
     static instance = new Logger();
     constructor() {
+        this._provider = process.env.GITHUB_ACTIONS === 'true'
+            ? new github_actions_ci_1.GitHubActionsLoggerProvider()
+            : new logger_provider_1.LocalCliLoggerProvider();
         if (process.env.GITHUB_ACTIONS === 'true') {
-            this._ci = 'GITHUB_ACTIONS';
             this.logLevel = process.env.ACTIONS_STEP_DEBUG === 'true' ? LogLevel.DEBUG : LogLevel.CI;
         }
     }
-    printLine(message, lineColor, optionalParams = []) {
-        if (lineColor && lineColor.length > 0) {
-            process.stdout.write(`${lineColor}${message}\x1b[0m\n`, ...optionalParams);
-        }
-        else {
-            process.stdout.write(`${message}\n`, ...optionalParams);
-        }
-    }
     /**
      * Logs a message to the console.
      * @param level The log level for this message.
@@ -70,78 +535,24 @@ class Logger {
      */
     log(level, message, optionalParams = []) {
         if (this.shouldLog(level)) {
-            switch (this._ci) {
-                case 'GITHUB_ACTIONS': {
-                    switch (level) {
-                        case LogLevel.DEBUG: {
-                            message.toString().split('\n').forEach((line) => {
-                                process.stdout.write(`::debug::${line}\n`, ...optionalParams);
-                            });
-                            break;
-                        }
-                        case LogLevel.CI:
-                        case LogLevel.INFO: {
-                            process.stdout.write(`${message}\n`, ...optionalParams);
-                            break;
-                        }
-                        default: {
-                            process.stdout.write(`::${level}::${message}\n`, ...optionalParams);
-                            break;
-                        }
-                    }
-                    break;
-                }
-                default: {
-                    const stringColor = {
-                        [LogLevel.DEBUG]: '\x1b[35m', // Purple
-                        [LogLevel.INFO]: undefined, // No color / White
-                        [LogLevel.CI]: undefined, // No color / White
-                        [LogLevel.UTP]: undefined, // No color / White
-                        [LogLevel.WARN]: '\x1b[33m', // Yellow
-                        [LogLevel.ERROR]: '\x1b[31m', // Red
-                    }[level] || undefined; // Default to no color / White
-                    this.printLine(message, stringColor, optionalParams);
-                    break;
-                }
-            }
+            this._provider.log(level, message, optionalParams);
         }
     }
     /**
      * Starts a log group. In CI environments that support grouping, this will create a collapsible group.
      */
     startGroup(message, optionalParams = [], logLevel = LogLevel.INFO) {
-        switch (this._ci) {
-            case 'GITHUB_ACTIONS': {
-                // if there is newline in message, only use the first line for group title
-                // then print the rest of the lines inside the group in cyan color
-                const firstLine = message.toString().split('\n')[0];
-                const restLines = message.toString().split('\n').slice(1);
-                process.stdout.write(`::group::${firstLine}\n`, ...optionalParams);
-                restLines.forEach(line => {
-                    this.printLine(line, '\x1b[36m', ...optionalParams);
-                });
-                break;
-            }
-            default: {
-                // No grouping in standard console
-                this.log(logLevel, message, optionalParams);
-                break;
-            }
+        if (this._provider.isCi) {
+            this._provider.startGroup(message, optionalParams);
+            return;
         }
+        this.log(logLevel, message, optionalParams);
     }
     /**
      * Ends a log group. In CI environments that support grouping, this will end the current group.
      */
     endGroup() {
-        switch (this._ci) {
-            case 'GITHUB_ACTIONS': {
-                process.stdout.write(`::endgroup::\n`);
-                break;
-            }
-            default: {
-                break; // No grouping in standard console
-            }
-        }
+        this._provider.endGroup();
     }
     /**
      * Logs a message with CI level.
@@ -175,59 +586,37 @@ class Logger {
      * @param title The title of the annotation.
      */
     annotate(logLevel, message, file, line, endLine, column, endColumn, title) {
-        let annotation = '';
-        switch (this._ci) {
-            case 'GITHUB_ACTIONS': {
-                const level = {
-                    [LogLevel.CI]: 'notice',
-                    [LogLevel.INFO]: 'notice',
-                    [LogLevel.DEBUG]: 'notice',
-                    [LogLevel.UTP]: 'notice',
-                    [LogLevel.WARN]: 'warning',
-                    [LogLevel.ERROR]: 'error',
-                }[logLevel] ?? 'notice';
-                const parts = [];
-                const appendPart = (key, value) => {
-                    if (value === undefined || value === null) {
-                        return;
-                    }
-                    const stringValue = value.toString();
-                    if (stringValue.length === 0) {
-                        return;
-                    }
-                    parts.push(`${key}=${this.escapeGitHubCommandValue(stringValue)}`);
-                };
-                appendPart('file', file);
-                if (line !== undefined && line > 0) {
-                    appendPart('line', line);
-                }
-                if (endLine !== undefined && endLine > 0) {
-                    appendPart('endLine', endLine);
-                }
-                if (column !== undefined && column > 0) {
-                    appendPart('col', column);
-                }
-                if (endColumn !== undefined && endColumn > 0) {
-                    appendPart('endColumn', endColumn);
-                }
-                appendPart('title', title);
-                const metadata = parts.length > 0 ? ` ${parts.join(',')}` : '';
-                annotation = `::${level}${metadata}::${this.escapeGitHubCommandValue(message)}`;
-                break;
-            }
+        const level = {
+            [LogLevel.CI]: 'notice',
+            [LogLevel.INFO]: 'notice',
+            [LogLevel.DEBUG]: 'notice',
+            [LogLevel.UTP]: 'notice',
+            [LogLevel.WARN]: 'warning',
+            [LogLevel.ERROR]: 'error',
+        }[logLevel] ?? 'notice';
+        const options = {};
+        if (file !== undefined && file !== '') {
+            options.file = file;
         }
-        if (annotation.length > 0) {
-            process.stdout.write(`${annotation}\n`);
+        if (line !== undefined) {
+            options.line = line;
         }
-        else {
-            this.log(logLevel, message);
+        if (endLine !== undefined) {
+            options.endLine = endLine;
         }
-    }
-    escapeGitHubCommandValue(value) {
-        return value
-            .replace(/%/g, '%25')
-            .replace(/\r/g, '%0D')
-            .replace(/\n/g, '%0A');
+        if (column !== undefined) {
+            options.column = column;
+        }
+        if (endColumn !== undefined) {
+            options.endColumn = endColumn;
+        }
+        if (title !== undefined && title !== '') {
+            options.title = title;
+        }
+        const backendLevel = level === 'error'
+            ? github_actions_ci_1.GitHubAnnotationLevel.Error
+            : (level === 'warning' ? github_actions_ci_1.GitHubAnnotationLevel.Warning : github_actions_ci_1.GitHubAnnotationLevel.Notice);
+        this._provider.annotate(backendLevel, message, options);
     }
     shouldLog(level) {
         if (level === LogLevel.CI) {
@@ -241,12 +630,79 @@ class Logger {
      * @param message The string to mask.
      */
     CI_mask(message) {
-        switch (this._ci) {
-            case 'GITHUB_ACTIONS': {
-                process.stdout.write(`::add-mask::${message}\n`);
-                break;
+        this._provider.mask(message);
+    }
+    /**
+     * Masks a credential value in CI environments before it appears in logs.
+     * This is a convenience wrapper around CI_mask for credential values.
+     * @param value The credential value to mask.
+     */
+    maskCredential(value) {
+        if (value && value.length > 0) {
+            this.CI_mask(value);
+        }
+    }
+    /**
+     * Logs command-line options with sensitive information scrubbed.
+     * Automatically removes passwords, tokens, emails, and other credentials from the output.
+     * @param options The options object to log (typically from commander.js).
+     * @param optionalParams Additional parameters to log.
+     */
+    debugOptions(options, ...optionalParams) {
+        // Avoid expensive scrubbing and stringification when debug logging is disabled.
+        if (this.logLevel !== LogLevel.DEBUG) {
+            return;
+        }
+        const scrubbed = this.scrubSensitiveData(options);
+        this.debug(JSON.stringify(scrubbed), ...optionalParams);
+    }
+    /**
+     * List of sensitive option keys that should be scrubbed from debug output.
+     */
+    SENSITIVE_KEYS = [
+        'password',
+        'email',
+        'serial',
+        'token',
+        'config',
+        'organization',
+        'username',
+        'servicesConfig',
+        'serviceaccountkey',
+    ];
+    /**
+     * Scrubs sensitive information from an object for safe logging.
+     * Creates a deep clone of the object and replaces sensitive values with [REDACTED].
+     * @param obj The object to scrub (typically command-line options).
+     * @returns A new object with sensitive values replaced.
+     */
+    scrubSensitiveData(obj) {
+        if (obj === null || obj === undefined) {
+            return obj;
+        }
+        if (typeof obj !== 'object') {
+            return obj;
+        }
+        if (Array.isArray(obj)) {
+            return obj.map((item) => this.scrubSensitiveData(item));
+        }
+        const scrubbedObj = {};
+        for (const key in obj) {
+            if (obj.hasOwnProperty(key)) {
+                const lowerKey = key.toLowerCase();
+                const isSensitive = this.SENSITIVE_KEYS.some(sensitiveKey => lowerKey.includes(sensitiveKey.toLowerCase()));
+                if (isSensitive) {
+                    scrubbedObj[key] = '[REDACTED]';
+                }
+                else if (typeof obj[key] === 'object') {
+                    scrubbedObj[key] = this.scrubSensitiveData(obj[key]);
+                }
+                else {
+                    scrubbedObj[key] = obj[key];
+                }
             }
         }
+        return scrubbedObj;
     }
     /**
      * Sets an environment variable in CI environments that support it.
@@ -254,44 +710,182 @@ class Logger {
      * @param value The value of the environment variable.
      */
     CI_setEnvironmentVariable(name, value) {
-        switch (this._ci) {
-            case 'GITHUB_ACTIONS': {
-                // needs to be appended to the temporary file specified in the GITHUB_ENV environment variable
-                const githubEnv = process.env.GITHUB_ENV;
-                // echo "MY_ENV_VAR=myValue" >> $GITHUB_ENV
-                if (githubEnv) {
-                    fs.appendFileSync(githubEnv, `${name}=${value}\n`, { encoding: 'utf8' });
-                }
+        this._provider.setEnvironmentVariable(name, value);
+    }
+    CI_setOutput(name, value) {
+        this._provider.setOutput(name, value);
+    }
+    static formatDurationMs(ms) {
+        if (ms === undefined || !Number.isFinite(ms)) {
+            return '-';
+        }
+        if (ms < 1000) {
+            return `${Math.round(ms)}ms`;
+        }
+        return `${(ms / 1000).toFixed(1)}s`;
+    }
+    static truncateStr(s, max) {
+        return s.length <= max ? s : s.slice(0, max) + '…';
+    }
+    static truncateSummaryToByteLimit(summary, byteLimit) {
+        const footer = `\n***Summary truncated due to size limits.***\n`;
+        const footerSize = Buffer.byteLength(footer, 'utf8');
+        const lines = summary.split('\n');
+        let rebuilt = '';
+        for (const line of lines) {
+            const nextSize = Buffer.byteLength(rebuilt + line + '\n', 'utf8') + footerSize;
+            if (nextSize > byteLimit) {
                 break;
             }
+            rebuilt += `${line}\n`;
         }
+        return rebuilt + footer;
     }
-    CI_setOutput(name, value) {
-        switch (this._ci) {
-            case 'GITHUB_ACTIONS': {
-                // needs to be appended to the temporary file specified in the GITHUB_OUTPUT environment variable
-                const githubOutput = process.env.GITHUB_OUTPUT;
-                // echo "myOutput=myValue" >> $GITHUB_OUTPUT
-                if (githubOutput) {
-                    fs.appendFileSync(githubOutput, `${name}=${value}\n`, { encoding: 'utf8' });
-                }
+    /**
+     * Returns the markdown byte limit for a given output target.
+     * Workflow summary may be backend constrained; stdout is intentionally uncapped.
+     */
+    getMarkdownByteLimit(target) {
+        return this._provider.getMarkdownByteLimit(target);
+    }
+    CI_appendWorkflowSummary(name, telemetry, options) {
+        if (telemetry.length === 0) {
+            return;
+        }
+        if (this.getMarkdownByteLimit('workflow-summary') === Number.POSITIVE_INFINITY) {
+            return;
+        }
+        const excludedTypes = new Set(['MemoryLeaks', 'MemoryLeak']);
+        const filtered = telemetry.filter(entry => !excludedTypes.has(entry.type || ''));
+        if (filtered.length === 0) {
+            return;
+        }
+        const completedActions = filtered.filter(e => e.type === 'Action' && e.phase === 'End');
+        const testResults = collectTestResults(filtered);
+        const additional = options?.additionalLogEntries ?? [];
+        const merged = mergeLogEntriesPreferringSeverity([
+            ...buildMergedLogList(filtered),
+            ...additional.filter(e => e.type === 'LogEntry' || e.type === 'Compiler'),
+        ]);
+        const pathFiltered = filterMergedByPath(merged, options);
+        const summaryLogs = filterNoiseFromSummaryLogEntries(pathFiltered);
+        const bySeverity = groupBySeverity(summaryLogs);
+        const limit = this.getMarkdownByteLimit('workflow-summary');
+        const builders = [
+            () => this.buildSummaryTimelineAndMergedLog(name, completedActions, bySeverity, testResults, limit),
+            () => this.buildSummaryCollapsibleWithMergedLog(name, completedActions, bySeverity, testResults, limit),
+            () => this.buildSummaryTimelineAndCounts(name, completedActions, summaryLogs.length, testResults, limit),
+        ];
+        let summary = '';
+        for (const build of builders) {
+            summary = build();
+            if (Buffer.byteLength(summary, 'utf8') <= limit) {
                 break;
             }
         }
+        if (Buffer.byteLength(summary, 'utf8') > limit) {
+            summary = Logger.truncateSummaryToByteLimit(summary, limit);
+        }
+        this._provider.appendStepSummary(summary);
     }
-    CI_appendWorkflowSummary(telemetry) {
-        switch (this._ci) {
-            case 'GITHUB_ACTIONS': {
-                const githubSummary = process.env.GITHUB_STEP_SUMMARY;
-                if (githubSummary) {
-                    let table = `| Key | Value |\n| --- | ----- |\n`;
-                    telemetry.forEach(item => {
-                        table += `| ${item.key} | ${item.value} |\n`;
-                    });
-                    fs.appendFileSync(githubSummary, table, { encoding: 'utf8' });
-                }
+    /**
+     * Builds summary: stats + action table + unit-test block + severity foldouts.
+     */
+    buildSummaryTimelineAndMergedLog(name, completedActions, bySeverity, testResults, byteLimit) {
+        let out = `## ${name} Summary\n\n`;
+        const totalDurationMs = completedActions.reduce((sum, a) => sum + (a.duration ?? (a.durationMicroseconds != null ? a.durationMicroseconds / 1000 : 0)), 0);
+        const totalSec = totalDurationMs / 1000;
+        const totalStr = totalSec >= 60 ? `${Math.round(totalSec / 60)}m ${Math.round(totalSec % 60)}s` : `${totalSec.toFixed(1)}s`;
+        out += `Errors: ${bySeverity.errorCritical.length}\n`;
+        out += `Warnings: ${bySeverity.warning.length}\n`;
+        out += `Total duration: ${totalStr}\n`;
+        out += `Actions: ${completedActions.length}\n`;
+        if (testResults.length > 0) {
+            out += `Tests: ${testResults.length}\n`;
+        }
+        out += '\n';
+        if (completedActions.length > 0) {
+            const remaining = byteLimit - Buffer.byteLength(out, 'utf8');
+            out += renderBuildActionsFoldoutMarkdown(completedActions, remaining);
+        }
+        if (testResults.length > 0) {
+            const remaining = byteLimit - Buffer.byteLength(out, 'utf8');
+            out += buildUnitTestJobSummaryMarkdown(testResults, remaining, '');
+        }
+        const limit = byteLimit;
+        const appendFoldout = (title, entries, dropSuffix, openByDefault) => {
+            if (entries.length === 0)
+                return;
+            const openAttr = openByDefault ? ' open' : '';
+            out += `<details${openAttr}><summary>${title} (${entries.length})</summary>\n\n`;
+            out += '```text\n';
+            const appended = appendWorkflowSummaryLogLines(out, entries, limit);
+            out = appended.out;
+            if (appended.omitted > 0) {
+                out += `... and ${appended.omitted} more ${dropSuffix}\n`;
             }
+            out += '```\n\n';
+            out += `</details>\n\n`;
+        };
+        appendFoldout('Error', bySeverity.errorCritical, '(see annotations).', true);
+        appendFoldout('Warning', bySeverity.warning, '(truncated; see full log).');
+        appendFoldout('Info', bySeverity.info, '(truncated; see full log).');
+        return out;
+    }
+    /**
+     * Builds summary with timeline in a <details> and merged log foldouts by severity.
+     * Used when primary builder would exceed size limit.
+     */
+    buildSummaryCollapsibleWithMergedLog(name, completedActions, bySeverity, testResults, byteLimit) {
+        let out = `## ${name} Summary\n\n`;
+        if (completedActions.length > 0) {
+            const remaining = byteLimit - Buffer.byteLength(out, 'utf8');
+            out += renderBuildActionsFoldoutMarkdown(completedActions, remaining);
+        }
+        if (testResults.length > 0) {
+            const remaining = byteLimit - Buffer.byteLength(out, 'utf8');
+            out += buildUnitTestJobSummaryMarkdown(testResults, remaining, '');
+        }
+        const limit = byteLimit;
+        const appendFoldout = (title, entries, dropSuffix, openByDefault) => {
+            if (entries.length === 0)
+                return;
+            const openAttr = openByDefault ? ' open' : '';
+            out += `<details${openAttr}><summary>${title} (${entries.length})</summary>\n\n`;
+            out += '```text\n';
+            const appended = appendWorkflowSummaryLogLines(out, entries, limit);
+            out = appended.out;
+            if (appended.omitted > 0)
+                out += `... and ${appended.omitted} more ${dropSuffix}\n`;
+            out += '```\n\n';
+            out += `</details>\n\n`;
+        };
+        appendFoldout('Error', bySeverity.errorCritical, '(see annotations).', true);
+        appendFoldout('Warning', bySeverity.warning, '(truncated; see full log).');
+        appendFoldout('Info', bySeverity.info, '(truncated; see full log).');
+        return out;
+    }
+    /**
+     * Fallback: list timeline (when actions exist) + unit-test block (when present) + compact count lines.
+     * Used when even collapsible summary would exceed 1 MB.
+     */
+    buildSummaryTimelineAndCounts(name, completedActions, logCount, testResults, byteLimit) {
+        let out = `## ${name} Summary\n\n`;
+        if (completedActions.length > 0) {
+            const remaining = byteLimit - Buffer.byteLength(out, 'utf8');
+            out += renderBuildActionsFoldoutMarkdown(completedActions, remaining);
+        }
+        if (testResults.length > 0) {
+            const remaining = byteLimit - Buffer.byteLength(out, 'utf8');
+            out += buildUnitTestJobSummaryMarkdown(testResults, remaining, '');
+        }
+        out += `Log entries: ${logCount}\n`;
+        out += `Actions: ${completedActions.length}\n`;
+        if (testResults.length > 0) {
+            out += `Tests: ${testResults.length}\n`;
         }
+        out += `\nSee annotations for details.\n`;
+        return out;
     }
 }
 exports.Logger = Logger;