@solarains/va-cli 0.1.1

package/dist/features/init/installer.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareInstallations = prepareInstallations;
+exports.applyInstallations = applyInstallations;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const manifest_1 = require("./manifest");
+const target_registry_1 = require("./target-registry");
+const templates_1 = require("./templates");
+async function readText(path) {
+    try {
+        return await (0, promises_1.readFile)(path, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return null;
+        }
+        throw error;
+    }
+}
+function isManagedFile(relativePath, contents, manifest) {
+    if (contents.includes(templates_1.MANAGED_MARKER)) {
+        return true;
+    }
+    return manifest?.files.includes(relativePath) ?? false;
+}
+function createAnalysis() {
+    return {
+        toCreate: [],
+        toRefresh: [],
+        toRemove: [],
+        conflicts: [],
+    };
+}
+async function prepareInstallations(input) {
+    const prepared = [];
+    for (const agentId of input.agentIds) {
+        const target = (0, target_registry_1.getAgentTarget)(agentId);
+        if (!target.supportedScopes.includes(input.scope)) {
+            throw new Error(`Target "${target.displayName}" does not support "${input.scope}" scope.`);
+        }
+        const rootDir = target.resolveRoot({
+            cwd: input.cwd,
+            homeDir: input.homeDir,
+            scope: input.scope,
+        });
+        const manifestPath = (0, node_path_1.join)(rootDir, manifest_1.MANIFEST_FILE_NAME);
+        const manifest = await (0, manifest_1.readManagedManifest)(manifestPath);
+        const files = await (0, templates_1.createAgentPackFiles)(target, input.scope);
+        const analysis = createAnalysis();
+        const nextRelativePaths = new Set(files.map((file) => file.relativePath));
+        for (const file of files) {
+            const absolutePath = (0, node_path_1.join)(rootDir, file.relativePath);
+            const existing = await readText(absolutePath);
+            if (existing === null) {
+                analysis.toCreate.push(file.relativePath);
+                continue;
+            }
+            if (isManagedFile(file.relativePath, existing, manifest)) {
+                analysis.toRefresh.push(file.relativePath);
+                continue;
+            }
+            analysis.conflicts.push(file.relativePath);
+        }
+        for (const relativePath of manifest?.files ?? []) {
+            if (!nextRelativePaths.has(relativePath)) {
+                analysis.toRemove.push(relativePath);
+            }
+        }
+        const existingManifest = await readText(manifestPath);
+        if (existingManifest !== null && manifest === null) {
+            analysis.conflicts.push(manifest_1.MANIFEST_FILE_NAME);
+        }
+        prepared.push({
+            target,
+            scope: input.scope,
+            rootDir,
+            manifestPath,
+            files,
+            analysis,
+        });
+    }
+    return prepared;
+}
+async function applyInstallations(prepared, options) {
+    const applied = [];
+    const timestamp = options.now ?? (() => new Date().toISOString());
+    for (const entry of prepared) {
+        if (entry.analysis.conflicts.length > 0 && !options.allowUnmanagedOverwrite) {
+            throw new Error(`Unmanaged files block ${entry.target.displayName} installation: ${entry.analysis.conflicts.join(', ')}. Re-run with --force or confirm overwrite interactively.`);
+        }
+        const overwritten = [...entry.analysis.conflicts];
+        for (const relativePath of entry.analysis.toRemove) {
+            const absolutePath = (0, node_path_1.join)(entry.rootDir, relativePath);
+            await (0, promises_1.rm)(absolutePath, { force: true });
+        }
+        for (const file of entry.files) {
+            const absolutePath = (0, node_path_1.join)(entry.rootDir, file.relativePath);
+            await (0, promises_1.mkdir)((0, node_path_1.dirname)(absolutePath), { recursive: true });
+            await (0, promises_1.writeFile)(absolutePath, file.contents, 'utf8');
+        }
+        await (0, promises_1.mkdir)(entry.rootDir, { recursive: true });
+        await (0, manifest_1.writeManagedManifest)(entry.manifestPath, {
+            managedBy: 'vaone',
+            manifestVersion: 1,
+            packId: 'vaone-agent-pack',
+            targetId: entry.target.id,
+            scope: entry.scope,
+            updatedAt: timestamp(),
+            files: entry.files.map((file) => file.relativePath),
+        });
+        applied.push({
+            target: entry.target,
+            scope: entry.scope,
+            rootDir: entry.rootDir,
+            created: [...entry.analysis.toCreate],
+            refreshed: [...entry.analysis.toRefresh],
+            overwritten,
+        });
+    }
+    return applied;
+}

