castle-web-cli 0.4.37 → 0.4.39

package/dist/buildArchive.d.ts

@@ -0,0 +1 @@
+export declare function buildKitArchives(kits?: string[]): void;

package/dist/buildArchive.js

@@ -0,0 +1,108 @@
+import { execFileSync } from 'child_process';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { ARCHIVE_NAME, PUBLISHED_SDK_VERSION, copyKitSource, getKitArchivePath, rewriteKitPackageJson, } from './init.js';
+import { getKitsDir, getSdkPackagePath, toPosixPath } from './localPaths.js';
+// Refs forced to "published" so the archived deck looks like one scaffolded
+// from a globally-installed castle-web (registry sdk + `castle-web` binary),
+// regardless of the workspace checkout we generate it from.
+const PUBLISHED_REFS = {
+    workspaceMode: false,
+    sdkRef: `^${PUBLISHED_SDK_VERSION}`,
+    cliCommand: 'castle-web',
+    cliDistAbs: null,
+    sdkPathPosix: null,
+};
+// Build the local sdk and `npm pack` it into a temp dir, returning the tarball
+// path. Installing a tarball (not a `file:` dir) gives the archive a real copy
+// of the sdk in node_modules instead of a symlink to the local checkout.
+function packSdk() {
+    const sdkDir = getSdkPackagePath();
+    if (!fs.existsSync(sdkDir)) {
+        throw new Error(`sdk/ not found at ${sdkDir}; build-archives must run from a workspace checkout.`);
+    }
+    console.log('Building sdk...');
+    execFileSync('npm', ['run', 'build'], { cwd: sdkDir, stdio: 'inherit' });
+    const dest = fs.mkdtempSync(path.join(os.tmpdir(), 'castle-sdk-pack-'));
+    console.log('Packing sdk...');
+    const out = execFileSync('npm', ['pack', '--pack-destination', dest], {
+        cwd: sdkDir,
+        encoding: 'utf8',
+    }).trim();
+    // npm pack prints the created tarball filename on its last line.
+    const file = out.split('\n').pop().trim();
+    return path.join(dest, file);
+}
+// Find every real kit under kits/ (a subdir with a package.json).
+function discoverKits(kitsDir) {
+    return fs.readdirSync(kitsDir).filter((name) => {
+        const dir = path.join(kitsDir, name);
+        return fs.statSync(dir).isDirectory() && fs.existsSync(path.join(dir, 'package.json'));
+    });
+}
+// Generate one ready-to-serve archive for `kit`: kit source (minus build junk)
+// + installed node_modules + a published-mode package.json, gzipped into the
+// bundled kit dir (cli/kits/<kit>/published-deck.tgz).
+function buildKitArchive(kit, sdkTarball) {
+    const kitDir = path.join(getKitsDir(), kit);
+    if (!fs.existsSync(path.join(kitDir, 'package.json'))) {
+        throw new Error(`Kit "${kit}" has no package.json at ${kitDir}.`);
+    }
+    const stagingRoot = fs.mkdtempSync(path.join(os.tmpdir(), `castle-archive-${kit}-`));
+    const deck = path.join(stagingRoot, 'deck');
+    try {
+        // Same filter the live scaffold uses, plus drop any prior archive.
+        copyKitSource(kitDir, deck, new Set([ARCHIVE_NAME]));
+        // A stale workspace lock would pin file:../../sdk; drop it before install.
+        fs.rmSync(path.join(deck, 'package-lock.json'), { force: true });
+        // Published-mode package.json, but point the sdk at the local tarball so
+        // the install copies our freshly-built sdk into node_modules.
+        const pkgPath = path.join(deck, 'package.json');
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+        rewriteKitPackageJson(pkg, kit, PUBLISHED_REFS);
+        pkg.dependencies['castle-web-sdk'] = `file:${toPosixPath(sdkTarball)}`;
+        fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+        // Deck deps are pure JS (no native binaries), so this mac-built
+        // node_modules runs as-is on linux/e2b.
+        console.log(`Installing deps for ${kit}...`);
+        execFileSync('npm', ['install', '--no-audit', '--no-fund', '--loglevel=error'], {
+            cwd: deck,
+            stdio: 'inherit',
+        });
+        // Restore the published sdk range (node_modules already holds the real
+        // sdk) and drop the lock pinning the local tarball path.
+        pkg.dependencies['castle-web-sdk'] = `^${PUBLISHED_SDK_VERSION}`;
+        fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+        fs.rmSync(path.join(deck, 'package-lock.json'), { force: true });
+        const archivePath = getKitArchivePath(kit);
+        fs.mkdirSync(path.dirname(archivePath), { recursive: true });
+        fs.rmSync(archivePath, { force: true });
+        console.log(`Archiving ${kit} -> ${archivePath}`);
+        execFileSync('tar', ['-czf', archivePath, '-C', deck, '.'], { stdio: 'inherit' });
+        const sizeMb = (fs.statSync(archivePath).size / 1e6).toFixed(1);
+        console.log(`  ${kit} archive: ${sizeMb} MB`);
+    }
+    finally {
+        fs.rmSync(stagingRoot, { recursive: true, force: true });
+    }
+}
+// Generate archives for the given kits (default: every kit under kits/). Builds
+// + packs the sdk once, then archives each kit against that same tarball.
+export function buildKitArchives(kits) {
+    const kitsDir = getKitsDir();
+    const targets = kits ?? discoverKits(kitsDir);
+    if (targets.length === 0) {
+        console.error(`No kits found under ${kitsDir}.`);
+        process.exit(1);
+    }
+    const sdkTarball = packSdk();
+    try {
+        for (const kit of targets)
+            buildKitArchive(kit, sdkTarball);
+    }
+    finally {
+        fs.rmSync(path.dirname(sdkTarball), { recursive: true, force: true });
+    }
+    console.log(`Done. Archived: ${targets.join(', ')}`);
+}

