@copado/agentia-cli 0.122.0-alpha.1 → 1.0.0-beta.0

package/dist/lib/cicd-region.js

@@ -1,8 +1,5 @@
-export const CICD_REGIONS = ['na', 'emea', 'emea2', 'apac', 'apac2'];
-export function isCicdRegion(value) {
-    return CICD_REGIONS.includes(value);
-}
-export function cicdBaseUrl(region) {
-    return `https://${region}.api.copado.com`;
-}
-//# sourceMappingURL=cicd-region.js.map
+import {modules} from './runtime.js';
+const CICD_REGIONS = modules["cicd-region.js"]["CICD_REGIONS"]
+const cicdBaseUrl = modules["cicd-region.js"]["cicdBaseUrl"]
+const isCicdRegion = modules["cicd-region.js"]["isCicdRegion"]
+export {CICD_REGIONS, cicdBaseUrl, isCicdRegion};

package/dist/lib/cli-update.js

@@ -1,84 +1,11 @@
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-import { AGENTIA_NPM_REGISTRY, AGENTIA_PACKAGE_NAME, AGENTIA_RELEASE_CHANNEL, fetchChannelVersion, isNewerVersion, } from './cli-version.js';
-const execFileAsync = promisify(execFile);
-let executeUpdateFn = executeNpmUpdate;
-export class CliUpdateError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'CliUpdateError';
-    }
-}
-export function setCliUpdateExecutorForTests(nextExecutor) {
-    executeUpdateFn = nextExecutor ?? executeNpmUpdate;
-}
-export function npmExecutable(platform = process.platform) {
-    return platform === 'win32' ? 'npm.cmd' : 'npm';
-}
-export function npmPackageScope(packageName = AGENTIA_PACKAGE_NAME) {
-    if (!packageName.startsWith('@')) {
-        return undefined;
-    }
-    const slashIndex = packageName.indexOf('/');
-    if (slashIndex <= 1) {
-        return undefined;
-    }
-    return packageName.slice(0, slashIndex);
-}
-export function npmRegistryArguments(registry = AGENTIA_NPM_REGISTRY, packageName = AGENTIA_PACKAGE_NAME) {
-    const args = ['--registry', registry];
-    const scope = npmPackageScope(packageName);
-    if (scope !== undefined) {
-        // npm --registry does not override scoped registries from user or project npmrc.
-        args.push(`--${scope}:registry=${registry}`);
-    }
-    return args;
-}
-export function npmUpdateArguments(version) {
-    return ['install', '--global', `${AGENTIA_PACKAGE_NAME}@${version}`, ...npmRegistryArguments()];
-}
-export function npmExecOptions(platform = process.platform) {
-    return {
-        maxBuffer: 10 * 1024 * 1024,
-        shell: platform === 'win32',
-        windowsHide: true,
-    };
-}
-export async function executeNpmUpdate(command, args) {
-    try {
-        await execFileAsync(command, [...args], npmExecOptions());
-    }
-    catch (error) {
-        const details = error instanceof Error ? error.message : '';
-        if (/EACCES|EPERM|permission denied/i.test(details)) {
-            throw new CliUpdateError('npm does not have permission to update the global Agentia CLI installation. Configure a writable npm global prefix and retry.');
-        }
-        throw new CliUpdateError(`npm could not update the Agentia CLI. Run \`${command} ${args.join(' ')}\` manually for npm diagnostics.`);
-    }
-}
-export async function runCliUpdate(options) {
-    const latestVersion = await fetchChannelVersion();
-    const updateAvailable = isNewerVersion(latestVersion, options.currentVersion);
-    const versionState = updateAvailable
-        ? 'update-available'
-        : isNewerVersion(options.currentVersion, latestVersion)
-            ? 'ahead'
-            : 'current';
-    const checkedOnly = options.checkOnly ?? false;
-    let updated = false;
-    if (updateAvailable && !checkedOnly) {
-        await executeUpdateFn(npmExecutable(), npmUpdateArguments(latestVersion));
-        updated = true;
-    }
-    return {
-        channel: AGENTIA_RELEASE_CHANNEL,
-        checkedOnly,
-        currentVersion: options.currentVersion,
-        latestVersion,
-        packageName: AGENTIA_PACKAGE_NAME,
-        updateAvailable,
-        updated,
-        versionState,
-    };
-}
-//# sourceMappingURL=cli-update.js.map
+import {modules} from './runtime.js';
+const CliUpdateError = modules["cli-update.js"]["CliUpdateError"]
+const executeNpmUpdate = modules["cli-update.js"]["executeNpmUpdate"]
+const npmExecOptions = modules["cli-update.js"]["npmExecOptions"]
+const npmExecutable = modules["cli-update.js"]["npmExecutable"]
+const npmPackageScope = modules["cli-update.js"]["npmPackageScope"]
+const npmRegistryArguments = modules["cli-update.js"]["npmRegistryArguments"]
+const npmUpdateArguments = modules["cli-update.js"]["npmUpdateArguments"]
+const runCliUpdate = modules["cli-update.js"]["runCliUpdate"]
+const setCliUpdateExecutorForTests = modules["cli-update.js"]["setCliUpdateExecutorForTests"]
+export {CliUpdateError, executeNpmUpdate, npmExecOptions, npmExecutable, npmPackageScope, npmRegistryArguments, npmUpdateArguments, runCliUpdate, setCliUpdateExecutorForTests};

