castle-cli-reboot 1.0.3 → 1.0.4

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "castle-cli-reboot",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "type": "module",
   "bin": {
     "ct": "./tool/castle-terminal.js"
   },
   "dependencies": {
+    "axios": "^1.20.0",
     "castle-cli": "^2.0.6",
+    "form-data": "^4.0.0",
     "http-server": "^14.1.1"
   }
 }
-

package/tool/castle-terminal.js

@@ -2,6 +2,7 @@
 import readline from 'readline';
 import { getDeck } from './gd.js';
 import { saveDeck } from './sd.js';
+import { uploadAudio } from './ua.js';
 
 const rl = readline.createInterface({
     input: process.stdin,
@@ -11,10 +12,11 @@ const rl = readline.createInterface({
 
 console.clear();
 console.log("======================================================");
-console.log("               Castle Custom Terminal                 ");
+console.log("               CASTLE COMMAND LINE INTERFACE REBOOT                 ");
 console.log("Available Commands:                                   ");
 console.log("  gd <id> [folder] - Extracts deck using its ID       ");
 console.log("  sd [folder]      - Saves the local deck             ");
+console.log("  ua <file>        - Uploads audio asset to Castle    ");
 console.log("  exit             - Exits Castle custom terminal     ");
 console.log("======================================================");
 
@@ -28,11 +30,13 @@ rl.on('line', async (line) => {
         return;
     }
 
-    // Handle space-separated command aliases like "get deck" or "save deck"
+    // Handle space-separated command aliases
     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');
+    } else if (/^upload\s+audio\b/i.test(input)) {
+        input = input.replace(/^upload\s+audio\b/i, 'ua');
     }
 
     const parts = input.split(/\s+/);
@@ -56,6 +60,14 @@ rl.on('line', async (line) => {
             await saveDeck(customPath);
             break;
         }
+        case 'ua':
+        case 'upload-audio':
+        case 'uploadaudio':
+        case 'upload': {
+            const filePath = parts[1];
+            await uploadAudio(filePath);
+            break;
+        }
         case 'exit':
         case 'quit':
             console.log("Exiting Terminal...");

package/tool/ua.js

@@ -0,0 +1,157 @@
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import { execSync } from 'child_process';
+import axios from 'axios';
+import FormData from 'form-data';
+
+function getToken() {
+    try {
+        const configPath = path.join(os.homedir(), '.castle', 'config.json');
+        if (fs.existsSync(configPath)) {
+            return JSON.parse(fs.readFileSync(configPath, 'utf8')).token;
+        }
+    } catch (e) {}
+    return null;
+}
+
+function getAudioDuration(filePath) {
+    try {
+        const cmd = `ffprobe -v error -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 "${filePath}"`;
+        const durationStr = execSync(cmd).toString().trim();
+        return parseFloat(durationStr);
+    } catch (err) {
+        console.error("Error checking audio duration with ffprobe. Ensure ffmpeg/ffprobe is installed.");
+        return 0;
+    }
+}
+
+function extractUrlId(url) {
+    if (!url) return '';
+    const filename = url.split('/').pop() || '';
+    return filename.replace(/\.[^/.]+$/, '');
+}
+
+async function uploadSingleFile(filePath) {
+    const filename = path.basename(filePath);
+    const token = getToken();
+
+    const form = new FormData();
+    const operations = {
+        query: `
+            mutation uploadAudioFile($file: Upload!) {
+                uploadAudioFile(file: $file) {
+                    fileId
+                    url
+                }
+            }
+        `,
+        variables: { file: null }
+    };
+
+    form.append('operations', JSON.stringify(operations));
+    form.append('map', JSON.stringify({ "0": ["variables.file"] }));
+    form.append('0', fs.createReadStream(filePath), filename);
+
+    const headers = {
+        ...form.getHeaders(),
+        'X-OS': 'cli',
+        'X-CLI-API-Version': '4',
+        'Accept': 'application/json',
+    };
+
+    if (token) {
+        headers['X-Auth-Token'] = token;
+    }
+
+    const response = await axios.post('https://api.castle.xyz/graphql', form, { headers });
+
+    if (response.data.errors) {
+        throw new Error(response.data.errors[0].message);
+    }
+
+    const result = response.data?.data?.uploadAudioFile;
+    if (result && result.url) {
+        result.urlId = extractUrlId(result.url);
+    }
+
+    return result;
+}
+
+export async function uploadAudio(filePath) {
+    if (!filePath) {
+        console.log("Usage: ua <filePath>");
+        return;
+    }
+
+    const fullPath = path.resolve(filePath);
+    if (!fs.existsSync(fullPath)) {
+        console.log(`Error: File not found at ${fullPath}`);
+        return;
+    }
+
+    const duration = getAudioDuration(fullPath);
+    const ext = path.extname(fullPath);
+    const baseName = path.basename(fullPath, ext);
+    const dir = path.dirname(fullPath);
+
+    console.log(`Audio Duration: ${duration.toFixed(2)}s`);
+
+    const results = [];
+
+    if (duration <= 30) {
+        console.log(`Uploading ${path.basename(fullPath)}...`);
+        try {
+            const res = await uploadSingleFile(fullPath);
+            console.log(`\nSuccess! Single Audio Uploaded:`);
+            console.log(`File ID: ${res.fileId}`);
+            console.log(`URL ID:  ${res.urlId}`);
+            console.log(`URL:     ${res.url}\n`);
+            return [res];
+        } catch (err) {
+            console.error("Upload error:", err.message);
+            return;
+        }
+    }
+
+    const chunkDuration = 30;
+    const totalChunks = Math.ceil(duration / chunkDuration);
+
+    console.log(`Audio exceeds 30s. Splitting into ${totalChunks} parts...`);
+
+    for (let i = 0; i < totalChunks; i++) {
+        const startTime = i * chunkDuration;
+        const chunkFileName = `${baseName}_part${i + 1}${ext}`;
+        const chunkPath = path.join(dir, `_temp_${chunkFileName}`);
+
+        console.log(`\n[Part ${i + 1}/${totalChunks}] Cutting ${startTime}s to ${startTime + chunkDuration}s...`);
+
+        const cutCmd = `ffmpeg -y -ss ${startTime} -t ${chunkDuration} -i "${fullPath}" -c copy "${chunkPath}" -loglevel error`;
+        execSync(cutCmd);
+
+        try {
+            console.log(`Uploading ${chunkFileName}...`);
+            const res = await uploadSingleFile(chunkPath);
+            console.log(`Part ${i + 1} Uploaded -> File ID: ${res.fileId} | URL ID: ${res.urlId} | URL: ${res.url}`);
+            results.push({ part: i + 1, ...res });
+        } catch (err) {
+            console.error(`Failed to upload part ${i + 1}:`, err.message);
+        } finally {
+            if (fs.existsSync(chunkPath)) {
+                fs.unlinkSync(chunkPath);
+            }
+        }
+    }
+
+    console.log(`\n=== All Audio Parts Uploaded ===`);
+    console.table(results);
+    return results;
+}
+
+if (process.argv[1] && process.argv[1].endsWith('ua.js')) {
+    const fileArg = process.argv[2];
+    if (fileArg) {
+        uploadAudio(fileArg);
+    }
+}
+

package/gd.js

@@ -1,135 +0,0 @@
-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);
-    }
-}