gamealgo-cli 0.1.6 → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dirichlet AI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,72 +1,57 @@
-# GameAlgo Client
+# GameAlgo CLI
 
-GameAlgo Client 是公开客户端仓库，包含 iOS SDK、Android SDK、REST helper、TapTap Maker / Lua SDK、CLI 和协议定义。
+`gamealgo-cli` is the independently released command-line client for GameAlgo. It is intended for AI coding agents and game developers to manage integration plans, event dictionaries, reports, scripts, configuration, keys, and experiments.
 
-产品能力、接入流程、埋点、实验、报表与优化方法由 GameAlgo Server 在线文档统一维护，不在本仓库保留副本。
+Source repository: <https://github.com/sunyuhao-code/GameAlgoCli>
 
-## AI Agent 从这里开始
-
-不要把 README 原样转发给开发者。先安装最新 CLI，再从目标环境读取当前文档并完成接入。
-
-| 环境 | Admin host | SDK / REST API |
-| --- | --- | --- |
-| 国内 | `https://game-algo-admin.dictapis.cn` | `https://game-algo-sdk.dictapis.cn` |
-| 海外 | `https://dirichlet.ai/algo_admin` | `https://dirichlet.ai/algo_sdk` |
+## Install
 
 ```bash
 npm install -g gamealgo-cli@latest
-gamealgo --version
-gamealgo docs agent-onboarding --host <admin-host>
+gamealgo version
 ```
 
-开发者通常只需要提供游戏维度的 Game Admin Key，格式为 `ga_admin_*`。在游戏项目根目录登录后，AI Agent 应通过 CLI 创建或读取运行时使用的 `ga_live_*`，完成 SDK 接入、事件验证、Report Pack 和实验配置。
+## Login
+
+Run login from the game repository that should own the credentials:
 
 ```bash
-gamealgo login --host <admin-host> --admin-key <ga_admin_xxx>
-gamealgo key list --json
-gamealgo key create --name <runtime-name> --json
-gamealgo key reveal --name <runtime-name> --json
+gamealgo login --host <admin-url> --admin-key <ga_admin_key>
+gamealgo whoami
 ```
 
-凭据保存在当前游戏项目的 `.gamealgo/cli.json`，不同游戏互不覆盖。需要其他主题时使用：
+The login is stored in the current project's `.gamealgo/cli.json`, which is automatically ignored by Git. Authenticated commands require this project-scoped login and verify its `gameId` against the Server before continuing, preventing credentials from another game from being reused accidentally.
+
+## Current help and documentation
 
 ```bash
-gamealgo docs --host <admin-host>
-gamealgo docs integration-guide --host <admin-host>
-gamealgo docs ai-tracking-manual --host <admin-host>
-gamealgo docs report-packs --host <admin-host>
-gamealgo docs experiment-integration-versions --host <admin-host>
-gamealgo docs agent-cli --host <admin-host>
+gamealgo help
+gamealgo help report publish
+gamealgo docs
+gamealgo docs sdk-integration
+gamealgo listapi
+gamealgo docs api GameAlgo.Init --platform lua
 ```
 
-## SDK 入口
+Help and documentation are fetched from the configured Server on every invocation. The CLI intentionally does not keep a documentation cache.
 
-- [iOS SDK](./ios/README.md)
-- [Android SDK](./android/README.md)
-- [REST helper](./rest-api/README.md)
-- [TapTap Maker / Lua SDK](./lua/README.md)
-- [CLI](./cli/README.md)
-- [Protocol OpenAPI](./protocol/openapi.yaml)
+Adjust S2S event forwarding can be configured with an explicit event allowlist:
 
-海外 SDK 地址包含 `/algo_sdk` 路径前缀，必须完整保留。客户端只能配置 `ga_live_*`；`ga_admin_*` 只允许用于开发机器、AI Agent 或 CI。
+```bash
+gamealgo marketing adjust configure \
+  --app-token "$ADJUST_APP_TOKEN" \
+  --s2s-token "$ADJUST_S2S_TOKEN" \
+  --s2s-events adjust-s2s-events.yaml \
+  --json
+```
 
