castle-cli-reboot 1.0.3

package/gd.js

@@ -0,0 +1,135 @@
+import { execSync } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import readline from 'readline';
+
+function getCastleModulePath(subpath) {
+    const localPath = path.resolve('./node_modules/castle-cli/dist', subpath);
+    if (fs.existsSync(localPath)) return localPath;
+    const parentLocalPath = path.resolve('../node_modules/castle-cli/dist', subpath);
+    if (fs.existsSync(parentLocalPath)) return parentLocalPath;
+    try {
+        const npmRoot = execSync('npm root -g', { stdio: ['pipe', 'pipe', 'ignore'] }).toString().trim();
+        const globalPath = path.join(npmRoot, 'castle-cli', 'dist', subpath);
+        if (fs.existsSync(globalPath)) return globalPath;
+    } catch (e) {}
+    throw new Error(`Could not find castle-cli module '${subpath}'. Make sure castle-cli is installed locally or globally.`);
+}
+
+const API = await import(`file://${getCastleModulePath('api.js')}`);
+const { setToken, getToken } = await import(`file://${getCastleModulePath('config.js')}`);
+
+function promptInput(query) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(query, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+
+async function ensureAuth() {
+    const savedToken = getToken();
+    const promptMsg = savedToken
+        ? 'Enter Castle Auth Token (or press Enter to use saved token): '
+        : 'Enter Castle Auth Token: ';
+
+    const inputToken = await promptInput(promptMsg);
+    if (inputToken) {
+        setToken(inputToken);
+    } else if (!savedToken) {
+        console.error("Error: Auth token is required.");
+        return false;
+    }
+    return true;
+}
+
+export async function getDeck(deckId, customPath) {
+    if (!deckId) {
+        console.error("Error: gd need's atleast two info, the deckId, then the Folder. like this: gd <deckId> <Folder>");
+        return;
+    }
+
+    if (!(await ensureAuth())) return;
+
+    const deckDir = path.resolve(customPath || '/sdcard/deck');
+    console.log(`Getting  ${deckId} to ${deckDir}...`);
+
+    try {
+        const deck = await API.deck(deckId);
+        if (!deck) {
+            console.error("You're not allowed to get this deck or it doesn't exist..");
+            return;
+        }
+
+        fs.rmSync(deckDir, { recursive: true, force: true });
+        fs.mkdirSync(deckDir, { recursive: true });
+
+        const cards = deck.cards?.length ? deck.cards : deck.initialCard ? [deck.initialCard] : [];
+
+        fs.writeFileSync(
+            path.join(deckDir, 'deck.json'),
+            JSON.stringify({
+                deckId: deck.deckId,
+                title: deck.title ?? '',
+                visibility: deck.visibility,
+                variables: deck.variables ?? [],
+                initialCard: deck.initialCard,
+                cards,
+            }, null, 2)
+        );
+
+        for (const card of cards) {
+            if (!card.cardId || !card.sceneDataUrl) continue;
+            console.log(`Decompiling Scene.json for card ${card.cardId}...`);
+
+            const sceneData = await API.downloadSceneData(card.sceneDataUrl);
+            const cardDir = path.join(deckDir, 'cards', card.cardId);
+            fs.mkdirSync(cardDir, { recursive: true });
+
+            fs.writeFileSync(path.join(cardDir, 'card.json'), JSON.stringify(card, null, 2));
+
+            const sceneDir = path.join(cardDir, 'scene');
+            fs.mkdirSync(sceneDir, { recursive: true });
+
+            const sceneObj = typeof sceneData === 'string' ? JSON.parse(sceneData) : sceneData;
+            fs.writeFileSync(path.join(sceneDir, 'scene.json'), JSON.stringify(sceneObj, null, 2));
+
+            const library = sceneObj.snapshot?.library || {};
+            const actors = sceneObj.snapshot?.actors || [];
+            const blueprintsDir = path.join(sceneDir, 'blueprints');
+            fs.mkdirSync(blueprintsDir, { recursive: true });
+
+            const slugMap = {};
+            for (const [uuid, entry] of Object.entries(library)) {
+                if (entry.entryType === 'actorBlueprint') {
+                    const safeName = (entry.title || uuid).replace(/[^a-zA-Z0-9_-]/g, '-').toLowerCase();
+                    slugMap[safeName] = uuid;
+                    fs.writeFileSync(path.join(blueprintsDir, `${safeName}.json`), JSON.stringify(entry, null, 2));
+                }
+            }
+
+            let actorsYaml = "";
+            actors.forEach((actor, index) => {
+                actorsYaml += `a${index}:\n`;
+                if (actor.title) actorsYaml += `  title: "${actor.title}"\n`;
+                if (actor.blueprintId) actorsYaml += `  blueprint: "${actor.blueprintId}"\n`;
+                actorsYaml += `  x: ${actor.x || 0}\n`;
+                actorsYaml += `  y: ${actor.y || 0}\n`;
+            });
+            fs.writeFileSync(path.join(sceneDir, 'actors.yaml'), actorsYaml);
+
+            const castleDir = path.join(sceneDir, '.castle');
+            fs.mkdirSync(castleDir, { recursive: true });
+            fs.writeFileSync(path.join(castleDir, 'slug-map.json'), JSON.stringify(slugMap, null, 2));
+        }
+
+        console.log(`Decompiled deck in ${deckDir}`);
+    } catch (err) {
+        console.error("Error during the decompilation", err);
+    }
+}

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "castle-cli-reboot",
+  "version": "1.0.3",
+  "type": "module",
+  "bin": {
+    "ct": "./tool/castle-terminal.js"
+  },
+  "dependencies": {
+    "castle-cli": "^2.0.6",
+    "http-server": "^14.1.1"
+  }
+}
+