package/dist/features/init/manifest.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MANIFEST_FILE_NAME = void 0;
+exports.readManagedManifest = readManagedManifest;
+exports.writeManagedManifest = writeManagedManifest;
+const promises_1 = require("node:fs/promises");
+exports.MANIFEST_FILE_NAME = '.vaone-managed.json';
+async function readManagedManifest(manifestPath) {
+    try {
+        const raw = await (0, promises_1.readFile)(manifestPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (parsed.managedBy !== 'vaone' ||
+            parsed.packId !== 'vaone-agent-pack' ||
+            parsed.manifestVersion !== 1 ||
+            !Array.isArray(parsed.files)) {
+            return null;
+        }
+        return parsed;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return null;
+        }
+        throw error;
+    }
+}
+async function writeManagedManifest(manifestPath, manifest) {
+    await (0, promises_1.writeFile)(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+}

package/dist/features/init/presentation.js

@@ -0,0 +1,147 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForTerminalEnter = waitForTerminalEnter;
+exports.showVisionAlphaWelcome = showVisionAlphaWelcome;
+exports.createInitPresenter = createInitPresenter;
+const core_1 = require("@inquirer/core");
+const chalk_1 = __importDefault(require("chalk"));
+const PALETTE = {
+    blue: chalk_1.default.hex('#4DA3FF'),
+    cyan: chalk_1.default.hex('#7DD3FC'),
+    dimBlue: chalk_1.default.hex('#6D84B3'),
+    darkBlue: chalk_1.default.hex('#214C8E'),
+    white: chalk_1.default.hex('#EAF4FF'),
+};
+const ART_COLUMN_WIDTH = 28;
+const WELCOME_ART = [
+    '        ╭──────────────╮',
+    '    ╭───┤  VA  SIGNAL  ├───╮',
+    '    │   ╰──────────────╯   │',
+    '    │    ▓▓██▓▓▒▒░░▒▒▓▓    │',
+    '    ╰────── market sync ───╯',
+];
+function supportsColor() {
+    return Boolean(process.stdout.isTTY) && !process.env.NO_COLOR;
+}
+function buildFrameLines(textLines, artLines) {
+    const maxLines = Math.max(textLines.length, artLines.length);
+    const lines = [];
+    for (let index = 0; index < maxLines; index += 1) {
+        const art = (artLines[index] ?? '').padEnd(ART_COLUMN_WIDTH);
+        const text = textLines[index] ?? '';
+        lines.push(`${colorize(art, 'blue')}${text}`);
+    }
+    return lines;
+}
+function colorize(value, tone) {
+    return supportsColor() ? PALETTE[tone](value) : value;
+}
+function renderFrame(textLines, artLines) {
+    return buildFrameLines(textLines, artLines).join('\n');
+}
+function splitDisplayLines(message) {
+    return message.split('\n');
+}
+const enterScreenPrompt = (0, core_1.createPrompt)((config, done) => {
+    (0, core_1.useKeypress)((key) => {
+        if ((0, core_1.isEnterKey)(key)) {
+            done();
+        }
+        if (key.name === 'c' && key.ctrl) {
+            process.stdout.write('\n');
+            process.exit(0);
+        }
+    });
+    return config.content;
+});
+function getWelcomeText() {
+    return [
+        colorize('VisionAlpha CLI', 'white'),
+        colorize('Operator bootstrap', 'cyan'),
+        '',
+        colorize('Preparing a branded setup flow for your agent apps.', 'dimBlue'),
+        colorize('Press Enter to begin / 按 Enter 开始', supportsColor() ? 'cyan' : 'white'),
+    ];
+}
+function waitForTerminalEnter() {
+    return new Promise((resolve) => {
+        const { stdin } = process;
+        if (!stdin.isTTY) {
+            resolve();
+            return;
+        }
+        const wasRaw = stdin.isRaw;
+        stdin.setRawMode(true);
+        stdin.resume();
+        const onData = (data) => {
+            const value = data.toString();
+            if (value === '\r' || value === '\n' || value === '\u0003') {
+                stdin.removeListener('data', onData);
+                stdin.setRawMode(Boolean(wasRaw));
+                stdin.pause();
+                if (value === '\u0003') {
+                    process.stdout.write('\n');
+                    process.exit(0);
+                }
+                resolve();
+            }
+        };
+        stdin.on('data', onData);
+    });
+}
+async function showVisionAlphaWelcome() {
+    const textLines = getWelcomeText();
+    const content = `\n${renderFrame(textLines, WELCOME_ART)}\n\n`;
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        process.stdout.write(content);
+        await waitForTerminalEnter();
+        return;
+    }
+    await enterScreenPrompt({ content });
+}
+function createInitPresenter(logger) {
+    function bullet() {
+        return supportsColor() ? colorize('•', 'cyan') : '-';
+    }
+    function vertical() {
+        return colorize('│', 'darkBlue');
+    }
+    return {
+        section(title) {
+            logger.plain('');
+            logger.plain(colorize(title, 'white'));
+            logger.plain(colorize('─'.repeat(title.length), 'darkBlue'));
+        },
+        list(items) {
+            for (const item of items) {
+                logger.plain(`${bullet()} ${item}`);
+            }
+        },
+        step(status, statusLabel, label) {
+            const renderedStatus = colorize(statusLabel, status === 'failed' ? 'cyan' : 'white');
+            logger.plain(`${bullet()} [${renderedStatus}] ${label}`);
+        },
+        openBox(title) {
+            logger.plain(colorize(`╭─ ${title}`, 'darkBlue'));
+            return {
+                write(message) {
+                    for (const line of splitDisplayLines(message)) {
+                        logger.plain(`${vertical()} ${line}`);
+                    }
+                },
+                close() {
+                    logger.plain(colorize('╰─', 'darkBlue'));
+                },
+            };
+        },
+        emptyLine() {
+            logger.plain('');
+        },
+        emphasize(value) {
+            return colorize(value, 'cyan');
+        },
+    };
+}

