gamealgo-cli 0.1.7 → 0.2.0

package/dist/commands/experiment.js

@@ -0,0 +1,373 @@
+import YAML from "yaml";
+import { parseFlags } from "../args.js";
+import { confirm, isInteractive, optionalNonNegativeInteger, positiveInteger, printResult } from "../output.js";
+import { objectValue, printExperimentRunVariantScripts, readObjectFile, validateExperimentRunVariantScripts, writeTextFile } from "../resources.js";
+import { optionalString } from "../utils.js";
+export async function handleExperiment(client, args, global) {
+    const sub = args.shift();
+    if (sub === "strategies" || sub === "list") {
+        const flags = parseFlags(args);
+        await printResult(await client.listExperimentV2Strategies(Boolean(flags["include-archived"] || flags.archived)), global);
+        return;
+    }
+    if (sub === "strategy") {
+        await handleExperimentStrategy(client, args, global);
+        return;
+    }
+    if (sub === "run") {
+        await handleExperimentRun(client, args, global);
+        return;
+    }
+    if (sub === "override") {
+        await handleExperimentOverride(client, args, global);
+        return;
+    }
+    if (sub === "integration-version") {
+        await handleExperimentIntegrationVersion(client, args, global);
+        return;
+    }
+    throw new Error("usage: gamealgo experiment <strategies|strategy|run|override|integration-version>");
+}
+export async function handleExperimentIntegrationVersion(client, args, global) {
+    const sub = args.shift();
+    const flags = parseFlags(args);
+    if (sub === "latest") {
+        await printResult(await client.getLatestExperimentIntegrationVersion(), global);
+        return;
+    }
+    if (sub === "list") {
+        const limit = optionalNonNegativeInteger(flags.limit, "--limit") ?? 100;
+        await printResult(await client.listExperimentIntegrationVersions(limit), global);
+        return;
+    }
+    if (sub === "get" || sub === "show") {
+        const version = positiveInteger(flags.version || args.shift(), "version");
+        await printResult(await client.getExperimentIntegrationVersion(version), global);
+        return;
+    }
+    if (sub === "create") {
+        const title = optionalString(flags.title);
+        const message = optionalString(flags.message);
+        if (!title || !message) {
+            throw new Error("usage: gamealgo experiment integration-version create --title <title> --message <message>");
+        }
+        await printResult(await client.createExperimentIntegrationVersion(title, message), global);
+        return;
+    }
+    if (sub === "update") {
+        const version = positiveInteger(flags.version || args.shift(), "version");
+        const message = optionalString(flags.message);
+        if (!message) {
+            throw new Error("usage: gamealgo experiment integration-version update --version <version> --message <message>");
+        }
+        await printResult(await client.updateExperimentIntegrationVersion(version, message), global);
+        return;
+    }
+    throw new Error("usage: gamealgo experiment integration-version <latest|list|get|create|update>");
+}
+export async function handleExperimentStrategy(client, args, global) {
+    const sub = args.shift();
+    if (sub === "show" || sub === "get") {
+        const flags = parseFlags(args);
+        const strategyKey = optionalString(flags.strategy || flags.key) || optionalString(args.shift());
+        if (!strategyKey)
+            throw new Error("usage: gamealgo experiment strategy show <strategyKey>");
+        const response = await client.getExperimentV2Strategy(strategyKey);
+        if (flags.out) {
+            await writeTextFile(String(flags.out), YAML.stringify(response));
+            await printResult({ ok: true, out: String(flags.out), strategyKey }, global);
+            return;
+        }
+        await printResult(response, global);
+        return;
+    }
+    if (sub === "publish" || sub === "upsert") {
+        const flags = parseFlags(args);
+        const filePath = optionalString(flags.file || flags.input) || optionalString(args.shift());
+        if (!filePath)
+            throw new Error("usage: gamealgo experiment strategy publish <strategy.yaml> --yes");
+        await requireYes(flags, global, "experiment strategy publish");
+        const body = await readObjectFile(filePath, "experiment strategy");
+        if (!optionalString(body.displayName)) {
+            throw new Error("experiment strategy requires displayName");
+        }
+        if (!optionalString(body.strategyKey || body.key)) {
+            throw new Error("experiment strategy requires strategyKey");
+        }
+        const requiredIntegrationVersion = optionalNonNegativeInteger(body.requiredIntegrationVersion, "requiredIntegrationVersion");
+        if (requiredIntegrationVersion === undefined) {
+            throw new Error("experiment strategy requires explicit requiredIntegrationVersion; use 0 when no client integration version is required");
+        }
+        const response = await client.upsertExperimentV2Strategy(body);
+        await printResult(response, global);
+        return;
+    }
+    if (sub === "default") {
+        const flags = parseFlags(args);
+        const strategyKey = optionalString(flags.strategy || flags.key) || optionalString(args.shift());
+        const filePath = optionalString(flags.file || flags.input) || optionalString(args.shift());
+        if (!strategyKey || !filePath)
+            throw new Error("usage: gamealgo experiment strategy default <strategyKey> <strategy.yaml> --yes");
+        await requireYes(flags, global, "experiment strategy default");
+        const response = await client.updateExperimentV2StrategyDefault(strategyKey, await readObjectFile(filePath, "experiment strategy default"));
+        await printResult(response, global);
+        return;
+    }
+    if (sub === "archive" || sub === "restore") {
+        const flags = parseFlags(args);
+        const strategyKey = optionalString(flags.strategy || flags.key) || optionalString(args.shift());
+        if (!strategyKey)
+            throw new Error(`usage: gamealgo experiment strategy ${sub} <strategyKey> --yes`);
+        await requireYes(flags, global, `experiment strategy ${sub}`);
+        await printResult(await client.archiveExperimentV2Strategy(strategyKey, sub === "archive"), global);
+        return;
+    }
+    if (sub === "rollback") {
+        const flags = parseFlags(args);
+        const strategyKey = optionalString(flags.strategy || flags.key) || optionalString(args.shift());
+        const versionId = optionalString(flags.version || flags["version-id"]);
+        const message = requiredMessage(flags, "experiment strategy rollback");
+        if (!strategyKey || !versionId) {
+            throw new Error("usage: gamealgo experiment strategy rollback <strategyKey> --version-id <versionId> --message <reason> --yes");
+        }
+        await requireYes(flags, global, "experiment strategy rollback");
+        await printResult(await client.rollbackExperimentV2Strategy(strategyKey, versionId, message), global);
+        return;
+    }
+    throw new Error("usage: gamealgo experiment strategy <show|publish|default|archive|restore|rollback>");
+}
+export async function handleExperimentRun(client, args, global) {
+    const sub = args.shift();
+    if (sub === "create") {
+        const flags = parseFlags(args);
+        const strategyKey = optionalString(flags.strategy || flags.key) || optionalString(args.shift());
+        const filePath = optionalString(flags.file || flags.input) || optionalString(args.shift());
+        if (!strategyKey || !filePath)
+            throw new Error("usage: gamealgo experiment run create <strategyKey> <run.yaml> [--manual] --yes");
+        await requireYes(flags, global, "experiment run create");
+        const body = await readObjectFile(filePath, "experiment run");
+        if (!optionalString(body.displayName))
+            throw new Error("experiment run requires displayName");
+        const objectiveTemplate = optionalString(body.objectiveTemplate);
+        if (!objectiveTemplate || !["ltv_proxy@1", "active_days@1"].includes(objectiveTemplate)) {
+            throw new Error("experiment run requires objectiveTemplate: ltv_proxy@1 or active_days@1");
+        }
+        if (!optionalString(body.baselineVariantId)) {
+            throw new Error("experiment run requires explicit baselineVariantId");
+        }
+        validateExperimentRunVariantScripts(body.variants);
+        const fileRunType = optionalString(body.type);
+        const flagRunType = optionalString(flags.type);
+        const manualFlag = flags.manual === true;
+        if (fileRunType && fileRunType !== "managed" && fileRunType !== "manual") {
+            throw new Error("experiment run type must be managed or manual");
+        }
+        if (flagRunType && flagRunType !== "managed" && flagRunType !== "manual") {
+            throw new Error("--type must be managed or manual");
+        }
+        if (manualFlag && flagRunType && flagRunType !== "manual") {
+            throw new Error("--manual conflicts with --type managed");
+        }
+        const requestedRunType = manualFlag ? "manual" : flagRunType;
+        if (requestedRunType && fileRunType && requestedRunType !== fileRunType) {
+            throw new Error(`experiment run type conflict: file uses ${fileRunType}, CLI requests ${requestedRunType}`);
+        }
+        const runType = requestedRunType || fileRunType || "managed";
+        body.type = runType;
+        if (runType !== "managed" && body.startCondition !== undefined) {
+            throw new Error("experiment run startCondition is supported only when type is managed");
+        }
+        if (runType === "managed") {
+            const minWindowDays = Number(body.minWindowDays);
+            const maxWindowDays = Number(body.maxWindowDays);
+            if (!Number.isInteger(minWindowDays) || minWindowDays < 1 || minWindowDays > 30) {
+                throw new Error("managed experiment run requires minWindowDays between 1 and 30");
+            }
+            if (!Number.isInteger(maxWindowDays) || maxWindowDays < minWindowDays || maxWindowDays > 60) {
+                throw new Error("managed experiment run requires maxWindowDays between minWindowDays and 60");
+            }
+        }
+        else {
+            process.stderr.write("Warning: creating a manual experiment. The platform will not automatically extend, conclude, or promote it; use manual mode only when the developer will manage the experiment decision.\n");
+        }
+        const result = await client.createExperimentV2Run(strategyKey, body);
+        await printResult(result, global);
+        if (!global.json)
+            printExperimentRunVariantScripts(result);
+        return;
+    }
+    if (sub === "show" || sub === "get") {
+        const flags = parseFlags(args);
+        const runId = optionalString(flags.run || flags["run-id"] || flags.id) || optionalString(args.shift());
+        if (!runId)
+            throw new Error("usage: gamealgo experiment run show <runId>");
+        const response = await client.getExperimentV2Run(runId);
+        if (flags.out) {
+            await writeTextFile(String(flags.out), YAML.stringify(response));
+            await printResult({ ok: true, out: String(flags.out), runId }, global);
+            return;
+        }
+        await printResult(response, global);
+        return;
+    }
+    if (sub === "status") {
+        const flags = parseFlags(args);
+        const runId = optionalString(flags.run || flags["run-id"] || flags.id) || optionalString(args.shift());
+        if (!runId)
+            throw new Error("usage: gamealgo experiment run status <runId>");
+        const response = await client.getExperimentV2Run(runId);
+        const run = response.run;
+        if (!run)
+            throw new Error(`experiment run not found: ${runId}`);
+        await printResult({
+            run: {
+                id: run.id,
+                strategyKey: run.strategyKey,
+                displayName: run.displayName,
+                type: run.type,
+                status: run.status,
+                objective: run.objective,
+                baselineVariantId: run.baselineVariantId,
+                requiredIntegrationVersion: run.requiredIntegrationVersion,
+                startedAt: run.startedAt,
+                endedAt: run.endedAt,
+                promotedVariantId: run.promotedVariantId,
+                currentAssessment: run.currentAssessment ?? null,
+            },
+        }, global);
+        return;
+    }
+    if (sub === "evaluate") {
+        const flags = parseFlags(args);
+        const runId = optionalString(flags.run || flags["run-id"] || flags.id) || optionalString(args.shift());
+        if (!runId)
+            throw new Error("usage: gamealgo experiment run evaluate <runId> --from YYYY-MM-DD --to YYYY-MM-DD --yes");
+        await requireYes(flags, global, "experiment run evaluate");
+        await printResult(await client.evaluateExperimentV2Run(runId, {
+            from: optionalString(flags.from || flags.start || flags.startDate),
+            to: optionalString(flags.to || flags.end || flags.endDate),
+            days: optionalString(flags.days),
+        }), global);
+        return;
+    }
+    if (sub === "report") {
+        const flags = parseFlags(args);
+        const runId = optionalString(flags.run || flags["run-id"] || flags.id) || optionalString(args.shift());
+        if (!runId)
+            throw new Error("usage: gamealgo experiment run report <runId> [--round <number> | --report-id <id>]");
+        const response = await client.getExperimentV2Run(runId);
+        const reports = Array.isArray(response.run?.reports) ? response.run.reports : [];
+        const reportId = optionalString(flags.report || flags["report-id"] || flags.id);
+        const round = flags.round === undefined ? undefined : positiveInteger(flags.round, "round");
+        const latestReport = objectValue(reports[reports.length - 1]);
+        const report = reports
+            .map((item) => objectValue(item))
+            .find((item) => {
+            if (!item)
+                return false;
+            if (reportId)
+                return item.id === reportId || item.evaluationId === reportId;
+            if (round !== undefined) {
+                const managed = objectValue(objectValue(item.report)?.managed);
+                return Number(managed?.roundNumber ?? Number(managed?.roundIndex) + 1) === round;
+            }
+            return item === latestReport;
+        });
+        if (!report) {
+            const selector = reportId ? `: ${reportId}` : round !== undefined ? ` for round ${round}` : "";
+            throw new Error(`experiment run report not found${selector}`);
+        }
+        await printResult({ runId, report }, global);
+        return;
+    }
+    if (sub === "objective") {
+        const flags = parseFlags(args);
+        const runId = optionalString(flags.run || flags["run-id"] || flags.id) || optionalString(args.shift());
+        const objectiveTemplate = optionalString(flags.objective || flags["objective-template"]);
+        if (!runId || !objectiveTemplate) {
+            throw new Error("usage: gamealgo experiment run objective <runId> --objective <ltv_proxy@1|active_days@1> --message <reason> --yes");
+        }
+        if (!["ltv_proxy@1", "active_days@1"].includes(objectiveTemplate)) {
+            throw new Error("experiment objective must be ltv_proxy@1 or active_days@1");
+        }
+        const message = requiredMessage(flags, "experiment run objective");
+        await requireYes(flags, global, "experiment run objective");
+        await printResult(await client.updateExperimentV2RunObjective(runId, objectiveTemplate, message), global);
+        return;
+    }
+    if (sub === "promote") {
+        const flags = parseFlags(args);
+        const runId = optionalString(flags.run || flags["run-id"] || flags.id) || optionalString(args.shift());
+        const variantId = optionalString(flags.variant || flags["variant-id"]) || optionalString(args.shift());
+        if (!runId || !variantId)
+            throw new Error("usage: gamealgo experiment run promote <runId> --variant <variantId> --message <reason> --yes");
+        const message = requiredMessage(flags, "experiment run promote");
+        await requireYes(flags, global, "experiment run promote");
+        await printResult(await client.promoteExperimentV2Run(runId, variantId, message), global);
+        return;
+    }
+    if (sub === "cancel") {
+        const flags = parseFlags(args);
+        const runId = optionalString(flags.run || flags["run-id"] || flags.id) || optionalString(args.shift());
+        if (!runId)
+            throw new Error("usage: gamealgo experiment run cancel <runId> --message <reason> --yes");
+        const message = requiredMessage(flags, "experiment run cancel");
+        await requireYes(flags, global, "experiment run cancel");
+        await printResult(await client.cancelExperimentV2Run(runId, message), global);
+        return;
+    }
+    throw new Error("usage: gamealgo experiment run <create|show|status|evaluate|report|objective|promote|cancel>");
+}
+export function requiredMessage(flags, action) {
+    const message = optionalString(flags.message);
+    if (!message)
+        throw new Error(`${action} requires --message <reason>`);
+    return message;
+}
+export async function handleExperimentOverride(client, args, global) {
+    const sub = args.shift();
+    if (sub === "list") {
+        const flags = parseFlags(args);
+        const runId = optionalString(flags.run || flags["run-id"] || flags.id) || optionalString(args.shift());
+        if (!runId)
+            throw new Error("usage: gamealgo experiment override list <runId>");
+        await printResult(await client.listExperimentV2Overrides(runId), global);
+        return;
+    }
+    if (sub === "set") {
+        const flags = parseFlags(args);
+        const runId = optionalString(flags.run || flags["run-id"] || flags.id) || optionalString(args.shift());
+        const userId = optionalString(flags.user || flags["user-id"] || flags.device || flags["device-id"]);
+        const variantId = optionalString(flags.variant || flags["variant-id"]);
+        if (!runId || !userId || !variantId)
+            throw new Error("usage: gamealgo experiment override set <runId> --user <userId> --variant <variantId> --yes");
+        await requireYes(flags, global, "experiment override set");
+        await printResult(await client.upsertExperimentV2Override(runId, userId, variantId), global);
+        return;
+    }
+    if (sub === "delete" || sub === "remove") {
+        const flags = parseFlags(args);
+        const runId = optionalString(flags.run || flags["run-id"] || flags.id) || optionalString(args.shift());
+        const userId = optionalString(flags.user || flags["user-id"] || flags.device || flags["device-id"]);
+        if (!runId || !userId)
+            throw new Error(`usage: gamealgo experiment override ${sub} <runId> --user <userId> --yes`);
+        await requireYes(flags, global, `experiment override ${sub}`);
+        await printResult(await client.deleteExperimentV2Override(runId, userId), global);
+        return;
+    }
+    throw new Error("usage: gamealgo experiment override <list|set|delete>");
+}
+export async function requireYes(flags, global, action) {
+    if (flags.yes)
+        return;
+    if (global.json) {
+        throw new Error(`${action} requires --yes in --json mode`);
+    }
+    if (!isInteractive()) {
+        throw new Error(`${action} requires --yes in non-interactive mode`);
+    }
+    const ok = await confirm(`Run ${action}?`);
+    if (!ok) {
+        throw new Error(`${action} cancelled`);
+    }
+}