-## 仓库结构
+## Compatibility
 
-```text
-ios/        iOS Swift Package SDK
-android/    Android Java SDK core
-rest-api/   REST API helper 和示例
-lua/        TapTap Maker / Lua SDK
-cli/        GameAlgo CLI
-protocol/   客户端协议定义
-examples/   接入示例
-```
+Before login and every authenticated command, the CLI checks `/admin/v1/cli/meta`. An outdated CLI is rejected with the exact npm upgrade command. The CLI and Server are released independently; compatibility is defined by the Server's minimum supported CLI version and protocol version.
 
-## 本地验证
+## Development
 
 ```bash
-npm install
+npm ci
 npm run check
 ```
-
-平台 SDK README 只描述与当前代码版本绑定的安装方式、公开 API 和运行时约束。业务流程与平台规则以 `gamealgo docs` 返回的在线文档为准。

package/dist/args.js

@@ -0,0 +1,80 @@
+export function parseGlobalFlags(args) {
+    const global = {
+        json: false,
+        host: process.env.GAMEALGO_ADMIN_HOST || process.env.GAMEALGO_HOST || "",
+        adminKey: process.env.GAMEALGO_GAME_ADMIN_KEY || "",
+        adminToken: process.env.GAMEALGO_ADMIN_TOKEN || "",
+    };
+    for (let index = 0; index < args.length;) {
+        const arg = args[index];
+        if (arg === "--json") {
+            global.json = true;
+            args.splice(index, 1);
+            continue;
+        }
+        if (arg === "--host") {
+            global.host = requireFlagValue(args, index, "--host");
+            args.splice(index, 2);
+            continue;
+        }
+        if (arg === "--admin-key") {
+            global.adminKey = requireFlagValue(args, index, "--admin-key");
+            args.splice(index, 2);
+            continue;
+        }
+        if (arg === "--admin-token") {
+            global.adminToken = requireFlagValue(args, index, "--admin-token");
+            args.splice(index, 2);
+            continue;
+        }
+        index += 1;
+    }
+    return global;
+}
+export function parseFlags(args) {
+    const flags = {};
+    for (let index = 0; index < args.length;) {
+        const arg = args[index];
+        if (!arg.startsWith("--")) {
+            index += 1;
+            continue;
+        }
+        const key = arg.slice(2);
+        const next = args[index + 1];
+        if (!next || next.startsWith("--")) {
+            flags[key] = true;
+            args.splice(index, 1);
+        }
+        else {
+            flags[key] = next;
+            args.splice(index, 2);
+        }
+    }
+    return flags;
+}
+export function parseSelectorFlags(args) {
+    const selectors = {};
+    for (let index = 0; index < args.length;) {
+        if (args[index] !== "--selector") {
+            index += 1;
+            continue;
+        }
+        const value = requireFlagValue(args, index, "--selector");
+        const separator = value.indexOf("=");
+        if (separator <= 0)
+            throw new Error("--selector must use key=value");
+        const key = value.slice(0, separator).trim();
+        const selectorValue = value.slice(separator + 1).trim();
+        if (!/^[A-Za-z][A-Za-z0-9_]{0,63}$/.test(key))
+            throw new Error(`invalid selector id: ${key}`);
+        selectors[key] = selectorValue;
+        args.splice(index, 2);
+    }
+    return selectors;
+}
+export function requireFlagValue(args, index, flag) {
+    const value = args[index + 1];
+    if (!value || value.startsWith("--"))
+        throw new Error(`${flag} requires a value`);
+    return value;
+}

package/dist/client.js