package/tool/castle-terminal.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+import readline from 'readline';
+import { getDeck } from './gd.js';
+import { saveDeck } from './sd.js';
+
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: 'castle-cli> '
+});
+
+console.clear();
+console.log("======================================================");
+console.log("               Castle Custom Terminal                 ");
+console.log("Available Commands:                                   ");
+console.log("  gd <id> [folder] - Extracts deck using its ID       ");
+console.log("  sd [folder]      - Saves the local deck             ");
+console.log("  exit             - Exits Castle custom terminal     ");
+console.log("======================================================");
+
+rl.prompt();
+
+rl.on('line', async (line) => {
+    let input = line.trim();
+
+    if (!input) {
+        rl.prompt();
+        return;
+    }
+
+    // Handle space-separated command aliases like "get deck" or "save deck"
+    if (/^get\s+deck\b/i.test(input)) {
+        input = input.replace(/^get\s+deck\b/i, 'gd');
+    } else if (/^save\s+deck\b/i.test(input)) {
+        input = input.replace(/^save\s+deck\b/i, 'sd');
+    }
+
+    const parts = input.split(/\s+/);
+    const cmd = parts[0].toLowerCase();
+
+    switch (cmd) {
+        case 'gd':
+        case 'get-deck':
+        case 'getdeck':
+        case 'get': {
+            const deckId = parts[1];
+            const customPath = parts[2];
+            await getDeck(deckId, customPath);
+            break;
+        }
+        case 'sd':
+        case 'save-deck':
+        case 'savedeck':
+        case 'save': {
+            const customPath = parts[1];
+            await saveDeck(customPath);
+            break;
+        }
+        case 'exit':
+        case 'quit':
+            console.log("Exiting Terminal...");
+            process.exit(0);
+            break;
+        default:
+            console.log(`Unknown Command: "${parts[0]}"`);
+            break;
+    }
+    rl.prompt();
+}).on('close', () => {
+    console.log('\nClosing Terminal.');
+    process.exit(0);
+});

package/tool/gd.js