package/dist/features/init/prompt.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatPromptKeysHelpTip = formatPromptKeysHelpTip;
+exports.createTerminalPrompt = createTerminalPrompt;
+const prompts_1 = require("@inquirer/prompts");
+const ZH_PROMPT_ACTIONS = {
+    navigate: '导航',
+    select: '选择',
+    all: '全选',
+    invert: '反选',
+    submit: '提交',
+};
+const ZH_PROMPT_KEYS = {
+    space: '空格',
+};
+function formatPromptKeysHelpTip(locale, keys) {
+    if (locale !== 'zh-CN') {
+        return undefined;
+    }
+    return keys
+        .map(([key, action]) => {
+        const localizedKey = ZH_PROMPT_KEYS[key] ?? key;
+        return `${localizedKey} ${ZH_PROMPT_ACTIONS[action] ?? action}`;
+    })
+        .join(' • ');
+}
+function createTerminalPrompt() {
+    let activePrompt = null;
+    let activeController = null;
+    function createPromptController() {
+        const controller = new AbortController();
+        activeController = controller;
+        return controller;
+    }
+    function trackPrompt(prompt) {
+        activePrompt = prompt;
+        return prompt.finally(() => {
+            if (activePrompt === prompt) {
+                activePrompt = null;
+            }
+        });
+    }
+    return {
+        async select({ message, choices, defaultValue, locale }) {
+            const controller = createPromptController();
+            const prompt = (0, prompts_1.select)({
+                message,
+                choices: choices.map((choice) => ({
+                    value: choice.value,
+                    name: choice.label,
+                    description: choice.description,
+                })),
+                default: defaultValue,
+                theme: locale === 'zh-CN'
+                    ? {
+                        style: {
+                            keysHelpTip(keys) {
+                                return formatPromptKeysHelpTip(locale, keys);
+                            },
+                        },
+                    }
+                    : undefined,
+            }, {
+                signal: controller.signal,
+            });
+            try {
+                return await trackPrompt(prompt);
+            }
+            finally {
+                if (activeController === controller) {
+                    activeController = null;
+                }
+            }
+        },
+        async multiselect({ message, choices, locale }) {
+            const controller = createPromptController();
+            const prompt = (0, prompts_1.checkbox)({
+                message,
+                choices: choices.map((choice) => ({
+                    value: choice.value,
+                    name: choice.label,
+                    description: choice.description,
+                    checked: choice.checked,
+                })),
+                pageSize: 8,
+                theme: locale === 'zh-CN'
+                    ? {
+                        style: {
+                            keysHelpTip(keys) {
+                                return formatPromptKeysHelpTip(locale, keys);
+                            },
+                        },
+                    }
+                    : undefined,
+            }, {
+                signal: controller.signal,
+            });
+            try {
+                return await trackPrompt(prompt);
+            }
+            finally {
+                if (activeController === controller) {
+                    activeController = null;
+                }
+            }
+        },
+        async confirm(message, defaultValue = false) {
+            const controller = createPromptController();
+            const prompt = (0, prompts_1.confirm)({
+                message,
+                default: defaultValue,
+            }, {
+                signal: controller.signal,
+            });
+            try {
+                return await trackPrompt(prompt);
+            }
+            finally {
+                if (activeController === controller) {
+                    activeController = null;
+                }
+            }
+        },
+        async close() {
+            activeController?.abort();
+            activeController = null;
+            activePrompt?.cancel();
+            activePrompt = null;
+            if (process.stdin.isTTY && process.stdin.isRaw) {
+                process.stdin.setRawMode(false);
+            }
+            process.stdin.pause();
+        },
+    };
+}

