castle-web-cli 0.4.1 → 0.4.2

package/dist/api.d.ts

@@ -2,9 +2,33 @@ export declare function startCLILogin(): Promise<{
     pollToken: string;
     url: string;
 }>;
-export declare function pollForCLILogin(pollToken: string): Promise<any>;
-export declare function me(): Promise<any>;
-export declare function myDecks(): Promise<any[]>;
+export interface MeResult {
+    userId: string;
+    username: string;
+    token: string;
+    isAnonymous: boolean;
+}
+export declare function pollForCLILogin(pollToken: string): Promise<MeResult | null>;
+export interface MeProfile {
+    userId: string;
+    username: string;
+    isAnonymous: boolean;
+    photo?: {
+        url?: string;
+    } | null;
+    photoFrame?: {
+        frameUrl?: string;
+    } | null;
+}
+export declare function me(): Promise<MeProfile | null>;
+export interface DeckSummary {
+    deckId: string;
+    title: string;
+    initialCard?: {
+        cardId: string;
+    } | null;
+}
+export declare function myDecks(): Promise<DeckSummary[]>;
 export declare function updateCardAndDeckV2(deck: Record<string, unknown>, card: Record<string, unknown>): Promise<{
     deckId: string;
     cardId: string;
@@ -13,13 +37,37 @@ export declare function createDeck(deck: Record<string, unknown>, card: Record<s
     deckId: string;
     cardId: string;
 }>;
-export declare function createSceneDataUploadConfig(cardIds: string[]): Promise<any[]>;
+export interface SceneDataUploadConfig {
+    cardId: string;
+    uploadId: string;
+    postUrl: string;
+    postFields: Record<string, string>;
+}
+export declare function createSceneDataUploadConfig(cardIds: string[]): Promise<SceneDataUploadConfig[]>;
+export interface UploadedSceneData {
+    cardId: string;
+    sceneDataUrl: string;
+}
 export declare function uploadSceneData(cards: Array<{
     cardId: string;
     uploadId: string;
-}>): Promise<any[]>;
+}>): Promise<UploadedSceneData[]>;
 export declare function uploadBase64(base64: string, filename: string): Promise<{
     fileId: string;
     url: string;
 }>;
 export declare function updateCardCustomBackgroundImage(cardId: string, backgroundImageFileId: string): Promise<void>;
+export interface WebDeckSourceUploadConfig {
+    deckId: string;
+    uploadId: string;
+    postUrl: string;
+    postFields: Record<string, string>;
+}
+export declare function createWebDeckSourceUploadConfig(deckId: string): Promise<WebDeckSourceUploadConfig>;
+export interface WebDeckSource {
+    deckId: string;
+    archiveUrl: string;
+    updatedAt: string;
+}
+export declare function webDeckSource(deckId: string): Promise<WebDeckSource | null>;
+export declare function saveWebDeckSource(deckId: string, uploadId: string): Promise<WebDeckSource>;

package/dist/api.js

@@ -25,10 +25,13 @@ function handleAPIError(data) {
         throw err;
     }
 }