@@ -0,0 +1,115 @@
+import { execSync } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import readline from 'readline';
+
+const npmRoot = execSync('npm root -g').toString().trim();
+const apiPath = path.join(npmRoot, 'castle-cli', 'dist', 'api.js');
+const configPath = path.join(npmRoot, 'castle-cli', 'dist', 'config.js');
+
+const API = await import(`file://${apiPath}`);
+const { setToken } = await import(`file://${configPath}`);
+
+function promptToken() {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question('Enter Castle Auth Token: ', (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+
+export async function getDeck(deckId, customPath) {
+    if (!deckId) {
+        console.error("Error: gd need's atleast two info, the deckId, then the Folder. like this: gd <deckId> <Folder>");
+        return;
+    }
+
+    const token = await promptToken();
+    if (!token) {
+        console.error("Error: Auth token is required.");
+        return;
+    }
+    setToken(token);
+
+    const deckDir = path.resolve(customPath || '/sdcard/deck');
+    console.log(`Getting  ${deckId} to ${deckDir}...`);
+
+    try {
+        const deck = await API.deck(deckId);
+        if (!deck) {
+            console.error("You're not allowed to get this deck or it doesn't exist..");
+            return;
+        }
+
+        fs.rmSync(deckDir, { recursive: true, force: true });
+        fs.mkdirSync(deckDir, { recursive: true });
+
+        const cards = deck.cards?.length ? deck.cards : deck.initialCard ? [deck.initialCard] : [];
+
+        fs.writeFileSync(
+            path.join(deckDir, 'deck.json'),
+            JSON.stringify({
+                deckId: deck.deckId,
+                title: deck.title ?? '',
+                visibility: deck.visibility,
+                variables: deck.variables ?? [],
+                initialCard: deck.initialCard,
+                cards,
+            }, null, 2)
+        );
+
+        for (const card of cards) {
+            if (!card.cardId || !card.sceneDataUrl) continue;
+            console.log(`Decompiling Scene.json for card ${card.cardId}...`);
+
+            const sceneData = await API.downloadSceneData(card.sceneDataUrl);
+            const cardDir = path.join(deckDir, 'cards', card.cardId);
+            fs.mkdirSync(cardDir, { recursive: true });
+
+            fs.writeFileSync(path.join(cardDir, 'card.json'), JSON.stringify(card, null, 2));
+
+            const sceneDir = path.join(cardDir, 'scene');
+            fs.mkdirSync(sceneDir, { recursive: true });
+
+            const sceneObj = typeof sceneData === 'string' ? JSON.parse(sceneData) : sceneData;
+            fs.writeFileSync(path.join(sceneDir, 'scene.json'), JSON.stringify(sceneObj, null, 2));
+
+            const library = sceneObj.snapshot?.library || {};
+            const actors = sceneObj.snapshot?.actors || [];
+            const blueprintsDir = path.join(sceneDir, 'blueprints');
+            fs.mkdirSync(blueprintsDir, { recursive: true });
+
+            const slugMap = {};
+            for (const [uuid, entry] of Object.entries(library)) {
+                if (entry.entryType === 'actorBlueprint') {
+                    const safeName = (entry.title || uuid).replace(/[^a-zA-Z0-9_-]/g, '-').toLowerCase();
+                    slugMap[safeName] = uuid;
+                    fs.writeFileSync(path.join(blueprintsDir, `${safeName}.json`), JSON.stringify(entry, null, 2));
+                }
+            }
+
+            let actorsYaml = "";
+            actors.forEach((actor, index) => {
+                actorsYaml += `a${index}:\n`;
+                if (actor.title) actorsYaml += `  title: "${actor.title}"\n`;
+                if (actor.blueprintId) actorsYaml += `  blueprint: "${actor.blueprintId}"\n`;
+                actorsYaml += `  x: ${actor.x || 0}\n`;
+                actorsYaml += `  y: ${actor.y || 0}\n`;
+            });
+            fs.writeFileSync(path.join(sceneDir, 'actors.yaml'), actorsYaml);
+
+            const castleDir = path.join(sceneDir, '.castle');
+            fs.mkdirSync(castleDir, { recursive: true });
+            fs.writeFileSync(path.join(castleDir, 'slug-map.json'), JSON.stringify(slugMap, null, 2));
+        }
+
+        console.log(`Decompiled deck in ${deckDir}`);
+    } catch (err) {
+        console.error("Error during the decompilation", err);
+    }
+}

package/tool/sd.js

@@ -0,0 +1,175 @@
+import { execSync } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import axios from 'axios';
+
+const npmRoot = execSync('npm root -g').toString().trim();
+const apiPath = path.join(npmRoot, 'castle-cli', 'dist', 'api.js');
+const API = await import(`file://${apiPath}`);
+
+export async function saveDeck(customPath) {
+    if (!customPath) {
+        console.error("Error: Please specify a directory path.");
+        return;
+    }
+
+    const deckDir = path.resolve(customPath);
+    console.log(`Compiling deck from "${deckDir}"...`);
+
+    try {
+        const deckJsonPath = path.join(deckDir, 'deck.json');
+        if (!fs.existsSync(deckJsonPath)) {
+            console.error(`Error: deck.json not found in "${deckDir}"`);
+            return;
+        }
+
+        const deckData = JSON.parse(fs.readFileSync(deckJsonPath, 'utf8'));
+        const cards = deckData.cards || [];
+        if (cards.length === 0) {
+            console.error("Error: Found 0 cards in the deck.");
+            return;
+        }
+
+        const cardData = cards[0];
+        const cardId = cardData.cardId;
+
+        const sceneDir = path.join(deckDir, 'cards', cardId, 'scene');
+        if (!fs.existsSync(sceneDir)) {
+            fs.mkdirSync(sceneDir, { recursive: true });
+        }
+
+        const sceneJsonPath = path.join(sceneDir, 'scene.json');
+
+        // 1. Load scene.json or create default schema
+        let sceneObj;
+        if (fs.existsSync(sceneJsonPath)) {
+            sceneObj = JSON.parse(fs.readFileSync(sceneJsonPath, 'utf8'));
+        } else {
+            console.log("Warning: scene.json not found. Creating default schema...");
+            sceneObj = {
+                snapshot: {
+                    actors: [],
+                    library: {}
+                }
+            };
+        }
+        sceneObj.snapshot = sceneObj.snapshot || {};
+
+        // 2. Compile Blueprints from blueprints/ directory
+        const blueprintsDir = path.join(sceneDir, 'blueprints');
+        const slugMapPath = path.join(sceneDir, '.castle', 'slug-map.json');
+
+        if (fs.existsSync(blueprintsDir)) {
+            sceneObj.snapshot.library = sceneObj.snapshot.library || {};
+            let slugMap = {};
+            if (fs.existsSync(slugMapPath)) {
+                slugMap = JSON.parse(fs.readFileSync(slugMapPath, 'utf8'));
+            }
+
+            const bpFiles = fs.readdirSync(blueprintsDir).filter(f => f.endsWith('.json'));
+            for (const file of bpFiles) {
+                const safeName = path.basename(file, '.json');
+                const bpContent = JSON.parse(fs.readFileSync(path.join(blueprintsDir, file), 'utf8'));
+                const uuid = bpContent.uuid || slugMap[safeName] || safeName;
+                sceneObj.snapshot.library[uuid] = bpContent;
+            }
+            console.log("Successfully compiled blueprints.");
+        }
+
+        // 3. Compile Actors from actors.yaml
+        const actorsYamlPath = path.join(sceneDir, 'actors.yaml');
+        if (fs.existsSync(actorsYamlPath)) {
+            const yamlContent = fs.readFileSync(actorsYamlPath, 'utf8');
+            const actors = [];
+            let currentActor = null;
+
+            const lines = yamlContent.split('\n');
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed || trimmed.startsWith('#')) continue;
+
+                if (line.match(/^a\d+:/)) {
+                    if (currentActor) actors.push(currentActor);
+                    currentActor = {};
+                } else if (currentActor) {
+                    const colonIdx = trimmed.indexOf(':');
+                    if (colonIdx !== -1) {
+                        const key = trimmed.substring(0, colonIdx).trim();
+                        let val = trimmed.substring(colonIdx + 1).trim();
+
+                        if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
+                            val = val.substring(1, val.length - 1);
+                        }
+                        if (!isNaN(val) && val !== '') {
+                            val = Number(val);
+                        } else if (val === 'true') val = true;
+                        else if (val === 'false') val = false;
+
+                        currentActor[key] = val;
+                    }
+                }
+            }
+            if (currentActor) actors.push(currentActor);
+
+            sceneObj.snapshot.actors = actors;
+            console.log("Successfully compiled actors from YAML.");
+        }
+
+        // 4. Save minified scene.json
+        fs.writeFileSync(sceneJsonPath, JSON.stringify(sceneObj));
+        console.log("Updated and minified scene.json.");
+
+        // 5. Generate upload configuration
+        console.log("Generating upload configuration for scene...");
+        const uploadConfigs = await API.createSceneDataUploadConfig([cardId]);
+        const uploadConfig = uploadConfigs[0];
+
+        const sceneContent = fs.readFileSync(sceneJsonPath, 'utf8');
+
+        // 6. Upload scene.json to S3
+        console.log("Uploading scene content to Castle...");
+        const formData = new FormData();
+        for (const [key, value] of Object.entries(uploadConfig.postFields)) {
+            formData.append(key, value);
+        }
+
+        formData.append('Content-Type', 'application/json');
+        formData.append('file', new Blob([sceneContent], { type: 'application/json' }), 'scene.json');
+
+        await axios.post(uploadConfig.postUrl, formData, {
+            maxContentLength: 100_000_000,
+            maxBodyLength: 1_000_000_000,
+        });
+
+        // 7. Submit update via GraphQL API
+        const deckInput = {
+            deckId: deckData.deckId,
+            title: deckData.title ?? "Deck",
+            visibility: deckData.visibility ?? "unlisted",
+            contentFlags: [],
+            initialCardId: cardId,
+            variables: deckData.variables ?? []
+        };
+
+        const cardInput = {
+            cardId: cardId,
+            title: cardData.title ?? "Card",
+            blocks: [],
+            uploadId: uploadConfig.uploadId,
+            makeInitialCard: true
+        };
+
+        const result = await API.updateCardAndDeckV2(deckInput, cardInput);
+
+        console.log("Successfully uploaded deck. Server response:");
+        console.log(JSON.stringify(result, null, 2));
+
+    } catch (err) {
+        console.error("Error while trying to executing save-deck:");
+        if (err.response && err.response.data) {
+            console.error("Details:", JSON.stringify(err.response.data, null, 2));
+        } else {
+            console.error(err.message);
+        }
+    }
+}