package/dist/commands/integration.js

@@ -0,0 +1,30 @@
+import { parseFlags } from "../args.js";
+import { printResult } from "../output.js";
+import { writeTextFile } from "../resources.js";
+import { announceTargetGame } from "../target.js";
+import { integrationEnvironment, integrationPlatform } from "../utils.js";
+export async function handleIntegration(client, args, global) {
+    const sub = args.shift();
+    const flags = parseFlags(args);
+    if (args.length)
+        throw new Error("unexpected positional arguments for integration command");
+    const environment = integrationEnvironment(flags.environment);
+    const platform = integrationPlatform(flags.platform);
+    if (sub === "get-plan" || sub === "plan") {
+        await announceTargetGame(client);
+        const response = await client.getIntegrationPlan(environment, platform);
+        await writeIntegrationOutput(response, flags, global);
+        return;
+    }
+    throw new Error("usage: gamealgo integration get-plan --environment <domestic|overseas> --platform <ios|android|maker|rest>");
+}
+export async function writeIntegrationOutput(value, flags, global) {
+    if (flags.out) {
+        if (typeof flags.out !== "string")
+            throw new Error("--out requires a file path");
+        await writeTextFile(flags.out, JSON.stringify(value, null, 2) + "\n");
+        await printResult({ ok: true, out: flags.out }, global);
+        return;
+    }
+    await printResult(value, global);
+}