package/dist/features/init/target-registry.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAgentTargetRegistry = getAgentTargetRegistry;
+exports.getAgentTarget = getAgentTarget;
+const node_path_1 = require("node:path");
+const TARGET_REGISTRY = [
+    {
+        id: 'codex',
+        displayName: 'Codex',
+        supportedScopes: ['project', 'user'],
+        resolveRoot({ cwd, homeDir, scope }) {
+            return scope === 'project'
+                ? (0, node_path_1.join)(cwd, '.codex', 'skills')
+                : (0, node_path_1.join)(homeDir, '.codex', 'skills');
+        },
+    },
+    {
+        id: 'claude',
+        displayName: 'Claude Code',
+        supportedScopes: ['project', 'user'],
+        resolveRoot({ cwd, homeDir, scope }) {
+            return scope === 'project'
+                ? (0, node_path_1.join)(cwd, '.claude', 'skills')
+                : (0, node_path_1.join)(homeDir, '.claude', 'skills');
+        },
+    },
+    {
+        id: 'openclaw',
+        displayName: 'OpenClaw',
+        supportedScopes: ['project', 'user'],
+        resolveRoot({ cwd, homeDir, scope }) {
+            return scope === 'project' ? (0, node_path_1.join)(cwd, 'skills') : (0, node_path_1.join)(homeDir, '.openclaw', 'skills');
+        },
+    },
+];
+function getAgentTargetRegistry() {
+    return TARGET_REGISTRY;
+}
+function getAgentTarget(targetId) {
+    const target = TARGET_REGISTRY.find((entry) => entry.id === targetId);
+    if (!target) {
+        throw new Error(`Unsupported agent target "${targetId}".`);
+    }
+    return target;
+}

