gamealgo-cli 0.1.7 → 0.2.0

package/dist/main.js

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+import { parseGlobalFlags } from "./args.js";
+import { createClient, handleAdminKey, login } from "./commands/auth.js";
+import { handleEvents } from "./commands/events.js";
+import { handleExperiment } from "./commands/experiment.js";
+import { handleIntegration } from "./commands/integration.js";
+import { handleGameKey } from "./commands/keys.js";
+import { handleMarketing } from "./commands/marketing.js";
+import { handleReport } from "./commands/report.js";
+import { handleFileResource } from "./commands/resources.js";
+import { loadPackageMetadata } from "./config.js";
+import { handleDocs, handleHelp } from "./docs.js";
+import { printResult } from "./output.js";
+export async function main() {
+    const args = process.argv.slice(2);
+    const global = parseGlobalFlags(args);
+    const command = args.shift();
+    if (command === "version" || command === "--version" || command === "-V") {
+        const metadata = await loadPackageMetadata();
+        if (global.json) {
+            await printResult({ ok: true, name: metadata.name, version: metadata.version }, global);
+        }
+        else {
+            console.log(metadata.version);
+        }
+        return;
+    }
+    try {
+        if (!command || command === "help" || command === "--help" || command === "-h") {
+            await handleHelp(args, global);
+            return;
+        }
+        const helpFlagIndex = args.findIndex((arg) => arg === "--help" || arg === "-h");
+        if (helpFlagIndex >= 0) {
+            args.splice(helpFlagIndex, 1);
+            await handleHelp([command, ...args], global);
+            return;
+        }
+        if (command === "login") {
+            await login(args, global);
+            return;
+        }
+        if (command === "whoami") {
+            const client = await createClient(global);
+            await printResult(await client.session(), global);
+            return;
+        }
+        if (command === "docs") {
+            await handleDocs(args, global);
+            return;
+        }
+        if (command === "listapi") {
+            await handleDocs(["api", "list", ...args], global);
+            return;
+        }
+        if (command === "admin-key") {
+            await handleAdminKey(args, global);
+            return;
+        }
+        const client = await createClient(global);
+        if (command === "experiment") {
+            await handleExperiment(client, args, global);
+            return;
+        }
+        if (command === "script") {
+            await handleFileResource(client, args, global, "script");
+            return;
+        }
+        if (command === "config") {
+            await handleFileResource(client, args, global, "config");
+            return;
+        }
+        if (command === "report") {
+            await handleReport(client, args, global);
+            return;
+        }
+        if (command === "key") {
+            await handleGameKey(client, args, global);
+            return;
+        }
+        if (command === "events") {
+            await handleEvents(client, args, global);
+            return;
+        }
+        if (command === "integration") {
+            await handleIntegration(client, args, global);
+            return;
+        }
+        if (command === "marketing") {
+            await handleMarketing(client, args, global);
+            return;
+        }
+        throw new Error(`Unknown command: ${command}`);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (global.json) {
+            console.log(JSON.stringify({ ok: false, error: message }, null, 2));
+        }
+        else {
+            console.error(`Error: ${message}`);
+        }
+        process.exitCode = 1;
+    }
+}
+await main();

package/dist/output.js