package/dist/commands/keys.js

@@ -0,0 +1,113 @@
+import { parseFlags } from "../args.js";
+import { confirm, isInteractive, printResult } from "../output.js";
+import { announceTargetGame } from "../target.js";
+import { optionalString } from "../utils.js";
+export async function handleGameKey(client, args, global) {
+    const sub = args.shift();
+    if (sub === "list") {
+        const keys = (await client.listGameKeys()).keys
+            .filter((key) => key.status === "active")
+            .map(publicGameKeyForCli);
+        await printResult({ keys }, global);
+        return;
+    }
+    if (sub === "create") {
+        const flags = parseFlags(args);
+        const name = optionalString(flags.name) || optionalString(args.shift());
+        if (!name)
+            throw new Error("usage: gamealgo key create --name <key-name>");
+        const response = await client.createGameKey(name);
+        await printResult({
+            ok: true,
+            created: response.created !== false,
+            name: response.key.name,
+            key: response.rawKey,
+            prefix: response.key.keyPrefix,
+            keyPrefix: response.key.keyPrefix,
+            status: response.key.status,
+            createdAt: response.key.createdAt,
+        }, global);
+        return;
+    }
+    if (sub === "reveal") {
+        await announceTargetGame(client);
+        const selector = keySelectorFromArgs(args, "gamealgo key reveal --name <key-name>");
+        const response = await client.revealGameKey(selector);
+        await printResult({
+            ok: true,
+            name: response.key.name,
+            key: response.rawKey,
+            prefix: response.key.keyPrefix,
+            keyPrefix: response.key.keyPrefix,
+            status: response.key.status,
+            createdAt: response.key.createdAt,
+        }, global);
+        return;
+    }
+    if (sub === "revoke") {
+        const flags = parseFlags(args);
+        if (!flags.yes && global.json) {
+            throw new Error("key revoke requires --yes in --json mode");
+        }
+        if (!flags.yes && !isInteractive()) {
+            throw new Error("key revoke requires --yes in non-interactive mode");
+        }
+        const selector = keySelectorFromFlags(flags, args, "gamealgo key revoke --name <key-name> --yes");
+        const key = await resolveGameKey(client, selector);
+        if (!flags.yes) {
+            const ok = await confirm(`Revoke client game key ${key.name} (${key.keyPrefix})?`);
+            if (!ok)
+                throw new Error("revoke cancelled");
+        }
+        const response = await client.revokeGameKey(key.id);
+        await printResult({ ok: true, key: publicGameKeyForCli(response.key) }, global);
+        return;
+    }
+    throw new Error("usage: gamealgo key <list|create|reveal|revoke>");
+}
+export function publicGameKeyForCli(key) {
+    return {
+        id: key.id,
+        name: key.name,
+        prefix: key.keyPrefix,
+        keyPrefix: key.keyPrefix,
+        status: key.status,
+        createdAt: key.createdAt,
+    };
+}
+export function keySelectorFromArgs(args, usage) {
+    const flags = parseFlags(args);
+    return keySelectorFromFlags(flags, args, usage);
+}
+export function keySelectorFromFlags(flags, args, usage) {
+    const id = optionalString(flags.id);
+    const name = optionalString(flags.name);
+    const prefix = optionalString(flags.prefix) || optionalString(flags["key-prefix"]);
+    const positionalName = !id && !name && !prefix ? optionalString(args.find((arg) => !arg.startsWith("--"))) : undefined;
+    const selector = {
+        id,
+        name: name || positionalName,
+        prefix,
+    };
+    if (!selector.id && !selector.name && !selector.prefix)
+        throw new Error(`usage: ${usage}`);
+    return selector;
+}
+export async function resolveGameKey(client, selector) {
+    if (selector.id) {
+        const key = (await client.listGameKeys()).keys.find((item) => item.status === "active" && item.id === selector.id);
+        if (!key)
+            throw new Error(`client game key not found: ${selector.id}`);
+        return key;
+    }
+    if (selector.name) {
+        const key = (await client.listGameKeys()).keys.find((item) => item.status === "active" && item.name === selector.name);
+        if (!key)
+            throw new Error(`client game key not found: ${selector.name}`);
+        return key;
+    }
+    const key = (await client.listGameKeys()).keys.find((item) => item.status === "active" && item.keyPrefix === selector.prefix);
+    if (!key)
+        throw new Error(`client game key not found: ${selector.prefix}`);
+    return key;
+}

