gamealgo-cli 0.1.7 → 0.2.1

package/dist/commands/report.js

@@ -0,0 +1,175 @@
+import { parseFlags, parseSelectorFlags } from "../args.js";
+import { formatDuration, printResult, reportTimeoutMs, startProgress, withCliMeta } from "../output.js";
+import { objectValue, readJsonFile, writeTextFile } from "../resources.js";
+import { announceTargetGame } from "../target.js";
+import { optionalString } from "../utils.js";
+export async function handleReport(client, args, global) {
+    const sub = args.shift();
+    if (sub === "pull") {
+        const flags = parseFlags(args);
+        const pack = await client.getReportPack();
+        const out = String(flags.out || "gamealgo-report-pack-v1.json");
+        await writeTextFile(out, JSON.stringify(pack.reportPack.content, null, 2) + "\n");
+        await printResult({ ok: true, out }, global);
+        return;
+    }
+    if (sub === "validate") {
+        const filePath = args.shift();
+        if (!filePath)
+            throw new Error("usage: gamealgo report validate <report-pack.json>");
+        const content = await readJsonFile(filePath);
+        await printResult(await client.previewReportPack(content), global);
+        return;
+    }
+    if (sub === "publish") {
+        const filePath = args.shift();
+        if (!filePath)
+            throw new Error("usage: gamealgo report publish <report-pack.json>");
+        parseFlags(args);
+        const content = await readJsonFile(filePath);
+        await announceTargetGame(client);
+        const response = await client.putReportPack(content);
+        await printResult({ ok: true, validation: response.reportPack.validation }, global);
+        return;
+    }
+    if (sub === "manifest" || sub === "list") {
+        parseFlags(args);
+        await printResult(await client.reportManifest(), global);
+        return;
+    }
+    if (sub === "result") {
+        const selectors = parseSelectorFlags(args);
+        const flags = parseFlags(args);
+        const startDate = String(flags.from || flags.start || flags.startDate || "");
+        const endDate = String(flags.to || flags.end || flags.endDate || "");
+        if (!startDate || !endDate)
+            throw new Error("usage: gamealgo report result --from YYYY-MM-DD --to YYYY-MM-DD [--platform ios|android|rest] [--tab name] [--group name] [--chart name] [--selector k=v]");
+        const timeoutMs = reportTimeoutMs(flags);
+        const platform = await resolveCliReportPlatform(client, flags.platform, selectors.platform, startDate, endDate);
+        const startedAt = Date.now();
+        const stopProgress = startProgress("Querying report results", timeoutMs);
+        let response;
+        try {
+            response = await client.queryReportDashboard({
+                startDate,
+                endDate,
+                tab: optionalString(flags.tab),
+                tabId: optionalString(flags["tab-id"]),
+                group: optionalString(flags.group),
+                groupId: optionalString(flags["group-id"]),
+                chart: optionalString(flags.chart),
+                chartId: optionalString(flags["chart-id"]),
+                platform,
+                selectors,
+                refresh: Boolean(flags.refresh),
+            }, { timeoutMs });
+        }
+        finally {
+            stopProgress();
+        }
+        const elapsedMs = Date.now() - startedAt;
+        const outputValue = withCliMeta(response, { elapsedMs, timeoutMs });
+        process.stderr.write(`Report 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),
+                results: Array.isArray(outputValue.results) ? outputValue.results.length : 0,
+                elapsedMs,
+            }, global);
+            return;
+        }
+        await printResult(outputValue, global);
+        return;
+    }
+    if (sub === "preview") {
+        const selectors = parseSelectorFlags(args);
+        const flags = parseFlags(args);
+        const filePath = String(flags.pack || flags.file || args.shift() || "");
+        const startDate = String(flags.from || flags.start || flags.startDate || "");
+        const endDate = String(flags.to || flags.end || flags.endDate || "");
+        if (!filePath || !startDate || !endDate) {
+            throw new Error("usage: gamealgo report preview --pack report-pack.json --from YYYY-MM-DD --to YYYY-MM-DD [--platform ios|android|rest] [--tab name] [--group name] [--chart name] [--selector k=v]");
+        }
+        const content = await readJsonFile(filePath);
+        const timeoutMs = reportTimeoutMs(flags);
+        const platform = await resolveCliReportPlatform(client, flags.platform, selectors.platform, startDate, endDate);
+        const startedAt = Date.now();
+        const stopProgress = startProgress("Previewing report results", timeoutMs);
+        let response;
+        try {
+            response = await client.previewReportDashboard({
+                content,
+                startDate,
+                endDate,
+                tab: optionalString(flags.tab),
+                tabId: optionalString(flags["tab-id"]),
+                group: optionalString(flags.group),
+                groupId: optionalString(flags["group-id"]),
+                chart: optionalString(flags.chart),
+                chartId: optionalString(flags["chart-id"]),
+                platform,
+                selectors,
+            }, { timeoutMs });
+        }
+        finally {
+            stopProgress();
+        }
+        const elapsedMs = Date.now() - startedAt;
+        const outputValue = withCliMeta(response, { elapsedMs, timeoutMs });
+        process.stderr.write(`Report preview 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),
+                results: Array.isArray(outputValue.results) ? outputValue.results.length : 0,
+                elapsedMs,
+            }, global);
+            return;
+        }
+        await printResult(outputValue, global);
+        return;
+    }
+    throw new Error("usage: gamealgo report <pull|validate|publish|manifest|result|preview>");
+}
+export async function resolveCliReportPlatform(client, flagValue, selectorValue, startDate, endDate) {
+    const flagPlatform = optionalCliReportPlatform(flagValue, "--platform");
+    const selectorPlatform = optionalCliReportPlatform(selectorValue, "--selector platform");
+    if (flagPlatform && selectorPlatform && flagPlatform !== selectorPlatform) {
+        throw new Error(`--platform ${flagPlatform} conflicts with --selector platform=${selectorPlatform}`);
+    }
+    const explicit = flagPlatform || selectorPlatform;
+    if (explicit) {
+        process.stderr.write(`Report platform: ${explicit} (explicit)\n`);
+        return explicit;
+    }
+    const preferences = objectValue(await client.getGamePreferences());
+    const reportDefaults = objectValue(preferences?.reportDefaults);
+    const gameDefault = optionalCliReportPlatform(reportDefaults?.reportPlatform, "game report default");
+    if (gameDefault) {
+        process.stderr.write(`Report platform: ${gameDefault} (game default)\n`);
+        return gameDefault;
+    }
+    const personalPreferences = objectValue(preferences?.preferences);
+    const personalDefault = optionalCliReportPlatform(personalPreferences?.reportPlatform, "saved report preference");
+    if (personalDefault) {
+        process.stderr.write(`Report platform: ${personalDefault} (saved preference)\n`);
+        return personalDefault;
+    }
+    const detected = objectValue(await client.countEventPlatforms(startDate, endDate));
+    const detectedPlatform = optionalCliReportPlatform(detected?.recommendedPlatform, "detected report platform");
+    if (!detectedPlatform) {
+        throw new Error("report platform could not be detected for the selected date range; pass --platform ios, --platform android, or --platform rest");
+    }
+    process.stderr.write(`Report platform: ${detectedPlatform} (detected from event data)\n`);
+    return detectedPlatform;
+}
+export function optionalCliReportPlatform(value, field) {
+    if (value === undefined || value === null || value === "")
+        return undefined;
+    if (value === "ios" || value === "android" || value === "rest")
+        return value;
+    throw new Error(`${field} must be ios, android, or rest`);
+}

