npm - castle-web-cli - Versions diffs - 0.4.92 → 0.4.93 - Mend

castle-web-cli 0.4.92 → 0.4.93

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (42) hide show

package/dist/agent.js +141 -22
package/dist/api.d.ts +8 -0
package/dist/api.js +10 -0
package/dist/bundle.js +2 -2
package/dist/get-deck.d.ts +1 -1
package/dist/get-deck.js +93 -22
package/dist/ide.js +123 -15
package/dist/imports.d.ts +22 -0
package/dist/imports.js +549 -0
package/dist/index.js +45 -15
package/dist/init.js +169 -1
package/dist/install.d.ts +1 -1
package/dist/install.js +14 -1
package/dist/metering.d.ts +1 -0
package/dist/metering.js +1 -1
package/dist/native/loop.js +1 -0
package/dist/native/openrouter.d.ts +1 -0
package/dist/native/openrouter.js +13 -6
package/dist/native/types.d.ts +1 -0
package/dist/normalize.js +4 -0
package/dist/openrouter-catalog.d.ts +3 -1
package/dist/openrouter-catalog.js +15 -10
package/dist/save-deck.d.ts +2 -0
package/dist/save-deck.js +25 -19
package/dist/serve.js +2 -2
package/dist/shell/assets/{index-DSIr52Kl.css → index-CWNH9QiB.css} +1 -1
package/dist/shell/assets/{index-BFCG4tLs.js → index-_C2BvstY.js} +21 -21
package/dist/shell/index.html +2 -2
package/dist/vitePlugins.d.ts +1 -0
package/dist/vitePlugins.js +33 -0
package/kits/basic-2d/CLAUDE.md +20 -0
package/kits/basic-2d/behaviors/Sprite.jsx +6 -1
package/kits/basic-2d/editors/BlueprintLibrary.jsx +14 -8
package/kits/basic-2d/editors/behaviorRegistry.js +8 -2
package/kits/basic-2d/engine/behaviorExtensions.js +5 -1
package/kits/basic-2d/engine/blueprint.js +39 -3
package/kits/basic-2d/engine/files.js +26 -5
package/kits/basic-2d/engine/scene.js +4 -1
package/kits/basic-2d/engine/systemRegistry.js +5 -1
package/package.json +1 -1
package/dist/pull.d.ts +0 -4
package/dist/pull.js +0 -119

package/dist/init.js CHANGED Viewed

@@ -2,6 +2,7 @@ import * as fs from "fs";
 import * as path from "path";
 import { COMMON_INSTRUCTIONS } from "./commonInstructions.js";
 import { installDeps } from "./install.js";