+function pickData(data, key) {
+    return (data.data?.[key] ?? null);
+}
 export async function startCLILogin() {
     const data = await graphql(`mutation { startCLILogin { pollToken url } }`);
     handleAPIError(data);
-    return data.data.startCLILogin;
+    return pickData(data, 'startCLILogin');
 }
 export async function pollForCLILogin(pollToken) {
     const data = await graphql(`query($pollToken: String!) {
@@ -37,12 +40,12 @@ export async function pollForCLILogin(pollToken) {
        }
      }`, { pollToken });
     handleAPIError(data);
-    return data.data?.pollForCLILogin ?? null;
+    return pickData(data, 'pollForCLILogin');
 }
 export async function me() {
     try {
         const data = await graphql(`query { me { userId username isAnonymous photo { url } photoFrame { frameUrl } } }`);
-        return data.data?.me ?? null;
+        return pickData(data, 'me');
     }
     catch {
         return null;
@@ -59,7 +62,8 @@ export async function myDecks() {
     }
   }`);
     handleAPIError(data);
-    return data.data?.me?.decks ?? [];
+    const meData = data.data?.me;
+    return meData?.decks ?? [];
 }
 export async function updateCardAndDeckV2(deck, card) {
     const data = await graphql(`mutation($deck: DeckInput!, $card: CardInput!) {
@@ -69,10 +73,8 @@ export async function updateCardAndDeckV2(deck, card) {
        }
      }`, { deck, card });
     handleAPIError(data);
-    return {
-        deckId: data.data.updateCardAndDeckV2.deck.deckId,
-        cardId: data.data.updateCardAndDeckV2.card.cardId,
-    };
+    const result = data.data?.updateCardAndDeckV2;
+    return { deckId: result.deck.deckId, cardId: result.card.cardId };
 }
 export async function createDeck(deck, card) {
     const data = await graphql(`mutation($deck: DeckInput!, $card: CardInput!) {
@@ -82,10 +84,8 @@ export async function createDeck(deck, card) {
        }
      }`, { deck, card });
     handleAPIError(data);
-    return {
-        deckId: data.data.createDeck.deckId,
-        cardId: data.data.createDeck.initialCard.cardId,
-    };
+    const result = data.data?.createDeck;
+    return { deckId: result.deckId, cardId: result.initialCard.cardId };
 }
 export async function createSceneDataUploadConfig(cardIds) {
     const data = await graphql(`mutation($cardIds: [ID!]!) {
@@ -94,14 +94,14 @@ export async function createSceneDataUploadConfig(cardIds) {
        }
      }`, { cardIds });
     handleAPIError(data);
-    return data.data.createSceneDataUploadConfig;
+    return pickData(data, 'createSceneDataUploadConfig');
 }
 export async function uploadSceneData(cards) {
     const data = await graphql(`mutation($cards: [CardSceneDataInput!]!) {
        uploadSceneData(cards: $cards) { cardId sceneDataUrl }
      }`, { cards });
     handleAPIError(data);
-    return data.data.uploadSceneData;
+    return pickData(data, 'uploadSceneData');
 }
 export async function uploadBase64(base64, filename) {
     const data = await graphql(`mutation($data: String!, $filename: String, $mimetype: String) {
@@ -110,7 +110,7 @@ export async function uploadBase64(base64, filename) {
        }
      }`, { data: base64, filename, mimetype: 'image/png' });
     handleAPIError(data);
-    return data.data.uploadBase64;
+    return pickData(data, 'uploadBase64');
 }
 export async function updateCardCustomBackgroundImage(cardId, backgroundImageFileId) {
     const data = await graphql(`mutation($cardId: ID!, $backgroundImageFileId: ID) {
@@ -118,3 +118,30 @@ export async function updateCardCustomBackgroundImage(cardId, backgroundImageFil
      }`, { cardId, backgroundImageFileId });
     handleAPIError(data);
 }
+export async function createWebDeckSourceUploadConfig(deckId) {
+    const data = await graphql(`mutation($deckId: ID!) {
+       createWebDeckSourceUploadConfig(deckId: $deckId) {
+         deckId uploadId postUrl postFields
+       }
+     }`, { deckId });
+    handleAPIError(data);
+    return pickData(data, 'createWebDeckSourceUploadConfig');
+}
+export async function webDeckSource(deckId) {
+    const data = await graphql(`query($deckId: ID!) {
+       webDeckSource(deckId: $deckId) {
+         deckId archiveUrl updatedAt
+       }
+     }`, { deckId });
+    handleAPIError(data);
+    return pickData(data, 'webDeckSource');
+}
+export async function saveWebDeckSource(deckId, uploadId) {
+    const data = await graphql(`mutation($deckId: ID!, $uploadId: ID!) {
+       saveWebDeckSource(deckId: $deckId, uploadId: $uploadId) {
+         deckId archiveUrl updatedAt
+       }
+     }`, { deckId, uploadId });
+    handleAPIError(data);
+    return pickData(data, 'saveWebDeckSource');
+}

package/dist/config.d.ts

@@ -1,2 +1,4 @@
 export declare function getToken(): string | null;
+export declare function getUserId(): string | null;
 export declare function setToken(token: string | null): void;
+export declare function setAuth(token: string, userId: string): void;

package/dist/config.js

@@ -12,23 +12,37 @@ function readConfigFile(filename) {
             return JSON.parse(fs.readFileSync(configFilePath, 'utf-8'));
         }
     }
-    catch { }
+    catch {
+        // missing / unreadable / malformed config is treated as no config
+    }
     return null;
 }
-export function getToken() {
-    const config = readConfigFile('config.json');
-    return config ? config.token : null;
-}
-export function setToken(token) {
+function writeConfig(updates) {
     const configDir = getConfigDir();
     fs.mkdirSync(configDir, { recursive: true });
     const existing = readConfigFile('config.json') ?? {};
-    if (token === null) {
-        delete existing.token;
-    }
-    else {
-        existing.token = token;
+    for (const [k, v] of Object.entries(updates)) {
+        if (v === null) {
+            delete existing[k];
+        }
+        else {
+            existing[k] = v;
+        }
     }
     const configFilePath = path.join(configDir, 'config.json');
     fs.writeFileSync(configFilePath, JSON.stringify(existing, null, 2), 'utf-8');
 }
+export function getToken() {
+    const c = readConfigFile('config.json');
+    return c && typeof c.token === 'string' ? c.token : null;
+}
+export function getUserId() {
+    const c = readConfigFile('config.json');
+    return c && typeof c.userId === 'string' ? c.userId : null;
+}
+export function setToken(token) {
+    writeConfig({ token });
+}
+export function setAuth(token, userId) {
+    writeConfig({ token, userId });
+}

package/dist/get-deck.d.ts

@@ -0,0 +1,3 @@
+export declare function getDeck(dir: string, options?: {
+    deckId?: string;
+}): Promise<void>;

package/dist/get-deck.js

@@ -0,0 +1,64 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { spawn } from 'child_process';
+import { nanoid } from 'nanoid';
+import * as api from './api.js';
+function readCastleJson(dir) {
+    const p = path.join(dir, 'castle.json');
+    if (!fs.existsSync(p))
+        return null;
+    return JSON.parse(fs.readFileSync(p, 'utf-8'));
+}
+function extractTarball(archivePath, targetDir) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('tar', ['-xzf', archivePath, '-C', targetDir], {
+            stdio: ['ignore', 'inherit', 'pipe'],
+        });
+        let stderr = '';
+        child.stderr?.on('data', (chunk) => { stderr += chunk.toString(); });
+        child.on('error', reject);
+        child.on('close', (code) => {
+            if (code !== 0) {
+                reject(new Error(`tar exited with code ${code}: ${stderr}`));
+                return;
+            }
+            resolve();
+        });
+    });
+}
+export async function getDeck(dir, options = {}) {
+    const targetDir = path.resolve(dir);
+    const existing = readCastleJson(targetDir);
+    const deckId = options.deckId ?? existing?.deckId;
+    if (!deckId) {
+        console.error(`No deckId. Either pass --deck-id <id> or run from a directory whose castle.json has one.`);
+        process.exit(1);
+    }
+    const source = await api.webDeckSource(deckId);
+    if (!source) {
+        console.error(`No source archive on server for deck ${deckId}. Run \`castle-web save-deck\` first.`);
+        process.exit(1);
+    }
+    console.log(`Fetching ${source.archiveUrl}`);
+    const res = await fetch(source.archiveUrl, { signal: AbortSignal.timeout(60000) });
+    if (!res.ok) {
+        throw new Error(`Archive fetch failed: HTTP ${res.status}`);
+    }
+    const buf = Buffer.from(await res.arrayBuffer());
+    const sizeKB = buf.length / 1024;
+    console.log(`Archive: ${sizeKB.toFixed(1)}KB (updated ${source.updatedAt})`);
+    fs.mkdirSync(targetDir, { recursive: true });
+    const tmpFile = path.join(os.tmpdir(), `castle-get-${nanoid(8)}.tar.gz`);
+    fs.writeFileSync(tmpFile, buf);
+    try {
+        await extractTarball(tmpFile, targetDir);
+    }
+    finally {
+        try {
+            fs.unlinkSync(tmpFile);
+        }
+        catch { /* nothing to clean */ }
+    }
+    console.log(`Extracted to ${targetDir}`);
+}

package/dist/ide-client.d.ts

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