package/dist/commands/resources.js

@@ -0,0 +1,95 @@
+import { readFile } from "node:fs/promises";
+import { join, basename } from "node:path";
+import { parseFlags } from "../args.js";
+import { printResult } from "../output.js";
+import { contentTypeForFileName, latestScriptVersionNames, sanitizeRemoteFileName, validateJsonText, writeTextFile } from "../resources.js";
+import { isScriptFileName, optionalString } from "../utils.js";
+export async function handleFileResource(client, args, global, resource) {
+    const sub = args.shift();
+    const isScript = resource === "script";
+    if (sub === "list") {
+        if (isScript) {
+            const flags = parseFlags(args);
+            await printResult(await client.listScriptVersions(optionalString(flags.name), Number(flags.limit || 50)), global);
+            return;
+        }
+        const files = (await client.listConfigFiles()).configFiles.filter((file) => isScriptFileName(file.name) === isScript);
+        await printResult({ files }, global);
+        return;
+    }
+    if (sub === "pull") {
+        const flags = parseFlags(args);
+        const outDir = String(flags.out || (isScript ? "scripts" : "configs"));
+        const all = Boolean(flags.all);
+        const names = args;
+        if (!all && names.length === 0)
+            throw new Error(`usage: gamealgo ${resource} pull <name> [--out dir]`);
+        if (isScript) {
+            const list = all
+                ? latestScriptVersionNames((await client.listScriptVersions(undefined, Number(flags.limit || 500))).scriptVersions)
+                : names.map((name) => sanitizeRemoteFileName(name));
+            const pulled = [];
+            for (const name of list) {
+                const versions = (await client.listScriptVersions(name, 1)).scriptVersions;
+                const latest = versions[0];
+                if (!latest)
+                    throw new Error(`script version not found: ${name}`);
+                const file = await client.getScriptVersion(name, latest.versionId);
+                const fileName = sanitizeRemoteFileName(file.scriptVersion.name);
+                const target = join(outDir, fileName);
+                await writeTextFile(target, file.scriptVersion.content);
+                pulled.push(target);
+            }
+            await printResult({ ok: true, files: pulled }, global);
+            return;
+        }
+        const list = all
+            ? (await client.listConfigFiles()).configFiles.filter((file) => isScriptFileName(file.name) === isScript).map((file) => file.name)
+            : names;
+        const pulled = [];
+        for (const name of list) {
+            const file = await client.getConfigFile(sanitizeRemoteFileName(name));
+            const fileName = sanitizeRemoteFileName(file.configFile.name);
+            const target = join(outDir, fileName);
+            await writeTextFile(target, file.configFile.content);
+            pulled.push(target);
+        }
+        await printResult({ ok: true, files: pulled }, global);
+        return;
+    }
+    if (sub === "publish") {
+        const flags = parseFlags(args);
+        const files = args;
+        if (files.length === 0)
+            throw new Error(`usage: gamealgo ${resource} publish <file...>`);
+        if (flags.name && files.length > 1) {
+            throw new Error("--name can only be used when publishing one file");
+        }
+        const published = [];
+        for (const filePath of files) {
+            const name = sanitizeRemoteFileName(String(flags.name || basename(filePath)));
+            const content = await readFile(filePath, "utf8");
+            if (isScript) {
+                const result = await client.createScriptVersion(name, content, contentTypeForFileName(name), optionalString(flags.message));
+                published.push(result.scriptVersion);
+                continue;
+            }
+            if (!isScript && (name.toLowerCase().endsWith(".json") || filePath.toLowerCase().endsWith(".json"))) {
+                validateJsonText(content, filePath);
+            }
+            const result = await client.putConfigFile(name, content, contentTypeForFileName(name));
+            published.push(result.configFile);
+        }
+        await printResult(isScript ? { ok: true, scriptVersions: published } : { ok: true, files: published }, global);
+        return;
+    }
+    if (isScript && (sub === "versions" || sub === "version")) {
+        const flags = parseFlags(args);
+        const name = optionalString(flags.name) || optionalString(args.shift());
+        if (!name)
+            throw new Error("usage: gamealgo script versions <name> [--limit 20]");
+        await printResult(await client.listScriptVersions(sanitizeRemoteFileName(name), Number(flags.limit || 50)), global);
+        return;
+    }
+    throw new Error(`usage: gamealgo ${resource} <list|pull|publish>`);
+}