+import { IMPORTS_DIR, lockImportTree } from "./imports.js";
 import { getCliEntryPath, getKitsDir, getRepoRoot, getSdkPackagePath, toPosixPath, } from "./localPaths.js";
 import { serve } from "./serve.js";
 const INDEX_HTML = `<!DOCTYPE html>
@@ -40,6 +41,9 @@ const PUBLISHED_SDK_VERSION = "0.4.10";
 // (the kit ships a config-only one with the editor layout / file filters), but
 // `scaffoldFromKit` strips any identity fields off it first -- a fresh deck has
 // no deckId until its first save-deck, which owns those fields.
+// The account the first-party kits are (to be) published under, so a kit
+// imported from the CLI's copy is named the same as one fetched from the server.
+const KIT_AUTHOR = "castle";
 const KIT_COPY_EXCLUDE = new Set([
     "node_modules",
     ".castle",
@@ -181,6 +185,170 @@ function scaffoldBare(projectDir) {
 }
 // Copy a framework kit from kits/<kit>/ into the new deck dir, dropping
 // build/dependency junk and castle.json.
+// Shared by both scaffold paths: resolve the kit directory or exit with the
+// list of kits that do exist.
+function requireKitDir(kit) {
+    const kitDir = path.join(getKitsDir(), kit);
+    if (fs.existsSync(kitDir) && fs.statSync(kitDir).isDirectory())
+        return kitDir;
+    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.");
+    return process.exit(1);
+}
+function readJsonFile(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function writeJsonFile(file, value) {
+    fs.writeFileSync(file, JSON.stringify(value, null, 2) + "\n", "utf8");
+}
+function getCliVersion() {
+    const pkg = readJsonFile(path.join(getKitsDir(), "..", "package.json"));
+    return typeof pkg?.version === "string" ? pkg.version : "0.0.0";
+}
+// The deck's entry point is the KIT's -- the deck has no engine code of its own
+// -- so index.html points into the import. Everything the kit's main.jsx imports
+// is relative to itself, so it needs no rewriting to run from there.
+function writeDeckIndexHtml(projectDir, alias, title) {
+    fs.writeFileSync(path.join(projectDir, "index.html"), `<!doctype html>
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no" />
+    <meta name="color-scheme" content="dark" />
+    <title>${title}</title>
+    <!-- Declare the dark scheme before the JS-imported CSS loads, so the frame
+         never paints light first (Safari won't repaint a composited iframe on a
+         color-scheme change). -->
+    <style>
+      html {
+        color-scheme: dark;
+        background: #0a0a0a;
+      }
+    </style>
+  </head>
+  <body>
+    <div id="root"></div>
+    <!-- Engine and editors come from the imported kit; this deck holds its own
+         scenes, drawings and behaviors. -->
+    <script type="module" src="/${IMPORTS_DIR}/${alias}/main.jsx"></script>
+  </body>
+</html>
+`, "utf8");
+}
+// The deck starts with its own copy of the kit's starter scene, so there is
+// something to open and edit on the first run. Refs inside it are rewritten to
+// point at the kit's copies of what they name (the scene is the deck's now, but
+// the blueprint and art it places still live in the import).
+function writeStarterScene(projectDir, kitDir, alias) {
+    const scene = readJsonFile(path.join(kitDir, "scenes", "main.scene"));
+    const prefix = `${IMPORTS_DIR}/${alias}/`;
+    const rewrite = (value) => {
+        if (typeof value === "string") {
+            return fs.existsSync(path.join(kitDir, value)) ? prefix + value : value;
+        }
+        if (Array.isArray(value))
+            return value.map(rewrite);
+        if (value && typeof value === "object") {
+            return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, rewrite(v)]));
+        }
+        return value;
+    };
+    fs.mkdirSync(path.join(projectDir, "scenes"), { recursive: true });
+    writeJsonFile(path.join(projectDir, "scenes", "main.scene"), scene ? rewrite(scene) : { name: "Main", actors: [] });
+}
+function makeImportedKitClaudeMd(alias) {
+    return `# Castle deck
+The engine, editors and built-in behaviors come from the **${alias}** kit, imported
+at \`${IMPORTS_DIR}/${alias}/\` and read-only. Read \`${IMPORTS_DIR}/${alias}/CLAUDE.md\`
+for the authoring guide: how scenes, blueprints, drawings and behaviors work.
+This deck holds only its own content -- \`scenes/\`, \`drawings/\`,
+\`blueprints/\`, \`behaviors/\` -- plus \`index.html\` (which points at the kit's
+entry point) and \`castle.json\` (editor config and the import pin).
+Do not edit anything under \`${IMPORTS_DIR}/\`: those files belong to the deck they
+came from, and are replaced wholesale when the import is updated. To change how
+something in the kit behaves, define your own behavior of the same name in
+\`behaviors/\` -- the deck's own files win over an import's.
+`;
+}
+// Scaffold a deck that IMPORTS its kit instead of copying it. The kit's files
+// land in `imports/<kit>/` (read-only, like any dependency) and the deck itself
+// holds only what is genuinely its own: an entry point, its config, and its
+// starting content. A kit fix then reaches the deck by re-fetching the import,
+// rather than being frozen into the deck at scaffold time -- which is what
+// copying the kit in meant.
+//
+// The kit comes from the copy shipped with this CLI, so `init` works offline and
+// needs no account. The pin records that origin; once kits are published as
+// decks it becomes a deckId + version and the files are fetched instead, with
+// the same deck shape either way.
+function scaffoldFromKitImport(kit, projectDir) {
+    const kitDir = requireKitDir(kit);
+    // Qualified like any other import (`<author>.<deck>`), and qualified NOW even
+    // though this copy is the CLI's: the alias is baked into every ref the deck
+    // writes, so it can't change later without rewriting them. Publishing the
+    // kits under the castle account turns the pin into a deckId; the name it is
+    // already known by stays put.
+    const alias = `${KIT_AUTHOR}.${kit}`;
+    const importDir = path.join(projectDir, IMPORTS_DIR, alias);
+    fs.mkdirSync(importDir, { recursive: true });
+    fs.cpSync(kitDir, importDir, {
+        recursive: true,
+        verbatimSymlinks: true,
+        filter: (src) => src === kitDir || !KIT_COPY_EXCLUDE.has(path.basename(src)),
+    });
+    const kitConfig = readJsonFile(path.join(kitDir, "castle.json")) ?? {};
+    const kitPkg = readJsonFile(path.join(kitDir, "package.json")) ?? {};
+    writeDeckIndexHtml(projectDir, alias, String(kitConfig.title ?? kit));
+    writeStarterScene(projectDir, kitDir, alias);
+    // The deck's own castle.json: the kit's editor config (panel layout, file
+    // filters) as a starting point -- it is the deck's to edit from here -- plus
+    // the import pin.
+    writeJsonFile(path.join(projectDir, "castle.json"), {
+        ...(kitConfig.editor ? { editor: kitConfig.editor } : {}),
+        imports: { [alias]: { source: "builtin", kit, version: getCliVersion() } },
+    });
+    // The kit's code runs from THIS deck's node_modules, so its dependencies are
+    // declared here (see syncImportDependencies, which does the same for imports
+    // added later).
+    const { sdkRef } = resolveScaffoldRefs();
+    const dependencies = {};
+    for (const [name, range] of Object.entries(kitPkg.dependencies ?? {})) {
+        dependencies[name] =
+            name === "castle-web-sdk" && String(range).startsWith("file:")
+                ? sdkRef
+                : String(range);
+    }
+    writeJsonFile(path.join(projectDir, "package.json"), {
+        name: path.basename(projectDir),
+        private: true,
+        type: "module",
+        dependencies,
+    });
+    fs.writeFileSync(path.join(projectDir, "CLAUDE.md"), makeImportedKitClaudeMd(alias));
+    appendCommonInstructions(projectDir);
+    lockImportTree(importDir);
+}
 function scaffoldFromKit(kit, projectDir) {
     const kitDir = path.join(getKitsDir(), kit);
     if (!fs.existsSync(kitDir) || !fs.statSync(kitDir).isDirectory()) {
@@ -278,7 +446,7 @@ export async function init(dir, opts = {}) {
         scaffoldBare(projectDir);
     }
     else {
-        scaffoldFromKit(kit, projectDir);
+        scaffoldFromKitImport(kit, projectDir);
     }
     console.log(`Created project in ${projectDir}/${bare ? "" : ` (from kit "${kit}")`}`);
     // Always install deps so the deck is ready to serve/edit immediately.

package/dist/install.d.ts CHANGED Viewed

@@ -1,2 +1,2 @@
 export declare function installDeps(projectDir: string, frozen: boolean): void;
-export declare function install(dir: string): void;
+export declare function install(dir: string): Promise<void>;

package/dist/install.js CHANGED Viewed

@@ -1,6 +1,7 @@
 import { execSync } from "child_process";
 import * as fs from "fs";
 import * as path from "path";
+import { restoreMissingImports, syncImportDependencies } from "./imports.js";
 function hasPnpm() {
     try {
         execSync("pnpm --version", { stdio: "ignore" });
@@ -53,12 +54,24 @@ export function installDeps(projectDir, frozen) {
 // `castle-web install <dir>`: put node_modules in place for a deck that already has
 // its source -- one fetched with `get-deck`, or one whose node_modules was dropped
 // (the cloud hosts treat it as regenerable and don't snapshot it).
-export function install(dir) {
+export async function install(dir) {
     const projectDir = path.resolve(dir);
     if (!fs.existsSync(path.join(projectDir, "package.json"))) {
         console.error(`No package.json in ${projectDir}.`);
         process.exit(1);
     }
+    // A fetched deck carries its import pins but not the files (imports/ is left
+    // out of the archive), so put them back before anything depends on them.
+    const restored = await restoreMissingImports(projectDir);
+    for (const alias of restored)
+        console.log(`Restored import ${alias}`);
+    // Imports declare packages the deck has to install (see syncImportDependencies).
+    // Re-done here, not just at add-import time, so a deck fetched with get-deck --
+    // which brings castle.json's pins but not the dependency files -- still ends up
+    // with everything its imports need once they are back.
+    const added = syncImportDependencies(projectDir);
+    for (const dep of added)
+        console.log(`Added dependency ${dep} from an import`);
     installDeps(projectDir, fs.existsSync(path.join(projectDir, "pnpm-lock.yaml")));
     console.log(`Installed deps in ${projectDir}`);
 }

package/dist/metering.d.ts CHANGED Viewed

@@ -11,6 +11,7 @@ export declare function meteringHeaders(opts: {
     deckDir: string;
     sessionId: string;
     route: MeteringRoute;
+    direct: boolean;
 }): Record<string, string>;
 /**
  * Merge metering headers into a claude spawn env. ANTHROPIC_CUSTOM_HEADERS is

package/dist/metering.js CHANGED Viewed

@@ -49,7 +49,7 @@ function deckIdFor(deckDir) {
     return parsed.deckId.replace(/[\r\n]/g, "") || null;
 }
 export function meteringHeaders(opts) {
-    if (!proxyInjected(opts.route))
+    if (opts.direct || !proxyInjected(opts.route))
         return {};
     const deckId = deckIdFor(opts.deckDir);
     return {

package/dist/native/loop.js CHANGED Viewed

@@ -599,6 +599,7 @@ async function runLoop(opts, toolSchemas, log) {
             const iterationStartedAt = Date.now();
             const streamResult = await streamChatCompletion({
                 apiKey: opts.apiKey,
+                baseUrl: opts.baseUrl,
                 model: opts.model,
                 messages,
                 tools: toolSchemas,

package/dist/native/openrouter.d.ts CHANGED Viewed

@@ -33,6 +33,7 @@ export type ORRoutingMode = "balanced" | "nitro" | "exacto" | "floor";
 export declare function applyRoutingMode(model: string, routing?: ORRoutingMode): string;
 export interface StreamChatOpts {
     apiKey: string;
+    baseUrl?: string;
     model: string;
     messages: ORMessage[];
     tools?: unknown[];

package/dist/native/openrouter.js CHANGED Viewed

@@ -19,11 +19,13 @@ import { failureForStatus } from "../agent-failures.js";
 // a local fake server instead of the real API -- read per-call (not hoisted
 // to a module-level const) so a test process that imports this module once
 // can still point successive runAgentNative calls at different fake servers.
-function openrouterUrl() {
-    // In a Castle sandbox the host injects OPENROUTER_BASE_URL pointing at the per-host
-    // llm-proxy (holds the real key, meters usage); otherwise talk to openrouter.ai directly.
+function openrouterUrl(base) {
+    // A user's OWN OpenRouter key passes `base` (openrouter.ai) so the run bypasses
+    // the proxy. Otherwise, in a Castle sandbox the host injects OPENROUTER_BASE_URL
+    // pointing at the per-host llm-proxy (holds the real key, meters usage); else
+    // talk to openrouter.ai directly. The test override wins over all of it.
     return (process.env.CASTLE_OPENROUTER_URL ||
-        `${process.env.OPENROUTER_BASE_URL || "https://openrouter.ai/api/v1"}/chat/completions`);
+        `${base || process.env.OPENROUTER_BASE_URL || "https://openrouter.ai/api/v1"}/chat/completions`);
 }
 const DEFAULT_MAX_RETRIES = 2; // -> 3 total connect attempts
 const RETRY_BASE_MS = 500;
@@ -91,7 +93,7 @@ async function connectWithRetry(init, opts) {
         }
         let res;
         try {
-            res = await fetch(openrouterUrl(), init);
+            res = await fetch(opts.url, init);
         }
         catch (err) {
             if (err instanceof Error && err.name === "AbortError")
@@ -253,7 +255,12 @@ export async function streamChatCompletion(opts) {
             },
             body: JSON.stringify(body),
             signal: opts.signal,
-        }, { signal: opts.signal, maxRetries: opts.maxRetries, onRetry: opts.onRetry });
+        }, {
+            url: openrouterUrl(opts.baseUrl),
+            signal: opts.signal,
+            maxRetries: opts.maxRetries,
+            onRetry: opts.onRetry,
+        });
     }
     catch (err) {
         if (err instanceof Error && err.name === "AbortError") {

package/dist/native/types.d.ts CHANGED Viewed

@@ -18,6 +18,7 @@ export interface NativeRunOpts {
     role: NativeRole;
     model: string;
     apiKey: string;
+    baseUrl?: string;
     reasoningEffort?: ORReasoningEffort;
     routing?: ORRoutingMode;
     providerTier?: string;

package/dist/normalize.js CHANGED Viewed

@@ -60,7 +60,11 @@ export function normalizeDeckPackageJson(projectDir) {
         }
     }
     if (changed) {
+        const prev = fs.statSync(pkgPath);
         fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n', 'utf-8');
+        // Machine wiring, not an edit: keep the old mtime so get-deck's staleness
+        // guard doesn't read a freshly fetched deck as locally modified.
+        fs.utimesSync(pkgPath, prev.atime, prev.mtime);
     }
     return changed;
 }

package/dist/openrouter-catalog.d.ts CHANGED Viewed

@@ -23,6 +23,8 @@ export type KeyCheck = {
 } | {
     status: "unavailable";
 };
-export declare function checkOpenrouterKey(apiKey: string): Promise<KeyCheck>;
+export declare function checkOpenrouterKey(apiKey: string, opts?: {
+    direct?: boolean;
+}): Promise<KeyCheck>;
 export declare function checkOpenrouterModel(slug: string): Promise<ModelCheck>;
 export declare function openrouterCatalogEntry(slug: string): Promise<CatalogEntry | null>;

package/dist/openrouter-catalog.js CHANGED Viewed

@@ -28,12 +28,17 @@ function modelsUrl() {
     return (process.env.CASTLE_OPENROUTER_MODELS_URL ??
         "https://openrouter.ai/api/v1/models");
 }
-// The key check sends the credential, so in a Castle sandbox it goes through the llm-proxy
-// (OPENROUTER_BASE_URL) — validating the real key the proxy swaps in. modelsUrl above is a
-// public GET and stays on openrouter.ai (the proxy requires a token).
-function keyUrl() {
-    return (process.env.CASTLE_OPENROUTER_KEY_URL ??
-        `${process.env.OPENROUTER_BASE_URL || "https://openrouter.ai/api/v1"}/key`);
+// The key check sends the credential, so by default (proxy mode) it goes through the llm-proxy
+// (OPENROUTER_BASE_URL) — validating the real key the proxy swaps in. `direct` (a user's OWN
+// OpenRouter key, which the proxy would reject) validates against openrouter.ai instead.
+// modelsUrl above is a public GET and stays on openrouter.ai (the proxy requires a token).
+function keyUrl(direct) {
+    if (process.env.CASTLE_OPENROUTER_KEY_URL)
+        return process.env.CASTLE_OPENROUTER_KEY_URL;
+    const base = direct
+        ? "https://openrouter.ai/api/v1"
+        : process.env.OPENROUTER_BASE_URL || "https://openrouter.ai/api/v1";
+    return `${base}/key`;
 }
 function cachePath() {
     return (process.env.CASTLE_OPENROUTER_CATALOG_CACHE ??
@@ -220,11 +225,11 @@ function keyHandle(apiKey) {
         h = (Math.imul(h, 31) + apiKey.charCodeAt(i)) | 0;
     return `k${(h >>> 0).toString(36)}`;
 }
-async function fetchKeyCheck(apiKey) {
+async function fetchKeyCheck(apiKey, direct) {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
     try {
-        const res = await fetch(keyUrl(), {
+        const res = await fetch(keyUrl(direct), {
             headers: { authorization: `Bearer ${apiKey}` },
             signal: controller.signal,
         });
@@ -249,7 +254,7 @@ async function fetchKeyCheck(apiKey) {
         clearTimeout(timer);
     }
 }
-export async function checkOpenrouterKey(apiKey) {
+export async function checkOpenrouterKey(apiKey, opts) {
     if (!apiKey)
         return { status: "bad-key" };
     const handle = keyHandle(apiKey);
@@ -260,7 +265,7 @@ export async function checkOpenrouterKey(apiKey) {
     const existing = keyInflight.get(handle);
     if (existing)
         return existing;
-    const p = fetchKeyCheck(apiKey)
+    const p = fetchKeyCheck(apiKey, opts?.direct)
         .then((result) => {
         // An "unavailable" verdict is deliberately NOT cached -- it means the
         // network hiccuped, and caching it would suppress validation for the

package/dist/save-deck.d.ts CHANGED Viewed

@@ -1,3 +1,5 @@
+export declare const SOURCE_ARCHIVE_EXCLUDES: string[];
+export declare function runTar(args: string[]): Promise<void>;
 export declare function archiveSource(projectDir: string): Promise<Buffer>;
 export type SaveVisibility = 'unlisted' | 'private';
 export interface SaveDeckOptions {

package/dist/save-deck.js CHANGED Viewed

@@ -6,38 +6,44 @@ import { nanoid } from 'nanoid';
 import * as api from './api.js';
 import * as config from './config.js';
 import { bundleProject } from './bundle.js';
-const SOURCE_ARCHIVE_EXCLUDES = ['node_modules', 'dist', '.castle', '.git'];
-export function archiveSource(projectDir) {
+// `imports/` is derived state like node_modules: a dependency's files belong to
+// the deck that published them, and castle.json's import pins are enough to fetch
+// them again -- so they neither bloat this deck's archive nor get republished as
+// part of it. (Being on this list also means `get-deck` leaves an existing
+// `imports/` in place when it refreshes a deck.)
+export const SOURCE_ARCHIVE_EXCLUDES = ['node_modules', 'dist', '.castle', '.git', 'imports'];
+export function runTar(args) {
     return new Promise((resolve, reject) => {
-        const tmpFile = path.join(os.tmpdir(), `castle-source-${nanoid(8)}.tar.gz`);
-        const args = ['-czf', tmpFile];
-        for (const ex of SOURCE_ARCHIVE_EXCLUDES)
-            args.push(`--exclude=./${ex}`);
-        args.push('-C', projectDir, '.');
         const child = spawn('tar', args, { stdio: ['ignore', 'ignore', 'pipe'] });
         let stderr = '';
         child.stderr?.on('data', (chunk) => { stderr += chunk.toString(); });
         child.on('error', reject);
         child.on('close', (code) => {
             if (code !== 0) {
-                try {
-                    fs.unlinkSync(tmpFile);
-                }
-                catch { /* nothing to clean */ }
                 reject(new Error(`tar exited with code ${code}: ${stderr}`));
                 return;
             }
-            try {
-                const buf = fs.readFileSync(tmpFile);
-                fs.unlinkSync(tmpFile);
-                resolve(buf);
-            }
-            catch (e) {
-                reject(e instanceof Error ? e : new Error(String(e)));
-            }
+            resolve();
         });
     });
 }
