@myvillage/cli 1.9.0 → 1.10.1

package/src/utils/templates.js

@@ -36,7 +36,7 @@ export function createGameProject(targetDir, options) {
   }
 
   // Write common files
-  writeFileSync(join(targetDir, 'package.json'), generatePackageJson(name, description, slug, type));
+  writeFileSync(join(targetDir, 'package.json'), generatePackageJson(name, description, slug, type, ageGroup));
   writeFileSync(join(targetDir, 'vite.config.js'), generateViteConfig());
   writeFileSync(join(targetDir, '.gitignore'), generateGitignore());
   writeFileSync(join(targetDir, 'README.md'), generateReadme(name, description, type, ageGroup));
@@ -66,7 +66,611 @@ export function createGameProject(targetDir, options) {
   }
 }
 
-function generatePackageJson(name, description, slug, type) {
+// ── Unity Game Project ─────────────────────────────────────────────
+
+export function createUnityGameProject(targetDir, options) {
+  const { name, description, type, ageGroup, platform } = options;
+  const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/(^-|-$)/g, '');
+  const className = name.replace(/[^a-zA-Z0-9]/g, '');
+
+  const dirs = [
+    '',
+    'Scripts',
+    'Scripts/MyVillageOS',
+    'builds',
+    'builds/ios',
+    'builds/android',
+    'builds/webgl',
+  ];
+
+  for (const dir of dirs) {
+    mkdirSync(join(targetDir, dir), { recursive: true });
+  }
+
+  // Config file (CLI reads this instead of package.json for Unity projects)
+  writeFileSync(join(targetDir, 'myvillage.json'), JSON.stringify({
+    name,
+    slug,
+    description,
+    engine: 'unity',
+    gameType: platform === 'webgl' ? 'UNITY_WEBGL' : 'UNITY_NATIVE',
+    category: type.toUpperCase(),
+    targetAge: ageGroup,
+    gameId: null,
+    lastDeployed: null,
+  }, null, 2) + '\n');
+
+  writeFileSync(join(targetDir, '.gitignore'), [
+    'builds/*/*.meta', 'Library/', 'Temp/', 'Logs/', 'obj/',
+    'UserSettings/', '.vs/', '*.csproj', '*.sln',
+  ].join('\n') + '\n');
+
+  // MyVillageOS integration scripts
+  writeFileSync(join(targetDir, 'Scripts/MyVillageOS/EdPlatformConfig.cs'), generateEdPlatformConfig());
+  writeFileSync(join(targetDir, 'Scripts/MyVillageOS/GameSessionReporter.cs'), generateGameSessionReporter());
+  writeFileSync(join(targetDir, 'Scripts/MyVillageOS/MyVillageAuth.cs'), generateMyVillageAuth());
+  writeFileSync(join(targetDir, 'Scripts/MyVillageOS/PKCEHelper.cs'), generatePKCEHelper());
+  writeFileSync(join(targetDir, 'Scripts/MyVillageOS/MyVillageEvents.cs'), generateMyVillageEvents());
+
+  // Game-specific loader template
+  writeFileSync(join(targetDir, `Scripts/${className}Loader.cs`), generateGameLoader(className, slug));
+
+  // README
+  writeFileSync(join(targetDir, 'README.md'), generateUnityReadme(name, slug, className, platform));
+}
+
+function generateEdPlatformConfig() {
+  return `using UnityEngine;
+using UnityEngine.Networking;
+
+/// <summary>
+/// MyVillageOS ed-platform API configuration.
+/// All endpoints use dynamic game slugs — no hardcoded game IDs.
+/// </summary>
+public static class EdPlatformConfig
+{
+    private const string ProductionUrl = "https://portal.myvillageproject.ai";
+    private const string DevelopmentUrl = "http://localhost:3000";
+
+    public static string BaseUrl
+    {
+        get
+        {
+#if UNITY_EDITOR || DEVELOPMENT_BUILD
+            return DevelopmentUrl;
+#else
+            return ProductionUrl;
+#endif
+        }
+    }
+
+    // Game catalog
+    public static string GamesListEndpoint => $"{BaseUrl}/api/v1/games";
+
+    // Per-game sessions
+    public static string SessionsEndpoint(string gameSlug) =>
+        $"{BaseUrl}/api/v1/games/{gameSlug}/sessions";
+
+    public static string SessionCompleteEndpoint(string gameSlug, string sessionId) =>
+        $"{SessionsEndpoint(gameSlug)}/{sessionId}/complete";
+
+    // Bundle URLs
+    public static string BundleUrl(string gameSlug, string bundleName)
+    {
+        string escaped = UnityWebRequest.EscapeURL(bundleName.ToLower());
+        return $"{BaseUrl}/api/v1/games/game-assets/games/{gameSlug}/bundles/{CurrentPlatform}/{escaped}";
+    }
+
+    public static string CurrentPlatform
+    {
+        get
+        {
+#if UNITY_IOS
+            return "ios";
+#elif UNITY_ANDROID
+            return "android";
+#elif UNITY_WEBGL
+            return "webgl";
+#else
+            return "desktop";
+#endif
+        }
+    }
+}
+`;
+}
+
+function generateGameSessionReporter() {
+  return `using UnityEngine;
+using UnityEngine.Networking;
+using System;
+using System.Collections;
+using System.Text;
+
+/// <summary>
+/// Manages game session lifecycle with the MyVillageOS ed-platform.
+/// Attach to a persistent GameObject. Call StartSession() when gameplay
+/// begins and CompleteSession() when the player finishes.
+/// </summary>
+public class GameSessionReporter : MonoBehaviour
+{
+    public static GameSessionReporter Instance { get; private set; }
+
+    [Header("Game Settings")]
+    [Tooltip("Your game's slug on the ed-platform (e.g. 'eternal-equations')")]
+    public string GameSlug;
+
+    private string currentSessionId;
+    private float sessionStartTime;
+
+    void Awake()
+    {
+        if (Instance != null && Instance != this) { Destroy(gameObject); return; }
+        Instance = this;
+        DontDestroyOnLoad(gameObject);
+    }
+
+    /// <summary>Start a new play session. Call when gameplay begins.</summary>
+    public void StartSession()
+    {
+        if (string.IsNullOrEmpty(GameSlug))
+        {
+            Debug.LogWarning("[MyVillageOS] GameSlug not set on GameSessionReporter");
+            return;
+        }
+        StartCoroutine(StartSessionCoroutine());
+    }
+
+    /// <summary>Complete the current session with a score. Call when the player finishes.</summary>
+    public void CompleteSession(int score, int correct = 0, int incorrect = 0, string difficulty = "medium")
+    {
+        if (string.IsNullOrEmpty(currentSessionId))
+        {
+            Debug.LogWarning("[MyVillageOS] No active session to complete");
+            return;
+        }
+        StartCoroutine(CompleteSessionCoroutine(score, correct, incorrect, difficulty));
+    }
+
+    private IEnumerator StartSessionCoroutine()
+    {
+        string url = EdPlatformConfig.SessionsEndpoint(GameSlug);
+        string json = JsonUtility.ToJson(new SessionStartRequest { platform = EdPlatformConfig.CurrentPlatform });
+
+        using (var req = new UnityWebRequest(url, "POST"))
+        {
+            req.uploadHandler = new UploadHandlerRaw(Encoding.UTF8.GetBytes(json));
+            req.downloadHandler = new DownloadHandlerBuffer();
+            req.SetRequestHeader("Content-Type", "application/json");
+            AddAuthHeader(req);
+
+            yield return req.SendWebRequest();
+
+            if (req.result == UnityWebRequest.Result.Success)
+            {
+                var response = JsonUtility.FromJson<SessionStartResponse>(req.downloadHandler.text);
+                currentSessionId = response.session?.id;
+                sessionStartTime = Time.realtimeSinceStartup;
+                MyVillageEvents.OnSessionStarted?.Invoke(currentSessionId);
+                Debug.Log($"[MyVillageOS] Session started: {currentSessionId}");
+            }
+            else
+            {
+                Debug.LogWarning($"[MyVillageOS] Failed to start session: {req.error}");
+            }
+        }
+    }
+
+    private IEnumerator CompleteSessionCoroutine(int score, int correct, int incorrect, string difficulty)
+    {
+        string url = EdPlatformConfig.SessionCompleteEndpoint(GameSlug, currentSessionId);
+        int duration = Mathf.RoundToInt(Time.realtimeSinceStartup - sessionStartTime);
+
+        var body = new SessionCompleteRequest
+        {
+            score = score,
+            duration = duration,
+            sessionData = new SessionData { correct = correct, incorrect = incorrect, difficulty = difficulty }
+        };
+
+        string json = JsonUtility.ToJson(body);
+
+        using (var req = new UnityWebRequest(url, "POST"))
+        {
+            req.uploadHandler = new UploadHandlerRaw(Encoding.UTF8.GetBytes(json));
+            req.downloadHandler = new DownloadHandlerBuffer();
+            req.SetRequestHeader("Content-Type", "application/json");
+            AddAuthHeader(req);
+
+            yield return req.SendWebRequest();
+
+            if (req.result == UnityWebRequest.Result.Success)
+            {
+                var response = JsonUtility.FromJson<SessionCompleteResponse>(req.downloadHandler.text);
+                int mvt = response.mvtAwarded;
+                MyVillageEvents.OnSessionCompleted?.Invoke(score, duration);
+                if (mvt > 0) MyVillageEvents.OnMVTAwarded?.Invoke(mvt);
+                Debug.Log($"[MyVillageOS] Session complete. Score: {score}, MVT: {mvt}");
+            }
+            else
+            {
+                Debug.LogWarning($"[MyVillageOS] Failed to complete session: {req.error}");
+            }
+        }
+
+        currentSessionId = null;
+    }
+
+    private void AddAuthHeader(UnityWebRequest req)
+    {
+        string token = PlayerPrefs.GetString("jwt_token", "");
+        if (!string.IsNullOrEmpty(token))
+            req.SetRequestHeader("Authorization", $"Bearer {token}");
+    }
+
+    // ── Request/Response DTOs ──
+
+    [Serializable] private class SessionStartRequest { public string platform; }
+    [Serializable] private class SessionStartResponse { public SessionInfo session; }
+    [Serializable] private class SessionInfo { public string id; }
+    [Serializable] private class SessionCompleteRequest { public int score; public int duration; public SessionData sessionData; }
+    [Serializable] private class SessionData { public int correct; public int incorrect; public string difficulty; }
+    [Serializable] private class SessionCompleteResponse { public int mvtAwarded; public bool rewardSkipped; }
+}
+`;
+}
+
+function generateMyVillageAuth() {
+  return `using UnityEngine;
+using UnityEngine.Networking;
+using System;
+using System.Collections;
+using System.Text;
+
+/// <summary>
+/// OAuth 2.0 + PKCE authentication with MyVillageOS.
+/// Call SignIn() to open the browser login flow. The JWT token is
+/// stored in PlayerPrefs and used automatically by GameSessionReporter.
+/// </summary>
+public class MyVillageAuth : MonoBehaviour
+{
+    public static MyVillageAuth Instance { get; private set; }
+
+    private const string ClientId = "mvos_0L7avBZtpKSIyAT_kZT0Lg";
+    private const string Scopes = "openid profile email phone villager offline_access";
+
+    private string codeVerifier;
+    private string state;
+
+    public bool IsSignedIn => !string.IsNullOrEmpty(PlayerPrefs.GetString("jwt_token", ""));
+
+    void Awake()
+    {
+        if (Instance != null && Instance != this) { Destroy(gameObject); return; }
+        Instance = this;
+        DontDestroyOnLoad(gameObject);
+    }
+
+    /// <summary>Open the MyVillageOS login page in the system browser.</summary>
+    public void SignIn()
+    {
+        codeVerifier = PKCEHelper.GenerateCodeVerifier();
+        string codeChallenge = PKCEHelper.GenerateCodeChallenge(codeVerifier);
+        state = Guid.NewGuid().ToString("N");
+
+        string redirectUri = GetRedirectUri();
+        string url = $"{EdPlatformConfig.BaseUrl}/api/oauth/authorize" +
+            $"?response_type=code&client_id={ClientId}" +
+            $"&redirect_uri={UnityWebRequest.EscapeURL(redirectUri)}" +
+            $"&scope={UnityWebRequest.EscapeURL(Scopes)}" +
+            $"&code_challenge={codeChallenge}&code_challenge_method=S256" +
+            $"&state={state}";
+
+        Application.OpenURL(url);
+    }
+
+    /// <summary>Call this when you receive the auth callback with a code.</summary>
+    public void HandleCallback(string code, string returnedState)
+    {
+        if (returnedState != state)
+        {
+            Debug.LogError("[MyVillageOS] OAuth state mismatch — possible CSRF attack");
+            return;
+        }
+        StartCoroutine(ExchangeCodeForToken(code));
+    }
+
+    /// <summary>Clear the stored token.</summary>
+    public void SignOut()
+    {
+        PlayerPrefs.DeleteKey("jwt_token");
+        PlayerPrefs.DeleteKey("refresh_token");
+        PlayerPrefs.Save();
+        MyVillageEvents.OnSignedOut?.Invoke();
+    }
+
+    private IEnumerator ExchangeCodeForToken(string code)
+    {
+        string url = $"{EdPlatformConfig.BaseUrl}/api/oauth/token";
+        string body = $"grant_type=authorization_code&code={code}" +
+            $"&redirect_uri={UnityWebRequest.EscapeURL(GetRedirectUri())}" +
+            $"&client_id={ClientId}&code_verifier={codeVerifier}";
+
+        using (var req = new UnityWebRequest(url, "POST"))
+        {
+            req.uploadHandler = new UploadHandlerRaw(Encoding.UTF8.GetBytes(body));
+            req.downloadHandler = new DownloadHandlerBuffer();
+            req.SetRequestHeader("Content-Type", "application/x-www-form-urlencoded");
+            req.timeout = 15;
+
+            yield return req.SendWebRequest();
+
+            if (req.result == UnityWebRequest.Result.Success)
+            {
+                var token = JsonUtility.FromJson<TokenResponse>(req.downloadHandler.text);
+                PlayerPrefs.SetString("jwt_token", token.access_token);
+                if (!string.IsNullOrEmpty(token.refresh_token))
+                    PlayerPrefs.SetString("refresh_token", token.refresh_token);
+                PlayerPrefs.Save();
+                MyVillageEvents.OnSignedIn?.Invoke();
+                Debug.Log("[MyVillageOS] Signed in successfully");
+            }
+            else
+            {
+                Debug.LogError($"[MyVillageOS] Token exchange failed: {req.error}");
+            }
+        }
+    }
+
+    private string GetRedirectUri()
+    {
+#if UNITY_EDITOR || UNITY_STANDALONE
+        return "http://localhost:8429/auth/callback";
+#else
+        // Replace with your app's deep link scheme
+        return "myvillagegame://auth/callback";
+#endif
+    }
+
+    [Serializable] private class TokenResponse
+    {
+        public string access_token;
+        public string refresh_token;
+        public int expires_in;
+    }
+}
+`;
+}
+
+function generatePKCEHelper() {
+  return `using System;
+using System.Security.Cryptography;
+using System.Text;
+
+/// <summary>PKCE (Proof Key for Code Exchange) helper for OAuth 2.0.</summary>
+public static class PKCEHelper
+{
+    public static string GenerateCodeVerifier()
+    {
+        byte[] bytes = new byte[32];
+        using (var rng = RandomNumberGenerator.Create()) { rng.GetBytes(bytes); }
+        return Convert.ToBase64String(bytes)
+            .TrimEnd('=').Replace('+', '-').Replace('/', '_');
+    }
+
+    public static string GenerateCodeChallenge(string codeVerifier)
+    {
+        using (var sha256 = SHA256.Create())
+        {
+            byte[] hash = sha256.ComputeHash(Encoding.ASCII.GetBytes(codeVerifier));
+            return Convert.ToBase64String(hash)
+                .TrimEnd('=').Replace('+', '-').Replace('/', '_');
+        }
+    }
+}
+`;
+}
+
+function generateMyVillageEvents() {
+  return `using System;
+
+/// <summary>
+/// Global events for MyVillageOS integration.
+/// Subscribe to these in your game scripts to react to auth and session changes.
+/// </summary>
+public static class MyVillageEvents
+{
+    // Auth
+    public static Action OnSignedIn;
+    public static Action OnSignedOut;
+
+    // Sessions
+    public static Action<string> OnSessionStarted;      // sessionId
+    public static Action<int, int> OnSessionCompleted;   // score, duration
+    public static Action<int> OnMVTAwarded;              // amount
+}
+`;
+}
+
+function generateGameLoader(className, slug) {
+  return `using UnityEngine;
+using UnityEngine.Networking;
+using System.Collections;
+
+/// <summary>
+/// Downloads and loads the AssetBundle for this mini-game.
+/// Attach to a GameObject in your loading scene.
+/// Set AssetName in the Inspector to your bundle file name.
+///
+/// Game slug: "${slug}"
+/// </summary>
+public class ${className}Loader : MonoBehaviour
+{
+    [Header("Bundle Settings")]
+    [Tooltip("The AssetBundle file name (e.g. 'my-game')")]
+    public string AssetName;
+
+    [Tooltip("The scene name inside the AssetBundle to load")]
+    public string SceneName;
+
+    private const string GameSlug = "${slug}";
+
+    void Start()
+    {
+        if (!string.IsNullOrEmpty(AssetName))
+            StartCoroutine(LoadBundle());
+    }
+
+    private IEnumerator LoadBundle()
+    {
+        string url = EdPlatformConfig.BundleUrl(GameSlug, AssetName);
+        Debug.Log($"[${className}Loader] Downloading bundle from: {url}");
+
+        using (var req = UnityWebRequestAssetBundle.GetAssetBundle(url))
+        {
+            var op = req.SendWebRequest();
+
+            while (!op.isDone)
+            {
+                // You can update a progress bar here: req.downloadProgress
+                yield return null;
+            }
+
+            if (req.result != UnityWebRequest.Result.Success)
+            {
+                Debug.LogError($"[${className}Loader] Bundle download failed: {req.error}");
+                yield break;
+            }
+
+            AssetBundle bundle = DownloadHandlerAssetBundle.GetContent(req);
+
+            // Start a game session
+            if (GameSessionReporter.Instance != null)
+            {
+                GameSessionReporter.Instance.GameSlug = GameSlug;
+                GameSessionReporter.Instance.StartSession();
+            }
+
+            // Load the scene from the bundle
+            if (!string.IsNullOrEmpty(SceneName))
+            {
+                string[] scenes = bundle.GetAllScenePaths();
+                if (scenes.Length > 0)
+                    UnityEngine.SceneManagement.SceneManager.LoadScene(scenes[0]);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Call this when the player finishes your game.
+    /// It reports the score to MyVillageOS and awards MVT tokens.
+    /// </summary>
+    public void OnGameComplete(int score, int correct = 0, int incorrect = 0)
+    {
+        if (GameSessionReporter.Instance != null)
+            GameSessionReporter.Instance.CompleteSession(score, correct, incorrect);
+    }
+}
+`;
+}
+
+function generateUnityReadme(name, slug, className, platform) {
+  const gameType = platform === 'webgl' ? 'UNITY_WEBGL' : 'UNITY_NATIVE';
+  return `# ${name}
+
+A MyVillageOS mini-game built with Unity.
+
+- **Slug:** \`${slug}\`
+- **Game Type:** \`${gameType}\`
+- **Platform:** ${platform || 'ios / android'}
+
+## Setup
+
+1. Open your Unity project (or create a new one)
+2. Copy the \`Scripts/\` folder into your Unity project's \`Assets/\` directory
+3. Create a GameObject and attach \`GameSessionReporter\` — set GameSlug to \`${slug}\`
+4. Create a GameObject and attach \`MyVillageAuth\` (for player sign-in)
+5. Build your game scenes
+
+## MyVillageOS Integration
+
+The generated scripts handle:
+
+| Script | Purpose |
+|--------|---------|
+| \`EdPlatformConfig.cs\` | API URL construction (auto-detects platform) |
+| \`GameSessionReporter.cs\` | Session start/complete + MVT rewards |
+| \`MyVillageAuth.cs\` | OAuth 2.0 + PKCE sign-in via browser |
+| \`PKCEHelper.cs\` | Crypto utilities for OAuth PKCE |
+| \`MyVillageEvents.cs\` | Global events (OnSignedIn, OnSessionCompleted, OnMVTAwarded) |
+| \`${className}Loader.cs\` | Downloads your AssetBundle from the ed-platform |
+
+## Building AssetBundles
+
+### For Mobile (iOS / Android)
+
+1. In Unity: **Assets → Build AssetBundles** (or use your build script)
+2. Output bundles to \`builds/ios/\` and/or \`builds/android/\`
+3. Deploy: \`myvillage deploy --platform ios\`
+
+### For Web (WebGL)
+
+1. In Unity: **File → Build Settings → WebGL → Build**
+2. Output to \`builds/webgl/\`
+3. Deploy: \`myvillage deploy --platform webgl\`
+
+## Reporting Scores
+
+When the player finishes your game, call:
+
+\`\`\`csharp
+// From any script:
+GameSessionReporter.Instance.CompleteSession(
+    score: 850,
+    correct: 8,
+    incorrect: 2,
+    difficulty: "medium"
+);
+\`\`\`
+
+This reports the score to MyVillageOS and awards MVT tokens to the player.
+
+## Listening to Events
+
+\`\`\`csharp
+void OnEnable()
+{
+    MyVillageEvents.OnMVTAwarded += ShowRewardPopup;
+    MyVillageEvents.OnSessionCompleted += OnGameDone;
+}
+
+void OnDisable()
+{
+    MyVillageEvents.OnMVTAwarded -= ShowRewardPopup;
+    MyVillageEvents.OnSessionCompleted -= OnGameDone;
+}
+
+void ShowRewardPopup(int amount) => Debug.Log($"Earned {amount} MVT!");
+void OnGameDone(int score, int duration) => Debug.Log($"Score: {score} in {duration}s");
+\`\`\`
+
+## Deploy
+
+\`\`\`bash
+myvillage deploy --platform ios        # Upload iOS bundles
+myvillage deploy --platform android    # Upload Android bundles
+myvillage deploy --platform webgl      # Upload WebGL build
+myvillage status                       # Check review status
+\`\`\`
+
+After deploying, an admin will review your game, set MVT rewards, and publish it.
+Published games appear automatically in the Izi Graham mobile app or M-UNI web platform.
+`;
+}
+
+// ── Three.js Templates ─────────────────────────────────────────────
+
+function generatePackageJson(name, description, slug, type, ageGroup) {
   return JSON.stringify({
     name: slug,
     version: '1.0.0',
@@ -85,8 +689,10 @@ function generatePackageJson(name, description, slug, type) {
       vite: '^5.0.0',
     },
     myvillage: {
+      name: name,
       gameId: null,
       gameType: type,
+      targetAge: ageGroup,
       lastDeployed: null,
     },
   }, null, 2) + '\n';