package/dist/compatibility.js

@@ -0,0 +1,62 @@
+import { loadPackageMetadata } from "./config.js";
+import { requestJson } from "./http.js";
+export const CLI_PROTOCOL_VERSION = 1;
+export async function assertServerCompatibility(host) {
+    const metadata = await requestJson(host, "/admin/v1/cli/meta", {
+        headers: { "Cache-Control": "no-cache" },
+    });
+    const local = await loadPackageMetadata();
+    if (metadata.protocolVersion !== CLI_PROTOCOL_VERSION) {
+        throw new Error(`This Server requires CLI protocol ${metadata.protocolVersion}, but this CLI supports protocol ${CLI_PROTOCOL_VERSION}. `
+            + `Upgrade with: ${metadata.upgradeCommand || `npm install -g ${metadata.packageName || local.name}@latest`}`);
+    }
+    if (compareVersions(local.version, metadata.minCliVersion) < 0) {
+        throw new Error(`gamealgo-cli ${local.version} is no longer supported by this Server; minimum version is ${metadata.minCliVersion}. `
+            + `Upgrade with: ${metadata.upgradeCommand || `npm install -g ${metadata.packageName || local.name}@latest`}`);
+    }
+    return metadata;
+}
+export function compareVersions(left, right) {
+    const leftParts = parseVersion(left);
+    const rightParts = parseVersion(right);
+    for (let index = 0; index < 3; index += 1) {
+        if (leftParts[index] !== rightParts[index])
+            return leftParts[index] < rightParts[index] ? -1 : 1;
+    }
+    return comparePrerelease(leftParts[3], rightParts[3]);
+}
+function parseVersion(value) {
+    const match = value.trim().match(/^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/);
+    if (!match)
+        throw new Error(`Invalid semantic version: ${value}`);
+    return [Number(match[1]), Number(match[2]), Number(match[3]), match[4] ? match[4].split(".") : []];
+}
+function comparePrerelease(left, right) {
+    if (!left.length && !right.length)
+        return 0;
+    if (!left.length)
+        return 1;
+    if (!right.length)
+        return -1;
+    const length = Math.max(left.length, right.length);
+    for (let index = 0; index < length; index += 1) {
+        const leftValue = left[index];
+        const rightValue = right[index];
+        if (leftValue === undefined)
+            return -1;
+        if (rightValue === undefined)
+            return 1;
+        if (leftValue === rightValue)
+            continue;
+        const leftNumber = /^\d+$/.test(leftValue) ? Number(leftValue) : undefined;
+        const rightNumber = /^\d+$/.test(rightValue) ? Number(rightValue) : undefined;
+        if (leftNumber !== undefined && rightNumber !== undefined)
+            return leftNumber < rightNumber ? -1 : 1;
+        if (leftNumber !== undefined)
+            return -1;
+        if (rightNumber !== undefined)
+            return 1;
+        return leftValue < rightValue ? -1 : 1;
+    }
+    return 0;
+}

