castle-web-cli 0.4.114 → 0.4.116

package/dist/install.js

@@ -1,16 +1,27 @@
-import { execSync } from "child_process";
-import * as fs from "fs";
-import * as path from "path";
-import { restoreMissingImports, syncImportDependencies } from "./imports.js";
+import { execSync, spawn } 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" });
+        execSync('pnpm --version', { stdio: 'ignore' });
         return true;
     }
     catch {
         return false;
     }
 }
+// Run an install command without blocking the event loop. `installDeps` also runs
+// INSIDE the serve (an import from the editor adds deps), and an `execSync` there
+// would freeze vite, the file API and the serve websocket for the whole install --
+// the editor would look hung, not busy.
+function run(command, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, { cwd, shell: true, stdio: 'inherit' });
+        child.on('error', reject);
+        child.on('close', (code) => code === 0 ? resolve() : reject(new Error(`\`${command}\` exited with code ${code}`)));
+    });
+}
 // Install a deck's deps. Prefer pnpm -- in the e2b template a pnpm store is baked
 // in, so this is near-instant (hardlinks from the store, no download). Fall back to
 // npm when pnpm isn't on PATH (e.g. a laptop that never installed it).
@@ -18,15 +29,12 @@ function hasPnpm() {
 // scripts (pnpm 10+ gates them and exits non-zero otherwise, and the deck's deps are
 // all prebuilt pure JS that don't need them). `frozen` installs straight from the
 // shipped lockfile (skips resolution -> no network, fast + deterministic).
-export function installDeps(projectDir, frozen) {
+export async function installDeps(projectDir, frozen) {
     if (hasPnpm()) {
-        console.log("Installing deps (pnpm)...");
-        const frozenFlag = frozen ? "--frozen-lockfile " : "";
+        console.log('Installing deps (pnpm)...');
+        const frozenFlag = frozen ? '--frozen-lockfile ' : '';
         try {
-            execSync(`pnpm install ${frozenFlag}--prefer-offline --ignore-scripts`, {
-                cwd: projectDir,
-                stdio: "inherit",
-            });
+            await run(`pnpm install ${frozenFlag}--prefer-offline --ignore-scripts`, projectDir);
         }
         catch (err) {
             if (!frozen)
@@ -36,19 +44,13 @@ export function installDeps(projectDir, frozen) {
             // wasn't regenerated). Rather than leave the deck with no node_modules,
             // retry with resolution allowed -- a little slower (re-resolves + may
             // fetch), but self-heals the drift instead of breaking.
-            console.warn("Frozen install failed; retrying with resolution (lockfile drift?)...");
-            execSync("pnpm install --prefer-offline --ignore-scripts", {
-                cwd: projectDir,
-                stdio: "inherit",
-            });
+            console.warn('Frozen install failed; retrying with resolution (lockfile drift?)...');
+            await run('pnpm install --prefer-offline --ignore-scripts', projectDir);
         }
     }
     else {
-        console.log("Installing deps (npm)...");
-        execSync("npm install --no-audit --no-fund --loglevel=error", {
-            cwd: projectDir,
-            stdio: "inherit",
-        });
+        console.log('Installing deps (npm)...');
+        await run('npm install --no-audit --no-fund --loglevel=error', projectDir);
     }
 }
 // `castle-web install <dir>`: put node_modules in place for a deck that already has
@@ -56,7 +58,7 @@ export function installDeps(projectDir, frozen) {
 // (the cloud hosts treat it as regenerable and don't snapshot it).
 export async function install(dir) {
     const projectDir = path.resolve(dir);
-    if (!fs.existsSync(path.join(projectDir, "package.json"))) {
+    if (!fs.existsSync(path.join(projectDir, 'package.json'))) {
         console.error(`No package.json in ${projectDir}.`);
         process.exit(1);
     }
@@ -72,6 +74,6 @@ export async function install(dir) {
     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")));
+    await installDeps(projectDir, fs.existsSync(path.join(projectDir, 'pnpm-lock.yaml')));
     console.log(`Installed deps in ${projectDir}`);
 }

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) {