@@ -0,0 +1,232 @@
+import { requestJson } from "./http.js";
+import { normalizeHost } from "./utils.js";
+export class GameAlgoAdminClient {
+    host;
+    adminKey;
+    sessionCache;
+    expectedGameId;
+    constructor(config, expectedGameId) {
+        this.host = normalizeHost(config.host);
+        this.adminKey = config.adminKey;
+        this.expectedGameId = expectedGameId;
+    }
+    async session() {
+        this.sessionCache ??= await this.get("/admin/v1/session");
+        return this.sessionCache;
+    }
+    async gameId() {
+        const session = await this.session();
+        const gameId = session.principal.gameId;
+        if (!gameId)
+            throw new Error("current credential is not scoped to a game");
+        if (this.expectedGameId && gameId !== this.expectedGameId) {
+            throw new Error(`project is bound to game ${this.expectedGameId}, but the current credential belongs to ${gameId}; run gamealgo login with the correct Game Admin Key`);
+        }
+        return gameId;
+    }
+    async assertProjectBinding() {
+        await this.gameId();
+    }
+    async listExperimentV2Strategies(includeArchived = false) {
+        const query = includeArchived ? "?includeArchived=1" : "";
+        return await this.get(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/strategies-v2${query}`);
+    }
+    async listExperimentIntegrationVersions(limit = 100) {
+        return await this.get(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/experiment-integration-versions?limit=${encodeURIComponent(String(limit))}`);
+    }
+    async getLatestExperimentIntegrationVersion() {
+        return await this.get(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/experiment-integration-versions/latest`);
+    }
+    async getExperimentIntegrationVersion(version) {
+        return await this.get(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/experiment-integration-versions/${version}`);
+    }
+    async createExperimentIntegrationVersion(title, message) {
+        return await this.post(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/experiment-integration-versions`, { title, message });
+    }
+    async updateExperimentIntegrationVersion(version, message) {
+        return await this.patch(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/experiment-integration-versions/${version}`, { message });
+    }
+    async getExperimentV2Strategy(strategyKey) {
+        return await this.get(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/strategies-v2/${encodeURIComponent(strategyKey)}`);
+    }
+    async upsertExperimentV2Strategy(body) {
+        return await this.post(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/strategies-v2`, body);
+    }
+    async updateExperimentV2StrategyDefault(strategyKey, body) {
+        return await this.put(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/strategies-v2/${encodeURIComponent(strategyKey)}/default`, body);
+    }
+    async archiveExperimentV2Strategy(strategyKey, archived) {
+        return await this.post(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/strategies-v2/${encodeURIComponent(strategyKey)}/archive`, { archived });
+    }
+    async rollbackExperimentV2Strategy(strategyKey, versionId, message) {
+        return await this.post(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/strategies-v2/${encodeURIComponent(strategyKey)}/rollback`, {
+            versionId,
+            message,
+        });
+    }
+    async createExperimentV2Run(strategyKey, body) {
+        return await this.post(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/strategies-v2/${encodeURIComponent(strategyKey)}/runs`, body);
+    }
+    async getExperimentV2Run(runId) {
+        return await this.get(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/experiment-runs-v2/${encodeURIComponent(runId)}`);
+    }
+    async evaluateExperimentV2Run(runId, query) {
+        const params = new URLSearchParams();
+        if (query.from)
+            params.set("from", query.from);
+        if (query.to)
+            params.set("to", query.to);
+        if (query.days)
+            params.set("days", query.days);
+        if (query.platform)
+            params.set("platform", query.platform);
+        const suffix = params.toString() ? `?${params.toString()}` : "";
+        return await this.post(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/experiment-runs-v2/${encodeURIComponent(runId)}/evaluate${suffix}`, {});
+    }
+    async promoteExperimentV2Run(runId, variantId, message) {
+        return await this.post(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/experiment-runs-v2/${encodeURIComponent(runId)}/promote`, {
+            variantId,
+            message,
+        });
+    }
+    async cancelExperimentV2Run(runId, message) {
+        return await this.post(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/experiment-runs-v2/${encodeURIComponent(runId)}/cancel`, { message });
+    }
+    async updateExperimentV2RunObjective(runId, objectiveTemplate, message) {
+        return await this.patch(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/experiment-runs-v2/${encodeURIComponent(runId)}/objective`, {
+            objectiveTemplate,
+            message,
+        });
+    }
+    async listExperimentV2Overrides(runId) {
+        return await this.get(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/experiment-runs-v2/${encodeURIComponent(runId)}/overrides`);
+    }
+    async upsertExperimentV2Override(runId, userId, variantId) {
+        return await this.post(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/experiment-runs-v2/${encodeURIComponent(runId)}/overrides`, { userId, variantId });
+    }
+    async deleteExperimentV2Override(runId, userId) {
+        return await this.post(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/experiment-runs-v2/${encodeURIComponent(runId)}/overrides/delete`, { userId });
+    }
+    async listConfigFiles() {
+        return await this.get(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/config-files`);
+    }
+    async getConfigFile(name) {
+        return await this.get(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/config-files/${encodeURIComponent(name)}`);
+    }
+    async putConfigFile(name, content, contentType) {
+        return await this.put(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/config-files/${encodeURIComponent(name)}`, { content, contentType });
+    }
+    async listScriptVersions(name, limit = 50) {
+        const params = new URLSearchParams();
+        if (name)
+            params.set("name", name);
+        params.set("limit", String(limit));
+        return await this.get(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/script-versions?${params.toString()}`);
+    }
+    async createScriptVersion(name, content, contentType, message) {
+        return await this.post(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/scripts/${encodeURIComponent(name)}/versions`, {
+            content,
+            contentType,
+            ...(message ? { message } : {}),
+        });
+    }
+    async getScriptVersion(name, versionId) {
+        return await this.get(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/scripts/${encodeURIComponent(name)}/versions/${encodeURIComponent(versionId)}`);
+    }
+    async getReportPack() {
+        return await this.get(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/report-pack`);
+    }
+    async previewReportPack(content) {
+        return await this.post(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/report-pack/preview`, { content });
+    }
+    async putReportPack(content) {
+        return await this.put(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/report-pack`, { content });
+    }
+    async reportManifest() {
+        return await this.get(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/reports/manifest`);
+    }
+    async queryReportDashboard(body, options = {}) {
+        return await this.post(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/reports/query`, body, options);
+    }
+    async previewReportDashboard(body, options = {}) {
+        return await this.post(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/reports/preview`, body, options);
+    }
+    async getGamePreferences() {
+        return await this.get(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/preferences`);
+    }
+    async countEventPlatforms(startDate, endDate) {
+        return await this.post(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/events/platform-counts`, { startDate, endDate });
+    }
+    async countEvents(body, options = {}) {
+        return await this.post(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/events/count`, body, options);
+    }
+    async listEventCatalog(days = 30, diagnostics = true) {
+        const params = new URLSearchParams({ days: String(days), diagnostics: diagnostics ? "1" : "0" });
+        return await this.get(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/events/catalog?${params.toString()}`);
+    }
+    async getEventCatalog(eventType) {
+        return await this.get(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/events/catalog/${encodeURIComponent(eventType)}`);
+    }
+    async applyEventCatalog(content) {
+        return await this.put(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/events/catalog`, content);
+    }
+    async deprecateEventCatalog(eventType) {
+        return await this.post(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/events/catalog/${encodeURIComponent(eventType)}/deprecate`, {});
+    }
+    async getIntegrationPlan(environment, platform) {
+        const params = new URLSearchParams({ environment, platform });
+        return await this.get(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/integration/plan?${params.toString()}`);
+    }
+    async getAdjustMarketing() {
+        return await this.get(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/marketing/adjust`);
+    }
+    async putAdjustMarketing(body) {
+        return await this.put(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/marketing/adjust`, body);
+    }
+    async syncAdjustMarketing(body, options = {}) {
+        return await this.post(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/marketing/adjust/sync`, body, options);
+    }
+    async listGameKeys() {
+        return await this.get(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/keys`);
+    }
+    async createGameKey(name) {
+        return await this.post(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/keys`, { name });
+    }
+    async revealGameKey(selector) {
+        return await this.post(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/keys/reveal`, selector);
+    }
+    async revokeGameKey(id) {
+        return await this.post(`/admin/v1/games/${encodeURIComponent(await this.gameId())}/keys/${encodeURIComponent(id)}/revoke`, {});
+    }
+    async get(path) {
+        return await requestJson(this.host, path, { headers: this.headers() });
+    }
+    async post(path, body, options = {}) {
+        return await requestJson(this.host, path, {
+            method: "POST",
+            headers: this.headers({ "Content-Type": "application/json" }),
+            body: JSON.stringify(body),
+            timeoutMs: options.timeoutMs,
+        });
+    }
+    async put(path, body) {
+        return await requestJson(this.host, path, {
+            method: "PUT",
+            headers: this.headers({ "Content-Type": "application/json" }),
+            body: JSON.stringify(body),
+        });
+    }
+    async patch(path, body) {
+        return await requestJson(this.host, path, {
+            method: "PATCH",
+            headers: this.headers({ "Content-Type": "application/json" }),
+            body: JSON.stringify(body),
+        });
+    }
+    headers(extra = {}) {
+        return {
+            "X-GameAlgo-Game-Admin-Key": this.adminKey,
+            ...extra,
+        };
+    }
+}