@@ -0,0 +1,82 @@
+import YAML from "yaml";
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+export function isInteractive() {
+    return Boolean(input.isTTY && output.isTTY);
+}
+export function reportTimeoutMs(flags) {
+    if (flags["timeout-ms"] !== undefined)
+        return Math.ceil(positiveNumberFlag(flags["timeout-ms"], "--timeout-ms"));
+    if (flags.timeout !== undefined)
+        return Math.ceil(positiveNumberFlag(flags.timeout, "--timeout") * 1000);
+    return undefined;
+}
+export function positiveNumberFlag(value, flag) {
+    if (typeof value === "boolean")
+        throw new Error(`${flag} requires a value`);
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed <= 0)
+        throw new Error(`${flag} must be a positive number`);
+    return parsed;
+}
+export function optionalNonNegativeInteger(value, field) {
+    if (value === undefined || value === null || value === "")
+        return undefined;
+    if (typeof value === "boolean")
+        throw new Error(`${field} must be a non-negative integer`);
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 0)
+        throw new Error(`${field} must be a non-negative integer`);
+    return parsed;
+}
+export function positiveInteger(value, field) {
+    const parsed = optionalNonNegativeInteger(value, field);
+    if (!parsed)
+        throw new Error(`${field} must be a positive integer`);
+    return parsed;
+}
+export function startProgress(label, timeoutMs) {
+    const startedAt = Date.now();
+    process.stderr.write(`${label}${timeoutMs ? `, timeout ${formatDuration(timeoutMs)}` : ""}...\n`);
+    const timer = setInterval(() => {
+        process.stderr.write(`${label} still running, elapsed ${formatDuration(Date.now() - startedAt)}...\n`);
+    }, 5000);
+    return () => clearInterval(timer);
+}
+export function withCliMeta(value, meta) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return value;
+    return {
+        ...value,
+        cli: {
+            elapsedMs: meta.elapsedMs,
+            ...(meta.timeoutMs ? { timeoutMs: meta.timeoutMs } : {}),
+        },
+    };
+}
+export function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    return `${(ms / 1000).toFixed(1)}s`;
+}
+export async function printResult(value, global) {
+    if (global.json) {
+        console.log(JSON.stringify(value, null, 2));
+        return;
+    }
+    if (typeof value === "string") {
+        console.log(value);
+        return;
+    }
+    console.log(YAML.stringify(value).trimEnd());
+}
+export async function confirm(question) {
+    const rl = createInterface({ input, output });
+    try {
+        const answer = await rl.question(`${question} [y/N] `);
+        return answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes";
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/resources.js

@@ -0,0 +1,93 @@
+import YAML from "yaml";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, basename } from "node:path";
+import { optionalString } from "./utils.js";
+export const SCRIPT_EXTENSIONS = new Set([".js", ".lua"]);
+export const FILE_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_.-]*$/;
+export async function readObjectFile(filePath, label) {
+    const text = await readFile(filePath, "utf8");
+    const parsed = filePath.endsWith(".json") ? JSON.parse(text) : YAML.parse(text);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error(`${label} file must be a JSON/YAML object`);
+    }
+    return parsed;
+}
+export function latestScriptVersionNames(value) {
+    if (!Array.isArray(value))
+        return [];
+    const names = new Set();
+    for (const item of value) {
+        const body = objectValue(item);
+        const name = optionalString(body?.name);
+        if (name && !names.has(name))
+            names.add(sanitizeRemoteFileName(name));
+    }
+    return [...names];
+}
+export function objectValue(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+export function validateExperimentRunVariantScripts(value) {
+    if (!Array.isArray(value))
+        throw new Error("experiment run requires variants array");
+    for (let index = 0; index < value.length; index += 1) {
+        const variant = objectValue(value[index]);
+        if (!variant)
+            throw new Error(`variants[${index}] must be an object`);
+        if (!Object.prototype.hasOwnProperty.call(variant, "script"))
+            continue;
+        const script = objectValue(variant.script);
+        if (!script || !optionalString(script.versionId)) {
+            throw new Error(`variants[${index}].script requires versionId; omit script for a config-only variant`);
+        }
+    }
+}
+export function printExperimentRunVariantScripts(value) {
+    const run = objectValue(objectValue(value)?.run);
+    if (!run || !Array.isArray(run.variants))
+        return;
+    console.log("\nVariant execution:");
+    for (const item of run.variants) {
+        const variant = objectValue(item);
+        if (!variant)
+            continue;
+        const variantId = optionalString(variant.variantId) ?? "(unknown)";
+        const versionId = optionalString(objectValue(variant.script)?.versionId);
+        console.log(`  ${variantId}: ${versionId ? `script ${versionId}` : "config-only"}`);
+    }
+}
+export async function readJsonFile(filePath) {
+    return JSON.parse(await readFile(filePath, "utf8"));
+}
+export async function writeTextFile(path, content) {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, content, "utf8");
+}
+export function sanitizeRemoteFileName(name) {
+    const trimmed = name.trim();
+    if (!trimmed || trimmed !== basename(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.includes("..")) {
+        throw new Error(`invalid remote file name: ${name}`);
+    }
+    if (!FILE_NAME_PATTERN.test(trimmed)) {
+        throw new Error(`invalid remote file name: ${name}`);
+    }
+    return trimmed;
+}
+export function validateJsonText(content, filePath) {
+    try {
+        JSON.parse(content);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`invalid JSON in ${filePath}: ${message}`);
+    }
+}
+export function contentTypeForFileName(name) {
+    if (name.endsWith(".json"))
+        return "application/json; charset=utf-8";
+    if (name.endsWith(".lua"))
+        return "application/lua; charset=utf-8";
+    if (name.endsWith(".js"))
+        return "text/javascript; charset=utf-8";
+    return "text/plain; charset=utf-8";
+}

package/dist/target.js

@@ -0,0 +1,3 @@
+export async function announceTargetGame(client) {
+    process.stderr.write(`GameAlgo target game: ${await client.gameId()}\n`);
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils.js

@@ -0,0 +1,23 @@
+import { SCRIPT_EXTENSIONS } from "./resources.js";
+export function normalizeHost(value) {
+    return value.trim().replace(/\/+$/, "");
+}
+export function integrationEnvironment(value) {
+    const environment = optionalString(value);
+    if (environment === "domestic" || environment === "overseas")
+        return environment;
+    throw new Error("--environment must be domestic or overseas");
+}
+export function integrationPlatform(value) {
+    const platform = optionalString(value);
+    if (platform === "ios" || platform === "android" || platform === "maker" || platform === "rest")
+        return platform;
+    throw new Error("--platform must be ios, android, maker, or rest");
+}
+export function optionalString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+export function isScriptFileName(name) {
+    const dot = name.lastIndexOf(".");
+    return dot >= 0 && SCRIPT_EXTENSIONS.has(name.slice(dot).toLowerCase());
+}

package/package.json

@@ -1,23 +1,32 @@
 {
   "name": "gamealgo-cli",
-  "version": "0.1.7",
+  "version": "0.2.0",
   "description": "GameAlgo command-line client for AI agents and game developers",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sunyuhao-code/GameAlgoCli.git"
+  },
+  "homepage": "https://github.com/sunyuhao-code/GameAlgoCli#readme",
+  "bugs": {
+    "url": "https://github.com/sunyuhao-code/GameAlgoCli/issues"
+  },
   "type": "module",
   "bin": {
-    "gamealgo": "dist/gamealgo.js"
+    "gamealgo": "dist/main.js"
   },
   "files": [
     "dist/",
-    "cli/README.md"
+    "README.md",
+    "LICENSE"
   ],
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build:cli": "tsc -p tsconfig.cli.json",
-    "check": "npm run build:cli && node --test rest-api/src/*.test.ts",
-    "cli": "node cli/gamealgo.ts",
-    "prepack": "npm run build:cli"
+    "build": "tsc -p tsconfig.json",
+    "check": "npm run build && node --test test/*.test.mjs",
+    "start": "node src/main.ts",
+    "prepack": "npm run build"
   },
   "engines": {
     "node": ">=24"