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

package/dist/lib/credential-sync.js

@@ -1,256 +1,12 @@
-import { createHash } from 'node:crypto';
-import { resolveAiCredentials } from './ai-config.js';
-import { AiGateway } from './ai-gateway.js';
-import { agentUsesCicdIntegration } from './ai-types.js';
-import { tryResolveCicdCredentials, } from './cicd-gateway.js';
-import { readCredentialSyncReceipt, readDefaults, resolveDefaults, writeCredentialSyncReceipt, } from './defaults-store.js';
-import { salesforceIdsEqual } from './salesforce-id.js';
-const CREDENTIAL_SYNC_SCHEMA_VERSION = 2;
-const AI_INTEGRATION_NAME = 'Agentia CLI Copado CICD';
-const activeSyncs = new Map();
-function fingerprint(value) {
-    return createHash('sha256').update(value).digest('hex');
-}
-function trimOptional(value) {
-    const trimmed = value?.trim();
-    return trimmed === undefined || trimmed.length === 0 ? undefined : trimmed;
-}
-export function missingProjectDefaultCredentialWarning() {
-    return [
-        'No CICD project default credential is configured.',
-        'Run `agentia cicd project default set --credential <credential-id>` to set one.',
-    ].join(' ');
-}
-export function missingProjectDefaultWorkSetWarning() {
-    return [
-        missingProjectDefaultCredentialWarning(),
-        'Then run `agentia cicd work update --source-credential <credential-id>` if the User Story should use it.',
-    ].join(' ');
-}
-export function missingStoryCredentialWarning(credentialId, workItemId) {
-    const updateTarget = workItemId === undefined ? '' : ` ${workItemId}`;
-    return [
-        'The User Story has no source credential in Copado CICD.',
-        `Run \`agentia cicd work update${updateTarget} --source-credential ${credentialId}\` to bind the project default credential.`,
-    ].join(' ');
-}
-export function differingStoryCredentialWarning(input) {
-    const updateTarget = input.workItemId === undefined ? '' : ` ${input.workItemId}`;
-    return [
-        'The User Story is already set to another environment which is not the project default.',
-        `Current source credential: ${input.storyCredentialId}.`,
-        `Current source environment: ${input.storyEnvironmentLabel}.`,
-        `Run \`agentia cicd work update${updateTarget} --source-credential ${input.projectDefaultCredentialId}\` to change it.`,
-    ].join(' ');
-}
-export function formatWorkSetEnvironmentLabel(workItem) {
-    const name = trimOptional(workItem.sourceEnvironmentName);
-    const id = trimOptional(workItem.sourceEnvironment);
-    if (name !== undefined && id !== undefined) {
-        return `${name} (${id})`;
-    }
-    return name ?? id ?? 'unknown';
-}
-export async function readProjectDefaultCredentialContext() {
-    const [localDefaults, globalDefaults] = await Promise.all([readDefaults('local'), readDefaults('global')]);
-    const resolved = resolveDefaults(localDefaults, globalDefaults, ['credential', 'environment']);
-    const credential = resolved.find((entry) => entry.key === 'credential')?.value;
-    const environment = resolved.find((entry) => entry.key === 'environment')?.value;
-    return {
-        ...(typeof credential === 'string' && credential.trim().length > 0
-            ? { credentialId: credential.trim() }
-            : {}),
-        ...(typeof environment === 'string' && environment.trim().length > 0
-            ? { environmentId: environment.trim() }
-            : {}),
-    };
-}
-export function sanitizeWorkSetUserStory(userStory) {
-    const safeUserStory = { ...userStory };
-    delete safeUserStory.oauthSignature;
-    return safeUserStory;
-}
-export async function reconcileWorkSetCredential(workItem) {
-    const projectDefault = await readProjectDefaultCredentialContext();
-    const storyCredential = trimOptional(workItem.sourceCredential);
-    const sanitized = sanitizeWorkSetUserStory(workItem);
-    if (projectDefault.credentialId === undefined) {
-        return {
-            updated: false,
-            warnings: [missingProjectDefaultWorkSetWarning()],
-            workItem: sanitized,
-        };
-    }
-    if (storyCredential === undefined) {
-        return {
-            updated: false,
-            warnings: [missingStoryCredentialWarning(projectDefault.credentialId, workItem.id)],
-            workItem: sanitized,
-        };
-    }
-    if (salesforceIdsEqual(storyCredential, projectDefault.credentialId)) {
-        return {
-            updated: false,
-            warnings: [],
-            workItem: sanitized,
-        };
-    }
-    const warning = differingStoryCredentialWarning({
-        projectDefaultCredentialId: projectDefault.credentialId,
-        storyCredentialId: storyCredential,
-        storyEnvironmentLabel: formatWorkSetEnvironmentLabel(sanitized),
-        workItemId: workItem.id,
-    });
-    return {
-        updated: false,
-        warnings: [warning],
-        workItem: sanitized,
-    };
-}
-function localReceiptMatches(receipt, context) {
-    return (receipt?.schemaVersion === context.schemaVersion &&
-        receipt.cicdBaseUrl === context.cicdBaseUrl &&
-        receipt.cicdKeyFingerprint === context.cicdKeyFingerprint &&
-        salesforceIdsEqual(receipt.credentialId, context.credentialId) &&
-        (receipt.environmentId ?? '') === (context.environmentId ?? '') &&
-        (receipt.orgId ?? '') === (context.orgId ?? ''));
-}
-function integrationWorkspace(integration) {
-    return integration.workspaceId ?? integration.workspace_id ?? undefined;
-}
-function matchingWorkspaceIntegrations(integrations, workspaceId) {
-    return integrations.filter((integration) => integration.type === 'copado_cicd' &&
-        integration.level === 'MEMBER' &&
-        integrationWorkspace(integration) === workspaceId);
-}
-function aiReceiptMatches(receipt, baseUrl, organizationId, workspaceId) {
-    return (receipt.ai?.baseUrl === baseUrl &&
-        receipt.ai.organizationId === organizationId &&
-        receipt.ai.workspaceId === workspaceId);
-}
-async function replaceAiIntegration(context, cicdCredentials, workspaceId, options) {
-    const integrations = await AiGateway.listIntegrations(options);
-    const matches = matchingWorkspaceIntegrations(integrations, workspaceId);
-    for (const integration of matches) {
-        // Replacement follows the established UI sequence because CICD credentials cannot be updated.
-        // eslint-disable-next-line no-await-in-loop
-        await AiGateway.deleteIntegration(integration.id, options);
-    }
-    const created = await AiGateway.createIntegration({
-        category: 'GENERAL',
-        config: { credentialId: context.credentialId },
-        credential: { apiKey: cicdCredentials.apiKey },
-        level: 'MEMBER',
-        name: AI_INTEGRATION_NAME,
-        type: 'copado_cicd',
-        workspaceId,
-    }, options);
-    const createdWorkspace = integrationWorkspace(created);
-    const createdCredentialId = created.config?.credentialId;
-    if ((created.type !== undefined && created.type !== 'copado_cicd') ||
-        (created.level !== undefined && created.level !== 'MEMBER') ||
-        (createdWorkspace !== undefined && createdWorkspace !== workspaceId) ||
-        (typeof createdCredentialId === 'string' &&
-            !salesforceIdsEqual(createdCredentialId, context.credentialId))) {
-        throw new Error('AI Gateway returned a Copado CICD integration that does not match the requested workspace context.');
-    }
-    return created.id;
-}
-function buildLocalContext(cicdCredentials, credentialId, environmentId, orgId) {
-    return {
-        cicdBaseUrl: cicdCredentials.baseUrl,
-        cicdKeyFingerprint: fingerprint(cicdCredentials.apiKey),
-        credentialId,
-        schemaVersion: CREDENTIAL_SYNC_SCHEMA_VERSION,
-        ...(environmentId === undefined ? {} : { environmentId }),
-        ...(orgId === undefined ? {} : { orgId }),
-    };
-}
-async function ensureAiIntegrationWithContext(input) {
-    const { aiOptions, cicdCredentials, context, force, workspaceId } = input;
-    const aiCredentials = resolveAiCredentials({ ...aiOptions, workspace: workspaceId });
-    const cached = await readCredentialSyncReceipt();
-    if (!force &&
-        localReceiptMatches(cached, context) &&
-        aiReceiptMatches(cached, aiCredentials.baseUrl, aiCredentials.orgId, workspaceId)) {
-        return {
-            credentialId: context.credentialId,
-            ...(context.environmentId === undefined ? {} : { environmentId: context.environmentId }),
-            integrationId: cached.ai?.integrationId,
-            ...(context.orgId === undefined ? {} : { orgId: context.orgId }),
-            workspaceId,
-        };
-    }
-    const integrationId = await replaceAiIntegration(context, cicdCredentials, workspaceId, aiOptions);
-    await writeCredentialSyncReceipt({
-        ...context,
-        ai: {
-            baseUrl: aiCredentials.baseUrl,
-            integrationId,
-            ...(aiCredentials.orgId === undefined ? {} : { organizationId: aiCredentials.orgId }),
-            workspaceId,
-        },
-    });
-    return {
-        credentialId: context.credentialId,
-        ...(context.environmentId === undefined ? {} : { environmentId: context.environmentId }),
-        integrationId,
-        ...(context.orgId === undefined ? {} : { orgId: context.orgId }),
-        workspaceId,
-    };
-}
-export async function ensureAgentCicdIntegration(agent, workspaceId, options = {}) {
-    if (!agentUsesCicdIntegration(agent) || options.noCredentialSync === true)
-        return undefined;
-    const cicdCredentials = tryResolveCicdCredentials({ forceRemote: true });
-    if (cicdCredentials === undefined)
-        return undefined;
-    if (workspaceId === undefined) {
-        throw new Error('AI dialogue did not identify its workspace. Pass --workspace or start a new dialogue before credential synchronization.');
-    }
-    const projectDefault = await readProjectDefaultCredentialContext();
-    const credentialId = trimOptional(options.credentialId) ?? projectDefault.credentialId;
-    if (credentialId === undefined) {
-        throw new Error(missingProjectDefaultCredentialWarning());
-    }
-    const aiCredentials = resolveAiCredentials({ ...options, workspace: workspaceId });
-    const orgId = aiCredentials.orgId === undefined ? undefined : String(aiCredentials.orgId);
-    const context = buildLocalContext(cicdCredentials, credentialId, projectDefault.environmentId, orgId);
-    const cached = await readCredentialSyncReceipt();
-    const cacheKey = [
-        aiCredentials.baseUrl,
-        orgId ?? '',
-        workspaceId,
-        cicdCredentials.baseUrl,
-        fingerprint(cicdCredentials.apiKey),
-        credentialId,
-        projectDefault.environmentId ?? '',
-    ].join('|');
-    if (options.forceCredentialSync !== true &&
-        localReceiptMatches(cached, context) &&
-        aiReceiptMatches(cached, aiCredentials.baseUrl, aiCredentials.orgId, workspaceId)) {
-        return {
-            credentialId: cached.credentialId,
-            ...(cached.environmentId === undefined ? {} : { environmentId: cached.environmentId }),
-            integrationId: cached.ai?.integrationId,
-            ...(cached.orgId === undefined ? {} : { orgId: cached.orgId }),
-            workspaceId,
-        };
-    }
-    const active = activeSyncs.get(cacheKey);
-    if (active !== undefined)
-        return active;
-    const sync = ensureAiIntegrationWithContext({
-        aiOptions: options,
-        cicdCredentials,
-        context,
-        force: options.forceCredentialSync === true,
-        workspaceId,
-    }).finally(() => activeSyncs.delete(cacheKey));
-    activeSyncs.set(cacheKey, sync);
-    return sync;
-}
-export function clearCredentialSyncsForTests() {
-    activeSyncs.clear();
-}
-//# sourceMappingURL=credential-sync.js.map
+import {modules} from './runtime.js';
+const clearCredentialSyncsForTests = modules["credential-sync.js"]["clearCredentialSyncsForTests"]
+const differingStoryCredentialWarning = modules["credential-sync.js"]["differingStoryCredentialWarning"]
+const ensureAgentCicdIntegration = modules["credential-sync.js"]["ensureAgentCicdIntegration"]
+const formatWorkSetEnvironmentLabel = modules["credential-sync.js"]["formatWorkSetEnvironmentLabel"]
+const missingProjectDefaultCredentialWarning = modules["credential-sync.js"]["missingProjectDefaultCredentialWarning"]
+const missingProjectDefaultWorkSetWarning = modules["credential-sync.js"]["missingProjectDefaultWorkSetWarning"]
+const missingStoryCredentialWarning = modules["credential-sync.js"]["missingStoryCredentialWarning"]
+const readProjectDefaultCredentialContext = modules["credential-sync.js"]["readProjectDefaultCredentialContext"]
+const reconcileWorkSetCredential = modules["credential-sync.js"]["reconcileWorkSetCredential"]
+const sanitizeWorkSetUserStory = modules["credential-sync.js"]["sanitizeWorkSetUserStory"]
+export {clearCredentialSyncsForTests, differingStoryCredentialWarning, ensureAgentCicdIntegration, formatWorkSetEnvironmentLabel, missingProjectDefaultCredentialWarning, missingProjectDefaultWorkSetWarning, missingStoryCredentialWarning, readProjectDefaultCredentialContext, reconcileWorkSetCredential, sanitizeWorkSetUserStory};