package/dist/lib/cli-version.js

@@ -1,142 +1,17 @@
-import { randomUUID } from 'node:crypto';
-import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
-import { get } from 'node:https';
-import path from 'node:path';
-import semver from 'semver';
-export const AGENTIA_PACKAGE_NAME = '@copado/agentia-cli';
-export const AGENTIA_RELEASE_CHANNEL = 'alpha';
-export const AGENTIA_NPM_REGISTRY = 'https://registry.npmjs.org';
-export const VERSION_CACHE_FILENAME = 'version-check.json';
-export const VERSION_CHECK_INTERVAL_MS = 60 * 60 * 1000;
-let registryClientFn = defaultVersionRegistryClient;
-export class CliVersionError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'CliVersionError';
-    }
-}
-export function setCliVersionRegistryClientForTests(nextClient) {
-    registryClientFn = nextClient ?? defaultVersionRegistryClient;
-}
-export function versionCachePath(cacheDir) {
-    return path.join(cacheDir, VERSION_CACHE_FILENAME);
-}
-export function isNewerVersion(candidate, current) {
-    if (semver.valid(candidate) === null) {
-        throw new CliVersionError(`npm returned an invalid Agentia CLI version: ${candidate}`);
-    }
-    if (semver.valid(current) === null) {
-        throw new CliVersionError(`The installed Agentia CLI version is invalid: ${current}`);
-    }
-    return semver.gt(candidate, current);
-}
-export function isVersionCacheStale(cache, now = new Date(), intervalMs = VERSION_CHECK_INTERVAL_MS) {
-    if (cache === undefined || cache.channel !== AGENTIA_RELEASE_CHANNEL) {
-        return true;
-    }
-    const checkedAt = Date.parse(cache.checkedAt);
-    return Number.isNaN(checkedAt) || now.getTime() - checkedAt >= intervalMs;
-}
-export async function readVersionCache(cachePath) {
-    try {
-        const parsed = JSON.parse(await readFile(cachePath, 'utf8'));
-        if (typeof parsed.checkedAt !== 'string' || typeof parsed.channel !== 'string') {
-            return undefined;
-        }
-        if (parsed.latestVersion !== undefined &&
-            (typeof parsed.latestVersion !== 'string' || semver.valid(parsed.latestVersion) === null)) {
-            return undefined;
-        }
-        return {
-            channel: parsed.channel,
-            checkedAt: parsed.checkedAt,
-            ...(parsed.latestVersion === undefined ? {} : { latestVersion: parsed.latestVersion }),
-        };
-    }
-    catch {
-        return undefined;
-    }
-}
-export async function writeVersionCache(cachePath, cache) {
-    await mkdir(path.dirname(cachePath), { recursive: true });
-    const temporaryPath = `${cachePath}.${process.pid}.${randomUUID()}.tmp`;
-    try {
-        await writeFile(temporaryPath, `${JSON.stringify(cache)}\n`, 'utf8');
-        await rename(temporaryPath, cachePath);
-    }
-    catch (error) {
-        await rm(temporaryPath, { force: true }).catch(() => { });
-        throw error;
-    }
-}
-export async function defaultVersionRegistryClient(url, timeoutMs) {
-    return new Promise((resolve, reject) => {
-        const request = get(url, {
-            headers: { accept: 'application/json' },
-            timeout: timeoutMs,
-        }, (response) => {
-            let body = '';
-            response.setEncoding('utf8');
-            response.on('data', (chunk) => {
-                body += chunk;
-            });
-            response.once('end', () => {
-                try {
-                    resolve({
-                        body: JSON.parse(body),
-                        statusCode: response.statusCode ?? 0,
-                    });
-                }
-                catch (error) {
-                    reject(error);
-                }
-            });
-        });
-        request.once('timeout', () => {
-            request.destroy(new Error('npm registry request timed out'));
-        });
-        request.once('error', reject);
-    });
-}
-export async function fetchChannelVersion(options = {}) {
-    const client = options.client ?? registryClientFn;
-    const timeoutMs = options.timeoutMs ?? 5000;
-    const packagePath = encodeURIComponent(AGENTIA_PACKAGE_NAME);
-    const url = `${AGENTIA_NPM_REGISTRY}/-/package/${packagePath}/dist-tags`;
-    let response;
-    try {
-        response = await client(url, timeoutMs);
-    }
-    catch {
-        throw new CliVersionError(`Unable to reach npm while checking the Agentia CLI ${AGENTIA_RELEASE_CHANNEL} channel.`);
-    }
-    if (response.statusCode < 200 || response.statusCode >= 300) {
-        throw new CliVersionError(`npm returned HTTP ${response.statusCode} while checking the Agentia CLI ${AGENTIA_RELEASE_CHANNEL} channel.`);
-    }
-    if (typeof response.body !== 'object' || response.body === null || Array.isArray(response.body)) {
-        throw new CliVersionError(`npm did not return valid dist-tags for the Agentia CLI.`);
-    }
-    const tags = response.body;
-    const version = tags[AGENTIA_RELEASE_CHANNEL];
-    if (typeof version !== 'string' || semver.valid(version) === null) {
-        throw new CliVersionError(`npm did not return a valid Agentia CLI ${AGENTIA_RELEASE_CHANNEL} version.`);
-    }
-    return version;
-}
-export async function refreshVersionCache(cachePath, now = new Date()) {
-    const checkedAt = now.toISOString();
-    const existing = await readVersionCache(cachePath);
-    const marker = {
-        channel: AGENTIA_RELEASE_CHANNEL,
-        checkedAt,
-        ...(existing?.channel === AGENTIA_RELEASE_CHANNEL && existing.latestVersion !== undefined
-            ? { latestVersion: existing.latestVersion }
-            : {}),
-    };
-    await writeVersionCache(cachePath, marker);
-    const latestVersion = await fetchChannelVersion();
-    const cache = { channel: AGENTIA_RELEASE_CHANNEL, checkedAt, latestVersion };
-    await writeVersionCache(cachePath, cache);
-    return cache;
-}
-//# sourceMappingURL=cli-version.js.map
+import {modules} from './runtime.js';
+const AGENTIA_NPM_REGISTRY = modules["cli-version.js"]["AGENTIA_NPM_REGISTRY"]
+const AGENTIA_PACKAGE_NAME = modules["cli-version.js"]["AGENTIA_PACKAGE_NAME"]
+const AGENTIA_RELEASE_CHANNEL = modules["cli-version.js"]["AGENTIA_RELEASE_CHANNEL"]
+const CliVersionError = modules["cli-version.js"]["CliVersionError"]
+const VERSION_CACHE_FILENAME = modules["cli-version.js"]["VERSION_CACHE_FILENAME"]
+const VERSION_CHECK_INTERVAL_MS = modules["cli-version.js"]["VERSION_CHECK_INTERVAL_MS"]
+const defaultVersionRegistryClient = modules["cli-version.js"]["defaultVersionRegistryClient"]
+const fetchChannelVersion = modules["cli-version.js"]["fetchChannelVersion"]
+const isNewerVersion = modules["cli-version.js"]["isNewerVersion"]
+const isVersionCacheStale = modules["cli-version.js"]["isVersionCacheStale"]
+const readVersionCache = modules["cli-version.js"]["readVersionCache"]
+const refreshVersionCache = modules["cli-version.js"]["refreshVersionCache"]
+const setCliVersionRegistryClientForTests = modules["cli-version.js"]["setCliVersionRegistryClientForTests"]
+const versionCachePath = modules["cli-version.js"]["versionCachePath"]
+const writeVersionCache = modules["cli-version.js"]["writeVersionCache"]
+export {AGENTIA_NPM_REGISTRY, AGENTIA_PACKAGE_NAME, AGENTIA_RELEASE_CHANNEL, CliVersionError, VERSION_CACHE_FILENAME, VERSION_CHECK_INTERVAL_MS, defaultVersionRegistryClient, fetchChannelVersion, isNewerVersion, isVersionCacheStale, readVersionCache, refreshVersionCache, setCliVersionRegistryClientForTests, versionCachePath, writeVersionCache};

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