package/dist/commands/marketing.js

@@ -0,0 +1,79 @@
+import { readFile } from "node:fs/promises";
+import YAML from "yaml";
+import { parseFlags } from "../args.js";
+import { formatDuration, printResult, reportTimeoutMs, startProgress, withCliMeta } from "../output.js";
+import { objectValue } from "../resources.js";
+import { optionalString } from "../utils.js";
+export async function handleMarketing(client, args, global) {
+    const provider = args.shift();
+    if (provider !== "adjust")
+        throw new Error("usage: gamealgo marketing adjust <get|configure|sync>");
+    const sub = args.shift();
+    if (sub === "get" || sub === "status") {
+        await printResult(await client.getAdjustMarketing(), global);
+        return;
+    }
+    if (sub === "configure" || sub === "set") {
+        const flags = parseFlags(args);
+        const current = await client.getAdjustMarketing();
+        const existing = current.integration || {};
+        const appToken = optionalString(flags["app-token"] || flags.appToken || existing.appToken);
+        const platform = optionalString(flags.platform || existing.platform) || "ios";
+        if (!appToken)
+            throw new Error("--app-token is required");
+        if (platform !== "ios" && platform !== "android")
+            throw new Error("--platform must be ios or android");
+        const body = {
+            appToken,
+            appName: optionalString(flags["app-name"] || flags.appName || existing.appName) || "",
+            platform,
+            currency: optionalString(flags.currency || existing.currency) || "USD",
+            status: optionalString(flags.status || existing.status) || "active",
+        };
+        const apiToken = optionalString(flags["api-token"] || flags.apiToken);
+        if (apiToken)
+            body.apiToken = apiToken;
+        const s2sToken = optionalString(flags["s2s-token"] || flags.s2sToken);
+        if (s2sToken)
+            body.s2sToken = s2sToken;
+        const s2sEventsPath = optionalString(flags["s2s-events"] || flags.s2sEvents);
+        if (s2sEventsPath)
+            body.s2sEventMappings = await readAdjustS2sEventMappings(s2sEventsPath);
+        const result = objectValue(await client.putAdjustMarketing(body));
+        await printResult({ ok: true, ...(result || {}) }, global);
+        return;
+    }
+    if (sub === "sync") {
+        const flags = parseFlags(args);
+        const timeoutMs = reportTimeoutMs(flags);
+        const startedAt = Date.now();
+        const stopProgress = startProgress("Syncing Adjust marketing spend", timeoutMs);
+        let response;
+        try {
+            response = await client.syncAdjustMarketing({
+                startDate: optionalString(flags.from || flags.start || flags.startDate),
+                endDate: optionalString(flags.to || flags.end || flags.endDate),
+            }, { timeoutMs });
+        }
+        finally {
+            stopProgress();
+        }
+        const elapsedMs = Date.now() - startedAt;
+        process.stderr.write(`Adjust sync finished in ${formatDuration(elapsedMs)}.\n`);
+        await printResult(withCliMeta(response, { elapsedMs, timeoutMs }), global);
+        return;
+    }
+    throw new Error("usage: gamealgo marketing adjust <get|configure|sync>");
+}
+export async function readAdjustS2sEventMappings(filePath) {
+    const text = await readFile(filePath, "utf8");
+    const parsed = filePath.endsWith(".json") ? JSON.parse(text) : YAML.parse(text);
+    const mappings = Array.isArray(parsed)
+        ? parsed
+        : parsed && typeof parsed === "object" && Array.isArray(parsed.events)
+            ? parsed.events
+            : null;
+    if (!mappings)
+        throw new Error(`${filePath} must be a JSON/YAML array or an object with events[]`);
+    return mappings;
+}