package/dist/init.js

@@ -1,9 +1,9 @@
-import { execSync } from 'child_process';
-import * as fs from 'fs';
-import * as path from 'path';
-import { COMMON_INSTRUCTIONS } from './commonInstructions.js';
-import { getCliEntryPath, getKitsDir, getRepoRoot, getSdkPackagePath, toPosixPath } from './localPaths.js';
-import { serve } from './serve.js';
+import { execSync } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import { COMMON_INSTRUCTIONS } from "./commonInstructions.js";
+import { getCliEntryPath, getKitsDir, getRepoRoot, getSdkPackagePath, toPosixPath, } from "./localPaths.js";
+import { serve } from "./serve.js";
 const INDEX_HTML = `<!DOCTYPE html>
 <html>
 <head>
@@ -31,14 +31,20 @@ card.appendChild(el);
 `;
 // 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';
+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.4';
+const PUBLISHED_SDK_VERSION = "0.4.4";
 // 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']);
+const KIT_COPY_EXCLUDE = new Set([
+    "node_modules",
+    ".castle",
+    "dist",
+    ".git",
+    "castle.json",
+]);
 // Resolve how a scaffolded deck should reference the sdk + cli. Both the bare
 // and kit scaffold paths go through here so they stay in sync.
 //   workspace mode (sdk/ sits next to cli/, i.e. running from a checkout):
