@copado/agentia-cli 1.2.0 → 1.3.0

package/dist/lib/agentia-command.js

@@ -1,8 +1,10 @@
 import { Command, Errors, ux } from '@oclif/core';
 import { format } from 'node:util';
-import { createTransactionId, runWithGatewayTransactionContext } from './cicd-gateway.js';
+import { createTransactionId, getGatewayClientOrigin, getGatewayTransactionOrigin, runWithGatewayTransactionContext, } from './cicd-gateway.js';
 import { colorizeCliSeverityError, colorizeCliSeverityText } from './cli-severity-color.js';
-import { isCommandOutputCaptureActive } from './command-output-buffer.js';
+import { COMMAND_HISTORY_TEXT_MAX_BYTES } from './command-history-sanitization.js';
+import { recordCommandHistory } from './command-history.js';
+import { isCommandOutputCaptureActive, runWithCommandOutputCapture, runWithoutCommandOutputCapture, } from './command-output-buffer.js';
 import { rememberIdeCommandError } from './ide-command-events.js';
 import { redactErrorMessage, redactSecrets } from './secret-redaction.js';
 const TRANSACTION_ID_REPORTED = Symbol('agentiaTransactionIdReported');
@@ -49,13 +51,40 @@ export function formatElapsedSecondsMessage(seconds) {
 export class AgentiaCommand extends Command {
     static enableJsonFlag = true;
     static experimental = false;
+    commandClientOrigin;
+    commandExecutionId;
+    commandHistoryCapture;
+    commandHistoryError;
+    commandHistoryResult;
+    commandHistoryStartedAtMs;
+    commandHistoryWritten = false;
     commandTransactionId;
     async _run() {
         const transactionId = createTransactionId();
+        this.commandClientOrigin = getGatewayTransactionOrigin() ?? getGatewayClientOrigin();
+        this.commandExecutionId = createTransactionId();
+        this.commandHistoryStartedAtMs = Date.now();
         this.commandTransactionId = transactionId;
-        return runWithGatewayTransactionContext({ origin: 'cli', referer: this.id, transactionId }, () => super._run());
+        return runWithGatewayTransactionContext({ origin: this.commandClientOrigin, referer: this.id, transactionId }, async () => {
+            let caught;
+            try {
+                const result = await this.runWithHistoryCapture(() => super._run());
+                if (this.commandHistoryError === undefined)
+                    this.commandHistoryResult = result;
+                return result;
+            }
+            catch (error) {
+                caught = error instanceof Error ? error : new Error(String(error));
+                this.commandHistoryError ??= caught;
+                throw error;
+            }
+            finally {
+                await this.recordCommandHistoryOnce(this.commandHistoryError ?? caught);
+            }
+        });
     }
     async catch(error) {
+        this.commandHistoryError = error;
         this.reportHumanErrorTransactionId(error);
         if (!this.jsonEnabled()) {
             colorizeCliSeverityError(error, 'error');
@@ -116,6 +145,7 @@ export class AgentiaCommand extends Command {
         };
     }
     toSuccessJson(result) {
+        this.commandHistoryResult = result;
         const warnings = this.jsonWarnings(result);
         return {
             result,
@@ -141,14 +171,14 @@ export class AgentiaCommand extends Command {
             }
             return action();
         }
-        ux.action.start(message);
+        runWithoutCommandOutputCapture(() => ux.action.start(message));
         try {
             const result = await action();
-            ux.action.stop();
+            runWithoutCommandOutputCapture(() => ux.action.stop());
             return result;
         }
         catch (error) {
-            ux.action.stop(ux.colorize('red', 'failed'));
+            runWithoutCommandOutputCapture(() => ux.action.stop(ux.colorize('red', 'failed')));
             throw error;
         }
     }
@@ -162,6 +192,25 @@ export class AgentiaCommand extends Command {
         ];
         return [...new Set(warnings)];
     }
+    async recordCommandHistoryOnce(error) {
+        if (this.commandHistoryWritten)
+            return;
+        this.commandHistoryWritten = true;
+        const capture = this.commandHistoryCapture;
+        await recordCommandHistory({
+            argv: this.argv,
+            clientOrigin: this.commandClientOrigin,
+            cliVersion: this.config.version,
+            commandId: this.id ?? '',
+            error,
+            executionId: this.commandExecutionId,
+            logs: capture?.events,
+            result: this.commandHistoryResult,
+            startedAtMs: this.commandHistoryStartedAtMs,
+            transactionId: this.commandTransactionId,
+            truncatedStreams: capture?.truncatedStreams,
+        });
+    }
     reportHumanErrorTransactionId(error) {
         if (this.jsonEnabled() || this.commandTransactionId === undefined) {
             return;
@@ -180,5 +229,19 @@ export class AgentiaCommand extends Command {
         const { warnings } = result;
         return Array.isArray(warnings) ? warnings.filter((warning) => typeof warning === 'string') : [];
     }
+    async runWithHistoryCapture(action) {
+        const capture = await runWithCommandOutputCapture(action, {
+            captureVisibleToCommand: false,
+            forwardStderr: true,
+            forwardStdout: true,
+            maxBytes: COMMAND_HISTORY_TEXT_MAX_BYTES,
+            onCapture: (captured) => {
+                this.commandHistoryCapture = captured;
+            },
+            tail: true,
+            trackEvents: true,
+        });
+        return capture.result;
+    }
 }
 //# sourceMappingURL=agentia-command.js.map

package/dist/lib/cicd-command.js

@@ -0,0 +1,3 @@
+import {modules} from './runtime.js';
+const CicdCommand = modules["cicd-command.js"]["CicdCommand"]
+export {CicdCommand};

package/dist/lib/cicd-connection.js

@@ -0,0 +1,22 @@
+import {modules} from './runtime.js';
+const CICD_ALLOW_PRODUCTION_ENV = modules["cicd-connection.js"]["CICD_ALLOW_PRODUCTION_ENV"]
+const CICD_CONNECTION_ENV = modules["cicd-connection.js"]["CICD_CONNECTION_ENV"]
+const CICD_CONNECTION_NAME_REGEX = modules["cicd-connection.js"]["CICD_CONNECTION_NAME_REGEX"]
+const activeCicdConnectionOverrideName = modules["cicd-connection.js"]["activeCicdConnectionOverrideName"]
+const assertProductionConnectionAllowed = modules["cicd-connection.js"]["assertProductionConnectionAllowed"]
+const assertValidCicdConnectionKind = modules["cicd-connection.js"]["assertValidCicdConnectionKind"]
+const assertValidCicdConnectionName = modules["cicd-connection.js"]["assertValidCicdConnectionName"]
+const clearProcessCicdConnectionOverride = modules["cicd-connection.js"]["clearProcessCicdConnectionOverride"]
+const deleteCicdNamedConnection = modules["cicd-connection.js"]["deleteCicdNamedConnection"]
+const formatCicdConnectionLabel = modules["cicd-connection.js"]["formatCicdConnectionLabel"]
+const getCicdNamedConnection = modules["cicd-connection.js"]["getCicdNamedConnection"]
+const listCicdNamedConnections = modules["cicd-connection.js"]["listCicdNamedConnections"]
+const parseCicdConnectionFromArgv = modules["cicd-connection.js"]["parseCicdConnectionFromArgv"]
+const productionWritesAllowed = modules["cicd-connection.js"]["productionWritesAllowed"]
+const resolveNamedCicdConnectionCredentials = modules["cicd-connection.js"]["resolveNamedCicdConnectionCredentials"]
+const runWithCicdConnectionOverride = modules["cicd-connection.js"]["runWithCicdConnectionOverride"]
+const setProcessCicdConnectionOverride = modules["cicd-connection.js"]["setProcessCicdConnectionOverride"]
+const setProcessProductionConnectionConfirmed = modules["cicd-connection.js"]["setProcessProductionConnectionConfirmed"]
+const summarizeCicdNamedConnection = modules["cicd-connection.js"]["summarizeCicdNamedConnection"]
+const upsertCicdNamedConnection = modules["cicd-connection.js"]["upsertCicdNamedConnection"]
+export {CICD_ALLOW_PRODUCTION_ENV, CICD_CONNECTION_ENV, CICD_CONNECTION_NAME_REGEX, activeCicdConnectionOverrideName, assertProductionConnectionAllowed, assertValidCicdConnectionKind, assertValidCicdConnectionName, clearProcessCicdConnectionOverride, deleteCicdNamedConnection, formatCicdConnectionLabel, getCicdNamedConnection, listCicdNamedConnections, parseCicdConnectionFromArgv, productionWritesAllowed, resolveNamedCicdConnectionCredentials, runWithCicdConnectionOverride, setProcessCicdConnectionOverride, setProcessProductionConnectionConfirmed, summarizeCicdNamedConnection, upsertCicdNamedConnection};

package/dist/lib/cicd-gateway.js

@@ -25,6 +25,7 @@ const getActiveHttpRequestOptionsForTests = modules["cicd-gateway.js"]["getActiv
 const getGatewayClientOrigin = modules["cicd-gateway.js"]["getGatewayClientOrigin"]
 const getGatewayReferer = modules["cicd-gateway.js"]["getGatewayReferer"]
 const getGatewayTransactionId = modules["cicd-gateway.js"]["getGatewayTransactionId"]
+const getGatewayTransactionOrigin = modules["cicd-gateway.js"]["getGatewayTransactionOrigin"]
 const isCicdWarningResponseBody = modules["cicd-gateway.js"]["isCicdWarningResponseBody"]
 const isCicdWarningStatus = modules["cicd-gateway.js"]["isCicdWarningStatus"]
 const maskUrlSecrets = modules["cicd-gateway.js"]["maskUrlSecrets"]
@@ -42,4 +43,4 @@ const scheduleGatewayEventLog = modules["cicd-gateway.js"]["scheduleGatewayEvent
 const setGatewayEventLogSenderForTests = modules["cicd-gateway.js"]["setGatewayEventLogSenderForTests"]
 const setHttpRequestForTests = modules["cicd-gateway.js"]["setHttpRequestForTests"]
 const tryResolveCicdCredentials = modules["cicd-gateway.js"]["tryResolveCicdCredentials"]
-export {ADV_GATEWAY_EVENT_SERVICE, AGENTIA_CLIENT_ORIGIN_ENV, AGENTIA_IDE_VERSION_ENV, AI_GATEWAY_EVENT_SERVICE, CICD_ENV, CRT_GATEWAY_EVENT_SERVICE, CicdGateway, CicdGatewayError, GATEWAY_EVENT_API_CALL, GATEWAY_EVENT_UNKNOWN, MCP_CICD_DEFAULT_REQUEST_TIMEOUT_MS, PLUGIN_GATEWAY_EVENT_SERVICE, buildGatewayEventLogPayload, cicdApiUrl, createTransactionId, discoverCicdBaseUrl, flushGatewayEventLogsForTests, formatCicdGatewayError, formatGatewayEventTimestamp, gatewayEventSource, gatewayRefererHeaders, gatewayUserAgent, getActiveHttpRequestOptionsForTests, getGatewayClientOrigin, getGatewayReferer, getGatewayTransactionId, isCicdWarningResponseBody, isCicdWarningStatus, maskUrlSecrets, maskedCicdApiUrl, normalizeCicdBaseUrl, parseRetryAfterHeader, resetGatewayEventLogSenderForTests, resetHttpRequestForTests, resolveAndValidateCicdEndpoint, resolveCicdCredentials, resolveCicdRequestTimeoutMs, resolveConfiguredCicdBaseUrl, runWithGatewayTransactionContext, scheduleGatewayEventLog, setGatewayEventLogSenderForTests, setHttpRequestForTests, tryResolveCicdCredentials};
+export {ADV_GATEWAY_EVENT_SERVICE, AGENTIA_CLIENT_ORIGIN_ENV, AGENTIA_IDE_VERSION_ENV, AI_GATEWAY_EVENT_SERVICE, CICD_ENV, CRT_GATEWAY_EVENT_SERVICE, CicdGateway, CicdGatewayError, GATEWAY_EVENT_API_CALL, GATEWAY_EVENT_UNKNOWN, MCP_CICD_DEFAULT_REQUEST_TIMEOUT_MS, PLUGIN_GATEWAY_EVENT_SERVICE, buildGatewayEventLogPayload, cicdApiUrl, createTransactionId, discoverCicdBaseUrl, flushGatewayEventLogsForTests, formatCicdGatewayError, formatGatewayEventTimestamp, gatewayEventSource, gatewayRefererHeaders, gatewayUserAgent, getActiveHttpRequestOptionsForTests, getGatewayClientOrigin, getGatewayReferer, getGatewayTransactionId, getGatewayTransactionOrigin, isCicdWarningResponseBody, isCicdWarningStatus, maskUrlSecrets, maskedCicdApiUrl, normalizeCicdBaseUrl, parseRetryAfterHeader, resetGatewayEventLogSenderForTests, resetHttpRequestForTests, resolveAndValidateCicdEndpoint, resolveCicdCredentials, resolveCicdRequestTimeoutMs, resolveConfiguredCicdBaseUrl, runWithGatewayTransactionContext, scheduleGatewayEventLog, setGatewayEventLogSenderForTests, setHttpRequestForTests, tryResolveCicdCredentials};

package/dist/lib/command-history-sanitization.js

@@ -0,0 +1,9 @@
+import {modules} from './runtime.js';
+const COMMAND_HISTORY_RESULT_MAX_BYTES = modules["command-history-sanitization.js"]["COMMAND_HISTORY_RESULT_MAX_BYTES"]
+const COMMAND_HISTORY_TEXT_MAX_BYTES = modules["command-history-sanitization.js"]["COMMAND_HISTORY_TEXT_MAX_BYTES"]
+const commandHistoryLogsText = modules["command-history-sanitization.js"]["commandHistoryLogsText"]
+const sanitizeCommandHistoryLogs = modules["command-history-sanitization.js"]["sanitizeCommandHistoryLogs"]
+const sanitizeCommandHistoryParameters = modules["command-history-sanitization.js"]["sanitizeCommandHistoryParameters"]
+const sanitizeCommandHistoryResult = modules["command-history-sanitization.js"]["sanitizeCommandHistoryResult"]
+const sanitizeCommandHistoryText = modules["command-history-sanitization.js"]["sanitizeCommandHistoryText"]
+export {COMMAND_HISTORY_RESULT_MAX_BYTES, COMMAND_HISTORY_TEXT_MAX_BYTES, commandHistoryLogsText, sanitizeCommandHistoryLogs, sanitizeCommandHistoryParameters, sanitizeCommandHistoryResult, sanitizeCommandHistoryText};

package/dist/lib/command-history.js

@@ -0,0 +1,11 @@
+import {modules} from './runtime.js';
+const COMMAND_HISTORY_DEFAULT_LIST_LIMIT = modules["command-history.js"]["COMMAND_HISTORY_DEFAULT_LIST_LIMIT"]
+const COMMAND_HISTORY_LIMIT = modules["command-history.js"]["COMMAND_HISTORY_LIMIT"]
+const clearCommandHistory = modules["command-history.js"]["clearCommandHistory"]
+const commandHistoryPath = modules["command-history.js"]["commandHistoryPath"]
+const readCommandHistory = modules["command-history.js"]["readCommandHistory"]
+const recordCommandHistory = modules["command-history.js"]["recordCommandHistory"]
+const recordMcpToolHistory = modules["command-history.js"]["recordMcpToolHistory"]
+const setCommandHistoryRootForTests = modules["command-history.js"]["setCommandHistoryRootForTests"]
+const shouldRecordCommandHistory = modules["command-history.js"]["shouldRecordCommandHistory"]
+export {COMMAND_HISTORY_DEFAULT_LIST_LIMIT, COMMAND_HISTORY_LIMIT, clearCommandHistory, commandHistoryPath, readCommandHistory, recordCommandHistory, recordMcpToolHistory, setCommandHistoryRootForTests, shouldRecordCommandHistory};

package/dist/lib/command-output-buffer.js

@@ -6,10 +6,15 @@ const appendCommandOutputLine = modules["command-output-buffer.js"]["appendComma
 const attachCapturedLogs = modules["command-output-buffer.js"]["attachCapturedLogs"]
 const attachCapturedOutputLogs = modules["command-output-buffer.js"]["attachCapturedOutputLogs"]
 const commandStdioCaptureOptions = modules["command-output-buffer.js"]["commandStdioCaptureOptions"]
+const isAnyCommandOutputCaptureActive = modules["command-output-buffer.js"]["isAnyCommandOutputCaptureActive"]
 const isCommandOutputCaptureActive = modules["command-output-buffer.js"]["isCommandOutputCaptureActive"]
+const readCapturedCommandOutputSnapshot = modules["command-output-buffer.js"]["readCapturedCommandOutputSnapshot"]
 const readCapturedCommandOutputText = modules["command-output-buffer.js"]["readCapturedCommandOutputText"]
 const redactCommandOutput = modules["command-output-buffer.js"]["redactCommandOutput"]
 const runWithCommandOutputCapture = modules["command-output-buffer.js"]["runWithCommandOutputCapture"]
+const runWithoutCommandOutputCapture = modules["command-output-buffer.js"]["runWithoutCommandOutputCapture"]
 const splitCommandOutputLines = modules["command-output-buffer.js"]["splitCommandOutputLines"]
+const tailUtf8 = modules["command-output-buffer.js"]["tailUtf8"]
+const truncateUtf8 = modules["command-output-buffer.js"]["truncateUtf8"]
 const withCapturedCommandOutput = modules["command-output-buffer.js"]["withCapturedCommandOutput"]
-export {COMMAND_OUTPUT_MAX_BYTES, MCP_STDIO_CAPTURE_OPTIONS, appendCommandOutput, appendCommandOutputLine, attachCapturedLogs, attachCapturedOutputLogs, commandStdioCaptureOptions, isCommandOutputCaptureActive, readCapturedCommandOutputText, redactCommandOutput, runWithCommandOutputCapture, splitCommandOutputLines, withCapturedCommandOutput};
+export {COMMAND_OUTPUT_MAX_BYTES, MCP_STDIO_CAPTURE_OPTIONS, appendCommandOutput, appendCommandOutputLine, attachCapturedLogs, attachCapturedOutputLogs, commandStdioCaptureOptions, isAnyCommandOutputCaptureActive, isCommandOutputCaptureActive, readCapturedCommandOutputSnapshot, readCapturedCommandOutputText, redactCommandOutput, runWithCommandOutputCapture, runWithoutCommandOutputCapture, splitCommandOutputLines, tailUtf8, truncateUtf8, withCapturedCommandOutput};

package/dist/lib/defaults-store.js

@@ -10,6 +10,7 @@ const migrateUserSettingsFromProjectConfig = modules["defaults-store.js"]["migra
 const readCredentialSyncReceipt = modules["defaults-store.js"]["readCredentialSyncReceipt"]
 const readDefaults = modules["defaults-store.js"]["readDefaults"]
 const readEnableLocalPromote = modules["defaults-store.js"]["readEnableLocalPromote"]
+const readGlobalConfigDocument = modules["defaults-store.js"]["readGlobalConfigDocument"]
 const readLastApexTestClassesSelected = modules["defaults-store.js"]["readLastApexTestClassesSelected"]
 const readLastBaseBranch = modules["defaults-store.js"]["readLastBaseBranch"]
 const readLastDevOrgBranch = modules["defaults-store.js"]["readLastDevOrgBranch"]
@@ -30,6 +31,7 @@ const resolveDefaults = modules["defaults-store.js"]["resolveDefaults"]
 const setDefaultsStorePathsForTests = modules["defaults-store.js"]["setDefaultsStorePathsForTests"]
 const setDefaultsStoreProjectRoot = modules["defaults-store.js"]["setDefaultsStoreProjectRoot"]
 const unsetDefaults = modules["defaults-store.js"]["unsetDefaults"]
+const updateGlobalConfigDocument = modules["defaults-store.js"]["updateGlobalConfigDocument"]
 const writeCredentialSyncReceipt = modules["defaults-store.js"]["writeCredentialSyncReceipt"]
 const writeDefaults = modules["defaults-store.js"]["writeDefaults"]
 const writeLastCommitSelections = modules["defaults-store.js"]["writeLastCommitSelections"]
@@ -37,4 +39,4 @@ const writeLastEnvironmentSyncName = modules["defaults-store.js"]["writeLastEnvi
 const writeLastWorkSelection = modules["defaults-store.js"]["writeLastWorkSelection"]
 const writeUpdateChannel = modules["defaults-store.js"]["writeUpdateChannel"]
 const writeUserContext = modules["defaults-store.js"]["writeUserContext"]
-export {DEFAULT_WORK_PUSH_RETRY_TIMEOUT_SECONDS, clearCredentialSyncReceipt, clearLastEnvironmentSyncName, clearLastKeysFromUserConfig, clearUserContext, getDefaultsStorePaths, isValidUserContext, migrateUserSettingsFromProjectConfig, readCredentialSyncReceipt, readDefaults, readEnableLocalPromote, readLastApexTestClassesSelected, readLastBaseBranch, readLastDevOrgBranch, readLastEnvironmentSyncName, readLastFullMetadataSelected, readLastPermissionSelected, readLastPullRequestBaseUrl, readLastWorkItem, readLastWorkItemId, readLastWorkItemTitle, readSkipNestedMetadataDetection, readSkipPullRequest, readUpdateChannel, readUserContext, readWorkPushRetryTimeoutSeconds, resetDefaultsStorePathsForTests, resolveDefaults, setDefaultsStorePathsForTests, setDefaultsStoreProjectRoot, unsetDefaults, writeCredentialSyncReceipt, writeDefaults, writeLastCommitSelections, writeLastEnvironmentSyncName, writeLastWorkSelection, writeUpdateChannel, writeUserContext};
+export {DEFAULT_WORK_PUSH_RETRY_TIMEOUT_SECONDS, clearCredentialSyncReceipt, clearLastEnvironmentSyncName, clearLastKeysFromUserConfig, clearUserContext, getDefaultsStorePaths, isValidUserContext, migrateUserSettingsFromProjectConfig, readCredentialSyncReceipt, readDefaults, readEnableLocalPromote, readGlobalConfigDocument, readLastApexTestClassesSelected, readLastBaseBranch, readLastDevOrgBranch, readLastEnvironmentSyncName, readLastFullMetadataSelected, readLastPermissionSelected, readLastPullRequestBaseUrl, readLastWorkItem, readLastWorkItemId, readLastWorkItemTitle, readSkipNestedMetadataDetection, readSkipPullRequest, readUpdateChannel, readUserContext, readWorkPushRetryTimeoutSeconds, resetDefaultsStorePathsForTests, resolveDefaults, setDefaultsStorePathsForTests, setDefaultsStoreProjectRoot, unsetDefaults, updateGlobalConfigDocument, writeCredentialSyncReceipt, writeDefaults, writeLastCommitSelections, writeLastEnvironmentSyncName, writeLastWorkSelection, writeUpdateChannel, writeUserContext};

package/dist/lib/dependency-from-changes.js

@@ -1,7 +1,9 @@
 import {modules} from './runtime.js';
+const normalizeDependencyInputPath = modules["dependency-from-changes.js"]["normalizeDependencyInputPath"]
 const resetGitChangedFilesForTests = modules["dependency-from-changes.js"]["resetGitChangedFilesForTests"]
 const resolveChangedPath = modules["dependency-from-changes.js"]["resolveChangedPath"]
 const resolvedSelectionsFromChangedFiles = modules["dependency-from-changes.js"]["resolvedSelectionsFromChangedFiles"]
+const resolvedSelectionsFromPaths = modules["dependency-from-changes.js"]["resolvedSelectionsFromPaths"]
 const selectionsFromChangedFiles = modules["dependency-from-changes.js"]["selectionsFromChangedFiles"]
 const setGitChangedFilesForTests = modules["dependency-from-changes.js"]["setGitChangedFilesForTests"]
-export {resetGitChangedFilesForTests, resolveChangedPath, resolvedSelectionsFromChangedFiles, selectionsFromChangedFiles, setGitChangedFilesForTests};
+export {normalizeDependencyInputPath, resetGitChangedFilesForTests, resolveChangedPath, resolvedSelectionsFromChangedFiles, resolvedSelectionsFromPaths, selectionsFromChangedFiles, setGitChangedFilesForTests};

package/dist/lib/dependency-source-context.js

@@ -0,0 +1,3 @@
+import {modules} from './runtime.js';
+const resolveDependencySourceContext = modules["dependency-source-context.js"]["resolveDependencySourceContext"]
+export {resolveDependencySourceContext};

package/dist/lib/help-agent-command.js

@@ -0,0 +1,3 @@
+import {modules} from './runtime.js';
+const runInteractiveHelpAgent = modules["help-agent-command.js"]["runInteractiveHelpAgent"]
+export {runInteractiveHelpAgent};

package/dist/lib/help-agent-interaction-history.js

@@ -0,0 +1,10 @@
+import {modules} from './runtime.js';
+const HELP_AGENT_INTERACTION_LIMIT = modules["help-agent-interaction-history.js"]["HELP_AGENT_INTERACTION_LIMIT"]
+const HELP_AGENT_INTERACTION_TEXT_MAX_BYTES = modules["help-agent-interaction-history.js"]["HELP_AGENT_INTERACTION_TEXT_MAX_BYTES"]
+const HELP_AGENT_INTERACTION_TTL_MS = modules["help-agent-interaction-history.js"]["HELP_AGENT_INTERACTION_TTL_MS"]
+const clearHelpAgentInteractions = modules["help-agent-interaction-history.js"]["clearHelpAgentInteractions"]
+const helpAgentInteractionHistoryPath = modules["help-agent-interaction-history.js"]["helpAgentInteractionHistoryPath"]
+const readHelpAgentInteractions = modules["help-agent-interaction-history.js"]["readHelpAgentInteractions"]
+const recordHelpAgentInteraction = modules["help-agent-interaction-history.js"]["recordHelpAgentInteraction"]
+const setHelpAgentInteractionHistoryRootForTests = modules["help-agent-interaction-history.js"]["setHelpAgentInteractionHistoryRootForTests"]
+export {HELP_AGENT_INTERACTION_LIMIT, HELP_AGENT_INTERACTION_TEXT_MAX_BYTES, HELP_AGENT_INTERACTION_TTL_MS, clearHelpAgentInteractions, helpAgentInteractionHistoryPath, readHelpAgentInteractions, recordHelpAgentInteraction, setHelpAgentInteractionHistoryRootForTests};

package/dist/lib/help-agent-session.js

@@ -0,0 +1,3 @@
+import {modules} from './runtime.js';
+const runHelpAgentSession = modules["help-agent-session.js"]["runHelpAgentSession"]
+export {runHelpAgentSession};

package/dist/lib/mcp/result.js

@@ -1,14 +1,52 @@
+import { createRequire } from 'node:module';
+import { runWithCicdConnectionOverride } from '../cicd-connection.js';
 import { createTransactionId, runWithGatewayTransactionContext } from '../cicd-gateway.js';
+import { recordMcpToolHistory } from '../command-history.js';
 import { mcpCommandIdFromToolName, mcpToolNameFromHandler } from './command-id.js';
 import { redactErrorMessage, redactSecrets } from './redaction.js';
+const require = createRequire(import.meta.url);
+const packageJson = require('../../../package.json');
 export { mcpToolNameFromHandler } from './command-id.js';
-export function runWithMcpToolContext(toolName, fn) {
-    return runWithGatewayTransactionContext({ origin: 'mcp', referer: mcpCommandIdFromToolName(toolName), transactionId: createTransactionId() }, fn);
+export function runWithMcpToolContext(toolName, fn, options = {}) {
+    const transactionId = createTransactionId();
+    const executionId = createTransactionId();
+    const commandId = mcpCommandIdFromToolName(toolName);
+    const startedAtMs = Date.now();
+    return runWithGatewayTransactionContext({ origin: 'mcp', referer: commandId, transactionId }, async () => {
+        let error;
+        try {
+            return await runWithCicdConnectionOverride(options.cicdConnection, fn);
+        }
+        catch (error_) {
+            error = error_;
+            throw error_;
+        }
+        finally {
+            await recordMcpToolHistory({
+                cliVersion: packageJson.version,
+                commandId,
+                error,
+                executionId,
+                startedAtMs,
+                transactionId,
+            });
+        }
+    });
+}
+export function cicdConnectionFromToolArgs(args) {
+    const first = args[0];
+    if (first === null || typeof first !== 'object' || Array.isArray(first))
+        return undefined;
+    const value = first.cicdConnection;
+    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
 }
 export function wrapMcpToolHandlers(handlers) {
     return Object.fromEntries(Object.entries(handlers).map(([name, handler]) => [
         name,
-        (...args) => runWithMcpToolContext(mcpToolNameFromHandler(name), () => handler(...args)),
+        (...args) => {
+            const cicdConnection = cicdConnectionFromToolArgs(args);
+            return runWithMcpToolContext(mcpToolNameFromHandler(name), () => handler(...args), { cicdConnection });
+        },
     ]));
 }
 export function toolResult(data) {

package/dist/lib/mcp/server.js

@@ -7,7 +7,7 @@ import { logVerboseDebug } from '../debug.js';
 import { migrateUserSettingsFromProjectConfig } from '../defaults-store.js';
 import { applyProjectRoot, hasExplicitProjectRoot } from '../project-root.js';
 import { runWithMcpRequestSignal } from './request-context.js';
-import { runWithMcpToolContext } from './result.js';
+import { cicdConnectionFromToolArgs, runWithMcpToolContext } from './result.js';
 import { withToolAnnotations } from './tool-annotations.js';
 import { registerAgentiaMcpTools } from './tools.js';
 const require = createRequire(import.meta.url);
@@ -105,10 +105,11 @@ function wrapMcpToolRegistration(server, lifecycleSignal, projectContextReady =
     server.registerTool = ((name, config, handler) => registerTool(name, withToolAnnotations(name, config), (...args) => {
         const extra = args.at(-1);
         const { dispose, signal } = combineSignals(extra?.signal, lifecycleSignal);
+        const cicdConnection = cicdConnectionFromToolArgs(args);
         return runWithMcpRequestSignal(signal, async () => {
             try {
                 await projectContextReady;
-                return await runWithMcpToolContext(name, async () => handler(...args));
+                return await runWithMcpToolContext(name, async () => handler(...args), { cicdConnection });
             }
             finally {
                 dispose();

package/dist/lib/mcp/testing-browser-tools.js

@@ -0,0 +1,194 @@
+import { mkdtemp } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { z } from 'zod';
+import { executeTestingLive, getTestingLiveHistory, getTestingLiveReports, getTestingLiveStatus, inspectTestingLive, saveTestingLiveScreenshot, setTestingLiveOptions, startTestingLive, stopTestingLive, } from '../testing-browser-operations.js';
+import { assertTestingLiveStopConfirmed, normalizeTestingLiveExecuteSource, normalizeTestingLiveRecorderOptions, normalizeTestingLiveStartScreen, shapeTestingLiveHistoryResult, } from '../testing-browser-requests.js';
+import { TESTING_LIVE_LIBRARIES } from '../testing-browser-types.js';
+import { safelyHandleTool } from './result.js';
+async function testingBrowserStart(args) {
+    const screen = normalizeTestingLiveStartScreen(args);
+    return {
+        result: await startTestingLive({
+            japIme: args.japIme,
+            jobId: args.job,
+            library: args.library,
+            noBootstrap: args.noBootstrap,
+            noBrowser: args.noBrowser,
+            projectId: args.project,
+            screen,
+            timeoutMs: args.timeoutSeconds === undefined ? undefined : args.timeoutSeconds * 1000,
+        }),
+    };
+}
+async function testingBrowserStop(args) {
+    assertTestingLiveStopConfirmed(args.confirm);
+    return { result: await stopTestingLive({ jobId: args.job, projectId: args.project, sessionId: args.sessionId }) };
+}
+async function testingBrowserStatus(args) {
+    return { result: await getTestingLiveStatus({ jobId: args.job, projectId: args.project, sessionId: args.sessionId }) };
+}
+async function testingBrowserExecute(args) {
+    normalizeTestingLiveExecuteSource({ keyword: args.keyword, lines: args.line }, { keyword: 'keyword', line: 'line' });
+    return {
+        result: await executeTestingLive({
+            args: args.argument,
+            jobId: args.job,
+            keyword: args.keyword,
+            lines: args.line,
+            projectId: args.project,
+            raw: args.raw,
+            sessionId: args.sessionId,
+        }),
+    };
+}
+async function testingBrowserInspect(args) {
+    return {
+        result: await inspectTestingLive({
+            jobId: args.job,
+            projectId: args.project,
+            sessionId: args.sessionId,
+        }),
+    };
+}
+async function testingBrowserScreenshot(args) {
+    const outputDir = await mkdtemp(join(tmpdir(), 'agentia-mcp-browser-screenshot-'));
+    return {
+        result: await saveTestingLiveScreenshot({
+            jobId: args.job,
+            output: join(outputDir, 'screenshot.png'),
+            projectId: args.project,
+            sessionId: args.sessionId,
+        }),
+    };
+}
+async function testingBrowserReports(args) {
+    return {
+        result: await getTestingLiveReports({
+            jobId: args.job,
+            projectId: args.project,
+            sessionId: args.sessionId,
+        }),
+    };
+}
+async function testingBrowserSetOptions(args) {
+    return {
+        result: await setTestingLiveOptions({
+            jobId: args.job,
+            projectId: args.project,
+            recorder: normalizeTestingLiveRecorderOptions(args.recorder),
+            sessionId: args.sessionId,
+        }),
+    };
+}
+async function testingBrowserHistory(args) {
+    const result = await getTestingLiveHistory({
+        includeFailed: args.includeFailed,
+        jobId: args.job,
+        keyword: args.keyword,
+        limit: args.limit,
+        projectId: args.project,
+        status: args.status,
+    });
+    return { result: shapeTestingLiveHistoryResult(result, args.linesOnly === true) };
+}
+export const testingBrowserMcpHandlers = {
+    testingBrowserExecute,
+    testingBrowserHistory,
+    testingBrowserInspect,
+    testingBrowserReports,
+    testingBrowserScreenshot,
+    testingBrowserSetOptions,
+    testingBrowserStart,
+    testingBrowserStatus,
+    testingBrowserStop,
+};
+const liveSessionSchema = {
+    job: z.number().int().positive().optional().describe('Optional CRT job ID.'),
+    project: z.number().int().positive().describe('CRT project ID.'),
+    sessionId: z.number().int().positive().optional().describe('Optional active CRT browser session ID.'),
+};
+const liveRecorderOptionsSchema = z.object({
+    enabled: z.boolean(),
+    enableHealingContext: z.boolean(),
+    enableHoverText: z.boolean(),
+    enableScrollText: z.boolean(),
+    enableSystemState: z.boolean(),
+    enableVerifyText: z.boolean(),
+    preferTableKeywords: z.boolean(),
+});
+export function registerTestingLiveMcpTools(server) {
+    server.registerTool('agentia_testing_browser_start', {
+        description: 'Start and bootstrap a CRT browser session.',
+        inputSchema: {
+            japIme: z.boolean().optional(),
+            job: z.number().int().positive().describe('CRT job ID.'),
+            library: z.enum(TESTING_LIVE_LIBRARIES).optional(),
+            noBootstrap: z.boolean().optional(),
+            noBrowser: z.boolean().optional(),
+            project: z.number().int().positive().describe('CRT project ID.'),
+            screen: z.string().max(100).optional(),
+            screenDepth: z.number().int().min(8).max(32).optional(),
+            screenHeight: z.number().int().min(240).max(4320).optional(),
+            screenWidth: z.number().int().min(320).max(7680).optional(),
+            timeoutSeconds: z.number().int().min(1).max(600).optional(),
+            viewport: z.string().max(100).optional(),
+        },
+        title: 'Agentia Testing Browser Start',
+    }, (args) => safelyHandleTool(() => testingBrowserStart(args)));
+    server.registerTool('agentia_testing_browser_stop', {
+        description: 'Stop the active CRT browser session. Requires explicit confirmation.',
+        inputSchema: { confirm: z.boolean().describe('Must be true to stop the session.'), ...liveSessionSchema },
+        title: 'Agentia Testing Browser Stop',
+    }, (args) => safelyHandleTool(() => testingBrowserStop(args)));
+    server.registerTool('agentia_testing_browser_status', {
+        description: 'Read status for the active CRT browser session.',
+        inputSchema: liveSessionSchema,
+        title: 'Agentia Testing Browser Status',
+    }, (args) => safelyHandleTool(() => testingBrowserStatus(args)));
+    server.registerTool('agentia_testing_browser_execute', {
+        description: 'Execute Robot Framework keywords in the active CRT browser session.',
+        inputSchema: {
+            argument: z.array(z.string().max(16_384)).max(100).optional(),
+            keyword: z.string().max(16_384).optional(),
+            line: z.array(z.string().max(16_384)).max(500).optional(),
+            raw: z.boolean().optional(),
+            ...liveSessionSchema,
+        },
+        title: 'Agentia Testing Browser Execute',
+    }, (args) => safelyHandleTool(() => testingBrowserExecute(args)));
+    server.registerTool('agentia_testing_browser_inspect', {
+        description: 'Inspect page state from the active CRT browser session.',
+        inputSchema: liveSessionSchema,
+        title: 'Agentia Testing Browser Inspect',
+    }, (args) => safelyHandleTool(() => testingBrowserInspect(args)));
+    server.registerTool('agentia_testing_browser_screenshot', {
+        description: 'Save a CRT browser screenshot to a temporary path.',
+        inputSchema: liveSessionSchema,
+        title: 'Agentia Testing Browser Screenshot',
+    }, (args) => safelyHandleTool(() => testingBrowserScreenshot(args)));
+    server.registerTool('agentia_testing_browser_reports', {
+        description: 'List browser session report metadata.',
+        inputSchema: liveSessionSchema,
+        title: 'Agentia Testing Browser Reports',
+    }, (args) => safelyHandleTool(() => testingBrowserReports(args)));
+    server.registerTool('agentia_testing_browser_set_options', {
+        description: 'Set CRT browser recorder options.',
+        inputSchema: { recorder: liveRecorderOptionsSchema, ...liveSessionSchema },
+        title: 'Agentia Testing Browser Set Options',
+    }, (args) => safelyHandleTool(() => testingBrowserSetOptions(args)));
+    server.registerTool('agentia_testing_browser_history', {
+        description: 'Read local CRT browser execution history.',
+        inputSchema: {
+            includeFailed: z.boolean().optional().describe('Include failed keyword executions.'),
+            job: z.number().int().positive().optional().describe('CRT job ID; defaults to the active session.'),
+            keyword: z.string().max(200).optional().describe('Filter by Robot Framework keyword name.'),
+            limit: z.number().int().min(1).max(500).optional(),
+            linesOnly: z.boolean().optional().describe('Flatten history into replayable keyword lines.'),
+            project: z.number().int().positive().describe('CRT project ID.'),
+            status: z.enum(['completed', 'failed', 'recorded']).optional(),
+        },
+        title: 'Agentia Testing Browser History',
+    }, (args) => safelyHandleTool(() => testingBrowserHistory(args)));
+}
+//# sourceMappingURL=testing-browser-tools.js.map

package/dist/lib/mcp/testing-tools.js

@@ -1,12 +1,13 @@
 /* eslint-disable unicorn/text-encoding-identifier-case -- CRT file APIs require the literal utf-8 enum. */
 import { z } from 'zod';
 import { createTestingDataTable, deleteTestingDataTable, getTestingDataTable, listTestingDataTables, TESTING_DATA_MAX_CELL_BYTES, TESTING_DATA_MAX_COLUMNS, TESTING_DATA_MAX_ROWS, updateTestingDataTable, } from '../testing-data-table.js';
+import { abortTestingBuild, countTestingBuilds, executeTestingBuildRun, getTestingBuild, getTestingBuildLogs, listTestingBuilds, searchTestingBuilds, } from '../testing-execution.js';
 import { buildTestingRunOptions } from '../testing-flags.js';
-import { abortTestingBuild, countTestingBuilds, createTestingJob, createTestingProject, createTestingRobot, createTestingUserParameter, createTestingVariable, deleteTestingJob, deleteTestingProject, deleteTestingRobot, deleteTestingUserParameter, deleteTestingVariable, downloadTestingJobFiles, executeTestingBuildRun, getTestingBuild, getTestingBuildLogs, getTestingJob, getTestingJobRefs, getTestingJobScheduleStatus, getTestingProject, getTestingProjectPermission, getTestingRobot, getTestingUserParameter, getTestingVariable, listTestingBuilds, listTestingJobFiles, listTestingJobs, listTestingProjectPermissions, listTestingProjects, listTestingRobots, listTestingUserParameters, listTestingVariables, removeTestingJobSchedule, searchTestingBuilds, setTestingJobSchedule, setTestingProjectPermission, updateTestingJob, updateTestingProject, updateTestingRobot, updateTestingUserParameter, updateTestingVariable, uploadTestingJobFiles, } from '../testing-operations.js';
+import { createTestingJob, createTestingProject, createTestingRobot, createTestingUserParameter, createTestingVariable, deleteTestingJob, deleteTestingProject, deleteTestingRobot, deleteTestingUserParameter, deleteTestingVariable, downloadTestingJobFiles, getTestingJob, getTestingJobRefs, getTestingJobScheduleStatus, getTestingProject, getTestingProjectPermission, getTestingRobot, getTestingUserParameter, getTestingVariable, listTestingJobFiles, listTestingJobs, listTestingProjectPermissions, listTestingProjects, listTestingRobots, listTestingUserParameters, listTestingVariables, removeTestingJobSchedule, setTestingJobSchedule, setTestingProjectPermission, updateTestingJob, updateTestingProject, updateTestingRobot, updateTestingUserParameter, updateTestingVariable, uploadTestingJobFiles, } from '../testing-operations.js';
 import { sanitizeTestingOutput } from '../testing-sanitization.js';
 import { TESTING_BUILD_STATUSES, TESTING_CONSOLE_COLORS, TESTING_JOB_PARALLEL_MODES, TESTING_JOB_SUITE_TYPES, TESTING_RECORD_BUILD_OPTIONS, TESTING_ROBOT_ACCEPTED_RUN_ENVIRONMENTS, TESTING_ROBOT_REPORTING, TESTING_ROBOT_REPORTING_DESCRIPTION, TESTING_ROBOT_RUN_ENVIRONMENT_DESCRIPTION, TESTING_ROBOT_TYPE_DESCRIPTION, TESTING_ROBOT_TYPES, TESTING_RUN_TYPES, TESTING_VARIABLE_TYPES, } from '../testing-types.js';
 import { safelyHandleTool } from './result.js';
-import { registerTestingLiveMcpTools, testingLiveMcpHandlers } from './testing-live-tools.js';
+import { registerTestingLiveMcpTools, testingBrowserMcpHandlers } from './testing-browser-tools.js';
 const projectIdSchema = z.number().int().positive().describe('CRT project ID.');
 const jobIdSchema = z.number().int().positive().describe('CRT job ID.');
 const optionalJobIdSchema = z.number().int().positive().optional().describe('CRT job ID.');
@@ -444,7 +445,7 @@ export const agentiaMcpTestingToolHandlers = {
     testingVariableGet,
     testingVariableList,
     testingVariableUpdate,
-    ...testingLiveMcpHandlers,
+    ...testingBrowserMcpHandlers,
 };
 export function registerAgentiaMcpTestingTools(server) {
     server.registerTool('agentia_testing_project_list', {