package/dist/features/init/templates.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MANAGED_MARKER = void 0;
+exports.resolveSkillSourceRoot = resolveSkillSourceRoot;
+exports.createAgentPackFiles = createAgentPackFiles;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+exports.MANAGED_MARKER = 'VAONE-MANAGED FILE';
+const SKILL_NAME = 'visionalpha-operator';
+async function pathExists(path) {
+    try {
+        await (0, promises_1.access)((0, node_path_1.join)(path, 'SKILL.md'));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function resolveSkillSourceRoot(input) {
+    const cwd = input?.cwd ?? process.cwd();
+    const execPath = input?.execPath ?? process.execPath;
+    const moduleDir = input?.moduleDir ?? __dirname;
+    const env = input?.env ?? process.env;
+    const candidates = [
+        env.VAONE_SKILL_SOURCE_DIR,
+        (0, node_path_1.join)(moduleDir, '..', '..', '..', 'skills', SKILL_NAME),
+        (0, node_path_1.join)(cwd, 'skills', SKILL_NAME),
+        (0, node_path_1.join)(cwd, 'va-cli', 'skills', SKILL_NAME),
+        (0, node_path_1.join)((0, node_path_1.dirname)(execPath), 'skills', SKILL_NAME),
+        (0, node_path_1.join)((0, node_path_1.dirname)(execPath), '..', 'skills', SKILL_NAME),
+        (0, node_path_1.join)((0, node_path_1.dirname)(execPath), '..', 'va-cli', 'skills', SKILL_NAME),
+    ]
+        .filter((candidate) => Boolean(candidate))
+        .map((candidate) => (0, node_path_1.resolve)(candidate));
+    const deduped = [...new Set(candidates)];
+    for (const candidate of deduped) {
+        if (await pathExists(candidate)) {
+            return candidate;
+        }
+    }
+    throw new Error(`Unable to locate the managed skill source for "${SKILL_NAME}". Checked: ${deduped.join(', ')}. Set VAONE_SKILL_SOURCE_DIR to override the lookup path.`);
+}
+function buildManagedHeader(target, relativePath) {
+    if (relativePath.endsWith('.yaml') || relativePath.endsWith('.yml')) {
+        return `# ${exports.MANAGED_MARKER}; target=${target.id}; path=${relativePath}`;
+    }
+    return `<!-- ${exports.MANAGED_MARKER}; target=${target.id}; path=${relativePath} -->`;
+}
+function injectManagedHeader(target, relativePath, contents) {
+    const header = buildManagedHeader(target, relativePath);
+    if (!relativePath.endsWith('SKILL.md') || !contents.startsWith('---\n')) {
+        return `${header}\n${contents}`;
+    }
+    const closingIndex = contents.indexOf('\n---\n', 4);
+    if (closingIndex === -1) {
+        return `${header}\n${contents}`;
+    }
+    const insertAt = closingIndex + '\n---\n'.length;
+    return `${contents.slice(0, insertAt)}${header}\n\n${contents.slice(insertAt)}`;
+}
+async function listRelativeFiles(rootDir, currentDir = rootDir) {
+    const entries = await (0, promises_1.readdir)(currentDir, { withFileTypes: true });
+    const files = await Promise.all(entries.map(async (entry) => {
+        const absolutePath = (0, node_path_1.join)(currentDir, entry.name);
+        if (entry.isDirectory()) {
+            return listRelativeFiles(rootDir, absolutePath);
+        }
+        return [absolutePath.slice(rootDir.length + 1)];
+    }));
+    return files.flat().sort();
+}
+async function createAgentPackFiles(target, scope) {
+    void scope;
+    const skillSourceRoot = await resolveSkillSourceRoot();
+    const relativeFiles = await listRelativeFiles(skillSourceRoot);
+    return Promise.all(relativeFiles.map(async (relativePath) => {
+        const contents = await (0, promises_1.readFile)((0, node_path_1.join)(skillSourceRoot, relativePath), 'utf8');
+        return {
+            relativePath: (0, node_path_1.join)(SKILL_NAME, relativePath),
+            description: `${target.displayName} VisionAlpha operator skill asset`,
+            contents: injectManagedHeader(target, (0, node_path_1.join)(SKILL_NAME, relativePath), contents),
+        };
+    }));
+}

package/dist/features/init/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/features/intelligence/intelligence-api-client.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryAssetIntelligence = queryAssetIntelligence;
+const authenticated_api_client_1 = require("../auth/authenticated-api-client");
+function createQueryString(query) {
+    const searchParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(query)) {
+        if (value === undefined) {
+            continue;
+        }
+        searchParams.set(key, String(value));
+    }
+    const encoded = searchParams.toString();
+    return encoded ? `?${encoded}` : '';
+}
+async function queryAssetIntelligence(context, query) {
+    return (0, authenticated_api_client_1.requestAuthenticatedJson)(context, `/v1/asset-intelligence/query${createQueryString(query)}`);
+}

package/dist/features/intelligence/intelligence-output.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderIntelligencePage = renderIntelligencePage;
+const output_1 = require("../../shared/output");
+function formatAssetName(input) {
+    return input.assetNameZh || input.assetNameEn || input.assetId;
+}
+function renderIntelligencePage(logger, page) {
+    (0, output_1.printSection)(logger, 'Query summary');
+    (0, output_1.printKeyValue)(logger, 'Returned rows', String(page.returnedRows));
+    (0, output_1.printKeyValue)(logger, 'Effective limit', String(page.limit));
+    (0, output_1.printKeyValue)(logger, 'Continuation', page.nextCursor
+        ? 'Another page is available. Run `vaone intelligence query --next`.'
+        : 'No additional page is available.');
+    (0, output_1.printSection)(logger, 'Results');
+    if (!page.items.length) {
+        logger.info('No intelligence rows matched the current query.');
+        return;
+    }
+    page.items.forEach((item, index) => {
+        if (index > 0) {
+            logger.plain('');
+        }
+        (0, output_1.printKeyValue)(logger, 'Asset', `${formatAssetName(item)} (${item.assetId})`);
+        (0, output_1.printKeyValue)(logger, 'Publish date', item.publishDate);
+        (0, output_1.printKeyValue)(logger, 'Issuer', item.issuer ?? 'unknown');
+        (0, output_1.printKeyValue)(logger, 'Source', item.fileName ?? item.fileId);
+        if (item.relevanceScore !== undefined) {
+            (0, output_1.printKeyValue)(logger, 'Relevance', String(item.relevanceScore));
+        }
+        (0, output_1.printList)(logger, [item.narrative.text || 'No narrative text available.']);
+        if (item.narrative.keyThemes.length) {
+            (0, output_1.printKeyValue)(logger, 'Key themes', item.narrative.keyThemes.join(', '));
+        }
+    });
+}

package/dist/features/intelligence/intelligence-query-state.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntelligenceQueryStateStore = void 0;
+const file_json_store_1 = require("../../state/stores/file-json-store");
+class IntelligenceQueryStateStore {
+    store;
+    constructor(filePath) {
+        this.store = new file_json_store_1.FileJsonStore(filePath);
+    }
+    async read() {
+        return this.store.read();
+    }
+    async save(state) {
+        await this.store.write(state);
+    }
+    async clear() {
+        await this.store.clear();
+    }
+}
+exports.IntelligenceQueryStateStore = IntelligenceQueryStateStore;

package/dist/features/usage/usage-api-client.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUsageSummary = getUsageSummary;
+const authenticated_api_client_1 = require("../auth/authenticated-api-client");
+async function getUsageSummary(context) {
+    return (0, authenticated_api_client_1.requestAuthenticatedJson)(context, '/v1/usage/summary');
+}