@@ -52,11 +58,17 @@ function resolveScaffoldRefs() {
     // npm package and need the published refs + `castle-web` binary.
     const workspaceMode = fs.existsSync(sdkPath);
     const sdkPathPosix = workspaceMode ? toPosixPath(sdkPath) : null;
-    const cliDistAbs = workspaceMode ? toPosixPath(path.dirname(getCliEntryPath())) : null;
+    const cliDistAbs = workspaceMode
+        ? toPosixPath(path.dirname(getCliEntryPath()))
+        : null;
     return {
         workspaceMode,
-        sdkRef: workspaceMode ? `file:${sdkPathPosix}` : `^${PUBLISHED_SDK_VERSION}`,
-        cliCommand: workspaceMode ? `node ${toPosixPath(getCliEntryPath())}` : 'castle-web',
+        sdkRef: workspaceMode
+            ? `file:${sdkPathPosix}`
+            : `^${PUBLISHED_SDK_VERSION}`,
+        cliCommand: workspaceMode
+            ? `node ${toPosixPath(getCliEntryPath())}`
+            : "castle-web",
         cliDistAbs,
         sdkPathPosix,
     };
@@ -66,9 +78,9 @@ function makeClaudeMd() {
     // 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');
+    const upstream = path.join(repoRoot, "CLAUDE.md");
     try {
-        return fs.readFileSync(upstream, 'utf8').trimEnd() + '\n';
+        return fs.readFileSync(upstream, "utf8").trimEnd() + "\n";
     }
     catch {
         return `# Castle Experimental Web\n\nSee https://github.com/castle-xyz/castle-experimental-web for the agent guide.\n`;
@@ -78,13 +90,15 @@ function makeClaudeMd() {
 // the kit's (or bare) CLAUDE.md is written; the AGENTS.md symlink picks the
 // appended content up for free.
 function appendCommonInstructions(projectDir) {
-    const claudePath = path.join(projectDir, 'CLAUDE.md');
-    const existing = fs.existsSync(claudePath) ? fs.readFileSync(claudePath, 'utf8').trimEnd() + '\n\n' : '';
+    const claudePath = path.join(projectDir, "CLAUDE.md");
+    const existing = fs.existsSync(claudePath)
+        ? fs.readFileSync(claudePath, "utf8").trimEnd() + "\n\n"
+        : "";
     fs.writeFileSync(claudePath, existing + COMMON_INSTRUCTIONS);
 }
 function tryMakeAgentsSymlink(agentsPath) {
     try {
-        fs.symlinkSync('CLAUDE.md', agentsPath);
+        fs.symlinkSync("CLAUDE.md", agentsPath);
     }
     catch {
         // symlink already exists / unsupported FS — non-fatal
@@ -95,37 +109,37 @@ function makePackageJson(projectDir) {
     return {
         name: path.basename(projectDir),
         private: true,
-        type: 'module',
+        type: "module",
         scripts: {
             restart: `${cliCommand} restart .`,
             screenshot: `${cliCommand} screenshot .`,
-            'save-deck': `${cliCommand} save-deck .`,
+            "save-deck": `${cliCommand} save-deck .`,
         },
         dependencies: {
-            'castle-web-sdk': sdkRef,
+            "castle-web-sdk": sdkRef,
         },
     };
 }
 // 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');
+    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')))
+    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());
+    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());
     appendCommonInstructions(projectDir);
     ensureAgentsSymlink(projectDir);
-    fs.writeFileSync(path.join(projectDir, 'package.json'), JSON.stringify(makePackageJson(projectDir), null, 2) + '\n');
+    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.
@@ -133,7 +147,7 @@ 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:');
+        console.error("Available kits:");
         try {
             const kits = fs
                 .readdirSync(getKitsDir())
@@ -142,12 +156,12 @@ function scaffoldFromKit(kit, projectDir) {
                 for (const name of kits)
                     console.error(`  ${name}`);
             else
-                console.error('  (none)');
+                console.error("  (none)");
         }
         catch {
-            console.error('  (none — kits/ directory is missing)');
+            console.error("  (none — kits/ directory is missing)");
         }
-        console.error('Or use `--kit none` for a bare code-only deck.');
+        console.error("Or use `--kit none` for a bare code-only deck.");
         process.exit(1);
     }
     fs.cpSync(kitDir, projectDir, {
@@ -161,10 +175,10 @@ function scaffoldFromKit(kit, projectDir) {
     // 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');
+    const pkgPath = path.join(projectDir, "package.json");
     if (fs.existsSync(pkgPath)) {
         try {
-            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+            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.
@@ -173,13 +187,13 @@ function scaffoldFromKit(kit, projectDir) {
             // the bare scaffold path uses.
             const { workspaceMode, sdkRef, cliDistAbs, sdkPathPosix } = resolveScaffoldRefs();
             if (pkg.dependencies &&
-                typeof pkg.dependencies['castle-web-sdk'] === 'string' &&
-                pkg.dependencies['castle-web-sdk'].startsWith('file:')) {
-                pkg.dependencies['castle-web-sdk'] = sdkRef;
+                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')
+                    if (typeof pkg.scripts[k] !== "string")
                         continue;
                     if (workspaceMode) {
                         pkg.scripts[k] = pkg.scripts[k]
@@ -189,13 +203,13 @@ function scaffoldFromKit(kit, projectDir) {
                     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(/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, '');
+                            .replace(/\.\.\/\.\.\/sdk/g, "");
                     }
                 }
             }
-            fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+            fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
         }
         catch {
             // kit shipped an unparseable package.json — leave it for the user to fix
@@ -203,13 +217,43 @@ function scaffoldFromKit(kit, projectDir) {
     }
     // 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');
+    const claudePath = path.join(projectDir, "CLAUDE.md");
     if (!fs.existsSync(claudePath)) {
         fs.writeFileSync(claudePath, makeClaudeMd());
     }
     appendCommonInstructions(projectDir);
     ensureAgentsSymlink(projectDir);
 }
+function hasPnpm() {
+    try {
+        execSync("pnpm --version", { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// Install the scaffolded deck's deps. Prefer pnpm -- in the e2b template a pnpm
+// store is baked in, so `pnpm install` is near-instant (hardlinks from the
+// store, no download). Fall back to npm when pnpm isn't on PATH (e.g. a local
+// laptop that never installed it). --prefer-offline uses the store/cache first
+// and only hits the network for anything missing.
+function installDeps(projectDir) {
+    if (hasPnpm()) {
+        console.log("Installing deps (pnpm)...");
+        execSync("pnpm install --prefer-offline", {
+            cwd: projectDir,
+            stdio: "inherit",
+        });
+    }
+    else {
+        console.log("Installing deps (npm)...");
+        execSync("npm install --no-audit --no-fund --loglevel=error", {
+            cwd: projectDir,
+            stdio: "inherit",
+        });
+    }
+}
 export async function init(dir, opts = {}) {
     const projectDir = path.resolve(dir);
     if (fs.existsSync(projectDir) && fs.readdirSync(projectDir).length > 0) {
@@ -217,45 +261,44 @@ export async function init(dir, opts = {}) {
         process.exit(1);
     }
     const kit = opts.kit ?? DEFAULT_KIT;
-    const bare = kit === 'none' || kit === 'bare';
+    const bare = kit === "none" || kit === "bare";
     if (bare) {
         scaffoldBare(projectDir);
     }
     else {
         scaffoldFromKit(kit, projectDir);
     }
-    console.log(`Created project in ${projectDir}/${bare ? '' : ` (from kit "${kit}")`}`);
-    // Auto-run npm install + serve so the page is up the moment the
-    // agent / user starts editing. Pass --no-serve to skip.
+    console.log(`Created project in ${projectDir}/${bare ? "" : ` (from kit "${kit}")`}`);
+    // Always install deps so the deck is ready to serve/edit immediately. The
+    // serve step is what `--no-serve` skips (callers like the cloud launcher run
+    // their own serve), but they still want the deps in place.
+    console.log("");
+    let installed = false;
+    try {
+        installDeps(projectDir);
+        installed = true;
+    }
+    catch {
+        console.error("dependency install failed; re-run `pnpm install` (or `npm install`) in the deck.");
+    }
     const autoServe = opts.serve !== false;
-    if (autoServe) {
-        console.log('');
-        console.log('Installing deps + serving (pass --no-serve to skip)...');
-        try {
-            execSync('npm install --no-audit --no-fund --loglevel=error', {
-                cwd: projectDir,
-                stdio: 'inherit',
-            });
-        }
-        catch {
-            console.error('npm install failed; skipping serve. Re-run yourself with `npm install && castle-web serve .` (& in your shell to background it).');
-            return;
-        }
+    if (autoServe && installed) {
         // Call serve() with detach so init returns once the server is up. serve()
         // handles the background spawn internally; init doesn't shell out.
         // Bind all interfaces by default so a tailnet / LAN browser can reach
         // the served page; users can override host on a subsequent serve call.
         // Open in the user's default browser unless we're clearly headless (SSH
         // session) or the user has opted out via CASTLE_WEB_CLI_NO_OPEN=1.
-        const noOpen = process.env.CASTLE_WEB_CLI_NO_OPEN === '1' ||
+        const noOpen = process.env.CASTLE_WEB_CLI_NO_OPEN === "1" ||
             !!process.env.SSH_CONNECTION ||
             !!process.env.SSH_TTY;
-        await serve(projectDir, { host: '0.0.0.0', detach: true, open: !noOpen });
+        await serve(projectDir, { host: "0.0.0.0", detach: true, open: !noOpen });
         return;
     }
-    console.log('');
-    console.log('Next steps:');
+    console.log("");
+    console.log("Next steps:");
     console.log(`  cd ${dir}`);
-    console.log('  npm install');
-    console.log('  castle-web serve .   # & in your shell to background it');
+    if (!installed)
+        console.log("  pnpm install   # or: npm install");
+    console.log("  castle-web serve .   # & in your shell to background it");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "castle-web-cli",
-  "version": "0.4.37",
+  "version": "0.4.39",
   "type": "module",
   "bin": {
     "castle-web": "./dist/index.js"