@@ -1,124 +1,15 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
-import { redactSecrets } from './secret-redaction.js';
-/** Total captured transcript size for one command. */
-export const COMMAND_OUTPUT_MAX_BYTES = 256 * 1024;
-const TRUNCATED_MARKER = '[truncated]\n';
-const URL_CREDENTIAL_PATTERN = /:\/\/[^/\s:@]+:[^/\s@]+@/g;
-const commandOutputStore = new AsyncLocalStorage();
-export function isCommandOutputCaptureActive() {
-    return commandOutputStore.getStore() !== undefined;
-}
-export function redactCommandOutput(text) {
-    return redactSecrets(text).replaceAll(URL_CREDENTIAL_PATTERN, '://[REDACTED]@');
-}
-export function appendCommandOutput(text) {
-    const buffer = commandOutputStore.getStore();
-    if (buffer === undefined || text.length === 0) {
-        return;
-    }
-    if (buffer.truncated) {
-        return;
-    }
-    const redacted = redactCommandOutput(text);
-    const combined = buffer.value + redacted;
-    if (combined.length <= COMMAND_OUTPUT_MAX_BYTES) {
-        buffer.value = combined;
-        return;
-    }
-    buffer.value = `${combined.slice(0, COMMAND_OUTPUT_MAX_BYTES - TRUNCATED_MARKER.length)}${TRUNCATED_MARKER}`;
-    buffer.truncated = true;
-}
-export function appendCommandOutputLine(message) {
-    if (message === undefined || message.length === 0) {
-        appendCommandOutput('\n');
-        return;
-    }
-    appendCommandOutput(message.endsWith('\n') ? message : `${message}\n`);
-}
-export function commandStdioCaptureOptions(command) {
-    return {
-        forwardStderr: true,
-        forwardStdout: !command.jsonEnabled(),
-    };
-}
-export const MCP_STDIO_CAPTURE_OPTIONS = {
-    forwardStderr: true,
-    forwardStdout: false,
-};
-function writeChunkToString(chunk) {
-    if (typeof chunk === 'string') {
-        return chunk;
-    }
-    if (chunk instanceof Uint8Array) {
-        return new TextDecoder().decode(chunk);
-    }
-    return String(chunk);
-}
-function wrapWrite(original, forward) {
-    return ((chunk, encoding, callback) => {
-        appendCommandOutput(writeChunkToString(chunk));
-        if (forward) {
-            return original(chunk, encoding, callback);
-        }
-        const cb = typeof encoding === 'function' ? encoding : callback;
-        if (typeof cb === 'function') {
-            cb();
-        }
-        return true;
-    });
-}
-export function splitCommandOutputLines(text) {
-    if (text.length === 0) {
-        return [];
-    }
-    const lines = text.split(/\r?\n/);
-    if (lines.at(-1) === '') {
-        lines.pop();
-    }
-    return lines;
-}
-export async function runWithCommandOutputCapture(fn, options = {}) {
-    const buffer = { truncated: false, value: '' };
-    const forwardStdout = options.forwardStdout !== false;
-    const forwardStderr = options.forwardStderr !== false;
-    return commandOutputStore.run(buffer, async () => {
-        const originalStdoutWrite = process.stdout.write;
-        const originalStderrWrite = process.stderr.write;
-        process.stdout.write = wrapWrite(originalStdoutWrite.bind(process.stdout), forwardStdout);
-        process.stderr.write = wrapWrite(originalStderrWrite.bind(process.stderr), forwardStderr);
-        try {
-            const result = await fn();
-            return { logs: splitCommandOutputLines(buffer.value), result };
-        }
-        finally {
-            process.stdout.write = originalStdoutWrite;
-            process.stderr.write = originalStderrWrite;
-        }
-    });
-}
-export function attachCapturedLogs(result, logs) {
-    if (logs.length === 0) {
-        return result;
-    }
-    return { ...result, logs };
-}
-export function readCapturedCommandOutputText() {
-    const buffer = commandOutputStore.getStore();
-    if (buffer === undefined || buffer.value.length === 0) {
-        return undefined;
-    }
-    const text = splitCommandOutputLines(buffer.value).join('\n');
-    return text.length === 0 ? undefined : text;
-}
-export function attachCapturedOutputLogs(body) {
-    const logs = readCapturedCommandOutputText();
-    if (logs === undefined) {
-        return body;
-    }
-    return { ...body, logs };
-}
-export async function withCapturedCommandOutput(fn, options = {}) {
-    const { logs, result } = await runWithCommandOutputCapture(fn, options);
-    return attachCapturedLogs(result, logs);
-}
-//# sourceMappingURL=command-output-buffer.js.map
+import {modules} from './runtime.js';
+const COMMAND_OUTPUT_MAX_BYTES = modules["command-output-buffer.js"]["COMMAND_OUTPUT_MAX_BYTES"]
+const MCP_STDIO_CAPTURE_OPTIONS = modules["command-output-buffer.js"]["MCP_STDIO_CAPTURE_OPTIONS"]
+const appendCommandOutput = modules["command-output-buffer.js"]["appendCommandOutput"]
+const appendCommandOutputLine = modules["command-output-buffer.js"]["appendCommandOutputLine"]
+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 isCommandOutputCaptureActive = modules["command-output-buffer.js"]["isCommandOutputCaptureActive"]
+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 splitCommandOutputLines = modules["command-output-buffer.js"]["splitCommandOutputLines"]
+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};