package/dist/config.js

@@ -0,0 +1,80 @@
+import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+export const GLOBAL_CONFIG_PATH = join(homedir(), ".gamealgo", "cli.json");
+export const PROJECT_CONFIG_DIR = ".gamealgo";
+export const PROJECT_CONFIG_FILE = "cli.json";
+export async function loadConfig() {
+    const localPath = await findProjectConfigPath(process.cwd());
+    const paths = localPath && localPath !== GLOBAL_CONFIG_PATH
+        ? [localPath, GLOBAL_CONFIG_PATH]
+        : [GLOBAL_CONFIG_PATH];
+    for (const configPath of paths) {
+        try {
+            return JSON.parse(await readFile(configPath, "utf8"));
+        }
+        catch {
+            // Try the next supported config location.
+        }
+    }
+    return null;
+}
+export async function loadProjectConfig() {
+    const configPath = await findProjectConfigPath(process.cwd());
+    if (!configPath)
+        return null;
+    try {
+        return JSON.parse(await readFile(configPath, "utf8"));
+    }
+    catch {
+        throw new Error(`project CLI config is invalid: ${configPath}`);
+    }
+}
+export async function findProjectConfigPath(startDir) {
+    let currentDir = startDir;
+    while (true) {
+        const candidate = join(currentDir, PROJECT_CONFIG_DIR, PROJECT_CONFIG_FILE);
+        try {
+            await readFile(candidate, "utf8");
+            return candidate;
+        }
+        catch {
+            const parentDir = dirname(currentDir);
+            if (parentDir === currentDir)
+                return null;
+            currentDir = parentDir;
+        }
+    }
+}
+export async function saveConfig(config) {
+    const configDir = join(process.cwd(), PROJECT_CONFIG_DIR);
+    const configPath = join(configDir, PROJECT_CONFIG_FILE);
+    await mkdir(configDir, { recursive: true, mode: 0o700 });
+    await chmod(configDir, 0o700).catch(() => undefined);
+    await ensureProjectConfigIgnored(configDir);
+    await writeFile(configPath, JSON.stringify(config, null, 2) + "\n", { encoding: "utf8", mode: 0o600 });
+    await chmod(configPath, 0o600).catch(() => undefined);
+    return configPath;
+}
+export async function ensureProjectConfigIgnored(configDir) {
+    const ignorePath = join(configDir, ".gitignore");
+    try {
+        const existing = await readFile(ignorePath, "utf8");
+        const rules = existing.split(/\r?\n/).map((line) => line.trim());
+        if (rules.includes("*") || rules.includes(PROJECT_CONFIG_FILE) || rules.includes(`/${PROJECT_CONFIG_FILE}`))
+            return;
+        const separator = existing && !existing.endsWith("\n") ? "\n" : "";
+        await writeFile(ignorePath, `${existing}${separator}${PROJECT_CONFIG_FILE}\n`, { encoding: "utf8", mode: 0o600 });
+    }
+    catch {
+        await writeFile(ignorePath, "*\n", { encoding: "utf8", mode: 0o600 });
+    }
+}
+export async function loadPackageMetadata() {
+    const packageJson = JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8"));
+    const name = typeof packageJson.name === "string" ? packageJson.name : "gamealgo-cli";
+    if (typeof packageJson.version !== "string" || !packageJson.version) {
+        throw new Error("CLI package version is missing");
+    }
+    return { name, version: packageJson.version };
+}