package/dist/commands/auth.js

@@ -0,0 +1,75 @@
+import { parseFlags } from "../args.js";
+import { GameAlgoAdminClient } from "../client.js";
+import { assertServerCompatibility } from "../compatibility.js";
+import { loadProjectConfig, saveConfig } from "../config.js";
+import { requestJson } from "../http.js";
+import { printResult } from "../output.js";
+import { normalizeHost } from "../utils.js";
+export async function login(args, global) {
+    const flags = parseFlags(args);
+    const host = normalizeHost(String(flags.host || global.host || ""));
+    const adminKey = String(flags["admin-key"] || global.adminKey || "");
+    if (!host)
+        throw new Error("--host is required");
+    if (!adminKey)
+        throw new Error("--admin-key is required");
+    await assertServerCompatibility(host);
+    const client = new GameAlgoAdminClient({ host, adminKey });
+    const session = await client.session();
+    if (session.principal.type !== "game_admin" || !session.principal.gameId) {
+        throw new Error("admin key is not scoped to a game");
+    }
+    const configPath = await saveConfig({ host, adminKey, gameId: session.principal.gameId });
+    await printResult({
+        ok: true,
+        host,
+        gameId: session.principal.gameId,
+        keyName: session.principal.keyName,
+        configPath,
+    }, global);
+}
+export async function createClient(global) {
+    const saved = await loadProjectConfig();
+    if (!saved) {
+        throw new Error("this project is not logged in; run `gamealgo login --host <url> --admin-key <key>` in the project directory");
+    }
+    if (!saved.gameId) {
+        throw new Error("this project's CLI login is not bound to a game; re-run `gamealgo login --host <url> --admin-key <key>` in the project directory");
+    }
+    const host = normalizeHost(global.host || saved?.host || "");
+    const adminKey = global.adminKey || saved?.adminKey || "";
+    if (!host || !adminKey) {
+        throw new Error("run `gamealgo login --host <url> --admin-key <key>` first");
+    }
+    await assertServerCompatibility(host);
+    const client = new GameAlgoAdminClient({ host, adminKey }, saved.gameId);
+    await client.assertProjectBinding();
+    return client;
+}
+export async function handleAdminKey(args, global) {
+    const sub = args.shift();
+    if (sub !== "create")
+        throw new Error("usage: gamealgo admin-key create --host <url> --admin-token <token> --game <gameId> --name <name>");
+    const flags = parseFlags(args);
+    const host = normalizeHost(String(flags.host || global.host || ""));
+    const adminToken = String(flags["admin-token"] || global.adminToken || "");
+    const gameId = String(flags.game || "");
+    const name = String(flags.name || "");
+    if (!host)
+        throw new Error("--host is required");
+    if (!adminToken)
+        throw new Error("--admin-token is required");
+    if (!gameId)
+        throw new Error("--game is required");
+    if (!name)
+        throw new Error("--name is required");
+    const response = await requestJson(host, `/admin/v1/games/${encodeURIComponent(gameId)}/admin-keys`, {
+        method: "POST",
+        headers: {
+            "X-GameAlgo-Admin-Token": adminToken,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ name }),
+    });
+    await printResult(response, global);
+}

