castle-web-cli 0.4.0 → 0.4.2

package/dist/index.js

@@ -1,53 +1,101 @@
 #!/usr/bin/env node
 import * as fs from 'fs';
+import * as path from 'path';
 import { login } from './login.js';
 import { serve } from './serve.js';
-import { push } from './push.js';
+import { saveDeck } from './save-deck.js';
+import { getDeck } from './get-deck.js';
 import { init } from './init.js';
-import { savePreviewImage, savePreviewIfNeeded } from './preview.js';
+import { connectWS, savePreviewImage, savePreviewIfNeeded, takeScreenshot } from './preview.js';
 const args = process.argv.slice(2);
 const command = args[0];
+const FLAGS_WITH_VALUES = new Set(['--port', '--out', '--host', '--kit', '--deck-id']);
+function findPositionalDir() {
+    for (let i = 1; i < args.length; i++) {
+        if (args[i].startsWith('--')) {
+            if (FLAGS_WITH_VALUES.has(args[i]))
+                i++;
+            continue;
+        }
+        return args[i];
+    }
+    return '.';
+}
+function getFlagValue(flag) {
+    const idx = args.indexOf(flag);
+    return idx >= 0 ? args[idx + 1] : undefined;
+}
+function readServeWsPort(dir) {
+    try {
+        const serveJson = JSON.parse(fs.readFileSync(path.join(path.resolve(dir), '.castle', 'serve.json'), 'utf-8'));
+        return serveJson.wsPort;
+    }
+    catch {
+        return undefined;
+    }
+}
+function getWsPort(dir) {
+    const explicit = getFlagValue('--port');
+    if (explicit)
+        return parseInt(explicit, 10);
+    const fromServe = readServeWsPort(dir);
+    if (fromServe)
+        return fromServe;
+    return 3738;
+}
 function usage() {
     console.log(`Usage:
-  castle-web init <dir>
-  castle-web serve [dir] [--port PORT] [--open]
+  castle-web init <dir> [--kit NAME]   (kits: basic-2d (default), rpg-2d, none)
+  castle-web serve [dir] [--port PORT] [--host HOST] [--open] [--detach]
   castle-web restart [--port PORT]
   castle-web screenshot [--out FILE] [--port PORT]
-  castle-web save-preview-image [dir] [--port PORT]
-  castle-web push [dir]
+  castle-web save-preview-image [dir] [--port PORT] [--no-restart]
+  castle-web save-deck [dir]
+  castle-web get-deck <dir> [--deck-id ID]
   castle-web login`);
     process.exit(1);
 }
 async function main() {
     switch (command) {
         case 'init': {
-            const dir = args[1];
-            if (!dir) {
-                console.error('Usage: castle-web init <dir>');
+            const dir = findPositionalDir();
+            if (dir === '.') {
+                console.error('Usage: castle-web init <dir> [--kit NAME]');
                 process.exit(1);
             }
-            init(dir);
+            const kit = getFlagValue('--kit');
+            init(dir, { kit });
             break;
         }
         case 'serve': {
-            const dir = args.find((a, i) => i > 0 && !a.startsWith('--')) ?? '.';
-            const portIdx = args.indexOf('--port');
-            const port = portIdx >= 0 ? args[portIdx + 1] : undefined;
+            const dir = findPositionalDir();
+            const port = getFlagValue('--port');
+            const host = getFlagValue('--host');
             const open = args.includes('--open');
-            await serve(dir, { port, open });
+            const detach = args.includes('--detach');
+            await serve(dir, { port, host, open, detach });
             break;
         }
-        case 'push': {
-            const dir = args.find((a, i) => i > 0 && !a.startsWith('--')) ?? '.';
-            const portIdx = args.indexOf('--port');
-            const wsPort = parseInt(portIdx >= 0 ? args[portIdx + 1] : '3738', 10);
-            await push(dir);
+        case 'save-deck': {
+            const dir = findPositionalDir();
+            await saveDeck(dir);
+            const wsPort = getWsPort(dir);
             await savePreviewIfNeeded(dir, wsPort);
             break;
         }
+        case 'get-deck': {
+            const dir = findPositionalDir();
+            if (dir === '.') {
+                console.error('Usage: castle-web get-deck <dir> [--deck-id ID]');
+                process.exit(1);
+            }
+            const deckId = getFlagValue('--deck-id');
+            await getDeck(dir, { deckId });
+            break;
+        }
         case 'restart': {
-            const portIdx = args.indexOf('--port');
-            const wsPort = parseInt(portIdx >= 0 ? args[portIdx + 1] : '3738', 10);
+            const dir = findPositionalDir();
+            const wsPort = getWsPort(dir);
             const { default: WS } = await import('ws');
             const ws = new WS(`ws://localhost:${wsPort}`);
             ws.on('open', () => {
@@ -58,43 +106,22 @@ async function main() {
             break;
         }
         case 'screenshot': {
-            const outIdx = args.indexOf('--out');
-            const outFile = outIdx >= 0 ? args[outIdx + 1] : 'screenshot.png';
-            const portIdx = args.indexOf('--port');
-            const wsPort = parseInt(portIdx >= 0 ? args[portIdx + 1] : '3738', 10);
-            const requestId = Math.random().toString(36).slice(2);
-            const { default: WS } = await import('ws');
-            const ws = new WS(`ws://localhost:${wsPort}`);
-            ws.on('open', () => {
-                ws.send(JSON.stringify({ type: 'screenshot_request', requestId }));
-            });
-            const timeout = setTimeout(() => {
-                console.error('Screenshot timed out. Is castle-web serve running?');
-                ws.close();
-                process.exit(1);
-            }, 3000);
-            ws.on('message', (raw) => {
-                try {
-                    const msg = JSON.parse(raw.toString());
-                    if (msg.type === 'screenshot_response' && msg.requestId === requestId) {
-                        clearTimeout(timeout);
-                        const base64 = msg.data.replace(/^data:image\/png;base64,/, '');
-                        fs.writeFileSync(outFile, Buffer.from(base64, 'base64'));
-                        console.log(`Saved ${outFile}`);
-                        ws.close();
-                        process.exit(0);
-                    }
-                }
-                catch { }
-            });
-            break;
+            const dir = findPositionalDir();
+            const outFile = getFlagValue('--out') ?? 'screenshot.png';
+            const wsPort = getWsPort(dir);
+            const ws = await connectWS(wsPort);
+            const base64 = await takeScreenshot(ws);
+            ws.close();
+            fs.writeFileSync(outFile, Buffer.from(base64, 'base64'));
+            console.log(`Saved ${outFile}`);
+            return;
         }
         case 'save-preview-image': {
-            const dir = args.find((a, i) => i > 0 && !a.startsWith('--')) ?? '.';
-            const portIdx = args.indexOf('--port');
-            const wsPort = parseInt(portIdx >= 0 ? args[portIdx + 1] : '3738', 10);
-            await savePreviewImage(dir, wsPort);
-            process.exit(0);
+            const dir = findPositionalDir();
+            const wsPort = getWsPort(dir);
+            const noRestart = args.includes('--no-restart');
+            await savePreviewImage(dir, wsPort, noRestart);
+            return;
         }
         case 'login':
             await login();
@@ -104,6 +131,6 @@ async function main() {
     }
 }
 main().catch((e) => {
-    console.error(e.message ?? e);
+    console.error(e instanceof Error ? e.message : String(e));
     process.exit(1);
 });

package/dist/init.d.ts

@@ -1 +1,3 @@
-export declare function init(dir: string): Promise<void>;
+export declare function init(dir: string, opts?: {
+    kit?: string;
+}): void;

package/dist/init.js

@@ -1,5 +1,6 @@
 import * as fs from 'fs';
 import * as path from 'path';
+import { getCliEntryPath, getKitsDir, getRepoRoot, getSdkPackagePath, toPosixPath } from './localPaths.js';
 const INDEX_HTML = `<!DOCTYPE html>
 <html>
 <head>
@@ -25,38 +26,183 @@ el.style.cssText = \`
 el.textContent = 'Hello Castle!';
 card.appendChild(el);
 `;
-const CLAUDE_MD = `@node_modules/castle-web-cli/AGENTS.md
-@node_modules/castle-web-sdk/AGENTS.md
-`;
-export async function init(dir) {
-    const projectDir = path.resolve(dir);
-    if (fs.existsSync(projectDir) && fs.readdirSync(projectDir).length > 0) {
-        console.error(`Directory "${dir}" is not empty.`);
-        process.exit(1);
+// Default kit copied by `init` when no --kit is given. `none`/`bare` skip the
+// kit and produce the minimal index.html + game.js stub above.
+const DEFAULT_KIT = 'basic-2d';
+// Registry version of castle-web-sdk to inject when scaffolding from a
+// globally-installed castle-web (not from inside the workspace). Bumped
+// alongside cli/sdk version bumps.
+const PUBLISHED_SDK_VERSION = '0.4.2';
+// Never copied into a fresh deck: build/dependency junk, and castle.json (a
+// fresh deck has no deckId until its first save-deck).
+const KIT_COPY_EXCLUDE = new Set(['node_modules', '.castle', 'dist', '.git', 'castle.json']);
+function relativeFromProject(projectDir, target) {
+    return toPosixPath(path.relative(projectDir, target));
+}
+function makeClaudeMd() {
+    // Inline the upstream CLAUDE.md content. An @-import works inside the
+    // castle-experimental-web checkout, but breaks when the scaffold lives
+    // outside the repo (the relative path no longer resolves).
+    const repoRoot = getRepoRoot();
+    const upstream = path.join(repoRoot, 'CLAUDE.md');
+    try {
+        return fs.readFileSync(upstream, 'utf8').trimEnd() + '\n';
     }
-    fs.mkdirSync(projectDir, { recursive: true });
-    fs.writeFileSync(path.join(projectDir, 'index.html'), INDEX_HTML);
-    fs.writeFileSync(path.join(projectDir, 'game.js'), GAME_JS);
-    fs.writeFileSync(path.join(projectDir, 'CLAUDE.md'), CLAUDE_MD);
-    const packageJson = {
+    catch {
+        return `# Castle Experimental Web\n\nSee https://github.com/castle-xyz/castle-experimental-web for the agent guide.\n`;
+    }
+}
+function tryMakeAgentsSymlink(agentsPath) {
+    try {
+        fs.symlinkSync('CLAUDE.md', agentsPath);
+    }
+    catch {
+        // symlink already exists / unsupported FS — non-fatal
+    }
+}
+function makePackageJson(projectDir) {
+    const cliEntry = relativeFromProject(projectDir, getCliEntryPath());
+    const sdkPackage = relativeFromProject(projectDir, getSdkPackagePath());
+    return {
         name: path.basename(projectDir),
         private: true,
         type: 'module',
-        dependencies: {
-            'castle-web-sdk': '*',
+        scripts: {
+            serve: `node ${cliEntry} serve . --open`,
+            restart: `node ${cliEntry} restart .`,
+            screenshot: `node ${cliEntry} screenshot .`,
+            'save-deck': `node ${cliEntry} save-deck .`,
         },
-        devDependencies: {
-            'castle-web-cli': '*',
+        dependencies: {
+            'castle-web-sdk': `file:${sdkPackage}`,
         },
     };
-    fs.writeFileSync(path.join(projectDir, 'package.json'), JSON.stringify(packageJson, null, 2) + '\n');
-    const { execSync } = await import('child_process');
-    execSync('npm install', { cwd: projectDir, stdio: 'inherit' });
-    console.log(`Created project in ${projectDir}/`);
+}
+// Some coding agents read AGENTS.md by convention. Symlink so they get the
+// same guidance without a duplicate copy.
+function ensureAgentsSymlink(projectDir) {
+    const agentsPath = path.join(projectDir, 'AGENTS.md');
+    if (fs.lstatSync(agentsPath, { throwIfNoEntry: false }))
+        return;
+    // Don't create a dangling link — only symlink when CLAUDE.md is present.
+    if (!fs.existsSync(path.join(projectDir, 'CLAUDE.md')))
+        return;
+    tryMakeAgentsSymlink(agentsPath);
+}
+// Bare scaffold: a plain code-only deck with no kit framework.
+function scaffoldBare(projectDir) {
+    fs.mkdirSync(projectDir, { recursive: true });
+    fs.writeFileSync(path.join(projectDir, 'index.html'), INDEX_HTML);
+    fs.writeFileSync(path.join(projectDir, 'game.js'), GAME_JS);
+    fs.writeFileSync(path.join(projectDir, 'CLAUDE.md'), makeClaudeMd());
+    ensureAgentsSymlink(projectDir);
+    fs.writeFileSync(path.join(projectDir, 'package.json'), JSON.stringify(makePackageJson(projectDir), null, 2) + '\n');
+}
+// Copy a framework kit from kits/<kit>/ into the new deck dir, dropping
+// build/dependency junk and castle.json.
+function scaffoldFromKit(kit, projectDir) {
+    const kitDir = path.join(getKitsDir(), kit);
+    if (!fs.existsSync(kitDir) || !fs.statSync(kitDir).isDirectory()) {
+        console.error(`Kit "${kit}" not found at ${kitDir}.`);
+        console.error('Available kits:');
+        try {
+            const kits = fs
+                .readdirSync(getKitsDir())
+                .filter((name) => fs.statSync(path.join(getKitsDir(), name)).isDirectory());
+            if (kits.length)
+                for (const name of kits)
+                    console.error(`  ${name}`);
+            else
+                console.error('  (none)');
+        }
+        catch {
+            console.error('  (none — kits/ directory is missing)');
+        }
+        console.error('Or use `--kit none` for a bare code-only deck.');
+        process.exit(1);
+    }
+    fs.cpSync(kitDir, projectDir, {
+        recursive: true,
+        // Keep symlinks verbatim so the kit's AGENTS.md -> CLAUDE.md stays a link.
+        verbatimSymlinks: true,
+        filter: (src) => src === kitDir || !KIT_COPY_EXCLUDE.has(path.basename(src)),
+    });
+    // The kit's package.json carries the kit's name; rename it to the deck dir.
+    // Kit-relative refs to `../../sdk` and `../../cli/dist` only resolve when the
+    // deck lives at castle-experimental-web/decks/<name>/. Rewrite both to
+    // absolute paths so the scaffolded deck works anywhere -- including under
+    // /tmp where macOS's /tmp -> /private/tmp symlink breaks relative-path math.
+    const pkgPath = path.join(projectDir, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+            pkg.name = path.basename(projectDir);
+            // Local-dev paths (`file:../../sdk` / `node ../../cli/dist/index.js`) only
+            // work when the deck lives inside the castle-experimental-web workspace.
+            // For a deck scaffolded from a globally-installed castle-web, rewrite to
+            // the published packages instead.
+            const sdkPath = getSdkPackagePath();
+            const cliEntry = getCliEntryPath();
+            const sdkIsLocal = fs.existsSync(sdkPath);
+            const cliIsLocal = fs.existsSync(cliEntry);
+            const sdkRef = sdkIsLocal ? `file:${toPosixPath(sdkPath)}` : `^${PUBLISHED_SDK_VERSION}`;
+            const cliDistAbs = cliIsLocal ? toPosixPath(path.dirname(cliEntry)) : null;
+            if (pkg.dependencies &&
+                typeof pkg.dependencies['castle-web-sdk'] === 'string' &&
+                pkg.dependencies['castle-web-sdk'].startsWith('file:')) {
+                pkg.dependencies['castle-web-sdk'] = sdkRef;
+            }
+            if (pkg.scripts) {
+                for (const k of Object.keys(pkg.scripts)) {
+                    if (typeof pkg.scripts[k] !== 'string')
+                        continue;
+                    if (cliDistAbs) {
+                        pkg.scripts[k] = pkg.scripts[k]
+                            .replace(/\.\.\/\.\.\/cli\/dist/g, cliDistAbs)
+                            .replace(/\.\.\/\.\.\/sdk/g, sdkIsLocal ? toPosixPath(sdkPath) : '');
+                    }
+                    else {
+                        // Globally-installed: route through the `castle-web` binary on PATH.
+                        pkg.scripts[k] = pkg.scripts[k]
+                            .replace(/node\s+\.\.\/\.\.\/cli\/dist\/index\.js/g, 'castle-web')
+                            .replace(/await import\((['"])\.\.\/\.\.\/cli\/dist\/bundle\.js\1\)/g, "await import('castle-web-cli/dist/bundle.js')")
+                            .replace(/\.\.\/\.\.\/sdk/g, '');
+                    }
+                }
+            }
+            fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+        }
+        catch {
+            // kit shipped an unparseable package.json — leave it for the user to fix
+        }
+    }
+    // Every deck needs a CLAUDE.md so coding agents know how castle-web works.
+    // Keep the kit's own if it ships one; otherwise generate from the upstream.
+    const claudePath = path.join(projectDir, 'CLAUDE.md');
+    if (!fs.existsSync(claudePath)) {
+        fs.writeFileSync(claudePath, makeClaudeMd());
+    }
+    ensureAgentsSymlink(projectDir);
+}
+export function init(dir, opts = {}) {
+    const projectDir = path.resolve(dir);
+    if (fs.existsSync(projectDir) && fs.readdirSync(projectDir).length > 0) {
+        console.error(`Directory "${dir}" is not empty.`);
+        process.exit(1);
+    }
+    const kit = opts.kit ?? DEFAULT_KIT;
+    const bare = kit === 'none' || kit === 'bare';
+    if (bare) {
+        scaffoldBare(projectDir);
+    }
+    else {
+        scaffoldFromKit(kit, projectDir);
+    }
+    console.log(`Created project in ${projectDir}/${bare ? '' : ` (from kit "${kit}")`}`);
     console.log('');
     console.log('Next steps:');
     console.log(`  cd ${dir}`);
-    console.log('  npx castle-web-cli serve --open');
-    console.log('  npx castle-web-cli login');
-    console.log('  npx castle-web-cli push');
+    console.log('  npm install');
+    console.log('  npm run serve');
+    console.log('  npm run save-deck');
 }

package/dist/localPaths.d.ts

@@ -0,0 +1,6 @@
+export declare function getPackageRoot(): string;
+export declare function getRepoRoot(): string;
+export declare function getCliEntryPath(): string;
+export declare function getSdkPackagePath(): string;
+export declare function getKitsDir(): string;
+export declare function toPosixPath(filepath: string): string;

package/dist/localPaths.js

@@ -0,0 +1,33 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+// Root of the castle-web-cli package itself (one up from dist/), regardless of
+// whether we're running from a workspace checkout or a globally-installed npm
+// package.
+export function getPackageRoot() {
+    return path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+}
+// Kept for backward compat: the "repo root" only makes sense in workspace
+// dev mode. Two levels up from dist/, i.e. one above the cli package.
+export function getRepoRoot() {
+    return path.resolve(getPackageRoot(), '..');
+}
+export function getCliEntryPath() {
+    return path.join(getPackageRoot(), 'dist', 'index.js');
+}
+// Workspace-only: kits live alongside cli/ in the repo. When castle-web is
+// installed globally we bundle kits inside the package itself (see below).
+export function getSdkPackagePath() {
+    return path.join(getRepoRoot(), 'sdk');
+}
+export function getKitsDir() {
+    // Prefer bundled kits (shipped inside the published cli package);
+    // fall back to the workspace `kits/` alongside cli/.
+    const bundled = path.join(getPackageRoot(), 'kits');
+    if (fs.existsSync(bundled))
+        return bundled;
+    return path.join(getRepoRoot(), 'kits');
+}
+export function toPosixPath(filepath) {
+    return filepath.split(path.sep).join('/');
+}

package/dist/login.js

@@ -11,7 +11,7 @@ export async function login() {
         await new Promise((r) => setTimeout(r, 1000));
         const user = await api.pollForCLILogin(pollToken);
         if (user) {
-            config.setToken(user.token);
+            config.setAuth(user.token, user.userId);
             console.log(`Logged in as @${user.username}`);
             return;
         }

package/dist/preview.d.ts

@@ -1,2 +1,5 @@
-export declare function savePreviewImage(dir: string, wsPort: number): Promise<void>;
+import type { WebSocket as WSClient } from 'ws';
+export declare function connectWS(wsPort: number): Promise<WSClient>;
+export declare function takeScreenshot(ws: WSClient): Promise<string>;
+export declare function savePreviewImage(dir: string, wsPort: number, noRestart?: boolean): Promise<void>;
 export declare function savePreviewIfNeeded(dir: string, wsPort: number): Promise<void>;

package/dist/preview.js

@@ -2,54 +2,62 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as api from './api.js';
 import * as config from './config.js';
-function connectWS(wsPort) {
-    return new Promise(async (resolve, reject) => {
-        const { default: WS } = await import('ws');
+export async function connectWS(wsPort) {
+    const { default: WS } = await import('ws');
+    return new Promise((resolve, reject) => {
         const ws = new WS(`ws://localhost:${wsPort}`);
         ws.on('error', () => reject(new Error('Could not connect. Is castle-web serve running?')));
         ws.on('open', () => resolve(ws));
     });
 }
-function takeScreenshot(ws) {
+export function takeScreenshot(ws) {
     return new Promise((resolve, reject) => {
         const requestId = Math.random().toString(36).slice(2);
+        const cleanup = () => {
+            clearTimeout(timeout);
+            ws.off('message', onMessage);
+        };
+        const fail = (error) => {
+            cleanup();
+            reject(error);
+        };
         const timeout = setTimeout(() => {
-            reject(new Error('Screenshot timed out.'));
-        }, 5000);
-        ws.on('message', (raw) => {
+            fail(new Error('Screenshot timed out. The deck must be open in a browser tab to capture a screenshot. Start `castle-web serve --open` or open the served URL in a browser.'));
+        }, 10000);
+        const onMessage = (raw) => {
             try {
                 const msg = JSON.parse(raw.toString());
-                if (msg.type === 'screenshot_response' && msg.requestId === requestId) {
-                    clearTimeout(timeout);
+                if (msg.type !== 'screenshot_response' || msg.requestId !== requestId)
+                    return;
+                if (typeof msg.data === 'string') {
+                    cleanup();
                     resolve(msg.data.replace(/^data:image\/png;base64,/, ''));
                 }
+                else if (msg.ok === false) {
+                    fail(new Error(msg.error || 'Could not capture screenshot.'));
+                }
+            }
+            catch {
+                // ignore malformed frames
             }
-            catch { }
-        });
+        };
+        ws.on('message', onMessage);
         ws.send(JSON.stringify({ type: 'screenshot_request', requestId }));
     });
 }
 function waitForRestart(ws) {
     return new Promise((resolve) => {
-        // restart, wait a moment for the deck to render its first frame
         ws.send(JSON.stringify({ type: 'restart' }));
-        setTimeout(resolve, 500);
+        setTimeout(resolve, 2000);
     });
 }
-export async function savePreviewImage(dir, wsPort) {
-    const projectDir = path.resolve(dir);
+function readCastleJson(projectDir) {
     const castleJsonPath = path.join(projectDir, 'castle.json');
-    if (!fs.existsSync(castleJsonPath)) {
-        console.error('No castle.json found. Push the deck first.');
-        process.exit(1);
-    }
-    const castleJson = JSON.parse(fs.readFileSync(castleJsonPath, 'utf-8'));
-    if (!config.getToken()) {
-        console.error('Not logged in. Run `castle-web login` first.');
-        process.exit(1);
-    }
-    const ws = await connectWS(wsPort);
-    await waitForRestart(ws);
+    if (!fs.existsSync(castleJsonPath))
+        return null;
+    return JSON.parse(fs.readFileSync(castleJsonPath, 'utf-8'));
+}
+async function captureAndUpload(projectDir, ws, castleJson) {
     const base64 = await takeScreenshot(ws);
     ws.close();
     fs.writeFileSync(path.join(projectDir, 'preview.png'), Buffer.from(base64, 'base64'));
@@ -58,27 +66,41 @@ export async function savePreviewImage(dir, wsPort) {
     await api.updateCardCustomBackgroundImage(castleJson.cardId, file.fileId);
     console.log('Set deck preview image.');
 }
+export async function savePreviewImage(dir, wsPort, noRestart = false) {
+    const projectDir = path.resolve(dir);
+    const castleJson = readCastleJson(projectDir);
+    if (!castleJson) {
+        console.error('No castle.json found. Save the deck first.');
+        process.exit(1);
+    }
+    if (!config.getToken()) {
+        console.error('Not logged in. Run `castle-web login` first.');
+        process.exit(1);
+    }
+    const ws = await connectWS(wsPort);
+    if (!noRestart)
+        await waitForRestart(ws);
+    await captureAndUpload(projectDir, ws, castleJson);
+}
 export async function savePreviewIfNeeded(dir, wsPort) {
     const projectDir = path.resolve(dir);
-    if (fs.existsSync(path.join(projectDir, 'preview.png'))) {
+    if (fs.existsSync(path.join(projectDir, 'preview.png')))
         return;
-    }
+    let ws;
     try {
-        const ws = await connectWS(wsPort);
+        ws = await connectWS(wsPort);
         await waitForRestart(ws);
-        const base64 = await takeScreenshot(ws);
-        ws.close();
-        const castleJsonPath = path.join(projectDir, 'castle.json');
-        if (!fs.existsSync(castleJsonPath))
+        const castleJson = readCastleJson(projectDir);
+        if (!castleJson) {
+            ws.close();
             return;
-        const castleJson = JSON.parse(fs.readFileSync(castleJsonPath, 'utf-8'));
-        fs.writeFileSync(path.join(projectDir, 'preview.png'), Buffer.from(base64, 'base64'));
-        console.log('Saved preview.png');
-        const file = await api.uploadBase64(base64, 'preview.png');
-        await api.updateCardCustomBackgroundImage(castleJson.cardId, file.fileId);
-        console.log('Set deck preview image.');
+        }
+        await captureAndUpload(projectDir, ws, castleJson);
     }
-    catch {
-        // serve not running, skip preview
+    catch (e) {
+        if (ws)
+            ws.close();
+        const msg = e instanceof Error ? e.message : String(e);
+        console.log(`Preview skipped: ${msg}`);
     }
 }

package/dist/save-deck.d.ts

@@ -0,0 +1,2 @@
+export declare function archiveSource(projectDir: string): Promise<Buffer>;
+export declare function saveDeck(dir: string): Promise<void>;