castle-web-cli 0.4.92 → 0.4.94

package/dist/ide.js

@@ -14,6 +14,7 @@ import { spawn as spawnPty } from "@lydell/node-pty";
 import headlessPkg from "@xterm/headless";
 import { SerializeAddon } from "@xterm/addon-serialize";
 import { WebSocketServer } from "ws";
+import { IMPORTS_DIR, importStatuses, updateImport } from "./imports.js";
 const HeadlessTerminal = headlessPkg.Terminal;
 const DIST_DIR = path.dirname(fileURLToPath(import.meta.url));
 // The bundled shell app (vite build output). `/` serves its index.html and
@@ -105,10 +106,20 @@ function parseKitEditorExtensions(deckDir) {
     }
     return exts;
 }
+// Files under `imports/` came from another deck. They are readable like any
+// other deck file -- the engine, editors and pickers all reference them -- but a
+// deck can't edit them, because editing one would mean editing somebody else's
+// deck. (Keeping your own version of a dependency's file is forking, a later
+// feature; copying it out into the deck works meanwhile.)
+function isImportPath(rel) {
+    return rel === IMPORTS_DIR || rel.startsWith(`${IMPORTS_DIR}/`);
+}
 // Resolve a client-supplied deck-relative path to an absolute path inside
 // `deckDir`, rejecting traversal / protected dirs. Mirrors serve.ts's