package/dist/commands/events.js

@@ -0,0 +1,79 @@
+import YAML from "yaml";
+import { parseFlags } from "../args.js";
+import { confirm, formatDuration, printResult, reportTimeoutMs, startProgress, withCliMeta } from "../output.js";
+import { readObjectFile, writeTextFile } from "../resources.js";
+import { announceTargetGame } from "../target.js";
+import { optionalString } from "../utils.js";
+export async function handleEvents(client, args, global) {
+    const sub = args.shift();
+    const flags = parseFlags(args);
+    if (sub === "list") {
+        if (args.length)
+            throw new Error("usage: gamealgo events list [--days 30] [--no-diagnostics]");
+        const days = Number(flags.days || 30);
+        if (!Number.isInteger(days) || days < 1 || days > 90)
+            throw new Error("--days must be an integer between 1 and 90");
+        await writeEventCatalogOutput(await client.listEventCatalog(days, flags["no-diagnostics"] !== true), flags, global);
+        return;
+    }
+    if (sub === "get") {
+        const eventType = args.shift();
+        if (!eventType || args.length)
+            throw new Error("usage: gamealgo events get <eventType>");
+        await writeEventCatalogOutput(await client.getEventCatalog(eventType), flags, global);
+        return;
+    }
+    if (sub === "apply") {
+        const filePath = args.shift();
+        if (!filePath || args.length)
+            throw new Error("usage: gamealgo events apply <events.yaml>");
+        const content = await readObjectFile(filePath, "event catalog");
+        await announceTargetGame(client);
+        await writeEventCatalogOutput(await client.applyEventCatalog(content), flags, global);
+        return;
+    }
+    if (sub === "deprecate") {
+        const eventType = args.shift();
+        if (!eventType || args.length)
+            throw new Error("usage: gamealgo events deprecate <eventType> [--yes]");
+        if (!flags.yes && !(await confirm(`Deprecate event ${eventType}?`)))
+            throw new Error("Cancelled");
+        await writeEventCatalogOutput(await client.deprecateEventCatalog(eventType), flags, global);
+        return;
+    }
+    if (sub !== "count")
+        throw new Error("usage: gamealgo events <list|get|apply|deprecate|count>");
+    const timeoutMs = reportTimeoutMs(flags);
+    const startedAt = Date.now();
+    const stopProgress = startProgress("Querying event counts", timeoutMs);
+    let response;
+    try {
+        response = await client.countEvents({
+            startDate: optionalString(flags.from || flags.start || flags.startDate),
+            endDate: optionalString(flags.to || flags.end || flags.endDate),
+            eventType: optionalString(flags["event-type"] || flags.eventType),
+        }, { timeoutMs });
+    }
+    finally {
+        stopProgress();
+    }
+    const elapsedMs = Date.now() - startedAt;
+    const outputValue = withCliMeta(response, { elapsedMs, timeoutMs });
+    process.stderr.write(`Event count query finished in ${formatDuration(elapsedMs)}.\n`);
+    if (flags.out) {
+        await writeTextFile(String(flags.out), JSON.stringify(outputValue, null, 2) + "\n");
+        await printResult({ ok: true, out: String(flags.out), elapsedMs }, global);
+        return;
+    }
+    await printResult(outputValue, global);
+}
+export async function writeEventCatalogOutput(value, flags, global) {
+    if (flags.out) {
+        const filePath = String(flags.out);
+        const content = filePath.endsWith(".json") ? JSON.stringify(value, null, 2) + "\n" : YAML.stringify(value);
+        await writeTextFile(filePath, content);
+        await printResult({ ok: true, out: filePath }, global);
+        return;
+    }
+    await printResult(value, global);
+}