+export async function archiveSource(projectDir) {
+    const tmpFile = path.join(os.tmpdir(), `castle-source-${nanoid(8)}.tar.gz`);
+    const args = ['-czf', tmpFile];
+    for (const ex of SOURCE_ARCHIVE_EXCLUDES)
+        args.push(`--exclude=./${ex}`);
+    args.push('-C', projectDir, '.');
+    try {
+        await runTar(args);
+        return fs.readFileSync(tmpFile);
+    }
+    finally {
+        try {
+            fs.unlinkSync(tmpFile);
+        }
+        catch { /* nothing to clean */ }
+    }
+}
 async function uploadSource(projectDir, deckId) {
     const archive = await archiveSource(projectDir);
     const sizeKB = archive.length / 1024;

package/dist/serve.js CHANGED Viewed

@@ -6,7 +6,7 @@ import { createServer } from 'vite';
 import { WebSocketServer, WebSocket } from 'ws';
 import { createIdeServer } from './ide.js';
 import { createAgentServer } from './agent.js';
-import { sceneFilesPlugin } from './vitePlugins.js';
+import { sceneFilesPlugin, importsAliasPlugin } from './vitePlugins.js';
 import { installFilesChangedWatcher } from './filesChanged.js';
 import * as config from './config.js';
 import { graphql as castleGraphql } from './api.js';
@@ -271,7 +271,7 @@ export async function serve(dir, options = {}) {
     process.on('exit', () => agentServer.shutdown());
     const vite = await createServer({
         root: projectDir,
-        plugins: [castlePlugin(wsPort, ideServer, agentServer), sceneFilesPlugin()],
+        plugins: [castlePlugin(wsPort, ideServer, agentServer), importsAliasPlugin(), sceneFilesPlugin()],
         server: {
             port,
             strictPort: true,