castle-web-cli 0.4.113 → 0.4.115

package/dist/imports.js

@@ -5,7 +5,7 @@ import * as api from './api.js';
 import { runTar } from './save-deck.js';
 import { normalizeDeckPackageJson } from './normalize.js';
 import { getKitsDir } from './localPaths.js';
-import { readCastleJsonOrThrow as readCastleJson, } from './castleJson.js';
+import { readCastleJson as tryReadCastleJson, readCastleJsonOrThrow as readCastleJson, } from './castleJson.js';
 // Adding another deck as a dependency (`castle-web add-import`; removing one is a
 // later command). Deliberately NOT `get-deck`: that one
 // replaces THIS deck's own source from the server (and carries guards for the
@@ -503,6 +503,94 @@ export async function addImport(dir, options = {}) {
     if (result.dependencies.length > 0)
         console.log('Run `castle-web install` to install them.');
 }
+// Take one import's update: replace its files with the version the server has
+// now, then follow that version's own pins for anything newly required. Both
+// `update-import` and the serve-start auto update come through here, so there
+// is one path that replaces an import's files rather than two that have to be
+// kept in step. `log` is how the caller labels the lines it produces.
+async function applyImportUpdate(deckDir, alias, update, source, log) {
+    await placeImport(deckDir, alias, update.deckId, source, update.via);
+    log(`Updated ${alias} (${update.from} -> ${source.updatedAt})`);
+    // Its own dependencies may have moved too.
+    const transitive = await addTransitiveImports(deckDir, alias, importedDeckIds(deckDir));
+    for (const t of transitive)
+        log(`Also imported ${IMPORTS_DIR}/${t} (needed by ${alias})`);
+}
+// Whether the deck behind an import asked to be tracked rather than pinned --
+// `autoUpdateWhenImported` in ITS castle.json, which is a statement its author
+// makes about their own deck (see castleJson.ts).
+//
+// Read from the copy already on disk, NOT from the version about to be fetched.
+// The flag the importer has is the one that was there when they took this
+// version; letting the incoming version answer would let any deck start pushing
+// to everyone who already imported it, after the fact. The cost is a one-update
+// lag both ways -- turning the flag on reaches an existing importer only once
+// they take an update by hand, and turning it off gets delivered by one last
+// auto update -- which is the safe direction for both.
+function importOptsIntoAutoUpdate(deckDir, alias) {
+    const config = tryReadCastleJson(path.join(deckDir, IMPORTS_DIR, alias));
+    return config?.autoUpdateWhenImported === true;
+}
+// Auto-update is honored only for imports of decks on the castle account. The
+// flag is the mechanism and this is a leash on it: a deck that pushes new code
+// to everyone who imported it is asking for a lot of trust, and until decks
+// carry some other signal of it, the only ones that get it are the ones we
+// publish (the framework kits -- the same account `init` qualifies their aliases
+// with).
+//
+// Deliberately not a setting: nothing a deck or a person can flip, since that
+// would be the leash undoing itself. The env var is a test seam -- the automated
+// check can't publish a deck to the castle account (nothing should), so it
+// substitutes which account counts and exercises both branches for real.
+const AUTO_UPDATE_ACCOUNT = process.env.CASTLE_AUTO_UPDATE_TRUSTED_ACCOUNT ?? 'castle';
+// Who published a deck. Readable without auth for the same decks webDeckSource
+// is, so this answers in a sandbox with no login. A lookup that fails answers
+// "not trusted": the failure direction has to be the one that leaves an import
+// where its deck's author pinned it.
+async function importIsOnTrustedAccount(deckId) {
+    const meta = await api.deckMeta(deckId).catch(() => null);
+    return meta?.creator?.username === AUTO_UPDATE_ACCOUNT;
+}
+// Move every opted-in import that the account gate allows to the version the
+// server has now.
+//
+// Called once from serve start (see serve.ts) and nowhere else: that is the one
+// moment where replacing a dependency's files can't pull the rug out from under
+// anything -- no editor is holding unsaved state and no play session is running
+// yet. A page reload happens mid-session, so it deliberately does not do this.
+//
+// Silent when nothing moves. Nothing here is fatal: an import that can't be
+// checked (offline, no source on the server, a bad archive) stays exactly as it
+// is pinned, and the serve starts anyway.
+export async function autoUpdateImports(deckDir) {
+    const pins = tryReadCastleJson(deckDir)?.imports ?? {};
+    const updated = [];
+    for (const [alias, pin] of Object.entries(pins)) {
+        // A kit copied from the CLI has no deck to ask; it moves when the CLI does.
+        if (!pin?.deckId)
+            continue;
+        if (!importOptsIntoAutoUpdate(deckDir, alias))
+            continue;
+        try {
+            if (!(await importIsOnTrustedAccount(pin.deckId)))
+                continue;
+            const source = await api.webDeckSource(pin.deckId);
+            if (!source || source.updatedAt === pin.version)
+                continue;
+            await applyImportUpdate(deckDir, alias, { deckId: pin.deckId, from: pin.version, via: pin.via }, source, (message) => console.log(`auto-update: ${message}`));
+            updated.push({ alias, from: pin.version, to: source.updatedAt });
+        }
+        catch (e) {
+            console.warn(`auto-update: left "${alias}" as it is -- ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    if (updated.length > 0) {
+        for (const dep of syncImportDependencies(deckDir)) {
+            console.log(`auto-update: added dependency ${dep}`);
+        }
+    }
+    return updated;
+}
 // `castle-web update-import [alias] [dir]`: re-fetch an import (or all of them)
 // at the version the server has now. Updates happen while editing, never on
 // someone else's behalf at play time -- the deck that gets published is one that
@@ -552,12 +640,7 @@ export async function updateImport(dir, options = {}) {
             changed = true;
             continue;
         }
-        await placeImport(deckDir, alias, pin.deckId, source, pin.via);
-        console.log(`Updated ${alias} (${pin.version} -> ${source.updatedAt})`);
-        // Its own dependencies may have moved too.
-        const transitive = await addTransitiveImports(deckDir, alias, importedDeckIds(deckDir));
-        for (const t of transitive)
-            console.log(`Also imported ${IMPORTS_DIR}/${t} (needed by ${alias})`);
+        await applyImportUpdate(deckDir, alias, { deckId: pin.deckId, from: pin.version, via: pin.via }, source, (message) => console.log(message));
         changed = true;
     }
     if (!changed)

package/dist/init.js

@@ -36,7 +36,7 @@ const DEFAULT_KIT = "physics-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.11";
+const PUBLISHED_SDK_VERSION = "0.4.12";
 // 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";
@@ -296,6 +296,13 @@ function makeKitPin(kitConfig, kit) {
     }
     return { source: "builtin", kit, version: getCliVersion() };
 }
+// The kit's editor block minus `fileTypes` -- the layout and file filters a new
+// deck starts from, without the vocabulary it resolves from the kit itself.
+function withoutFileTypes(editor) {
+    const rest = { ...(editor ?? {}) };
+    delete rest.fileTypes;
+    return rest;
+}
 // 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
@@ -331,8 +338,14 @@ function scaffoldFromKitImport(kit, projectDir) {
     // 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.
+    //
+    // `fileTypes` is deliberately NOT copied. It is the kit's own vocabulary, and
+    // the deck resolves it live from every import's castle.json (see
+    // editorConfig.resolveFileTypes) -- so the kit keeps owning it, a kit fix
+    // reaches the deck like any other, and a kit imported LATER contributes its
+    // types too, which a copy taken at scaffold time never could.
     writeJsonFile(path.join(projectDir, "castle.json"), {
-        ...(kitConfig.editor ? { editor: kitConfig.editor } : {}),
+        ...(kitConfig.editor ? { editor: withoutFileTypes(kitConfig.editor) } : {}),
         imports: { [alias]: makeKitPin(kitConfig, kit) },
     });
     // The kit's code runs from THIS deck's node_modules, so its dependencies are

package/dist/serve.js

@@ -8,6 +8,7 @@ import { createIdeServer, FAVICON_LINK_TAGS } from './ide.js';
 import { createAgentServer } from './agent.js';
 import { sceneFilesPlugin, importsAliasPlugin } from './vitePlugins.js';
 import { installFilesChangedWatcher } from './filesChanged.js';
+import { autoUpdateImports } from './imports.js';
 import * as config from './config.js';
 import { graphql as castleGraphql } from './api.js';
 import { executeCommand } from './castle-host/host.js';
@@ -214,6 +215,21 @@ export async function serve(dir, options = {}) {
         await serveDetached(projectDir, options);
         return;
     }
+    // Imports whose decks opted into auto-update move to their latest version
+    // now, before anything is served. Serve start is the only safe moment for it:
+    // the process is booting, so no editor holds unsaved state and no play
+    // session is running against the copy being replaced.
+    //
+    // Skipped when this deck already has a live serve. That deck IS open -- the
+    // dedup above normally returns before here, but an explicit --port/--host
+    // asks for a second serve, and a second serve is not a reason to replace
+    // files under the first one's session.
+    if (!existingServe(projectDir)) {
+        // A failure to check must never keep the deck from opening.
+        await autoUpdateImports(projectDir).catch((e) => {
+            console.warn(`auto-update: skipped -- ${e instanceof Error ? e.message : String(e)}`);
+        });
+    }
     // Close stdin when not attached to a TTY so the process can be cleanly
     // backgrounded with `&` (otherwise stdin reads can block or hold the parent).
     if (!process.stdin.isTTY) {