-// writeProjectFile guards so the builtin editor can't escape the deck.
-function resolveDeckPath(deckDir, requestedPath) {
+// writeProjectFile guards so the builtin editor can't escape the deck. Callers
+// that are about to CHANGE the file pass `mutation`, which additionally refuses
+// anything a dependency owns.
+function resolveDeckPath(deckDir, requestedPath, opts = {}) {
     if (typeof requestedPath !== "string" || requestedPath.trim() === "") {
         return { ok: false, error: "Missing file path." };
     }
@@ -128,7 +139,14 @@ function resolveDeckPath(deckDir, requestedPath) {
     if (rel.startsWith("..") || path.isAbsolute(rel)) {
         return { ok: false, error: `Path outside the deck: ${requestedPath}` };
     }
-    return { ok: true, abs, rel: rel.split(path.sep).join("/") };
+    const relPosix = rel.split(path.sep).join("/");
+    if (opts.mutation && isImportPath(relPosix)) {
+        return {
+            ok: false,
+            error: `${relPosix} belongs to an imported deck and is read-only.`,
+        };
+    }
+    return { ok: true, abs, rel: relPosix };
 }
 // Recursively list deck files (relative POSIX paths, sorted), skipping the
 // ignore dirs above and dotfiles like .DS_Store.
@@ -191,17 +209,39 @@ function readEditorConfig(deckDir) {
 // Extensions the kit owns a rich editor for. A kitless (bare) deck has no kit
 // entry, so this is empty and the builtin editor renders everything. A deck may
 // override the default list via `castle.json` `editor.extensions`.
+// Where the kit lives for this deck: the deck itself when it holds the kit's
+// files, else the import that provides one. A deck built on an imported kit has
+// no `main.jsx` of its own -- its entry point is the kit's, at
+// `imports/<alias>/main.jsx` -- so looking only in the deck root would read as
+// "no kit" and hand every .scene / .pxart to the builtin text editor.
+function findKitRoot(deckDir) {
+    if (fs.existsSync(path.join(deckDir, "main.jsx")))
+        return deckDir;
+    const importsDir = path.join(deckDir, IMPORTS_DIR);
+    let aliases;
+    try {
+        aliases = fs.readdirSync(importsDir);
+    }
+    catch {
+        return null;
+    }
+    for (const alias of aliases.sort()) {
+        const root = path.join(importsDir, alias);
+        if (fs.existsSync(path.join(root, "main.jsx")))
+            return root;
+    }
+    return null;
+}
 function kitEditorExtensions(deckDir) {
     const configured = readEditorConfig(deckDir).extensions;
     if (configured)
         return configured;
-    // `main.jsx` is the kit entry point; bare decks scaffold game.js + index.html
-    // with no main.jsx, so its absence means "no kit, builtin editor for all".
-    if (!fs.existsSync(path.join(deckDir, "main.jsx")))
+    const kitRoot = findKitRoot(deckDir);
+    if (!kitRoot)
         return [];
     // Prefer the kit's own getFileKind (authoritative per deck); fall back to the
     // known rich content types if it couldn't be read/parsed.
-    const parsed = parseKitEditorExtensions(deckDir);
+    const parsed = parseKitEditorExtensions(kitRoot);
     if (parsed && parsed.length > 0)
         return parsed;
     return FALLBACK_KIT_EDITOR_EXTS;
@@ -222,6 +262,30 @@ function filterDeckFiles(files, config) {
     }
     return result;
 }
+// Filter each import by the editor config of the deck it came from: strip the
+// `imports/<alias>/` prefix so the dependency's own visible/hidden globs match
+// the paths they were written against, then put it back.
+function filterImportedFiles(deckDir, imported) {
+    const byAlias = new Map();
+    for (const file of imported) {
+        const [, alias, ...rest] = file.split("/");
+        if (!alias || rest.length === 0)
+            continue;
+        const list = byAlias.get(alias);
+        if (list)
+            list.push(rest.join("/"));
+        else
+            byAlias.set(alias, [rest.join("/")]);
+    }
+    const out = [];
+    for (const [alias, relFiles] of byAlias) {
+        const config = readEditorConfig(path.join(deckDir, IMPORTS_DIR, alias));
+        for (const rel of filterDeckFiles(relFiles, config)) {
+            out.push(`${IMPORTS_DIR}/${alias}/${rel}`);
+        }
+    }
+    return out;
+}
 function sendJson(res, status, body) {
     res.writeHead(status, {
         "content-type": "application/json; charset=utf-8",
@@ -246,7 +310,7 @@ function handleFilesWrite(deckDir, req, res) {
         catch {
             return sendJson(res, 400, { error: "Invalid JSON body." });
         }
-        const resolved = resolveDeckPath(deckDir, body.path);
+        const resolved = resolveDeckPath(deckDir, body.path, { mutation: true });
         if (!resolved.ok)
             return sendJson(res, 400, { error: resolved.error });
         if (typeof body.contents !== "string") {
@@ -308,7 +372,7 @@ function handleFilesMkdir(deckDir, req, res) {
         catch {
             return sendJson(res, 400, { error: "Invalid JSON body." });
         }
-        const resolved = resolveDeckPath(deckDir, body.path);
+        const resolved = resolveDeckPath(deckDir, body.path, { mutation: true });
         if (!resolved.ok)
             return sendJson(res, 400, { error: resolved.error });
         try {
@@ -345,10 +409,10 @@ function handleFilesRename(deckDir, req, res) {
         catch {
             return sendJson(res, 400, { error: "Invalid JSON body." });
         }
-        const from = resolveDeckPath(deckDir, body.from);
+        const from = resolveDeckPath(deckDir, body.from, { mutation: true });
         if (!from.ok)
             return sendJson(res, 400, { error: from.error });
-        const to = resolveDeckPath(deckDir, body.to);
+        const to = resolveDeckPath(deckDir, body.to, { mutation: true });
         if (!to.ok)
             return sendJson(res, 400, { error: to.error });
         if (!fs.existsSync(from.abs)) {
@@ -383,7 +447,7 @@ function handleFilesDelete(deckDir, req, res) {
         catch {
             return sendJson(res, 400, { error: "Invalid JSON body." });
         }
-        const resolved = resolveDeckPath(deckDir, body.path);
+        const resolved = resolveDeckPath(deckDir, body.path, { mutation: true });
         if (!resolved.ok)
             return sendJson(res, 400, { error: resolved.error });
         if (!fs.existsSync(resolved.abs)) {
@@ -418,15 +482,59 @@ function handleFilesApi(deckDir, req, res, reqPath) {
         });
         return true;
     }
+    if (action === "imports") {
+        // Reports only: whether each import is behind the version its deck has now.
+        // Taking the update is a deliberate act (`castle-web update-import`), never
+        // something that happens to a deck while it is open.
+        void importStatuses(deckDir)
+            .then((imports) => sendJson(res, 200, { imports }))
+            .catch(() => sendJson(res, 200, { imports: [] }));
+        return true;
+    }
+    if (action === "update-import") {
+        // Takes the update for one import. Deliberate by construction: the editor
+        // asks first, and this is the only path from the panel that changes what a
+        // dependency contains.
+        void (async () => {
+            let body;
+            try {
+                body = JSON.parse(await readRequestBody(req));
+            }
+            catch {
+                return sendJson(res, 400, { error: "Invalid JSON body." });
+            }
+            if (typeof body.alias !== "string" || !body.alias) {
+                return sendJson(res, 400, { error: "Missing import name." });
+            }
+            try {
+                await updateImport(deckDir, { alias: body.alias });
+                sendJson(res, 200, { ok: true, alias: body.alias });
+            }
+            catch (e) {
+                sendJson(res, 500, { error: e instanceof Error ? e.message : String(e) });
+            }
+        })();
+        return true;
+    }
     if (action === "list") {
         // `?all=1` returns the unfiltered listing (the "show hidden files & folders"
         // toggle) -- still minus the always-ignored dirs (node_modules/.castle/...),
         // just without the deck's visible/hidden path curation.
         const url = new URL(req.url ?? "/", "http://localhost");
         const listed = listDeckFiles(deckDir);
-        const files = url.searchParams.get("all") === "1"
-            ? listed
-            : filterDeckFiles(listed, readEditorConfig(deckDir));
+        let files = listed;
+        if (url.searchParams.get("all") !== "1") {
+            // Each deck curates its own files. The importing deck's visible/hidden
+            // paths name its own dirs (a kit's name scenes/, drawings/ ...), so
+            // applying them to imports would hide every import by omission -- an
+            // import is instead filtered by the config of the deck it came from, which
+            // is the deck that knows which of its files are worth showing.
+            const own = listed.filter((f) => !isImportPath(f));
+            files = [
+                ...filterDeckFiles(own, readEditorConfig(deckDir)),
+                ...filterImportedFiles(deckDir, listed.filter(isImportPath)),
+            ].sort((a, b) => a.localeCompare(b));
+        }
         sendJson(res, 200, { files });
         return true;
     }

package/dist/imports.d.ts

@@ -0,0 +1,22 @@
+export declare const IMPORTS_DIR = "imports";
+export declare function lockImportTree(dir: string): void;
+export declare function syncImportDependencies(deckDir: string): string[];
+export declare function restoreMissingImports(deckDir: string): Promise<string[]>;
+export interface ImportStatus {
+    alias: string;
+    deckId: string | null;
+    version: string;
+    latest: string | null;
+    updateAvailable: boolean;
+    via?: string;
+}
+export declare function importStatuses(deckDir: string): Promise<ImportStatus[]>;
+export declare function addImport(dir: string, options?: {
+    deckId?: string;
+    alias?: string;
+}): Promise<void>;
+export declare function updateImport(dir: string, options?: {
+    alias?: string;
+    check?: boolean;
+    revert?: boolean;
+}): Promise<void>;