@frockbot/computer-host-runtime 0.3.16 → 0.3.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frockbot/computer-host-runtime",
-  "version": "0.3.16",
+  "version": "0.3.18",
   "private": false,
   "type": "module",
   "exports": {

package/src/runtime.test.ts

@@ -14,6 +14,7 @@ import { dirname, join } from "node:path";
 import { describe, expect, test } from "bun:test";
 import {
   APPLET_SDK_VERSION,
+  appletSdkInstallScript,
   APPLET_SHIM_PATH,
   appletShimScript,
   APPLETS_ROOT,
@@ -447,7 +448,7 @@ state running`);
     );
   });
 
-  test("the update runner replaces files and installs nothing", () => {
+  test("the update runner replaces files and only repairs Applet dependencies", () => {
     expect(UPDATE_PHASES.map((phase) => phase.name)).toEqual([
       "runtime",
       "applets",
@@ -459,16 +460,16 @@ state running`);
     const updateDocument = UPDATE_PHASES.map((phase) => phase.body).join("\n");
     expect(updateDocument).not.toContain("apt-get");
     expect(updateDocument).not.toContain("playwright-core/cli.js install");
-    // An in-place update swaps names over files it owns and leaves the SDK's
-    // dependency tree — which an `applet dev` may be running out of — alone.
-    // The one install it carries is the SDK itself, and only while the SDK
-    // is absent, which is exactly when nothing can be running out of it.
+    // An in-place update swaps names over files it owns. It installs the SDK
+    // only while absent, and fills the four shared React dependencies only
+    // when the resolution probe proves an older installation needs repair.
     expect(updateDocument).not.toContain("miniflare@");
     const installs = updateDocument
       .split("\n")
       .filter((line) => line.includes("npm install"));
     expect(installs).toEqual([
       `  if npm install --prefix ${APPLETS_ROOT} --no-audit --no-fund @frockbot/applet-sdk@${APPLET_SDK_VERSION}; then`,
+      `    npm install --prefix ${APPLETS_ROOT} --no-audit --no-fund react@19.2.8 react-dom@19.2.8 @types/react@19.2.18 @types/react-dom@19.2.4 || true`,
     ]);
     expect(updateDocument).toContain(
       `if [ ! -d ${APPLETS_ROOT}/node_modules/@frockbot/applet-sdk ]; then`,
@@ -509,18 +510,70 @@ describe("the applets phase", () => {
     expect(APPLETS_ROOT.startsWith(`${RUNTIME_ROOT}/`)).toBe(true);
   });
 
-  test("an SDK that cannot be fetched leaves a record and not a failed run", () => {
-    // `@frockbot/applet-sdk` is not on npm yet. A Computer whose SDK could not
-    // be installed still browses, execs, and syncs, so the phase records the
-    // failure for the doctor rather than failing provisioning.
+  test("recreates shared Applet dependencies outside every durable source root", () => {
+    const provision = PROVISION_PHASES.find(
+      (phase) => phase.name === "applets",
+    )!.body;
+    const update = UPDATE_PHASES.find(
+      (phase) => phase.name === "applets",
+    )!.body;
+
+    expect(APPLETS_ROOT).toBe(`${RUNTIME_ROOT}/applets`);
+    expect(APPLETS_ROOT).not.toContain("/agent-data/");
+    expect(provision).toContain(appletSdkInstallScript);
+    expect(update).toContain(appletSdkInstallScript);
+    expect(appletSdkInstallScript).toContain(
+      `npm install --prefix ${APPLETS_ROOT}`,
+    );
+    expect(appletSdkInstallScript).not.toContain("user-packages");
+  });
+
+  test("repairs old SDK installs and verifies every shared build import", () => {
+    const fallback =
+      `npm install --prefix ${APPLETS_ROOT} --no-audit --no-fund ` +
+      "react@19.2.8 react-dom@19.2.8 @types/react@19.2.18 @types/react-dom@19.2.4";
+    const fallbackProbe = `cd ${APPLETS_ROOT} && node -e "require.resolve('react-dom/client')"`;
+
+    expect(appletSdkInstallScript).toContain(fallback);
+    expect(appletSdkInstallScript).toContain(fallbackProbe);
+    expect(appletSdkInstallScript).toContain(
+      `SDK_RESOLUTION_ERROR=$(cd ${APPLETS_ROOT} && node -e`,
+    );
+    for (const specifier of [
+      "react-dom/client",
+      "react",
+      "@frockbot/applet-sdk/client",
+    ]) {
+      expect(appletSdkInstallScript).toContain(`'${specifier}'`);
+    }
+    expect(appletSdkInstallScript.indexOf(fallbackProbe)).toBeLessThan(
+      appletSdkInstallScript.indexOf(fallback),
+    );
+    expect(appletSdkInstallScript.indexOf(fallback)).toBeLessThan(
+      appletSdkInstallScript.indexOf("SDK_RESOLUTION_ERROR=$(cd"),
+    );
+    expect(appletSdkInstallScript).toContain(`> ${APPLETS_SDK_FAILURE_PATH}`);
+  });
+
+  test("an SDK that cannot be fetched or resolved leaves a record and not a failed run", () => {
+    // A Computer whose SDK could not be installed or resolved still browses,
+    // execs, and syncs, so the phase records the failure for the doctor rather
+    // than failing provisioning.
     const applets = PROVISION_PHASES.find((phase) => phase.name === "applets")!;
     expect(applets.body).toContain(`> ${APPLETS_SDK_FAILURE_PATH}`);
     expect(applets.body).toContain(`rm -f ${APPLETS_SDK_FAILURE_PATH}`);
     expect(boxDoctorScript).toContain("record applets-sdk fail");
     expect(boxDoctorScript).toContain("record applets-sdk pass");
+    expect(
+      boxDoctorScript.indexOf(`[ -f ${APPLETS_SDK_FAILURE_PATH} ]`),
+    ).toBeLessThan(
+      boxDoctorScript.indexOf(
+        `[ -d ${APPLETS_ROOT}/node_modules/@frockbot/applet-sdk ]`,
+      ),
+    );
   });
 
-  test("runs again rather than once, because the SDK has not shipped", () => {
+  test("runs again rather than once so old SDK installs can be repaired", () => {
     const applets = PROVISION_PHASES.find((phase) => phase.name === "applets")!;
     expect(applets.always).toBe(true);
     expect(provisionScript).not.toContain('[ ! -f "$MARKERS/applets"');

package/src/runtime.ts

@@ -1350,10 +1350,14 @@ ordinary file tools, then use \`applet\` — it is on your PATH:
 | \`applet dev\` | run it locally on this Computer and print a URL to open in the browser |
 
 The SDK and its runtime live under \`${APPLETS_ROOT}\`, installed when this
-Computer was provisioned. An Applet **never runs for real here**: \`applet dev\`
-is a preview, and publishing hands the built artifact to the kernel, which runs
-it. If \`applet\` says the SDK is not installed, run the self-check and read the
-\`applets-sdk\` line.
+Computer was provisioned and repaired by a runtime update when missing. Applet
+projects have no durable \`node_modules\`: dependency, cache, VCS, and ordinary
+build directories are excluded from Workspace sync, and the SDK resolves
+imports from this shared installation. The three files a publish explicitly
+requests from \`dist/\` are the only build-output exception. An Applet **never
+runs for real here**: \`applet dev\` is a preview, and publishing hands the
+built artifact to the kernel, which runs it. If \`applet\` says the SDK is not
+installed, run the self-check and read the \`applets-sdk\` line.
 `,
   },
   {
@@ -1643,19 +1647,22 @@ exec "$APPLET" "$@"
 `;
 
 /**
- * Installs the Applets SDK when, and only when, it is absent.
+ * Installs the Applets SDK when it is absent and verifies its shared imports.
  *
  * Guarded, and deliberately not fatal: a Computer that cannot fetch the SDK
  * is still a Computer — it browses, execs, and syncs — so the failure is
  * recorded as a file the doctor reports under `applets-sdk` rather than as a
  * phase that fails and leaves the whole run resumable-but-unfinished.
  *
- * The `[ ! -d ]` guard is also what makes this safe inside an in-place
- * update. The only thing that runs out of `${APPLETS_ROOT}` is `applet dev`,
- * and the shim refuses to start it while the SDK is missing, so an install
- * that runs only when the SDK is missing never touches a tree a process is
- * using. Once the SDK is present neither provisioning nor an update installs
- * again; a newer SDK arrives with the next provisioning adoption.
+ * The React fallback repairs SDK releases published before those build-time
+ * dependencies moved from development/peer metadata into dependencies. It is
+ * idempotent and runs only when Node cannot resolve `react-dom/client` from
+ * the shared prefix. The final probe covers React, React DOM, and the SDK's
+ * client entry; its concise failure is durable input to box-doctor.
+ *
+ * Changing this script changes the runtime document digest, which is the
+ * version marker that causes every existing Computer to run UPDATE_PHASES on
+ * its next open.
  */
 export const appletSdkInstallScript = `if [ ! -d ${APPLETS_ROOT}/node_modules/@frockbot/applet-sdk ]; then
   if npm install --prefix ${APPLETS_ROOT} --no-audit --no-fund @frockbot/applet-sdk@${APPLET_SDK_VERSION}; then
@@ -1663,6 +1670,16 @@ export const appletSdkInstallScript = `if [ ! -d ${APPLETS_ROOT}/node_modules/@f
   else
     printf '%s\\n' "npm could not install @frockbot/applet-sdk@${APPLET_SDK_VERSION}" > ${APPLETS_SDK_FAILURE_PATH}
   fi
+fi
+if [ -d ${APPLETS_ROOT}/node_modules/@frockbot/applet-sdk ]; then
+  if ! (cd ${APPLETS_ROOT} && node -e "require.resolve('react-dom/client')") >/dev/null 2>&1; then
+    npm install --prefix ${APPLETS_ROOT} --no-audit --no-fund react@19.2.8 react-dom@19.2.8 @types/react@19.2.18 @types/react-dom@19.2.4 || true
+  fi
+  if SDK_RESOLUTION_ERROR=$(cd ${APPLETS_ROOT} && node -e "for (const id of ['react-dom/client', 'react', '@frockbot/applet-sdk/client']) { try { require.resolve(id) } catch { console.error('could not resolve ' + id); process.exitCode = 1 } }" 2>&1); then
+    rm -f ${APPLETS_SDK_FAILURE_PATH}
+  else
+    printf '%s\\n' "Applets SDK dependency resolution failed: $SDK_RESOLUTION_ERROR" > ${APPLETS_SDK_FAILURE_PATH}
+  fi
 fi`;
 
 /** The files the `applets` phase installs, with their modes. */
@@ -1883,13 +1900,12 @@ elif [ -x ${APPLET_SHIM_PATH} ]; then
 else
   record applets fail "no ${APPLET_SHIM_PATH}; provisioning installs it, and no Applet can be checked, built, or previewed without it"
 fi
-# Named and non-fatal on purpose: \`@frockbot/applet-sdk\` is not published
-# yet, so the provisioning phase's guarded install is expected to fail and
-# leave this file rather than fail the whole run. This is where that shows up.
-if [ -d ${APPLETS_ROOT}/node_modules/@frockbot/applet-sdk ]; then
-  record applets-sdk pass "the Applets SDK is installed under ${APPLETS_ROOT}"
-elif [ -f ${APPLETS_SDK_FAILURE_PATH} ]; then
+# Named and non-fatal on purpose: an install or dependency-resolution failure
+# leaves this file rather than failing the whole Computer run.
+if [ -f ${APPLETS_SDK_FAILURE_PATH} ]; then
   record applets-sdk fail "$(head -n 1 ${APPLETS_SDK_FAILURE_PATH} 2>/dev/null); everything else on this Computer is unaffected"
+elif [ -d ${APPLETS_ROOT}/node_modules/@frockbot/applet-sdk ]; then
+  record applets-sdk pass "the Applets SDK and its shared imports resolve under ${APPLETS_ROOT}"
 else
   record applets-sdk fail "no Applets SDK under ${APPLETS_ROOT} and no record of an attempt; it installs when this Computer is next provisioned"
 fi