package/dist/lib/cursor-mcp-config.js

@@ -1,174 +1,16 @@
-import { existsSync } from 'node:fs';
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import path from 'node:path';
-export const AGENTIA_MCP_SERVER_NAME = 'agentia';
-export const AGENTIA_MCP_ENTRY = {
-    args: ['mcp', 'start'],
-    command: 'agentia',
-    env: { AGENTIA_PROJECT_ROOT: ['$', '{workspaceFolder}'].join('') },
-    type: 'stdio',
-};
-let testDeps;
-export function setCursorMcpDepsForTests(deps) {
-    testDeps = deps;
-}
-export function resetCursorMcpDepsForTests() {
-    testDeps = undefined;
-}
-function resolveDeps(overrides = {}) {
-    const merged = { ...testDeps, ...overrides };
-    return {
-        existsSync: merged.existsSync ?? existsSync,
-        homedir: merged.homedir ?? homedir,
-        pathEnv: merged.pathEnv ?? process.env.PATH ?? '',
-        platform: merged.platform ?? process.platform,
-        readFile: merged.readFile ?? ((filePath, encoding) => readFile(filePath, encoding)),
-        writeFile: merged.writeFile ?? ((filePath, contents, encoding) => writeFile(filePath, contents, encoding)),
-    };
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-export function globalCursorMcpPath(home = homedir()) {
-    return path.join(home, '.cursor', 'mcp.json');
-}
-export function localCursorMcpPath(projectRoot) {
-    return path.join(projectRoot, '.cursor', 'mcp.json');
-}
-export function isAgentiaMcpEntry(value) {
-    if (!isRecord(value)) {
-        return false;
-    }
-    if (value.command !== 'agentia') {
-        return false;
-    }
-    if (!Array.isArray(value.args) || value.args.length !== 2) {
-        return false;
-    }
-    return value.args[0] === 'mcp' && value.args[1] === 'start';
-}
-export function hasConflictingAgentiaEntry(value) {
-    return isRecord(value) && Object.keys(value).length > 0 && !isAgentiaMcpEntry(value);
-}
-export function findAgentiaMcpServer(document) {
-    const servers = document?.mcpServers;
-    if (!isRecord(servers)) {
-        return undefined;
-    }
-    for (const [name, entry] of Object.entries(servers)) {
-        if (isAgentiaMcpEntry(entry)) {
-            return { entry, name };
-        }
-    }
-    return undefined;
-}
-function commandOnPath(command, pathEnv, platform, exists) {
-    const extensions = platform === 'win32' ? ['.cmd', '.exe', '.bat', ''] : [''];
-    for (const dir of pathEnv.split(path.delimiter)) {
-        if (dir.trim().length === 0) {
-            continue;
-        }
-        for (const extension of extensions) {
-            if (exists(path.join(dir, `${command}${extension}`))) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-function standardCursorAppLocations(home, platform) {
-    if (platform === 'darwin') {
-        return ['/Applications/Cursor.app'];
-    }
-    if (platform === 'win32') {
-        return [
-            path.join(home, 'AppData', 'Local', 'Programs', 'cursor', 'Cursor.exe'),
-            path.join(home, 'AppData', 'Local', 'Programs', 'Cursor', 'Cursor.exe'),
-        ];
-    }
-    return ['/usr/share/cursor', '/opt/Cursor', path.join(home, '.local', 'share', 'cursor')];
-}
-export function detectCursorInstall(deps = {}) {
-    const resolved = resolveDeps(deps);
-    const globalPath = globalCursorMcpPath(resolved.homedir());
-    const configPresent = resolved.existsSync(globalPath);
-    const onPath = commandOnPath('cursor', resolved.pathEnv, resolved.platform, resolved.existsSync) ||
-        commandOnPath('agent', resolved.pathEnv, resolved.platform, resolved.existsSync);
-    const appPresent = standardCursorAppLocations(resolved.homedir(), resolved.platform).some((filePath) => resolved.existsSync(filePath));
-    return {
-        configPresent,
-        detected: configPresent || onPath || appPresent,
-        onPath,
-    };
-}
-export async function readCursorMcpDocument(filePath, deps = {}) {
-    const resolved = resolveDeps(deps);
-    if (!resolved.existsSync(filePath)) {
-        return { exists: false };
-    }
-    try {
-        const contents = await resolved.readFile(filePath, 'utf8');
-        const parsed = JSON.parse(contents);
-        if (!isRecord(parsed)) {
-            return { error: `Cursor MCP config at ${filePath} must contain a JSON object.`, exists: true };
-        }
-        return { document: parsed, exists: true };
-    }
-    catch (error) {
-        if (error instanceof SyntaxError) {
-            return { error: `Cursor MCP config at ${filePath} contains invalid JSON.`, exists: true };
-        }
-        throw error;
-    }
-}
-export function inspectCursorMcpStatus(document, filePath, exists) {
-    const matched = findAgentiaMcpServer(document);
-    const namedEntry = document?.mcpServers?.[AGENTIA_MCP_SERVER_NAME];
-    return {
-        configured: matched !== undefined,
-        conflicting: matched === undefined && hasConflictingAgentiaEntry(namedEntry),
-        exists,
-        path: filePath,
-        serverName: matched?.name,
-    };
-}
-export async function getCursorMcpStatus(projectRoot, deps = {}) {
-    const resolved = resolveDeps(deps);
-    const localPath = localCursorMcpPath(projectRoot);
-    const globalPath = globalCursorMcpPath(resolved.homedir());
-    const [localFile, globalFile] = await Promise.all([
-        readCursorMcpDocument(localPath, deps),
-        readCursorMcpDocument(globalPath, deps),
-    ]);
-    return {
-        global: inspectCursorMcpStatus(globalFile.document, globalPath, globalFile.exists),
-        local: inspectCursorMcpStatus(localFile.document, localPath, localFile.exists),
-    };
-}
-export async function upsertAgentiaCursorMcp(filePath, deps = {}) {
-    const resolved = resolveDeps(deps);
-    const current = await readCursorMcpDocument(filePath, deps);
-    if (current.error !== undefined) {
-        throw new Error(current.error);
-    }
-    const document = current.document ?? {};
-    const servers = isRecord(document.mcpServers) ? { ...document.mcpServers } : {};
-    const existing = findAgentiaMcpServer(document);
-    const targetName = existing?.name ?? AGENTIA_MCP_SERVER_NAME;
-    const existed = current.exists && servers[targetName] !== undefined;
-    servers[targetName] = { ...AGENTIA_MCP_ENTRY };
-    document.mcpServers = servers;
-    try {
-        await mkdir(path.dirname(filePath), { recursive: true });
-    }
-    catch {
-        // Best-effort directory creation; writeFile still runs for injectable test deps.
-    }
-    await resolved.writeFile(filePath, `${JSON.stringify(document, null, 2)}\n`, 'utf8');
-    return {
-        path: filePath,
-        status: existed || current.exists ? 'updated' : 'created',
-    };
-}
-//# sourceMappingURL=cursor-mcp-config.js.map
+import {modules} from './runtime.js';
+const AGENTIA_MCP_ENTRY = modules["cursor-mcp-config.js"]["AGENTIA_MCP_ENTRY"]
+const AGENTIA_MCP_SERVER_NAME = modules["cursor-mcp-config.js"]["AGENTIA_MCP_SERVER_NAME"]
+const detectCursorInstall = modules["cursor-mcp-config.js"]["detectCursorInstall"]
+const findAgentiaMcpServer = modules["cursor-mcp-config.js"]["findAgentiaMcpServer"]
+const getCursorMcpStatus = modules["cursor-mcp-config.js"]["getCursorMcpStatus"]
+const globalCursorMcpPath = modules["cursor-mcp-config.js"]["globalCursorMcpPath"]
+const hasConflictingAgentiaEntry = modules["cursor-mcp-config.js"]["hasConflictingAgentiaEntry"]
+const inspectCursorMcpStatus = modules["cursor-mcp-config.js"]["inspectCursorMcpStatus"]
+const isAgentiaMcpEntry = modules["cursor-mcp-config.js"]["isAgentiaMcpEntry"]
+const localCursorMcpPath = modules["cursor-mcp-config.js"]["localCursorMcpPath"]
+const readCursorMcpDocument = modules["cursor-mcp-config.js"]["readCursorMcpDocument"]
+const resetCursorMcpDepsForTests = modules["cursor-mcp-config.js"]["resetCursorMcpDepsForTests"]
+const setCursorMcpDepsForTests = modules["cursor-mcp-config.js"]["setCursorMcpDepsForTests"]
+const upsertAgentiaCursorMcp = modules["cursor-mcp-config.js"]["upsertAgentiaCursorMcp"]
+export {AGENTIA_MCP_ENTRY, AGENTIA_MCP_SERVER_NAME, detectCursorInstall, findAgentiaMcpServer, getCursorMcpStatus, globalCursorMcpPath, hasConflictingAgentiaEntry, inspectCursorMcpStatus, isAgentiaMcpEntry, localCursorMcpPath, readCursorMcpDocument, resetCursorMcpDepsForTests, setCursorMcpDepsForTests, upsertAgentiaCursorMcp};

package/dist/lib/data-flags.js

@@ -1,61 +1,8 @@
-import { Flags } from '@oclif/core';
-import { readFileSync } from 'node:fs';
-export const jsonBodyFlags = {
-    file: Flags.string({
-        char: 'f',
-        description: 'Path to a JSON file body',
-        exclusive: ['stdin'],
-    }),
-    stdin: Flags.boolean({
-        description: 'Read the JSON body from stdin',
-        exclusive: ['file'],
-    }),
-};
-export function parseJsonValue(raw, label) {
-    try {
-        return JSON.parse(raw);
-    }
-    catch {
-        throw new Error(`Invalid JSON for ${label}.`);
-    }
-}
-export async function readStdin() {
-    return new Promise((resolve, reject) => {
-        let data = '';
-        process.stdin.setEncoding('utf8');
-        process.stdin.on('data', (chunk) => {
-            data += chunk;
-        });
-        process.stdin.on('end', () => resolve(data));
-        process.stdin.on('error', reject);
-    });
-}
-export async function readJsonBodyFromFileOrStdin(options) {
-    if (options.file !== undefined && options.file.trim().length > 0) {
-        return parseJsonValue(readFileSync(options.file, 'utf8'), options.label);
-    }
-    if (options.stdin) {
-        const raw = await readStdin();
-        if (raw.trim().length === 0) {
-            throw new Error(`${options.label} stdin was empty.`);
-        }
-        return parseJsonValue(raw, options.label);
-    }
-    if (options.required) {
-        throw new Error(`Provide --file or --stdin for ${options.label}.`);
-    }
-    return undefined;
-}
-export function assertJsonObject(value, label) {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
-        throw new Error(`${label} must be a JSON object.`);
-    }
-    return value;
-}
-export function assertJsonArray(value, label) {
-    if (!Array.isArray(value)) {
-        throw new TypeError(`${label} must be a JSON array.`);
-    }
-    return value;
-}
-//# sourceMappingURL=data-flags.js.map
+import {modules} from './runtime.js';
+const assertJsonArray = modules["data-flags.js"]["assertJsonArray"]
+const assertJsonObject = modules["data-flags.js"]["assertJsonObject"]
+const jsonBodyFlags = modules["data-flags.js"]["jsonBodyFlags"]
+const parseJsonValue = modules["data-flags.js"]["parseJsonValue"]
+const readJsonBodyFromFileOrStdin = modules["data-flags.js"]["readJsonBodyFromFileOrStdin"]
+const readStdin = modules["data-flags.js"]["readStdin"]
+export {assertJsonArray, assertJsonObject, jsonBodyFlags, parseJsonValue, readJsonBodyFromFileOrStdin, readStdin};