package/dist/lib/credential-store.js

@@ -1,160 +1,39 @@
-import { Entry } from '@napi-rs/keyring';
-export const KEYRING_SERVICE = 'agentia-cli';
-export const ALL_CREDENTIAL_TYPES = ['cicd', 'crt', 'ai'];
-const CREDENTIAL_ACCOUNTS = {
-    ai: 'copado-ai-pat-token',
-    cicd: 'copado-cicd-api-key',
-    crt: 'copado-crt-pat-token',
-};
-const AI_DOMAIN_ACCOUNT = 'copado-ai-domain';
-const AI_GATEWAY_URL_ACCOUNT = 'copado-ai-gateway-url';
-const AI_ORG_ID_ACCOUNT = 'copado-ai-org-id';
-const AI_WORKSPACE_ID_ACCOUNT = 'copado-ai-workspace-id';
-const CICD_BASE_URL_ACCOUNT = 'copado-cicd-base-url';
-const CRT_DOMAIN_ACCOUNT = 'copado-crt-domain';
-const CRT_LIVE_VIEWER_ACCOUNT = 'copado-crt-live-viewer-key';
-const CRT_ORG_ID_ACCOUNT = 'copado-crt-org-id';
-export class CredentialStoreError extends Error {
-    credentialType;
-    constructor(credentialType) {
-        super(`Secure storage is unavailable for ${credentialLabel(credentialType)}.`);
-        this.name = 'CredentialStoreError';
-        this.credentialType = credentialType;
-    }
-}
-const defaultEntryFactory = (service, account) => new Entry(service, account);
-let entryFactory = defaultEntryFactory;
-export function setCredential(type, secret) {
-    setCredentialForKey(type, secret);
-}
-export function setCredentialForKey(type, secret, keychainId) {
-    try {
-        entryFactory(KEYRING_SERVICE, credentialAccount(type, keychainId)).setPassword(secret);
-    }
-    catch {
-        throw new CredentialStoreError(type);
-    }
-}
-export function getCredential(type) {
-    return getCredentialForKey(type);
-}
-export function getCredentialForKey(type, keychainId) {
-    return entryFactory(KEYRING_SERVICE, credentialAccount(type, keychainId)).getPassword();
-}
-export function deleteCredential(type) {
-    return deleteCredentialForKey(type);
-}
-export function deleteCredentialForKey(type, keychainId) {
-    return entryFactory(KEYRING_SERVICE, credentialAccount(type, keychainId)).deletePassword();
-}
-function credentialAccount(type, keychainId) {
-    return keychainId === undefined ? CREDENTIAL_ACCOUNTS[type] : `${CREDENTIAL_ACCOUNTS[type]}:${keychainId}`;
-}
-export function deleteAiDomain() {
-    return entryFactory(KEYRING_SERVICE, AI_DOMAIN_ACCOUNT).deletePassword();
-}
-export function deleteAiGatewayUrl() {
-    return entryFactory(KEYRING_SERVICE, AI_GATEWAY_URL_ACCOUNT).deletePassword();
-}
-export function deleteAiOrgId() {
-    return entryFactory(KEYRING_SERVICE, AI_ORG_ID_ACCOUNT).deletePassword();
-}
-export function deleteAiWorkspaceId() {
-    return entryFactory(KEYRING_SERVICE, AI_WORKSPACE_ID_ACCOUNT).deletePassword();
-}
-export function deleteCicdBaseUrl() {
-    return entryFactory(KEYRING_SERVICE, CICD_BASE_URL_ACCOUNT).deletePassword();
-}
-export function deleteCrtDomain() {
-    return entryFactory(KEYRING_SERVICE, CRT_DOMAIN_ACCOUNT).deletePassword();
-}
-export function deleteCrtOrgId() {
-    return entryFactory(KEYRING_SERVICE, CRT_ORG_ID_ACCOUNT).deletePassword();
-}
-export function setCicdBaseUrl(baseUrl) {
-    setEntry('cicd', CICD_BASE_URL_ACCOUNT, baseUrl);
-}
-export function getCicdBaseUrl() {
-    return entryFactory(KEYRING_SERVICE, CICD_BASE_URL_ACCOUNT).getPassword();
-}
-export function setAiDomain(domain) {
-    setEntry('ai', AI_DOMAIN_ACCOUNT, domain);
-}
-export function getAiDomain() {
-    return entryFactory(KEYRING_SERVICE, AI_DOMAIN_ACCOUNT).getPassword();
-}
-export function setAiGatewayUrl(url) {
-    setEntry('ai', AI_GATEWAY_URL_ACCOUNT, url);
-}
-export function getAiGatewayUrl() {
-    return entryFactory(KEYRING_SERVICE, AI_GATEWAY_URL_ACCOUNT).getPassword();
-}
-export function setAiOrgId(orgId) {
-    setEntry('ai', AI_ORG_ID_ACCOUNT, orgId);
-}
-export function getAiOrgId() {
-    return entryFactory(KEYRING_SERVICE, AI_ORG_ID_ACCOUNT).getPassword();
-}
-export function setAiWorkspaceId(workspaceId) {
-    setEntry('ai', AI_WORKSPACE_ID_ACCOUNT, workspaceId);
-}
-export function getAiWorkspaceId() {
-    return entryFactory(KEYRING_SERVICE, AI_WORKSPACE_ID_ACCOUNT).getPassword();
-}
-export function setCrtDomain(domain) {
-    setEntry('crt', CRT_DOMAIN_ACCOUNT, domain);
-}
-export function getCrtDomain() {
-    return entryFactory(KEYRING_SERVICE, CRT_DOMAIN_ACCOUNT).getPassword();
-}
-export function setCrtOrgId(orgId) {
-    setEntry('crt', CRT_ORG_ID_ACCOUNT, orgId);
-}
-export function getCrtOrgId() {
-    return entryFactory(KEYRING_SERVICE, CRT_ORG_ID_ACCOUNT).getPassword();
-}
-export function setCrtLiveViewerSecret(sessionId, secret) {
-    setEntry('crt', crtLiveViewerAccount(sessionId), secret);
-}
-export function getCrtLiveViewerSecret(sessionId) {
-    return entryFactory(KEYRING_SERVICE, crtLiveViewerAccount(sessionId)).getPassword();
-}
-export function deleteCrtLiveViewerSecret(sessionId) {
-    return entryFactory(KEYRING_SERVICE, crtLiveViewerAccount(sessionId)).deletePassword();
-}
-export function credentialLabel(type) {
-    if (type === 'cicd')
-        return 'Copado API key (CICD)';
-    if (type === 'crt')
-        return 'PAK (CRT)';
-    return 'PAK (AI)';
-}
-export function maskSecret(secret) {
-    if (secret.length > 10) {
-        return `${secret.slice(0, 5)}...${secret.slice(-5)}`;
-    }
-    return `${secret.slice(0, 5)}...`;
-}
-function setEntry(type, account, secret) {
-    try {
-        entryFactory(KEYRING_SERVICE, account).setPassword(secret);
-    }
-    catch {
-        throw new CredentialStoreError(type);
-    }
-}
-function crtLiveViewerAccount(sessionId) {
-    if (!Number.isSafeInteger(sessionId) || sessionId <= 0) {
-        throw new Error('CRT live session ID must be a positive integer.');
-    }
-    return `${CRT_LIVE_VIEWER_ACCOUNT}:${sessionId}`;
-}
-// Test-only hook
-export function setEntryFactoryForTests(factory) {
-    entryFactory = factory;
-}
-// Test-only hook
-export function resetEntryFactoryForTests() {
-    entryFactory = defaultEntryFactory;
-}
-//# sourceMappingURL=credential-store.js.map
+import {modules} from './runtime.js';
+const ALL_CREDENTIAL_TYPES = modules["credential-store.js"]["ALL_CREDENTIAL_TYPES"]
+const CredentialStoreError = modules["credential-store.js"]["CredentialStoreError"]
+const KEYRING_SERVICE = modules["credential-store.js"]["KEYRING_SERVICE"]
+const credentialLabel = modules["credential-store.js"]["credentialLabel"]
+const deleteAiDomain = modules["credential-store.js"]["deleteAiDomain"]
+const deleteAiGatewayUrl = modules["credential-store.js"]["deleteAiGatewayUrl"]
+const deleteAiOrgId = modules["credential-store.js"]["deleteAiOrgId"]
+const deleteAiWorkspaceId = modules["credential-store.js"]["deleteAiWorkspaceId"]
+const deleteCicdBaseUrl = modules["credential-store.js"]["deleteCicdBaseUrl"]
+const deleteCredential = modules["credential-store.js"]["deleteCredential"]
+const deleteCredentialForKey = modules["credential-store.js"]["deleteCredentialForKey"]
+const deleteCrtDomain = modules["credential-store.js"]["deleteCrtDomain"]
+const deleteCrtLiveViewerSecret = modules["credential-store.js"]["deleteCrtLiveViewerSecret"]
+const deleteCrtOrgId = modules["credential-store.js"]["deleteCrtOrgId"]
+const getAiDomain = modules["credential-store.js"]["getAiDomain"]
+const getAiGatewayUrl = modules["credential-store.js"]["getAiGatewayUrl"]
+const getAiOrgId = modules["credential-store.js"]["getAiOrgId"]
+const getAiWorkspaceId = modules["credential-store.js"]["getAiWorkspaceId"]
+const getCicdBaseUrl = modules["credential-store.js"]["getCicdBaseUrl"]
+const getCredential = modules["credential-store.js"]["getCredential"]
+const getCredentialForKey = modules["credential-store.js"]["getCredentialForKey"]
+const getCrtDomain = modules["credential-store.js"]["getCrtDomain"]
+const getCrtLiveViewerSecret = modules["credential-store.js"]["getCrtLiveViewerSecret"]
+const getCrtOrgId = modules["credential-store.js"]["getCrtOrgId"]
+const maskSecret = modules["credential-store.js"]["maskSecret"]
+const resetEntryFactoryForTests = modules["credential-store.js"]["resetEntryFactoryForTests"]
+const setAiDomain = modules["credential-store.js"]["setAiDomain"]
+const setAiGatewayUrl = modules["credential-store.js"]["setAiGatewayUrl"]
+const setAiOrgId = modules["credential-store.js"]["setAiOrgId"]
+const setAiWorkspaceId = modules["credential-store.js"]["setAiWorkspaceId"]
+const setCicdBaseUrl = modules["credential-store.js"]["setCicdBaseUrl"]
+const setCredential = modules["credential-store.js"]["setCredential"]
+const setCredentialForKey = modules["credential-store.js"]["setCredentialForKey"]
+const setCrtDomain = modules["credential-store.js"]["setCrtDomain"]
+const setCrtLiveViewerSecret = modules["credential-store.js"]["setCrtLiveViewerSecret"]
+const setCrtOrgId = modules["credential-store.js"]["setCrtOrgId"]
+const setEntryFactoryForTests = modules["credential-store.js"]["setEntryFactoryForTests"]
+export {ALL_CREDENTIAL_TYPES, CredentialStoreError, KEYRING_SERVICE, credentialLabel, deleteAiDomain, deleteAiGatewayUrl, deleteAiOrgId, deleteAiWorkspaceId, deleteCicdBaseUrl, deleteCredential, deleteCredentialForKey, deleteCrtDomain, deleteCrtLiveViewerSecret, deleteCrtOrgId, getAiDomain, getAiGatewayUrl, getAiOrgId, getAiWorkspaceId, getCicdBaseUrl, getCredential, getCredentialForKey, getCrtDomain, getCrtLiveViewerSecret, getCrtOrgId, maskSecret, resetEntryFactoryForTests, setAiDomain, setAiGatewayUrl, setAiOrgId, setAiWorkspaceId, setCicdBaseUrl, setCredential, setCredentialForKey, setCrtDomain, setCrtLiveViewerSecret, setCrtOrgId, setEntryFactoryForTests};